Magic number (programming)

: For other uses of the term, see magic number .

In computer programming, a magic number is a special constant used for some specific purpose. It is called magic because its value or presence is inexplicable without some additional knowledge.

Magic numbers are often chosen based on (among other factors):

ASCII code (most common)

Representation in hexadecimal (e.g. decimal 305419896 equals 0x12345678)

Sometimes Hexspeak is used

= Magic numbers in files =

An early convention in the Unix operating system was that (Binary numeral system) files started with two bytes containing a magic number identifying the type of the file. These were originally used by the Unix Linker and Loader (computing). The concept has been expanded on over time, and is now in current use by many other programs across many operating systems. It is a form of in-band signaling.

In a quick Hack (technology slang), the very earliest magic numbers were PDP-11 branch instructions. The concept of magic numbers can be generalised to all files, since any unencoded binary data is essentially a number; most file formats can thus be identified by some signature that occurs somewhere in the file. Detecting such sequences is therefore an effective way of distinguishing between file formats - and can often yield further Information at the same time.

Some examples:

Compiled Java programming language class files (bytecode) start with 0xCAFEBABE on big-endian systems.

GIF image files have the ASCII code for GIF89a (0x474946383961) or GIF87a (0x474946383761)

JPEG image files have the ASCII code for JFIF (0x4A464946) followed by more Metadata (computing) about the file.

PNG image files begin with an 8-byte signature which identifies the file as a PNG file and allows immediate detection of some common file-transfer problems: 211 P N G

32 (0x89504e470d0a1a0a)

Standard MIDI music files have the ASCII code for MThd (0x4D546864) followed by more metadata about the file.

Unix script files usually start with a shebang, #! (0x2321, or 0x2123 on little-endian processors) followed by the path to an interpreter.

Old MS-DOS .exe files and the newer Microsoft Windows Portable_Executable (Portable Executable) .exe files start with the ASCII string MZ (0x4D5A), the initials of the designer of the file format, Mark Zbikowski.

The Berkeley Fast File System superblock format is identified as either 0x19540119 or 0x011954 depending on version; both represent the birthday of author Marshall Kirk McKusick.

Executables for the Game Boy and Game Boy Advance handheld video game systems have a 48-byte or 156-byte magic number, respectively, at a fixed spot in the header. This magic number encodes a bitmap of the Nintendo logo.

Old Fat_binary (containing code for both 68K processors and PowerPC processors) on Mac OS 9 contained the ASCII code for Joy! (0x4A6F7921) as a prefix.

The Unix program file can read and interpret magic numbers from files.

= Magic numbers in code =

The term magic number also refers to the bad programming practice of using numbers directly in source code without explanation. In most cases this makes programs harder to read, understand, and maintain, although most guides make an exception for the numbers zero and one.

For example, to shuffle the values in an array randomly, this Pseudocode will do the job:

for i from 1 to 52 j := i + randomInt(53 - i) - 1 swapEntries(i, j)

The function randomInt(x) chooses a random integer between 1 to x , inclusive, and swapEntries(i, j) swaps the i th and j th entries in the array.

In the above example, 52 is a magic number. It is considered better programming style to write:

var int deckSize := 52 for i from 1 to deckSize j := i + randomInt(deckSize + 1 - i) - 1 swapEntries(i, j)

This is preferred for at least five reasons:

It is easier to read and understand. A programmer reading the first example might wonder, What does the number 52 mean here Why 52 The programmer might infer the meaning after reading the code carefully, but it s not obvious. Magic numbers become particularly confusing when the same number is used for different purposes in one section of code.

It is easier to maintain. Changing the value of a magic number is error-prone, because it s rare to use a value just once in a program. Usually the same value is used several places in the code. To change the first example to use a Tarot deck, which has 78 cards, a programmer might naively replace every instance of 52 in the program with 78. This would have two problems. First, it would miss the value 53 on the second line of the example, which would cause the algorithm to fail in a subtle way. Second, it would likely replace the characters 52 everywhere, regardless of whether they refer to the deck size or to something else entirely, which could introduce bugs. By contrast, changing the value of the deckSize variable in the second example would be a simple, one-line change.

It facilitates parameterization. For example, if we wanted to turn the above example into a general procedure that shuffles a deck of n cards, we would only have to turn deckSize into a parameter of that procedure. In the first example we d have to make several changes.

It helps detect typos. Using a variable (instead of a literal) lets you take advantage of your compiler s checking (if it has any). Accidentally typing 62 instead of 52 would go undetected, whereas typing dekSize instead of deckSize would result in the compiler warning you that dekSize is undeclared.

It can reduce typing in some Integrated development environments. If an IDE supports AutoComplete, it will fill in most of the variable s name from the first few letters.

Magic numbers are also great candidates of becoming Variable#Constant.

= Magic debug values =

Magic debug values are specific values written to random Access Memory during memory allocation or deallocation, so that it will later be possible to tell whether or not they have become corrupted and to make it obvious when values taken from uninitialized memory are being used.

Memory is usually viewed in hexadecimal, so common values used are often repeated digits or Hexspeak.

Famous and common examples include:

*0xBAADF00D *0xBADBADBADBAD : Burroughs B6700 uninitialized memory (48-bit words) *0xC001D00D *0xC0DEBABE *0xC0EDBABE *0xCACACACA : In spanish, caca is a pre-teenager use word equivalent to feces *0xCAFECAFE *0xCCCCCCCC : Used by Microsoft s Visual C Plus Plus Compiler to mark uninitialised stack (computing) areas in debug mode *0xCDCDCDCD : Used by Microsoft s C++ debugging dynamic memory allocation to mark uninitialised heap areas *0xDDDDDDDD : Used by MicroQuill s SmartHeap and Microsoft s C++ debugging heap to mark memory returned to the heap *0xDEADBEEF : Famously used on IBM systems such as the RS/6000, also in OPENSTEP Enterprise and the Commodore International Amiga *0xEBEBEBEB : From MicroQuill s SmartHeap *0x..FACADE : Used by a number of real-time operating systemes *0x......FD : Used by Microsoft s C++ debugging heap to mark guard bytes in the heap *0xFEEDBABE *OxFEEDFACE : Seen in Mach-O binaries on Apple Computers Mac OS X platform *0xFEEEFEEE : Used by Microsoft s C++ compiler to mark the storage area of a deleted class (computer science) in debug mode

Note that most of these are each 8 nybbles (32 Bits) long, as most modern computers are designed to manipulate 32 bits at a time.

The prevalence of these values in Microsoft technology is no coincidence; they are discussed in detail in Steve McGuire s well-known book Writing Solid Code from Microsoft Press. He gives a variety of criteria for these values, such as:

They should not be useful; that is, most algorithms that operate on them should be expected to do something unusual. Numbers like zero don t fit this criterion.

They should be easily recognized by the programmer as invalid values in the debugger.

On machines that don t have byte alignment, they should be odd, so that dereferencing them as addresses causes an exception.

They should cause an exception, or perhaps even a debugger break, if executed as code.

Since they were often used to mark areas of memory that were essentially empty, some of these terms came to be used in phrases meaning gone, aborted, flushed from memory ; e.g. Your program is DEADBEEF .

Pietr Brandehörst s ZUG programming language initialised memory to either 0x0000, 0xDEAD or 0xFFFF in development environment and to 0x0000 in the live environment, on the basis that uninitialised variables should be encouraged to misbehave under development to trap them, but encouraged to behave in a live environment to reduce errors.

=References=

[http://www.libpng.org/pub/png/spec/1.0/PNG-Rationale.html#R.PNG-file-signature PNG file signature, Rationale]

[http://www.decafbad.com/twiki/bin/view/Main/HexOddities Hex Oddities]