If you memorize it you don't have to context switch when you look it up. The benefits of memorization are enormous if it reduces your the number of times you have look up details to zero. It's similar to touch typing vs hunt and peck typing with the following exceptions:

1. context switches are much more expensive than looking at a keyboard to find the key to press,

2. memorization enables you have a more complete mental model which greatly speeds up design, reduces bugs and enables you to find bugs faster.

3. you gain surprising insights if you can run the program in your head when you are falling asleep, in the shower or walking around.

When I am doing cryptanalysis the first thing I do is commit the protocol to memory. Sadly if I'm not working on it 24-7 I quickly forget and have to rememorize.

If you didn't develop in that timeframe you might not get the difference between then and today. It takes forever to look things up so you end up memorizing instead. And it isn't a big deal because the number of things needed to be a successful software developer wasn't that great. To be successful and finish projects more or less on time, memorization was needed.

Edit: For example, for a different project I knew the hex codes for every 8051 instruction. This was necessary to be successful debugging using a logic analyzer. Looking up each op-code would be prohibitively slow.

It's a caching problem. If memory access is slow you want to cache more, if not then you don't bother. Things you use a lot will spend more time in the cache, things you don't you'll have to keep retrieving from memory.

We really aren't as different from computers as we sometimes like to believe.

When you memorize all the details of an instruction set, there is a qualitative difference when you code in it.

It's like the difference between being a stammering tourist in a foreign country who is constantly flipping through a dictionary to make elementary utterances, and a native speaker.

I first realized this many years ago after writing an emulator for the Motorola MC68010. Unrelated to that project, I had the occasion to write some assembly code in the same instruction set. Just, wow ...! It was like, I .. know ... everything ! (cue sound of thunder, lightning effect.)

You move a lot faster by memory. I regularly switch between Ruby, JavaScript, Python, and Scala at work and it's quite insane, I spend way too much time realizing language Y doesn't have feature X I use in language Z and looking it up vs rare moments of flow when I've been using the same language for more than a week or two.

> Why did you have to memorize everything? I have also done x86 assembly. You remember what you can. You look up the rest. Same today.

Looking stuff up took a lot longer then. It's the difference between firing up a search engine and typing words versus getting in your car, driving to the library, finding parking, walking to the door, finding the card catalog, finding the right card in the catalog, finding the right stack, finding the book on the shelf, scanning the book index, then finding the right page in the book. Memorizing had a better payoff back then.

Or think of it another way: looking stuff up today is like accessing L2 memory, and back then it was like a cache miss, where you had to take a trip out to disk before you could continue useful work.