Magic number (programming)

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 others):

• ASCII code (most common)
• Representation in hexadecimal (e.g. decimal 305419896 is hexadecimal 0x12345678)
• Sometimes hexspeak is used

Magic numbers in files

An early convention in the Unix operating system was that (binary) 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. The concept has been expanded on over time, and is now in current use by many other programs across many operating systems. In a wiggly hack, 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 class files (bytecode) start with 0xCAFEBABE.
• 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 about the file.
• 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) followed by the path to an interpreter.
• Old MS-DOS LE (Linear Executable) .exe files and the newer Windows PE (Portable Executable) .exe files start with the ASCII string 'MZ', the initials of the designer of the file format. (0x4D5A)
• 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.

• ELF Binaries (Linux executable files) as follows:

If we break the hexadecimal values up, the first four denote the first four bytes of the magic number, which basically say it's an ELF binary. The next three are the class, data and version respectively and the eighth bit would seem to denote the ABI (elf(5) and /usr/include/sys/elf_common.h seem to agree with me).

(see for details)

The Unix command 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:

The following is wikicode, a proposed pseudocode for BambooWeb articles.

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

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

This is preferred for two 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.

• 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. 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 constant in the second example would be a simple, one-line change.

Magic debug values

Magic debug values are specific values written to memory during 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 

0xBAADFEED 

0xC0EDBABE 

0xC001D00D 

0xCCCCCCCC 

Used by Microsoft's C++ compiler to mark uninitialised stack areas in debug mode.

0xCDCDCDCD 

Used by Microsoft's C++ debugging heap to mark uninitialised heap areas.

0xDDDDDDDD 

Used by MicroQuill's IBM systems such as the RS/6000, also in OPENSTEP Enterprise and the Commodore Amiga.

0xEBEBEBEB 

From MicroQuill's SmartHeap.

0xFD  

Used by Microsoft's C++ debugging heap to mark class 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