2 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 use in many articles:

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

3 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

0xBADBADBADBAD

Burroughs B6700 "uninitialized" memory (48-bit words)

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 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 Amiga.

0xEBEBEBEB

From MicroQuill's SmartHeap.

OxFACADE

Used by a number of real-time OS's

0xFD

Used by Microsoft's C++ debugging heap to mark guard byte s in the heap.

0xFEEEFEEE

Used by Microsoft's C++ compiler to mark the storage area of a deleted 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 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".

4 References

• PNG file signature, Rationale

Computer science Programming Anti-patterns

<Hide>