Appendix IX - Change Log

The course changes. Sections get added, explanations get rewritten, and occasionally something here turns out to be wrong and gets fixed.

This is the record of that, newest first. It is worth a look if you worked through a section a while ago and want to know whether it still says what it said, or if you are returning after a break and would rather not re-read everything to find out what moved.

Nothing in the main course depends on this appendix. If you are reading the course for the first time, you can skip it entirely.

Most of what appears here started with somebody getting in touch. If you have spotted a mistake, or something in the course did not make sense, S1 explains where to send it.

27 September 2026

• New: a companion course. The Devpac80 Companion builds four of this course's programs again on the Einstein itself, with HiSoft's Devpac80. S33 now points to it.

26 September 2026

• New: Appendix XII, writing your programs on the Einstein with Zen. An optional alternative to VS Code: building the course's programs on the Einstein itself with Zen, the 1984 editor-assembler, and what to change in course source so that Zen accepts it.
• The keyboard, put right (S8, S25, Appendices V and X). The Einstein has two grey cursor keys, not four arrow keys: a horizontal one (right, or left with SHIFT) and a vertical one (down, or up with SHIFT). The three keys marked with a single arrow are the [, ] and ^ character keys, and those are what MAME puts on your Left, Right and Up arrows; its Tab and Down arrow are the cursor keys. Appendix V now says which matrix key is which, and exercise 8.3's answer names the keys properly.

25 September 2026

• S13's "Tables of rows" has been rewritten at length. The idea is unchanged: a table with rows is one run of bytes, the element at a row and column is at (row x width) + column from the start, and a power-of-two row width lets ADD HL,HL stand in for the multiply the Z80 does not have. The old version said all that in a page; the new one walks through a six by eight table one step at a time, finding the row, then the column, then the real address, and shows why a five-value row is usually stored eight bytes wide. Exercises 13.4 and 13.5 are unchanged.

23 September 2026

• S11 no longer says its print routine is one you will use for the rest of the course. It is not: from S17 your program owns the screen, and RST 8 / DEFB 158 cannot write readable text on it - S17 has always said so, and S11 promised the opposite. What the section teaches is unchanged and still holds; the loop you write there is the one S31 uses to put text on a screen of your own, with the two printing lines swapped for a write to the name table. Only the claims about later sections have been corrected.

16 September 2026

• S3, S5, S6 and S7 now say which register values you should expect to match. The register lines shown were taken from a freshly started machine, and the registers a program never sets hold whatever was left behind, so yours can differ - especially if you have run other programs first. That is fine; only the values the program sets need to match, and each section now says which those are.

15 September 2026

• Three new sections, S31 to S33, take the course past its first game. S31. A Game You Can Lose gives Rockfall a title screen, three lives and a game over, run as a state machine dispatched through a table - which is S14's table of routines finally doing the job it was taught for, reached with a CALL so the state's own RET comes back. S32. Three Events, Three Noises wires the sound chip into the game: S27 explained the chip and nothing had used it since, and the finished game was silent. It also documents a trap that could not come up before, because it needs sound and keyboard in the same program - the mixer and the keyboard matrix share register 7, and a mixer byte that does not preserve its top two bits makes the controls go deaf for exactly as long as each sound lasts. S33. Where You Go From Here closes the course: what you can now do, what was deliberately left out and where to find it, and the point that this machine is under-documented enough that there is still room to be first at something.
• The appendices have moved from 31-41 to 34-44 to make room. Nothing in them changed and every link still works; only their position in the running order is different.
• Every section and appendix title is now in Title Case - "Changing What Happens Next" where it read "Changing what happens next". The titles are the only thing that changed; the headings inside each page are untouched, and so is every word of the material. Cross-references were updated to match, so the name a section gives itself and the name the previous section calls it by are still the same string.
• S4's first Change one thing edit asked a question the reader had no way to answer. Deleting the jump makes the program run its own data byte as an instruction, and the register it quietly damages is E - but working out which instruction means knowing that 93 encodes LD E,L, and the course has no opcode table anywhere to look that up in. The edit now gives that part away, since it was never discoverable, and asks the question that is: the program printed the right answer while corrupting a register, so what would ever have told you? The point it is making - that nothing marks a byte as data, and the same 93 is a character or an instruction depending only on how the processor arrives at it - is now stated rather than implied. It names no register values, because they are not reproducible: the machine hands your program whatever the last one left behind, so the exact contents of DE depend on what you ran before it. That DE changes is the point, and that is what the edit now says.
• S4 and S5 both printed an assembler listing that the assembler does not produce. Each showed a jump with its target left blank - c3 00 00 in S4, 18 00 in S5 - and explained that the address was not yet known when the line was printed, with the correction appearing after the end of the file. That is not what z80asm does. It reads the whole source before it prints anything, so both listings show their targets already filled in, as c3 04 01 and 18 01, and the loose bytes after the end of the file were never there at all. Both sections now print the listing exactly as the assembler writes it - including the header, footer, ORG line and blank-line rows that were previously described as trimmed away - and both explanations have been rewritten around what it really says. S4's point about little-endian byte order is unchanged, and is now made from the bytes the assembler actually prints.

12 September 2026

• S27 has one Change one thing edit fixed. It asked you to compare a new note against "S25's 625 Hz example", and there is no such example - not in S25, not anywhere in the course. 625 Hz is in fact the answer to the question: the section's own formula turns a period of 200 into exactly that. The edit now asks you to work out both frequencies from the formula and then say which way the note moved.
• S24 has a number corrected in its program and one claim withdrawn. The asteroid was placed at X = 156, four pixels from where the rest of the section assumes it is: the Change one thing edit asks you to park the rocket at 152 and then 153 and says one of them will light up, and with the asteroid at 156 they both do. It is now at 160, which puts the boundary exactly between those two positions - one press of D apart - and matches the worked example a few paragraphs earlier about a last column of 159 meeting a first column of 160. The section also said that painting the backdrop only on a hit would stain the screen permanently; on the machine the colour goes as soon as you back away, so that sentence has gone. What replaces it is the part that holds: a program that only ever writes on a hit never says "no collision", so what the screen shows the rest of the time is out of its hands. The edit now asks you to watch what happens rather than telling you in advance.
• S23 has one Change one thing edit reworded. It asked you to fly upward and fire while moving, which this program cannot do: the key call reports one key at a time, as S21 says, so holding one key and pressing another gets you one of the two. It now asks you to fire and then hold the key, which produces the same effect - a bullet that leaves at the ship's own speed and never gets off its nose. Its trouble table also said that a stack leak kills the machine "minutes later"; that is now seconds, to match the correction in S21.
• S21 has one edit reworded, one explanation corrected, and two claims about timing put right. The section explains the down clamp of 175 by saying the rocket would otherwise lose its flame to the sprite-list terminator at 208 - but the flame slides off the bottom of the screen seventeen pixels above that height, and by the time 208 is reached the whole rocket is off screen anyway. The clamp is exactly right and its real reason is the screen's last line, which the section also gives; the 208 is a second hazard further down, and the Change one thing edit now asks you to add a third sprite so that there is something left for it to switch off. And the section twice said that a routine leaving by JP instead of RET leaks stack until the program dies "minutes" later. It dies within seconds - the unmodified loop runs happily for a minute, the leaking one is gone in under three. The part of that warning worth keeping is unchanged: the damage arrives hundreds of loop passes after the instruction responsible, which is what makes it hard to find.
• S19 has two Change one thing edits fixed. The one that sets the early clock bit gave an X of 16, which shifts the sprite thirty-two pixels left and puts all eight of its pixels off the edge of the screen - so the question about what happens to its left half had nothing to look at. It now says 28, which leaves the right half against the left edge, and asks for 16 afterwards as the thing to explain. And the edit that makes a sprite transparent asked whether it is still being processed, which you could only answer by remembering a sentence from earlier on the page; it now tells you how to find out, by putting five sprites on one line with the transparent one first and counting how many of the rest you can see. The answer is three.
• S18 has one edit reworded, two exercises rewritten, and a claim about its own palette withdrawn. The Change one thing edit that changes a spot's ground from transparent to black asked what appears around each spot, and nothing does: on a black backdrop, black ink and transparency look exactly alike. The edit now says so, explains why, and asks you to change the backdrop and watch the spots refuse to follow - which is the difference made visible, and a better lesson than the question was reaching for. Exercise 18.3 told you that eight of the sixteen colours had only ever been seen in documentation and asked you to correct the table where it was wrong; all sixteen are right, so it now asks you to check the table and to work out which one of the sixteen is not really a colour at all, which has a definite answer. The sentence above the palette marking eight of the colours as less certain has gone with it, and so has the claim that the missing corners are nearly the same blue as the screen behind them: they are exactly the same blue, which is a sharper version of the same lesson. And exercise 18.5 no longer says that nobody has tried it.
• S17 has three edits reworded and one explanation corrected. Two of the Change one thing edits - the one that drops the third bank load and the one that shortens the copy to eight bytes - produce a blank screen rather than a broken one, and neither said so, which makes a correct result look like a typo. Both now tell you what you will see and ask why that is the answer. The paragraph on losing the ROM's text output said a printed character corrupts the patterns that forty cells share; on the screen the section builds it is more than two hundred, and printing one character changes every cell in that third of the screen showing the same tile, which is a better illustration than the original. And the note on reading video memory no longer explains the timing of the video chip - it just tells you to keep the loop around the read, and what to put back first if a read misbehaves.
• S16 has three Change one thing edits and two exercises fixed. The edit that changes a colour byte to 94h asked you to describe what you see, and what you see is nothing whatever: colour 4 is the same dark blue as the screen behind your shape, so the change is invisible. It now says so and makes working out why the exercise, with a second colour to try afterwards. The edit that points a cell at pattern 35 asked where the diamond moves to, when in fact it disappears - it now asks what took its place, and adds a second step that puts a copy of a letter from the boot screen there instead. The edit that writes to row 9 now warns you about the gap that appears in the text, which is more noticeable than the missing diamond. Exercise 16.5 asked you to print a pattern byte as eight characters, which needs a way to test one bit and the course does not reach one for another six sections; it now points out that CP 128 and ADD A,A between them do the job with what you already have, and warns that the cell holds a sliver of the character next door. And 16.6 no longer states that the video chip needs a pause before a read is ready - it tells you what to do if a read comes back wrong instead.
• S14 has three Change one thing edits reworded, all for the same reason: each told you what sort of answer to expect and the machine gives a different sort. The edit that indexes past the end of the table asked what gets printed, when in practice nothing is - it now says so and points you at HL instead. The edit that deletes the doubling asked which message prints, when none does: you get a screenful of solid blocks and the program never comes back, which the edit now warns you about so you have Restart ready. And the edit that reorders the table asked you to swap all three lines, which leaves the middle entry in the middle and changes nothing at all - it now asks for the first two, and then for the reversal as a second step with the non-change as the thing to explain. The section also gains a note about the baffling error the assembler gives if you try to load HL through a register pair.
• S13 has one illustration corrected. The diagram showing five array bytes laid out in memory gave them specific addresses, and no program in the section actually puts them there. It now says the address is only an example and tells you to assemble your own listing to find where yours landed.
• S12 has two edits made clearer. The exercise that asks you to find how much stack you have now tells you to look at the whole screen rather than only at whether your own program came back, because there is more than one way for a deep stack to go wrong and the first one you meet leaves your program working perfectly. And the Change one thing edit that leaks twenty pushes now asks you to be clear about whether you are predicting that the machine survives or that the program does, since the answers differ.
• S11 has two fixes, both of them questions that told you the wrong answer. One Change one thing edit said that converting the print routine to use BC as its pointer would stop one line assembling; it does not, and the converted routine works perfectly. The edit now asks you to notice that, and then to try bringing the character into B, which is the line that really is refused. And exercise 11.3 asked why the second of two loads gets something different from the first, when at the address it gives you both bytes read the same. It now asks you to run it twice, once there and once on your own text, and explain why only one of the two pairs differs.
• S10 has one Change one thing edit fixed. It asked you to break a coordinate by writing only one of its two bytes, and then explain the difference - but with the numbers it gave you the broken line lands exactly on top of the correct one and there is nothing to see. It now tells you to move one coordinate first, which is the same warning exercise 10.5 was already giving four paragraphs later.
• S9 has two Change one thing edits reworded. One asked whether two characters printed before the read turn up in the echo, and then told you they do not - they do, if you print them where the instruction said. It now asks you to try both positions and work out which is which. The other, which stops reading at the first space, now tells you the screen will look exactly the same and points you at HL for the difference, because otherwise the edit looks like it did nothing at all.
• S8 has two exercises clarified. The one that prints a key's code as a number needs a way to ask whether a value is ten or more, which the section had not given you and now admits you will have to look up. And the pair of loops that prove a call can destroy your counter now warns you that the second of the two never stops, so you know to have Restart ready rather than sitting there counting. It also points out that one of the four arrow keys does something you will not expect.
• Four sections pointed you at the wrong thing next. S3, S5, S8 and S16 each ended by naming the following section under a title it does not have, and in S3's case describing material that section does not cover. All four now name the section you will actually get. Nothing in the sections themselves changed.
• Two paragraphs were broken on the website. In S6, the Change one thing edit that starts from 255 had lost the number entirely and been split in two. In S16, the opening paragraph had a stray bullet point hanging off the end of it. Both were faults in how the pages were built rather than in what they said, and both now read as they were written.
• S7 has three fixes. Its closing paragraph announced the next section as "Keeping things in memory", which is not what S8 is about; it now points at Reading the keyboard, which is what actually follows. One Change one thing edit asked which letter prints after a condition is swapped, when in fact neither does, and now says so. And the box exercise asked for two straight pieces where four are needed, one for each side, and did not warn that some codes in the graphics range print nothing at all.
• Appendix I now says three useful things about the graphics range above 127: that some codes print nothing, that the straight pieces sit at the edges of the character square rather than through the middle, and that code 160 is a solid block.
• S6 now warns you, in the Change one thing edit that swaps the two DECs, not to expect letters and not to be alarmed by an empty screen.
• S5 has a correction. In the register line printed for the deliberately broken absolute jump, A read 41; it is 4A, the code for the J the program had just printed. Everything else in that display was right. The assembler listing is also now described as a trimmed extract, as S4's is, and the exercise that measures how far a relative jump reaches now tells you to read the distance from the error message rather than counting your own reserved bytes.
• S4 has two fixes. The assembler listing it prints is now described as the trimmed extract it always was, so the extra header and footer lines you get from running z80asm -l yourself no longer look like a mistake. And the last Change one thing edit has been reworded: it asked what happens when you move a label, but answering why needed a fact about the print call that the course does not reach until S6.
• Appendix X - Worked Solutions added, and now complete. It gives a complete, tested program for every exercise the course sets - S3 to S28, eighty-eight of them, every one assembled and run before it was written down. One answer, 28.2's, records a failure rather than a success: the program is right and the machine does not do what the exercise expects, which is being looked into. It is long enough to come in two parts: Appendix X holds S3 to S16, and Appendix X (continued) picks up at S17, where the course takes the screen over and starts building a game. The Change one thing edits are deliberately left unanswered: those work by making you predict before you look, and running the edit tells you more than reading an answer would.

11 September 2026

• S1 gains a short section on getting in touch: reporting a mistake, saying when an explanation is unclear, or offering to write something.
• S2 now explains the prompt you are left at when the machine boots with no disc: what MOS is, why a real Einstein would normally start from a disc instead, and why the extension means you do not need one.
• S3 gains a section explaining the Z80's registers: what they are, why a processor needs them, and why the accumulator is the one that matters most. The LD section no longer repeats that material and now covers the order of its two operands instead.
• Every section's opening heading is now Introduction, where it previously read "Why this matters". Nothing else about those sections changed.

9 September 2026

• Appendix VIII - Running Your Game on a Real Einstein added. It takes the finished .COM from S29 or S30 to a disc image a real machine will boot from a Gotek.
• Appendices I to VII published for the first time: character codes, other assemblers, what sits behind RST 8, the memory map, the keyboard matrix, drawing a line, and the disc format. The course already referred to several of them by name before they were available.
• S2 now states that its install instructions are written for macOS, and describes the extension correctly: pressing Run starts the Einstein for you rather than expecting one to be running already.
• S3 gains step-by-step instructions for creating a folder and a file in VS Code, a screenshot of the Run and Restart buttons, and an explanation of what each does and where to look for your program's output. This followed a reader getting as far as the setup and having nowhere to go next.
• S29 and S30 now point at Appendix VIII from their closing sections.
• Appendix VII reworded: it previously said nothing in the course would ever put a game on a disc, which Appendix VIII has since made untrue.
• The extension's download link moved. It is now on the Downloads page at tatungbytes.co.uk/downloads/tatung-einstein-development, and the address the course gave before that no longer works.

5 September 2026

• S4 to S30 published, taking the course from its first jump through to a complete game and splitting a project across several files.

4 September 2026

• S1 to S3 published. The first version of the course.