Why Reading Backwards Is Hard: Endianness in Computing and Directionality in DNA

I kept running into the same frustrating asymmetry in two very different places: low-level systems code and molecular biology. In both, information flows in a particular direction—and handling the reverse always felt harder than it should be.

This post draws an analogy between endianness in computer systems and DNA strand directionality. Both deal with the same abstract problem: interpreting structured information that flows in a particular order. And both require complex machinery to handle the less intuitive direction.

What Is Endianness, Really?

When a computer stores a multi-byte value (like an integer or float), it has to choose which byte comes first in memory. This choice is called endianness, and it affects how that data is interpreted across different systems or platforms.

Let's take the number 0x12345678. It's 4 bytes long. In memory, this number could be stored in two ways:

Big-endian:

text
Address 0x00: 0x12
Address 0x01: 0x34
Address 0x02: 0x56
Address 0x03: 0x78

Little-endian:

text
Address 0x00: 0x78
Address 0x01: 0x56
Address 0x02: 0x34
Address 0x03: 0x12

To a human reading memory as a list of hex bytes, big-endian feels more "natural": it starts with the most significant byte, like how we read numbers in decimal (thousands → hundreds → tens → ones). Little-endian, in contrast, starts with the least significant byte, and reconstructing the value requires flipping things mentally or programmatically.

Worth noting: modern Intel and AMD CPUs use little-endian format, while many network protocols (like TCP/IP) assume big-endian, hence the need for conversion functions like htonl() and ntohl().

This is one of those things that sounds obvious after you've internalized it, but the first few times you hit it, it's incredibly unintuitive.

What surprised me is that the same constraint shows up in a place that seems completely unrelated at first: DNA.

Directionality in DNA: 5′ to 3′ vs. 3′ to 5′

DNA is composed of two strands running in opposite directions. Each strand has a polarity: one end is labeled 5′ (five-prime) and the other is 3′ (three-prime), based on the carbon numbering of the sugar in the DNA backbone. During processes like replication or transcription, enzymes can only read or write in the 5′ → 3′ direction.

This creates a problem:

• One strand (the leading strand) can be synthesized smoothly in the 5′ → 3′ direction.
• The other strand (the lagging strand) is oriented 3′ → 5′, which enzymes can't directly synthesize.

So what does the cell do?

It works around it.

Okazaki Fragments: Nature's Version of byte[] Reassembly

To replicate the lagging strand, the cell:

1. Synthesizes short fragments of DNA (called Okazaki fragments) in the 5′ → 3′ direction.
2. Uses an enzyme called ligase to stitch the fragments together.
3. Coordinates the effort using primase (to lay down short primers) and DNA polymerase (to extend them).

This is similar to a computer program that reads a little-endian byte array and reconstructs the intended value by reversing the byte order.

The Analogy, Mapped Out

Like all analogies, this one breaks if you push it too far. But at the level of information flow, it holds surprisingly well.

Real-World Challenges

In Software

When developers work across systems with different endianness (e.g., saving data on an x86 machine, then reading it on an ARM processor), they must explicitly manage byte order. Otherwise, a number like 0x00000001 might be read as 0x01000000—a completely different value.

This is especially tricky in network programming, file parsing (binary formats like WAV, BMP, or custom log formats), and cross-platform embedded development.

A typical workaround is to serialize everything into big-endian, since it's unambiguous, and let systems convert as needed.

In Bioinformatics

Strand direction matters a lot in genomics. Gene annotations specify whether a gene is on the forward or reverse strand. Variant calling tools need to know the strand to identify correct reference and alternate alleles. Short-read mappers must align sequencing reads based on the correct strand orientation.

Failing to account for strand direction leads to serious errors: false variant calls, misaligned transcripts, and incorrect conclusions about gene regulation.

Complexity as a Cost of Reversal

Both systems (computers and cells) pay a cost for handling the "wrong" direction:

• In computers, reading or writing in little-endian format adds friction for humans and protocols.
• In biology, replicating or transcribing against the grain requires extra enzymes, additional processing steps, and increases the chance for replication errors.

Why not just make everything go in one direction?

Because the architecture is inherited. It was evolved or designed long ago, and changing it system-wide would break everything else that depends on it. Much like DNA polymerases can't evolve to write 3′ → 5′ because the chemistry doesn't allow it, CPUs can't easily switch endianness without breaking compatibility with a vast ecosystem of binaries, OSs, and tools.

Final Thought

What's interesting here isn't the difficulty itself, but how both fields converged on similar solutions. Primers and ligases mirror serializers and deserializers. Enzymes and repair complexes resemble parsing logic and error-correcting code.

Sometimes the best insights come not from specialization, but from seeing one domain in the mirror of another.

I didn't fully appreciate how deep this parallel ran until I started working across both domains at once. Now I see versions of it everywhere.