Information is just order

Here's a thought to hold onto before any biology: information lives in the order of things, not in the things themselves. The letters c, a, and t are nothing special on their own. Put them in one order and you get "cat"; rearrange them and you get "act." Same three letters, different information, purely because of sequence.

DNA works exactly this way. It stores every instruction for building and running a living thing using an alphabet of only four letters, and all the information is in the order those letters come in. That's the whole trick. Everything below is just the details of how nature pulls it off.

The four letters

DNA is a long chain, and hanging off that chain, one after another, are four kinds of chemical unit called bases. We label them by their first letters:

  • A — adenine
  • T — thymine
  • G — guanine
  • C — cytosine

That's the entire alphabet. A stretch of DNA might read ...ATGGCATTC... and so on for millions of letters. The chemistry of the individual base doesn't carry meaning; the sequence does. Just like ink doesn't mean anything, but the shapes you make with it do.

The letters pair up — and that's the clever part

DNA isn't a single strand. It's two strands twisted together into the famous double helix, like a twisted ladder. The two strands face each other, and the bases reach across to meet in the middle, forming the rungs.

But they don't meet randomly. A always pairs with T. G always pairs with C. Every time. This is base pairing, and it's the most important structural fact about DNA.

Why does it matter so much? Because it makes the two strands complementary. If one strand reads:

A T G G C A

then the other strand is completely determined:

T A C C G T

You could throw away one strand entirely and rebuild it perfectly from the other, just by following the pairing rule. This is what lets DNA be copied faithfully every time a cell divides, and it's a built-in backup: if one strand gets damaged, the cell can consult its partner to repair it. Base pairing is both the filing system and the error-check, baked into the shape of the molecule.

Reading the code three letters at a time

Now, how does a sequence of A/T/G/C turn into an actual working protein?

Recall that a protein is a chain of small parts called amino acids, and living things use 20 different ones. The order of amino acids determines the protein's shape, and the shape determines what it does. So the cell's job is to translate a string of DNA letters into the right string of amino acids.

Here's the rule: the cell reads the sequence three letters at a time. Each group of three is called a codon, and each codon names one amino acid.

Take this stretch:

A T G   G G A   T T C   ...

The cell reads ATG, then GGA, then TTC, marching along in steps of three. Each triplet is looked up in a fixed table — the genetic code — and the matching amino acid gets added to the growing protein chain. GGA, for instance, always means the amino acid glycine. The cell keeps going, codon by codon, until it reaches a special stop codon that says "protein finished."

There are also punctuation signals. ATG typically doubles as the "start here" mark, and three particular codons mean "stop." So the code isn't just a list of amino acids — it has built-in begin and end markers, exactly like the capital letter and full stop of a sentence.

Why four letters is enough (the counting that makes it click)

People are often surprised that all of life runs on a four-letter alphabet. Let's see why four is not just enough but comfortably enough.

The cell reads in triplets. How many different triplets can you make from four letters?

4 x 4 x 4 = 64

Sixty-four possible codons. But proteins are built from only 20 amino acids. So the code has 64 words to name 20 things plus a few punctuation marks — a generous surplus.

That surplus isn't wasted; it's protective. Because there are more codons than amino acids, most amino acids are named by several different codons. Glycine, for example, is spelled by four different triplets that all start with GG. This is called redundancy, and it's a safety feature: if a single letter gets changed by accident, there's a decent chance the codon still points to the same amino acid, and the protein comes out unchanged. The code has slack in it on purpose.

Now compare the alternatives. A two-letter alphabet read in triplets would give only 2 x 2 x 2 = 8 words — not enough to name 20 amino acids. You could rescue it by reading in longer chunks, but then every instruction gets longer and copying gets slower and more error-prone. A much larger alphabet, say 26 letters, would pack more meaning per letter but would be chemically fiddly and harder to copy accurately. Four letters read three at a time sits in a sweet spot: simple enough to store and copy reliably, rich enough to describe every protein in every living thing.

Nature didn't calculate this and choose it. Evolution stumbled into a code that worked and then kept it — which is why the same codon table shows up in bacteria, oak trees, and people alike. That near-universality is one of the strongest clues that everything alive descends from a common ancestor.

Pulling it together

DNA carries information the same way any written language does: in the order of its letters. The alphabet has four letters — A, T, G, C — and they pair in a fixed way, A with T and G with C, which is what lets DNA be copied and repaired reliably. To build a protein, the cell reads the sequence three letters at a time; each codon names one amino acid, with start and stop codons for punctuation.

Four letters in triplets give 64 possible words for 20 amino acids — plenty, with room to spare that even protects against small errors. It's a modest alphabet running an enormous library, and the reason it works is the same reason 26 letters can write every book ever written: with sequence, a little goes a very long way.

If you want the bigger picture of what these instructions are, start with what a gene is; to see what happens when one of these letters changes, read what mutations actually are.