Hacker News Reader

>Old systems are surprisingly understandable after a few hours' research and fooling around.

This is why I say old computers never die - their owners do! Old systems have lots of technology to engage the hacker mind.

By the way, my favourite emulator is Oriculator, which emulates the Oric-1/Atmos/Telestrat/Pravetz 8-bit machines that never had much of a chance in the 80's .. just look at this beautiful code, for example, of how to emulate a 6502:

https://code.google.com/p/oriculator/source/browse/trunk/650...

With the revival of emulation of these systems, we're even getting new software written for them - in the modern era, titles are being released for these old machines that we would never have though possible in the 80's. Just look at this beautiful collection for the Oric-1 - all made in the 21st Century - for example:

http://space1999.defence-force.org/

http://stormlord.defence-force.org/

http://1337.defence-force.org/

http://im.defence-force.org/

http://skooldaze.defence-force.org/

http://oricium.defence-force.org/

Featuring Gameplay and Graphics that we would never have thought possible in the 80's!

http://www.oric.org/software/pulsoids-1515.html

Check out this collection from Twilighte, who before his untimely departure was a real master of this platform in the 21st century:

http://www.oric.org/index.php?page=software&fille=softwarese...

So much fun to be had on these old machines!

I wonder why it's possible to get "better" programs for old hardware now.

Is it because the field of CS has advanced further, which means that we can apply modern ideas and algorithms?

Or is it because we can cheat and have a toolchain running on vastly superior hardware, which enables us to use it in ways that would have been too time-consuming to develop back in the day?

Probably a bit of these two, and a third one:

today, we have plenty of programmers who have been at it for thirty years. They got started on these very machines, and in the meantime they have been doing other things on other computers—but which were still programming—and now, if they decide to go back to the original computers, their instincts more than compensate for the lost familiarity.

In some of my last years as a student (late nineties), I dug up my old ZX81 from my parents' basement, and the effects of all three items were visible: I had access to a cross-assembler that I ran on a SPARC workstation. Techniques that may or may not have been known in the 1980s were now published and available on the Internet for anyone curious about them. And my ability to concentrate and understand the issues I was facing was better than when I was eight.

I don't think fancy algorithms and data structures are common or particularly useful in retrocomputing. I think it's primarily because programs were written back then under strict time and financial constraints, whereas now retroprograms and homebrew are written as hobbies, with the lack of deadlines and abundance of passion that entails.

I don't know about that - I've been following the Oric scene for a while and my perception is that there are indeed old programmers returning to the systems of their youth with renewed vigour, but also a better understanding for how to organize their project - and sources - in a way that makes more sense. 30 years of optimizing code does tend to turn you into a better developer, and when you return - for no reason other than the pure joy of it - to these old systems, often things are done in unique ways. Twilighte found a new video mode for the Oric-1 which inspired him to write games that were a bit more modern in their sense of quality and playability - I think the machines that came after the Oric inspired him quite a bit.

It also helps that the toolchains are far superior to what we used to have .. I never would have thought, in my youth, that I'd be writing C code for the Oric-1, but indeed the OSDK has a C compiler that makes the effort of packing code into 48k a lot more fun than it used to be!

But in the end, you don't write software for these old machines unless you have a lot of passion, and that's what counts, I think. There is a lot of passion for the Oric-1 these days, that is for sure .. at least in the small scene that keeps the machines alive.

You're right, decades of experience are also very important (though there are youngsters starting on platforms like the NES or TI graphing calculators doing cool stuff as well).

I'm not sure I agree about toolchains, though. The 6502 is not a very good target for C compilation, pretty much any assembly programmer can code circles around what cc65 produces. So, no offense to you or anyone else that writes C for 8-bit machines, but I don't think any of the new games and programs that really "push the limits" of these machines are written in C. So that leaves modern cross assemblers, which are indeed much more capable than common target/native assemblers of the olden days, but don't exactly afford a quantum leap of productivity either.

Then again, modern emulators are a godsend for debugging.

>>Then again, modern emulators are a godsend for debugging.

Hell yeah they are. I think thats also a key factor for why development on the old machines is experiencing a revival.

It sounds like there's at least some "cheating" going on. The article talks about "mappers" which were embedded into the cartridge to take advantage of extra memory included in the cartridge. Back in the 80s, that form of cheating allowed the cartridge to double the amount of memory, but on today's hardware, you could use the same technique to get considerably more memory.

Official NES mappers allowed up to 1 megabyte of ROM (512kb program ROM, 512kb graphics ROM). I can't really imagine needing more than that for an NES game.

Yes, theoretically you could stick an ARM processor in a cartridge and run most of the game off that, using the PPU as a glorified framebuffer. But many (most?) retroprogrammers are in it largely for the engineering/optimization challenge (or else, why wouldn't you just write a retro-styled PC game), so they draw the line for "cheating" much more strictly than even you have. e.g. some fan translators refusing to expand the ROM size of a game and butchering the translation to fit (Japanese text is much more dense than English), instead of using a larger ROM to fit a better translation. Or some NES homebrew programmers not using mappers at all and working within the constraints of NROM (32kb program rom and 8kb graphics rom). So I wouldn't accuse any of these homebrew programmers of "cheating," because if they were actually guilty of it, those in "the scene" would have called their bluffs long ago.

FWIW, I put cheating in quotes because it doesn't seem like cheating to me. It's only cheating the original specs of the machine. If the developers of actual cartridges were allowed to make use of that trick, why shouldn't modern day retroprogrammers have that option?

But if a retroprogrammer were to use a mapper to achieve a 1 meg ROM, modern hardware would make that a decision with very little negative consequences. A programmer at the time might have to live with a game that cost well over $100.

So cheating in quotes because people did it in their actual cartridges. Cheating without quotes would be something like breaking out of the emulator sandbox and embedding the Quake engine.

25 years experience helps a lot, there are much better tools available (cross-assemblers, editors, make, git), and there's a wealth of documentation that just wasn't available back then.

The edit-compile-test cycle is near instant and debugging from an emulator is a lot easier than debugging on the real hardware.

A 6502 in ~2500 lines of C? Really? Bookmarked :)

I can top that :) (although it hasn't been used in a production emulator)

I wrote this a few years ago - it's ~500 lines taking advantage of the logic behind the instruction set (instead of a jump table) and it can run Apple I BASIC at least.

https://github.com/happycube/chadslab/tree/master/m6502

Yeah, imo trying to actually do some instruction decoding rather than just a massive switch case is a lot nicer.

Looks really clean. Nicely done.

That is similar to my approach to emulating the Gameboy Color's Z80-like CPU. Not yet completed - probably never will be :(

MC Kids was one of your favorite games? My wife and I actually played that the other night and wondered who actually bought it when it came out? Was it something you wanted or was it a random gift of some sort?

Honestly, I don't remember how we got it. I was four years old when it was released. My mom used to go into Funcoland and just buy whatever looked good, or maybe what an employee recommended. Actually, I should ask her if she remembers.

And yeah, I'm a big fan. Aside from just growing up with it, it's a really solid NES-era platformer. If you're curious to learn more about it, one of the developers actually maintains a blog and has written about it a few times. He also posts on HN infrequently.

http://games.greggman.com/game/m_c_kids/

http://games.greggman.com/game/programming_m_c__kids/

Also he & the other two primary developers actually signed my cartridge:

http://gamesplusone.com/mckidscart.jpg

I'm a dork.

It was a solid game. It was dynamic enough to remain interesting. And the difficulty level was perfect for my ~6 year old self. Though, I don't think I ever actually beat it. Got stuck on Hamburgler too many times.

Cinemassacre did a really good review of it here: http://cinemassacre.com/2006/09/01/mckids/

It's pretty fun to work on this kind of stuff. I wrote an OperaFS (3DO CD filesystem) extractor in Go to get at a video file that was contained in an old game.

Admittedly, I should get back to work - because I still don't know how to play the video file that I pulled out.

I have always wondered how did they get all the ROMS for the games. Any insight?

Use a ROM dumper! You need access to the original hardware, then the dumper reads out the chip.

To make a dumper you first need to find the ROM pinouts for the chips they used. This tells you which pins select an address, which pins output data, etc. Then, build a dumper (for example writing an Arduino program) that selects each address one by one, and outputs the response from the chip in a format your computer can read.