(This post is part of a guided tour of my book, Computational Photography, on sale now for $49.95 with free shipping.)

If you peel back the dust cover of Computational Photography you can see the actual hardcover of the hardcover book. This is the case cover, in book-speak, and is made by taking a hardboard called gray board and wrapping a printed sheet of paper around it, gluing it down on the back like gift wrap. The edges and most of the folds on the inside of the case cover are then hidden by the endpapers. Everything has a purpose.

Here’s a video of the case cover of my book being assembled.

The front of the case cover looks to be a series of colored-stripes, speckled all over with darker dots. If you think the dots look like static on an old TV set you are on the right track because the cover is an image from one of my works called Static Films, which is a video project.

If you have a loupe or a magnifying glass and have the book in front of you take a closer look, a very close look. The colored stripes with darker specks are really made up of many colors, each stripe having its own set, though all of the stripes have colors in common.

What’s going on?

Throughout the book are hidden surprises (I’m only telling you about a few of them in this Guide) and the surprise here is that this is not static at all but a coded text. The best kind of code isn’t a super-complex one relying on quantum physics, nothing like that at all. The best kind of code is a code that doesn’t seem to be a code, a code that no one tries to decode.

That’s what we have here.

As you know, computers like to work with binary code, ones and zeros. Even letters are, a little deeper down, represented by ones and zeros. How many digits do you need to encode the alphabet?

With a single digit you can only represent two letters. For example, you can say that a “0” will be an “A” and a “1” will be a “B”. That’s not a very large alphabet but it’s a start. If we use two binary digits we can have four letters in our alphabet. “00” can now be the “A”, “01” can be a “B”, “10” can be “C”, and “11” can be “D”. Now we are getting somewhere. Each digit you add doubles the number of letters the binary code can represent.

With two digits we can represent four letters and it might seem at first that you need only five digits to have enough digits to represent the entire twenty-six letter alphabet (with a few left over):

1 digits = 2 letters
2 digits = 4 letters
3 digits = 8 letters
4 digits = 16 letters
5 digits = 32 letters

Unfortunately, the capital letters and lowercase letters need to be represented separately, and then you have to take into account the numbers, punctuation, diacritical marks, mathematical symbols, and everything else that you might imagine typing with a keyboard. Assign a unique series of ones and zeros to each of these and you’ll find that you need a series of eight digits to represent any single letter or other symbol.

Putting this all together into some sort of universal standard has already been done, the most well-known standard is called ASCII (pronounced “ass-key”), and although it is a little old-fashioned now, that is the standard I used for my Static Films.

Using this table you can see that the letter “T” (capital T) is represented as

01010100

Lowercase “h” is

01101000

Lowercase “e” is

01100101

And thus, The word “The” comes out as

01010100 01101000 01100101

A little mind-numbing but it does give us a clear-cut way to take a letter, convert it to a universally recognized series of ones and zeros and, if we like, to go backward and convert those ones and zeros flawlessly back into text.

The series

01010100 01101000 01100101 00100000 01110010 01100101 01110011 01110100 00100000 01101001 01110011 00100000 01110011 01101001 01101100 01100101 01101110 01100011 01100101 00101110

looks intimidating but it converts easily enough to

The rest is silence.

There are twenty groups of digits. Look them up on the ASCII table and you get the English text, with spaces and the period at the end each having their own eight-digit sequence.

It’s a simple code. The ones and zeros assigned to each letter are arbitrary—there’s no reason you couldn’t have a different ASCII with different eight-digit codes for each of the letters. The power of this one is that everyone has agreed on the real ASCII’s letter assignments and so given a series of letters I can transform them into ones and zeros and back and anyone I give the ones and zeros to can, with the ASCII table, convert them back into letters without error.

The problem, as I mentioned before, is that this isn’t a very good code. It simplicity is an issue but the more troublesome problem is that it looks like a code. It looks very much like a code, and even if I didn’t use the official ASCII table for my code, even if I used a different one of my own invention, the very nature if all those ones and zeros is a powerful invitation to codebreakers to try to discover the hidden message. A code that looks like a code attracts attention.

What if we put all the groups together, without those helpful spaces?

0101010001101000011001010010000001110010011001010111001101110100001000000110100101110011001000000111001101101001011011000110010101101110011000110110010100101110

That looks more challenging, but only a little. What if we put them in a grid?

And then color the ones black and the zeros white?

And now, here’s the trick, what if we let the colors represent the numbers? There are only two possible digits—a one or a zero—and there are only two possible colors—a black or white. Instead of showing the numerals we show just the colors, which we can easily convert back to the ones and zeros if we wanted to:

It looks a lot like static. We can make these grids taller and wider—the exact same size as a photograph—and then if we make a series of these fake-static images and play them quickly, one after the other, we have a video, each static frame different, and a very compelling illusion that what is playing is indeed static.

The code is simple, converting the code to black and white pixels is trivial, but transforming the code into something that doesn’t look like a code is extraordinarily powerful. A 4k video frame is about 4000 by 2000 pixels, which is eight million total pixels. That’s a million eight-digit letters! If the length of the average word in English is five characters then each video frame will hold on the order of two hundred thousand words. The entire Bible, once encoded, would take up only three static pictures, three 4k video frames—it would go by in its entirety in one-tenth of a second.

You could put entire libraries on a few minutes of static at the end of home movies and send that library all over the world and you could be fairly assured that your secret would be safe because it would be unexamined.

The acquisition of the Hope Diamond by the Smithsonian Institution in 1958 illustrates the same concept at work. Rather than using an armored car or a special detachment of detectives to transport the famous jewel from New York City to Washington, DC, jeweler Harry Winston took it to the post office and, with no fanfare at all, sent it registered mail. Relatively unguarded, the package was safe from would-be thieves by the virtue of it not seeming to be the Hope Diamond under guard.

Black and white static works fine, in a conceptual way, for the Bible, which talks a lot about Light and Darkness, but what about other texts? What if you wanted to encode the works of Shakespeare—what color would make sense?

One thought is that you can add colors to the mix without messing up the code by using sets of colors rather than single colors. For example, if black equals a “1” in our Bible Static Film we might consider a set of colors (black, green, blue) where any of them will equal the “1” and another set (say, orange, pink, turquoise) equals the “0”. So, for example, a series such as “black, black, pink, green” would be translated as 1101. The black and green are both ones, the pink is a zero, and the green is also a one.

You could make these color sets as large as you wanted, containing dozens, hundreds, even thousands of colors each as long as a color was in only one set and not on both sets. Any color in the first set would be a “1”, any color in the second set would be a “0”.

Color static!

But just making up random colors for the works of Shakespeare seems arbitrary and unjustified. We need a plan on why certain colors are chosen.

And that is simple, too. Just read through every Shakespeare play and every Shakespeare sonnet and whenever you encounter a color term write that color term down and write down the context of the use of that term. Make a database. Count only the ones where the use of the word refers to a literal color rather than the color term used metaphorically. Then go to the Pantone database and find your best guess on what color matches Shakespeare’s usage. Assign that color to one of the two sets of colors.

Now we have two sets of colors, with lots of different colors. It’s looking good.

You can refine this further by noticing that certain colors are mentioned many times in Shakespeare’s plays and other colors are mentioned only once or twice. You can adjust your sets so that colors that are mentioned more often have a greater likelihood of appearing in the static, their likelihood equal to how often Shakespeare used the color. Even better, the colors contain not only information on what colors are used in the plays but how often they are used. Layers of data, layers of meaning.

We’re not done yet. Rather than putting all of Shakespeare’s work in one giant pile and converting it all at once to colorful static, why not segment each play and sonnet by date of composition and convert each in sequence? Do that and you get bands of color since in one play the word “red” might be mentioned many times, in another brown tones might dominate.

Bands of static-y color, each band a different overall color and, upon closer inspection, each band filled with many more colors.

This is the original video from which the case cover image was taken.

The endpapers of the book look like dark static, all black and black-gray, and the process to create them was similar to that of the case cover. The source text that was converted into “static” is Moby Dick.