← Binary Course — Part E, lesson 4 of 4 (Reading real machine words)

21. Where to Go Next

The concept

Twenty lessons back, Lesson 1 asked why a computer counts in binary at all rather than decimal. Every lesson since has built on that answer, one layer at a time: place value in an unfamiliar base (Part A), operations that touch bits without any notion of carrying (Part B), the scheme a machine actually uses to represent a negative number (Part C), and where the point sits in a fraction that no stored word ever marks for you (Part D). Part E's four lessons pulled all of that into one final idea — a stored word never announces its own meaning; every reading always comes from something outside the bits — and then put that idea to work on a real 32-bit word from a real 1956 machine.

That idea is the actual destination this whole course was headed toward, not just Part E's own topic. Every earlier lesson was really teaching one piece of "what a convention can decide a word means"; Lesson 18 just finally said so out loud, and Lessons 19-20 proved it on real and constructed cases. None of that fluency was built for its own sake — it exists to be spent reading actual machine words, on actual old hardware, the moment a specific machine's own quirks are in front of you.

This lesson closes the course by being honest about two things: what's still missing before that reading can happen on a specific real machine, and where to go get it.

Example 1 — What fluency now looks like

Handed a real 32-bit word and told its machine's format and scale factor, decoding it is no longer a multi-lesson project — it's one short pass: check the sign bit, read the magnitude as a fraction, apply the stated scale, and if the sign says negative, remember that "sign-magnitude-looking" doesn't necessarily mean sign-magnitude behaving — check what the actual negation rule is before trusting a value.

0011 0000 0000 0000 0000 0000 0000 0000, at q = 4
-> sign 0, magnitude 0.375, value 0.375 x 2^4 = 6

That's Lesson 19's own example, worked in one line instead of a full lesson's worth of steps — not because the reasoning got shorter, but because it's no longer new reasoning.

Example 2 — What's deliberately still missing

This course never taught what a word means when it's read as an instruction rather than a number — which bits are the operation, which are an address, how a machine decides which of the two a given word even is. It never touched a specific machine's own address notation, its particular quirks (a non-standard hex alphabet used only for raw word contents on one real machine, for instance, deliberately left out of this course as too specific to be general fluency), or how to actually write and run a program. Those weren't oversights — Part E's own worked example already showed real machines can diverge from this course's clean categories in a specific, documented way, and a whole course's worth of a specific machine's specific divergences is exactly the kind of content this course chose to stay one level above.

Example 3 — Where that missing piece actually exists

For one of the machines this course used as a running example, that missing piece is already written: a companion course exists that picks up exactly where this one stops, teaching the LGP-30's own instruction set, its real address notation, and its own particular quirks — including the parts Example 2 just named as out of scope here. Reading that course no longer means learning binary, hex, two's complement, or fixed-point scale alongside it; that prerequisite is done. Other drum machines from the same era — the IBM 650, the Bendix G-15, the RPC-4000 — share enough of that same flavor (rotating memory, an explicit concern with instruction timing, the same fixed-point-not-floating-point arithmetic Part D covered) that they're natural candidates for companion courses of their own one day. None of those exist yet, and this course doesn't pretend otherwise — but whenever one does, it'll be able to start exactly where this one just ended, the same way the LGP-30 course already can.

Exercises

Exercise 1. In your own words: what's the one idea that Parts A through D were each, in their own way, quietly building toward, and that Part E finally named directly?

Exercise 2. A friend, hearing you've finished this course, asks if they can now sit down and read any LGP-30 program by eye. What do you tell them they'd still need, and why doesn't finishing this course already cover it?

Exercise 3. Why might a future course on the IBM 650 or the Bendix G-15 be able to skip re-teaching place value, two's complement, and fixed-point scale from scratch?

Show Answer Key

1. That a stored word never carries its own meaning — no bit pattern announces on its own whether it's unsigned, which of the three signed schemes applies, what scale a fraction is at, or even which bits count toward the value at all (Lesson 19's spacer bit). Every one of those readings comes from something outside the bits: a stated convention, or whichever operation reads the word. Parts A-D each demonstrated one piece of this without naming it (Lesson 9's sign convention "lives outside the bits," Lesson 14's same-six-bits trap, Lesson 16's scale as bookkeeping); Part E made it the lesson's actual subject.

2. They'd still need the machine's own instruction set — which bits mean which operation, how an address is written and read, and that particular machine's own quirks (this course flagged, without teaching, that at least one real machine uses a non-standard hex alphabet just for raw word contents). This course teaches how to read any stored word once you're told what convention applies to it; it deliberately never taught what any specific machine's own instructions, opcodes, or addressing notation actually are. That's a different, narrower kind of knowledge — machine-specific rather than general — and it's exactly what a course built around one specific machine covers next.

3. Because none of that is actually specific to the IBM 650 or the Bendix G-15 — it's the same general numeracy this course just spent 21 lessons on, and both machines would use some version of it (a base to count in, some scheme for negative numbers, some way to track a fraction's scale) without needing their own dedicated explanation of why two's complement works or how to convert a decimal fraction to binary. A machine-specific course can start straight from "here's how this particular machine's own bits are laid out," exactly the way Lesson 19 didn't have to re-derive two's complement before using it on the LGP-30 — it just applied it.

This is the last lesson. Binary place value, hex as its compact shorthand, bitwise logic and packed fields, three ways to represent a negative number and why one of them won, tracking a binary point by hand, and the discipline of asking what a word means before trusting any answer it gives — that's the whole course, and it's now reusable anywhere a raw word needs reading.