Back when I was writing 6502, you didn't keep it all in your head, you kept it in reams of tractor-fed dot matrix paper, usually with a lot of scribbled pencil notes and corrections.

I've done a bit of embedded development for 8-bit machines in the modern era, and I sincerely tip my hat to the engineers who were doing it in the 80s. Even with the best tooling available, you'd have needed an enormous amount of organisation and discipline to keep track of your code. I was doing some research about the assemblers available for the Hitachi 6303[0]/Motorola 6800[1] in the early 80s, and I'm amazed by what people accomplished with the limitations of these tools. Just to name one thing, the two assemblers I've linked to only supported SIX character labels, and no local-only labels within subroutines either. To compare, in my own work I was limiting myself to FORTY characters for the sake of being descriptive.

Having said all this, the relative simplicity of these architectures is really refreshing compared to embedded work on modern systems. There's something to be said for being able to roughly keep track of the whole system state in your head.

0: http://www.bitsavers.org/components/hitachi/_dataBooks/U24_H...

1: http://www.bitsavers.org/components/motorola/6800/exorciser/...

We were out better selves back then.

Seriously though any project of size almost had to involve large amounts of code written or printed on paper. Lots and lots of paper.

This code is extremely well organized and documented. I don’t know what the original code would have looked like in terms of documentation, but I imagine there was a lot of it printed on paper with handwritten notes and stuff.

Overall though, assembly programming is much like any high level language: you organize your code into functions and blocks etc. Just writing one super long wall of code with a rat’s nest of jumps throughout is asking for serious trouble.

Can anyone explain this to a modern engineer? Why would you need to hold this in your head?