Welcome to Code Like It’s 198x

I don’t remember exactly when I decided I wanted to make games. It was definitely when I
was a kid. If I had to guess, I’d say I was about 7 or 8. Maybe even younger. That’s when
I first became consciously aware of the idea — the moment when I looked at the screen and
thought, someone made this, and then wondered if maybe I could too.

I was absolutely inspired by the legendary game developers of the time — the ones whose
names were printed in loading screens or whispered about in playgrounds. I devoured
books and magazines with titles like Write Games for Your Micro-Computer, which felt
like secret manuals to a world I desperately wanted to join. (Yes, they really called
them "micro-computers" back then — to separate them from the hulking beasts used by
serious people in ties and lanyards.)

The first computer that was mine was a ZX Spectrum 48K. That’s exactly why this series
starts with the Speccy. It shaped the way I thought about computers. I read every Speccy
magazine I could get my hands on — Your Sinclair, CRASH!, and occasionally Sinclair
User. My friends had Commodore 64s and Amstrads, so I read ZZAP! 64, Commodore Force,
and whatever else they passed around at school. We didn’t just play games — we lived them.

At school, we had a few BBC Micros — not for fun, mind you, but for serious educational
stuff. Still, I tinkered with them when I could. Later, the school added a couple of Acorn
Archimedes machines. At the time, they didn’t impress me (I was a loyal Amiga kid), but I’ve
since come to appreciate their legacy. The RISC chips inside those machines planted the seeds
that would eventually grow into the ARM processors running in nearly everything today —
including the MacBook I’m typing this on.

Eventually, I upgraded to a Spectrum +2 with a built-in tape deck — a major quality-of-life
upgrade, at least by 80s standards. Later came the Amiga 500, and eventually the Amiga 1200.
But by then, the golden age of home computing in the UK was already fading. The PC era had
arrived, and the scrappy charm of our beloved 8- and 16-bit machines was slipping away.

By 1997, I was leaving school and heading to college — and I still hadn’t made a single game.

I’d dabbled, of course. I wrote a disk magazine filled with reviews and shared it around at
school (though I suspect most people just wiped it and reused the disk for pirating games —
as was tradition). In hindsight, I probably missed the boat by a few years. But the itch never
went away.

I even started a degree in Computer Games Programming. It didn’t go so well — turns out
academia and I were not a great match — but it nudged me towards web development, and later
into a full-time software career. I discovered PHP, then Ruby, then a whole world of tools
and languages. And I’ve been lucky enough to build a life around code.

But the itch is still there.

So I’ve decided to scratch it — publicly, enthusiastically, and one system at a time.

What is Code Like It’s 198x?

Code Like It’s 198x is a challenge I’m setting for myself — but I hope you’ll come
along for the ride.

It’s a personal journey, a passion project, and a way to finally chase the dream I left
sitting in a pile of cassette tapes and half-filled notebooks.

It’s a chance to:

• Learn (or relearn) the fundamentals of game development on vintage systems
• Explore the quirks and constraints of 8-bit and 16-bit hardware
• Teach what I learn, from the ground up, as clearly as I can
• Share everything — tools, code, problems, breakthroughs, and probably the occasional rant

We’ll be working directly with the machines that shaped the early years of home computing
and video games. For each system, we’ll start at “Hello World” and build toward real-time
graphics, sound, input handling, and small but complete games.

Whether it’s sprite management on the C64, scrolling on the NES, or the vector wizardry
of the Vectrex, we’re going deep — and doing it all in the open.

What systems are we going to cover?

The short version: lots.

The longer version: here’s a taste of what’s on the roadmap, in roughly the order we’ll
tackle them.

• ZX Spectrum – My first love. Underpowered, but bursting with possibility.
• Commodore 64 – The first computer I ever used. SID music and hardware sprites await.
• Amstrad CPC – A dev favourite back in the day. Plenty of RAM, decent screen modes.
• BBC Micro – Common in UK schools. Solid BASIC and I/O support.
• MSX / MSX2 – Completely new to me. Let’s learn together.
• Atari 800 / XL / XE – Big in the US, with excellent graphics capabilities.
• Apple II – A legend in its own right, and a gateway to Apple’s early ecosystem.
• NES – Our first console. Let’s see what low-level development really means here.
• Sega Master System – A fair counterpart to the NES. Let’s compare approaches.
• Game Boy – Monochrome, minimal RAM, and more charm than should be possible.
• Amiga 500 / 600 / 1200 – Multimedia powerhouses. Welcome to the 16-bit era.
• Atari ST – Music-friendly and MIDI-capable. Let’s find out why musicians loved it.
• SNES – Tilemaps, audio tricks, and multiple graphics modes.
• Vectrex – Vector graphics. No pixels, just lines. Totally unique.
• PC Engine / TurboGrafx-16 – A system that blurs the 8- and 16-bit lines.
• Sharp X68000 – Arcade-class hardware in a desktop case. Only in Japan.
• Classic Macintosh – A GUI-first, event-driven departure from everything else.
• Acorn Archimedes – The machines I resented in school. Time to make peace.

If it’s programmable and it came out before Y2K, I’m interested.

And yes — at some point, I may dip into early consoles like the PlayStation, Saturn,
and Dreamcast. But let’s not get ahead of ourselves.

If your favourite system isn’t listed, let me know. I’m open to adding more — I just
can’t promise when.

Who is this for?

Primarily? Me.

But also you — if you’ve ever felt the same tug. If you grew up in the 80s or 90s and
wondered how the games you loved were made, or if you're newer to all this but curious
about the roots of modern gaming and computing, this series is for you.

No prior experience is required. You don’t even need to know how to code — though it
might help. I’ll explain as I go, and try to make the journey as beginner-friendly
as possible.

What can you expect?

This isn’t going to be quick. There’s a lot to cover — and that’s part of the fun.

Expect to see:

• Emulator setups and cross-development toolchains
• Deep dives into how graphics and audio worked on each machine
• Code in multiple languages — including good old assembly
• Small, complete game projects
• A public GitHub repository with all the source code and tooling

This is a “learn in public” project. I’ll document every step, good and bad. We’ll
celebrate the wins and untangle the bugs together.

Why now?

Because I’ve spent decades writing “serious” software — scalable, maintainable,
reliable systems for the modern web. But somewhere along the way, I lost the sense
of wonder that first got me into coding.

Digging into these old systems brings that feeling back.

It started with a simple thought: What should I do with my Spectrum Next?

That question quickly became: What if I tried to make the games I never made as a kid?

Then it became this.

Let’s find out what it really means to Code Like It’s 198x.

I hope you’ll join me.