Why computers can't read

1

Concept

Computers store and transform numbers. A text file is ultimately bytes, and a screen draws shapes according to agreed encodings and fonts. None of those layers supplies a human reader’s concepts, intentions, or background knowledge. Saying that a computer “reads” is convenient shorthand for a pipeline that preserves symbols, chooses units, and computes learned relationships among them.

The first boundary is encoding. Unicode assigns code points to a vast repertoire of text elements; UTF-8 defines how those code points are represented as one or more bytes. A byte value alone is ambiguous without an encoding. Even visible characters are not always single units: an accented glyph can be represented as a precomposed code point or as a base letter followed by a combining mark. Emoji may combine several code points into one displayed grapheme.

Normalization can make canonically equivalent representations consistent, but applying it is a policy choice. Source code, passwords, identifiers, and natural language can require different treatment. Whitespace also carries information: spaces, line breaks, tabs, and nonbreaking spaces may look similar while producing different byte sequences. Before modelling begins, the system must decide which distinctions to preserve.

The next boundary is tokenization. A tokenizer maps text to discrete vocabulary entries and integer IDs. Those integers are labels, not quantities: token 900 is not semantically “larger” than token 12. A tokenizer may use characters, words, subwords, or bytes as fallback units. Its segmentation decides sequence length and which surface patterns the model can reuse directly.

An embedding table then maps each ID to a learned vector. Initially those vectors contain no dictionary definitions. Training changes them and later network weights so that representations become useful for prediction. The same initial token embedding can participate in different contextual states. “Bat” in a cave and “bat” in baseball begins at one vocabulary row, then surrounding tokens change its representation through the network.

Syntax and semantics are therefore not delivered by Unicode or the tokenizer. They emerge imperfectly from patterns in training data, architectural biases, and objectives. A model can learn that a closing quote often follows an opening quote, that subjects constrain verbs, or that certain names co-occur with professions. Those regularities can support useful behavior without forming an explicit symbolic grammar or a verified knowledge base.

This layered view explains several failures. Corrupted bytes can break decoding before the model sees text. Visually confusable Unicode can hide a changed identifier. An inefficient tokenizer can fragment one language into many positions. Rare spellings may receive weak learned representations. A fluent model can still attach the wrong real-world referent because its objective rewards probable continuation rather than grounded verification.

So computers can process text with extraordinary sophistication, but each layer has a precise contract. Bytes preserve data. Encodings map bytes to textual symbols. Tokenizers map text to IDs. Embeddings and neural layers learn numerical representations. Decoding maps scores back to tokens, and an encoding renders them. Keeping these boundaries separate prevents the vague word “reading” from hiding where information enters, changes, or is lost.