Magic

(programming)

In the context of computer programming,

magic is an informal term for abstraction;
it is used to describe code that handles
complex tasks while hiding that
complexity to present a simple interface.
The term is somewhat tongue-in-cheek,
and often carries bad connotations,
implying that the true behavior of the code
is not immediately apparent. For example,
Perl's polymorphic typing and closure
mechanisms are often called "magic". The
term implies that the hidden complexity is
at least in principle understandable, in
contrast to black magic and deep magic
(see Variants), which describe arcane
techniques that are deliberately hidden or
extremely difficult to understand. However,
the term can also be applied endearingly,
suggesting a "charm" about the code. The
action of such abstractions is described
as being done "automagically", a
portmanteau of "automatically" and
"magically".
Referential opacity
"Magic" refers to procedures which make
calculations based on data not clearly
provided to them, by accessing other
modules, memory positions or global
variables that they are not supposed to (in
other words, they are not referentially
transparent). According to most recent
software architecture models, even when
using structured programming, it is usually
preferred to make each function behave
the same way every time the same
arguments are passed to it, thereby
following one of the basic principles of
functional programming. When a function
breaks this rule, it is often said to contain
"magic".

A simplified example of negative magic is

the following code in PHP:

function magic()
{
global $somevariable;

echo $somevariable;
}

$somevariable = true;
 magic();

While the code above is clear and

maintainable, if it is seen in a large project,
it is often hard to understand where the
function magic() gets its value from. It
is preferred to write that code using the
following concept:

function
noMagic($myvariable)
{
echo $myvariable;
}
 $somevariable = true;

noMagic($somevariable);

Non-orthogonality

Any SV [scalar value] may be

magical, that is, it has special
features that a normal SV does
not have.

— Larry Wall, perlguts

manual page,[1] Perl 5
This definition of magic or magical can be
extended to a data type, code fragment,
keyword, or machine address that has
properties not shared by otherwise
identical objects. The magical properties
may or may not be documented.

In ISO C, file handles (of type FILE )

cannot be safely copied as their
addresses[2] may be magic. That is, the
runtime environment may place original
file handles in a hard-coded address
range, and not provide file handle
behaviour to a user-created copy at
another address. Consequently, the
standard library routines accept pointers
to file handles, of type FILE * ,
instead.
In Perl 5, the statement
while(<file_handle>) implicitly
assigns the line read from the file by
<file_handle> to the variable $_ , and
applies the defined() function to
the expression so that any successfully
read string, even "0" or the empty
string, evaluates as true and continues
the while() loop. This does not
happen to <file_handle> anywhere else,
or to while() with any other control
expression.[3]
In an emulator, especially one in
development, the emulated machine's
system call points may be magic; when
they are called, the emulator may run
native code for convenience, speed or
access to physical hardware, and set up
the emulated CPU and memory as if it
had executed the original code.
For instance, the CALL statement
of BBC BASIC V treats the system
call addresses of Acorn MOS
magically; instead of attempting to
branch to ARM code at those
addresses, it raises a software
interrupt in RISC OS equivalent to
the system call.[4] The effect is to
 emulate Acorn MOS sufficiently for
8-bit BASIC programs not
containing assembly language to
run without modification.
Also in BBC BASIC, not only does the
numeric variable @% control print
formatting, it accepts direct assignment
of ANSI printf format strings,
normally a type mismatch error.[4]
In JavaScript, evaluation of the
typeof operator succeeds when the
operand is an undeclared identifier,
which would normally result in a
ReferenceError .
 Any comment that has an effect on the
code is magic.
Memory-mapped I/O addresses and
volatile variables are also magic in this
sense, although the term is not normally
applied.

Variants
Deep magic refers to techniques that are
not widely known, and may be deliberately
kept secret. The number of such
techniques has arguably decreased in
recent years, especially in the field of
cryptography where security through
obscurity has been increasingly
abandoned in favour of security through
design which allows, and often
encourages, public scrutiny. The Jargon
File makes a distinction[5] between deep
magic, which refers to code based on
esoteric theoretical knowledge, and black
magic, which refers to code based on
techniques that appear to work but which
lack a theoretical explanation.

It also defines heavy wizardry, which

refers to code based on obscure or
undocumented intricacies of particular
hardware or software.‌For an example, the
infamous “You are not expected to
understand this” comment: many readers
of Lions Book, a didactically annotated
commentary on the Unix version 6 kernel
source code, interpreted this comment,
found in the code, to suggest some deep
theoretical wisdom was on display in the
obscure snippet, but in fact its "magical"
function was merely dependant on a
peculiarity of the way the C Compiler was
optimised for the PDP-11 hardware on
which version 6 of Unix was designed to
run.

See also
Magic number (programming)
Black box
Cargo cult programming
 Nothing-up-my-sleeve number

References
1. "perlguts – perldoc.perl.org" (http://perldoc.
perl.org/perlguts.html) . 5 October 2014.
Retrieved 18 February 2015.

2. Banahan, Mike; Brady, Declan; Doran, Mark

(1991). "9.10.3 The stdio.h header
file". The C book: Featuring the ANSI C
standard. The Instruction Set (2nd ed.).
Wokingham, England: Addison-Wesley
Publishers. p. 234. ISBN 0-201-54433-4. "It
is not safe to copy these objects within the
program; sometimes their addresses may
be 'magic'."

3. "perlop – perldoc.perl.org" (http://perldoc.p

erl.org/perlop.html) . 7 September 2010.
 Retrieved 17 February 2011.

4. "27. Keywords" (http://developer.riscos.co

m/PRM/BBCBASIC.PDF) (PDF). BBC
BASIC Reference Manual (1st ed.).
Cambridge, England: Acorn Computers.
October 1992. pp. 229, 349. ISBN 1-85250-
103-0. Retrieved 9 May 2007.

5. "Deep Magic" (http://catb.org/jargon/html/

D/deep-magic.html) . Jargon File.

Retrieved from
"https://en.wikipedia.org/w/index.php?
title=Magic_(programming)&oldid=1125196485"
This page was last edited on 2 December 2022, at
18:24 (UTC). •
Content is available under CC BY-SA 3.0 unless
otherwise noted.