How Data Is Actually Represented
Bits, bytes, two's complement, IEEE 754, and UTF-8 — why 0.1 + 0.2 != 0.3 and why your loss curves wobble.
🎯 By the end you'll understand
That your disk, RAM, and network carry nothing but bytes, and that "integer", "float", and "text" are contracts about how to read them. You'll be able to read two's-complement bits, dissect an IEEE 754 float (and explain the 0.30000000000000004 the Lesson 1.1 widget showed you), diagnose mojibake as a wrong-codec bug rather than data loss, and see why a CSV file is not a format until somebody writes the contract down. TraceLab's runs.csv gets its contract written today — wrongly, on purpose.
KEY INSIGHTData has no types — readers do
The disk stores bytes. The types live in an agreement between whoever writes and whoever reads — and most of that agreement is unwritten.
Three small mysteries have been stalking your research life. Your interpreter insists 0.1 + 0.2 == 0.3 is False. A loss curve that should be smooth develops a faint wobble — or flatlines entirely after a long run, as if training stopped caring. And one day a robot named Café-3 shows up in a teammate's spreadsheet as Café-3. These look like three unrelated gremlins. They are one phenomenon: somewhere, bytes were written under one contract and read under another — or the contract itself (IEEE 754) has fine print you never read.
Every value your programs touch is, physically, a sequence of bytes — and bytes are just numbers 0–255. A byte sequence means nothing on its own. Meaning comes from a contract: two's complement turns bytes into signed integers, IEEE 754 turns them into floats, UTF-8 turns them into text. Serialization formats — CSV, JSON, Parquet — are contracts about those contracts. Almost every "weird data bug" you will ever hit is two parties honoring different contracts while both believe they're honoring the same one.
CORE CONCEPTEverything is bytes
A bit is the only thing hardware can store: one of two states. A byte is eight of them — 2⁸ = 256 possible values, which is why you'll see bytes written as numbers 0–255 or, more usefully, as two hexadecimal digits (0x00–0xFF; one hex digit per 4-bit half, which is the entire reason programmers use hex). That's the complete inventory of the physical world: RAM is bytes, your SSD is bytes, an HTTP response is bytes, model.pt is bytes. There is no second kind of stuff.
Which means a question you've probably never asked is the most important question in this lesson: given these bytes, what do they mean? The honest answer is that the question is ill-posed. Watch what happens when we take four bytes — 43 61 66 c3 — and read them under three different contracts:
Café — that dangling 0xc3 is half of an é, and it will matter later.)This connects straight back to Lesson 1.2: every Python object you mapped on the heap is itself bytes — a PyObject header (refcount, type pointer) followed by a payload. A Python float is roughly 24 bytes of object wrapping, with exactly 8 bytes of IEEE 754 inside. The type pointer is how live Python remembers the contract. But the moment a value leaves the process — written to runs.csv, sent over a socket, pickled to disk — the type pointer stays behind. Only payload bytes travel. Whoever reads them must already know the contract, because the bytes will cheerfully accept any interpretation, as the figure shows.
So this lesson is really three contracts and then the meta-game: how integers are encoded (two's complement), how reals are approximated (IEEE 754), how text is encoded (UTF-8), and how files and wire formats declare — or fatally fail to declare — which of these apply where.
HOW IT WORKSIntegers: two's complement, the trick that makes hardware simple
Unsigned integers are the obvious encoding: each bit is a power of two, 10011100 = 128 + 16 + 8 + 4 = 156. The interesting question is negatives. The naive answer — spend one bit on sign, keep the rest as magnitude — is a mess in hardware: you get two zeros (+0 and −0) and addition needs special cases. Every modern CPU instead uses two's complement, and it's worth thirty seconds to see why it's beautiful rather than arbitrary.
The rule: in an n-bit signed integer, the top bit doesn't mean "negative sign" — it means −2ⁿ⁻¹. All other bits keep their positive weights. So in 8 bits, 10011100 = −128 + 16 + 8 + 4 = −100. Equivalently: to negate a number, flip every bit and add one. The payoff is that addition, subtraction, and multiplication become the same circuit for signed and unsigned values — the hardware just adds bits modulo 2ⁿ and lets the contract in your head decide what the result means. One adder, no special cases, one zero.
- Range is asymmetric: int8 spans −128…+127. There is one more negative number than positive, so
-(-128)overflows back to −128. (This exact asymmetry produces real CVEs in C code.) - −1 is all ones:
11111111= −128 + 127 = −1 — which is also unsigned 255. When you see 255 or 65535 or 4294967295 appear where a −1 belonged, you're watching a signed value being read under the unsigned contract. - Overflow wraps silently: 127 + 1 = −128 in int8. The hardware doesn't error; it computes mod 2⁸, as designed.
"But Python ints never overflow!" Correct — and now you know the price. A Python int is an arbitrary-precision heap object (28 bytes for the number 1, as Lesson 1.1 noted), grown digit-by-digit as needed. That's a luxury contract that only exists inside the interpreter. The moment you touch the ML stack, you're back on hardware contracts: np.int8, torch.uint8, and friends are real fixed-width two's-complement integers. np.int8(127) + np.int8(1) gives −128 (NumPy warns on scalar operations like this; whole-array arithmetic wraps without a peep). Quantizing a model to int8 means mapping your weights onto exactly these 256 bucket values — the entire field of quantization is negotiation with this lesson.
A joint encoder reports angle as a uint16 tick count, 0–65535, wrapping at the mechanical zero. Read it as int16 and positions past half a revolution come out negative; subtract two readings across the wrap point without modular arithmetic and your velocity estimate spikes to ±30,000 ticks per cycle. Firmware-to-driver integer contract mismatches like this are a steady source of "the robot twitched once and nobody knows why."
CORE CONCEPTFloats: IEEE 754, the contract your metrics live under
Real numbers are uncountably infinite; 64 bits give you at most 2⁶⁴ distinct values. A float is therefore necessarily an approximation scheme, and IEEE 754 (the 1985 standard that essentially all modern hardware implements) is a very specific one: binary scientific notation. A float64 spends its bits as 1 sign bit, 11 exponent bits, and 52 fraction bits, encoding
value = (-1)sign × 1.fraction₅₂bits × 2(exponent − 1023) # a number is representable IFF it can be written as (integer) × 2^(integer) # 0.5 = 1 × 2⁻¹ ✓ exact # 0.1 = 1/10 — denominator has a factor of 5 → binary digits repeat forever ✗
That last line is the autopsy Lesson 1.1 promised. In binary, 1/10 is 0.000110011001100110011… — repeating forever, exactly like 1/3 repeats in decimal. The 52-bit fraction has to chop it somewhere and round. What Python actually stores when you type 0.1 is:
>>> print(f"{0.1:.55f}") # the value ACTUALLY stored 0.1000000000000000055511151231257827021181583404541015625 >>> 0.1 # repr prints the SHORTEST string that round-trips 0.1 >>> 0.1 + 0.2 # two pre-rounded inputs, then the sum rounds AGAIN 0.30000000000000004 >>> (0.1 + 0.2) == 0.3 # 0.3 itself rounds DOWN; the sum landed one ULP above False >>> import math >>> math.isclose(0.1 + 0.2, 0.3) True
So 0.1 + 0.2 != 0.3 is not a bug, not "floating point being random," and not Python-specific (every IEEE 754 language gives the identical bits). It's three separate, perfectly deterministic roundings: 0.1 rounds up by ~5.5×10⁻¹⁸, 0.2 rounds up by twice that, their sum rounds again, and 0.3 — independently — rounds down. The two sides differ by exactly one ULP (unit in the last place): the gap between adjacent representable floats at that magnitude. The widget below lets you inspect all four bit patterns.
Now the part that quietly corrupts research metrics: floats are not evenly spaced. The same 52 fraction bits get stretched over every octave [2ᵏ, 2ᵏ⁺¹), so the gap between neighbors doubles each time the magnitude doubles. Near 1.0 a float64 ULP is ~2.2×10⁻¹⁶; near 2⁵³ it is 2 — at which point 9007199254740992 + 1 has no representation and rounds back to where it started. Integers stay exact only up to 2⁵³ (float64) or 2²⁴ = 16,777,216 (float32). Three direct consequences for your daily life:
# 1) ACCUMULATION — error compounds with every add >>> total = 0.0 >>> for _ in range(10): total += 0.1 >>> total 0.9999999999999999 >>> import math; math.fsum([0.1] * 10) # exact-rounded summation exists 1.0 # 2) ABSORPTION — a big sum stops seeing small terms (float32 here) >>> import numpy as np >>> np.float32(16_777_216.0) + np.float32(1.0) 16777216.0 # the +1 vanished — the gap here is 2 # 3) CATASTROPHIC CANCELLATION — subtracting near-equals erases real digits >>> (1e8 + 0.1) - 1e8 0.09999999403953552 # only ~8 of your 16 digits survived
Each of these has a famous ML face. Accumulation is why a mean computed by naive summation over millions of rows drifts, and why summing the same numbers in a different order gives different bits — float addition is not associative, which is also why GPU parallel reductions (whose thread scheduling varies run to run) can produce slightly different losses from identical seeds; that's a real component of "my loss curves wobble between supposedly identical runs." Absorption is the flatlined metric: accumulate per-batch losses into a float32 running sum for long enough and the sum outgrows the batches — every subsequent add rounds back, and your "average" quietly freezes. Cancellation is the classic naive variance formula E[x²] − E[x]² returning a tiny negative number for data with a large mean, and your pipeline crashing on sqrt — the reason textbooks teach Welford's online algorithm instead.
Never compare floats with == across computations (use math.isclose / np.allclose; equality of a value with itself, unchanged, is fine). Accumulate metrics in float64 even if the model runs bf16/float32 — this is exactly why optimizers keep float32 master weights in mixed-precision training. For high-stakes sums, math.fsum or Kahan summation; for running mean/variance, Welford. And know the two special values: inf (overflow, e.g. 1e309) and nan, which poisons everything it touches and is the only value where x != x — the standard quick NaN test.
SEE ITExplore the bytes yourself
Everything below is computed live from real bit patterns — no canned answers. Three lenses on the same physical reality. In the text lens, encode a value to UTF-8 bytes, then deliberately decode them with the wrong codec and watch mojibake appear (and repair). In the integer lens, slide through int8 and watch the two contracts (signed/unsigned) disagree about the same bits. In the float lens, dissect the actual IEEE 754 fields of 0.1 + 0.2 — then use the precision-gap explorer to watch a running sum stop absorbing your additions.
Things worth hunting for. In the float lens, compare 0.1 + 0.2 against 0.3 — same printed neighborhood, different final mantissa bits — and notice that 2⁵³ + 1 produces bit-for-bit identical storage to 2⁵³: the +1 never survived rounding. In the text lens, see how loss=0.31 is indestructible under every codec (pure ASCII is the safe intersection of nearly all encodings — which is exactly why encoding bugs hide until the first non-ASCII robot name). And note that Latin-1 never raises an error: it happily assigns a character to every byte, so the failure is silent. The exception you'd prefer never comes.
HOW IT WORKSText vs bytes: UTF-8 and the anatomy of mojibake
Here's the mental separation that Python 3 enforces in its type system: a str is a sequence of code points — abstract integers that Unicode assigns to characters (é is U+00E9, θ is U+03B8, the em dash is U+2014). Code points are platonic; they have no bytes. To store or transmit text you must encode it — apply a contract mapping code points to bytes — and the reader must decode with the same contract. str.encode() and bytes.decode() are that boundary, and the whole game of text handling is knowing which side of it you're standing on.
UTF-8 won the encoding wars (it's the declared encoding of the overwhelming majority of the web — north of 95% by W3Techs' running survey) because its design is genuinely clever:
U+0000–U+007F 0xxxxxxx # 1 byte — ASCII, unchanged U+0080–U+07FF 110xxxxx 10xxxxxx # 2 bytes — é, θ, ñ, ü… U+0800–U+FFFF 1110xxxx 10xxxxxx 10xxxxxx # 3 bytes — —, ✓, 中, क… U+10000–U+10FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx # 4 bytes — emoji, 𝕏… # leading byte declares the sequence length; continuation bytes always start 10, # so a reader dropped mid-stream can resynchronize at the next character.
Every ASCII file is already valid UTF-8 — that backward compatibility is why adoption was even possible, and also why bugs lie dormant: a pipeline tested only on English logs has literally never exercised its encoding path. And because UTF-8 is a byte stream (no multi-byte code units), it has no endianness problem — one less clause for the contract.
Now the failure mode, precisely. Mojibake is decoding with the wrong codec. The bytes are intact; the reader applied the wrong contract:
>>> row = "2026-06-12 09:14,Café-3,loss=0.31" >>> data = row.encode("utf-8") # é → two bytes: c3 a9 >>> data.decode("cp1252") # a Windows laptop's locale default reads it… '2026-06-12 09:14,Café-3,loss=0.31' # …one byte per char: c3→Ã, a9→© >>> data.decode("utf-8") # the bytes were never damaged '2026-06-12 09:14,Café-3,loss=0.31'
Three diagnostic rules fall out. First, mojibake is repairable — re-read the original bytes with the right codec — unless someone saves the garbled text, re-encoding the junk characters and destroying the original bytes (the dreaded double-encoding). Second, the reverse direction is louder: bytes written by a legacy cp1252 producer (é = single byte e9) make a UTF-8 reader raise UnicodeDecodeError, because e9 announces a 3-byte sequence that never arrives. An exception beats silent garbage — Latin-1's "never fails, always lies" behavior is the worse outcome. Third, count carefully: len("Café") is 4 but its UTF-8 encoding is 5 bytes. Truncate byte buffers at fixed lengths (or compute HTTP Content-Length from character counts) and you'll shear a multi-byte character in half, producing invalid UTF-8 at the cut.
open("runs.csv") without an encoding= argument uses your locale's default — UTF-8 on macOS and modern Linux, but often cp1252 on Windows in Western locales. The same script, the same file, different results per machine. PEP 686 schedules UTF-8 as the universal default for Python 3.15; until your whole fleet runs that, the rule is mechanical: every open() of a text file names its encoding. Explicit contract, no locale roulette.
COMPARISONSerialization formats are contracts — most of them unwritten
Everything so far concerned single values. Real systems ship structured data — rows, dicts, tensors — and a serialization format is the contract for flattening structure into bytes and back. Judge any format by the clauses it actually pins down: text encoding, field separation and escaping, types, number fidelity, byte order, and what happens when the schema evolves. By that standard:
| Format | Contract written down? | Types | Floats round-trip? | The classic failure |
|---|---|---|---|---|
| CSV | RFC 4180 exists; almost nobody fully follows it | none — everything is text | only if the writer prints full precision (Python's repr does; f"{x:.4f}" doesn't) | unquoted commas, unstated encoding, Excel "helpfully" re-typing your data |
| JSON | RFC 8259, genuinely followed | 6 types; numbers are decimal text | yes via shortest-repr — but NaN/Infinity are illegal, and Python's json.dumps emits them anyway by default | JavaScript readers store every number as float64 → integer IDs above 2⁵³ silently corrupt (why Twitter's API ships both id and id_str) |
| pickle | Python-internal, version-coupled | arbitrary Python objects | exact — ships the bits | unpickling runs arbitrary code: never load pickles you didn't create; the docs themselves warn you |
NumPy .npy / Parquet / protobuf | yes — schema, dtype, and byte order recorded in the file | real typed columns/fields | exact — ships the bits | opaque to humans and grep; you need the library and the schema |
The deep split in that table: text formats serialize numbers through decimal; binary formats ship the bits. Decimal round-trips are safe only because modern languages print shortest-round-trip representations (Python has since 3.1) — the moment a human "cleans up" the output with %.4f, 40+ bits of mantissa are gone forever and no reader can recover them.
Binary formats buy exactness but inherit a clause text never needed: endianness. A multi-byte number must be laid out somehow — least-significant byte first (little-endian: x86 and, in practice, virtually all ARM deployments) or most-significant first (big-endian, also called network byte order, used by TCP/IP headers). Get it wrong and the bytes of 1 read back as 16,777,216:
>>> import struct >>> struct.pack("<I", 1) # little-endian uint32: low byte first b'\x01\x00\x00\x00' >>> struct.pack(">I", 1) # big-endian ("network byte order") b'\x00\x00\x00\x01' >>> struct.unpack("<I", struct.pack(">I", 1))[0] # read under the wrong contract 16777216
This is why well-designed binary formats record byte order in their headers — a NumPy .npy file's dtype string ('<f8': little-endian float64) is the contract made explicit, which is precisely what lets your robot's ARM board and your x86 workstation share telemetry dumps safely. Your robot firmware speaking raw structs over a socket has no such header; its contract lives in a C header file and a prayer. The lesson generalizes: a format is exactly as trustworthy as its written-down clauses. Which brings us to the format we're about to inflict on ourselves.
TRACELABSpec'ing runs.csv — wrongly, on purpose
TraceLab v0 (the 21-line script from Lesson 1.1) writes runs.csv, and until today its format existed only as an accident of the code. Time to commit the cardinal act of engineering: write the contract down. We're going to ratify the format v0 actually implements — which means ratifying its bugs. This is deliberate. You now have the byte-level knowledge to see every landmine in advance, and in Lesson 1.9 you'll build v0 against this exact spec so that each clause can fail on schedule and teach its lesson.
# TRACELAB-SPEC-001 — the runs.csv on-disk format (v0) # STATUS: "it works on my machine" — every clause below is load-bearing AND wrong 1. A run is one line, terminated by "\n". 2. Fields are separated by ",". Values MUST NOT contain commas. (Enforcement mechanism: hope.) 3. Field 1 is the local wall-clock time, "YYYY-MM-DD HH:MM". No timezone. 4. Remaining fields are "key=value" strings. A value is whatever string the producer happened to print. Floats: any decimal rendering is fine — "0.31", "0.3100", "3.1e-1" are all "the same number" (they are not). 5. Text encoding: unspecified. The file is opened without encoding=, so each machine applies its locale default. On the lab Linux box that's UTF-8. Probably. 6. Numbers are not numbers. They are strings. Consumers parse however they like.
Now read it back with this lesson's eyes. Every clause maps to a byte-level failure you can predict today:
| Clause | The byte-level failure, on schedule | The one-line fix v0 refuses (for now) |
|---|---|---|
| 5 — encoding unspecified | Café-3 leaves Linux as …43 61 66 c3 a9 2d 33…; a Windows reader's cp1252 locale renders Café-3. The reverse trip — cp1252 writer, UTF-8 reader — dies with UnicodeDecodeError mid-experiment. | open(…, encoding="utf-8"), on both sides |
| 4 — floats are "whatever printed" | a producer logging f"{loss:.4f}" discards 40+ mantissa bits irreversibly; "0.31" == "0.3100" is False as strings, so dedup and run-comparison silently break | write repr(loss); compare with math.isclose |
| 6 — numbers are strings | summing the loss column replays accumulation error in whatever order the reader scans — two "identical" aggregations disagree in the last digits | math.fsum / Welford for aggregates |
| 2 — commas forbidden by hope | the day someone logs gripper=arm,left, every later field shifts one column over — and nothing errors | the stdlib csv module's RFC 4180 quoting |
| 3 — local wall-clock, no timezone | runs logged around a DST change un-orderable; two labs' timestamps incomparable | UTC, ISO-8601 — revisited properly in Stage 3 |
Notice what changed today, even though the code didn't: these are no longer surprises waiting to happen. They are documented debts with named fixes — which is most of the distance between a script and engineering. The debts stay in, per the Stage 1 plan: their pain is the syllabus. When the mojibake incident actually fires, you'll diagnose it from the bytes in minutes, not days.
WEAKNESSWhere this bites
Two mathematically equal computations rarely produce equal bits: 0.1 + 0.2 != 0.3, a sum forward != the same sum backward, the same reduction on GPU != CPU. Code that dedups runs by exact loss value, uses floats as dict keys, or gates on metric == best works in the demo and fails probabilistically in production. Use math.isclose / np.allclose with explicit tolerances — and treat "needs a tolerance" as a design smell telling you to compare something more stable (a step count, a checksum of inputs) instead.
The classic shape: developed on Linux (UTF-8 locale), deployed to a collaborator on Windows (cp1252 locale) — same script, same bytes, different decoded text, zero exceptions. It hides for months because ASCII-only data is immune; the first é in a robot name detonates it. Worse, a helpful colleague "fixes" the garbled file by saving it, re-encoding the mojibake and destroying the original bytes. The discipline is one mechanical rule, and CI can grep for violations: no bare open() on text, ever.
Python's json.dumps(float("nan")) happily emits NaN — which RFC 8259 forbids, so a strict JavaScript or Go reader rejects the whole document; your one diverged run breaks the dashboard for everyone (pass allow_nan=False to fail at write time instead). Excel's eager type inference renamed so much biology that the field surrendered: gene symbols like SEPT1 were being silently read as dates in supplementary CSVs (documented at scale by Ziemann et al., 2016, Genome Biology), and in 2020 the HGNC renamed dozens of genes — SEPT1 → SEPTIN1 — partly to escape it. When the contract is implicit, the most aggressive reader in your pipeline rewrites your data.
KEY INSIGHTHow this connects
- Memory (1.2) — the heap objects you mapped there are these bytes plus a live type pointer. Serialization is what happens when the payload leaves home and the type pointer can't come along — the contract has to travel out-of-band.
- Big-O as a budget (1.6) — now that "data" means a countable number of bytes, we can start costing operations honestly: scans, copies, lookups — and TraceLab's full-file
find_runfinally gets billed. - TraceLab v0 (1.9) — you'll write v0 against TRACELAB-SPEC-001, defects ratified and documented, and catalog its sins as the formal debt ledger for the rest of the course.
The deeper habit this lesson installs: when data looks wrong, ask "what are the actual bytes, and what contract did each party apply?" before blaming tools. Mojibake, wobbling metrics, shifted CSV columns, corrupted IDs in JSON — every one of them yields to that single question in minutes.
GLOSSARYKey terms introduced
- Two's complement
- The signed-integer encoding where the top bit carries weight −2ⁿ⁻¹; makes signed and unsigned arithmetic the same mod-2ⁿ hardware, with silent wraparound on overflow.
- IEEE 754
- The 1985 floating-point standard nearly all hardware implements: sign, exponent, fraction encoding binary scientific notation, plus inf and NaN.
- Significand (mantissa)
- The fraction part of a float — 52 bits in float64 with an implicit leading 1 — which sets how many significant digits survive.
- ULP (unit in the last place)
- The gap between a float and its nearest representable neighbor; doubles with every power of two of magnitude, which is why big sums absorb small additions.
- Code point
- The abstract integer Unicode assigns a character (é = U+00E9). Code points have no bytes until an encoding is applied.
- UTF-8
- The dominant variable-length Unicode encoding: ASCII-compatible 1-byte codes, 2–4 byte sequences elsewhere, self-synchronizing continuation bytes, no endianness.
- Mojibake
- Garbled text produced by decoding bytes with the wrong codec. The bytes are intact and the damage reversible — until someone re-saves the garbage.
- Endianness
- The byte order of multi-byte numbers: little-endian (low byte first; x86, ARM in practice) vs big-endian (network byte order). A clause every binary format must declare.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1Why exactly is 0.1 + 0.2 == 0.3 False — and what should you write instead?›
1/10 and its relatives are infinitely repeating fractions in binary, so 0.1, 0.2, and 0.3 are each rounded to the nearest float64 at parse time. Adding the first two rounds a third time, landing one ULP above the value 0.3 rounded to (0.3 rounds down). Deterministic, identical in every IEEE 754 language. Compare computed floats with math.isclose/np.allclose — or restructure to avoid comparing floats at all.
2A colleague opens runs.csv on Windows and sees Café-3. What happened mechanically — and is the data lost?›
The file was written as UTF-8, where é is two bytes (c3 a9); their reader decoded with the locale default cp1252, which maps each byte to its own character: Ã + ©. Nothing is lost — the bytes are intact, and re-decoding as UTF-8 repairs it perfectly. It becomes permanent only if someone saves the garbled text, re-encoding the junk. Root cause: TRACELAB-SPEC-001 clause 5 — no declared encoding. Fix: encoding="utf-8" on both sides.
3After days of training, your float32 running-average loss flatlines while everything else says learning continues. What's the mechanism, and name two fixes.›
Absorption. Float spacing doubles each power of two; once the running sum grows large, the float32 gap exceeds twice each per-batch loss, so every add rounds back to the unchanged sum — at 16,777,216, even +1.0 vanishes. Fixes: accumulate in float64 (gap is 2²⁹ times finer at any magnitude); use compensated summation (math.fsum, Kahan) or a streaming mean (Welford); or log per-step values and aggregate offline. Same family of fixes as mixed-precision training's float32 master weights.
4Why is "it's a CSV file" not actually a format specification?›
Because the clauses that make bytes meaningful are all still open: text encoding? quoting/escaping of separators and newlines inside values? header row? types — is 001 a string or the number 1? how were floats rendered — full repr or truncated %.4f? RFC 4180 answers some of this but is honored sporadically (Excel famously applies its own type inference). A format is only the clauses both writer and reader actually honor — for binary formats add byte order, which is why .npy records its dtype as e.g. '<f8'.