I’ve been working with an Apple ][ emulator lately, remembering some of the charms it had that we’ve largely lost since.
Users of the Apple, or my old Franklin, or many of the other systems out there at the time, had a much more “up close and personal” relationship with the hardware and with the software. I remember my parents talking about a System/360 they’d used in graduate school with punch cards, and wondering how anyone could stand it, when instant feedback from the computer was available right in our den.
Applesoft BASIC and DOS 3.3 were programs, sure, but there was much less distance between me typing at the keyboard and the programs I wrote than there is now between me and any Java program I write. BASIC and DOS intermingled easily, though with a very different vibe than shell scripting has. There’s was no compile-link-wait-wait-run-oh-no-recompile-link-wait-maybe cycle. I could type A=1 into the thing, then PRINT A five minutes later and get back “1″. Writing programs didn’t feel like a separate process from using the computer.
(Logo also felt that way a lot of the time, though it was kind of its own separate environment.)
After I ran the program, or broke out of it for whatever reason, I still had access to variables and could see what happened.
Applesoft was my preferred language then, and I’ve blamed it for years for my spaghetti programming tendencies. Coming back to it, though, I’m not sure I’m right about that blame. Sure, life with all global variables and no named subroutines is probably not a great way to learn if you value encapsulation, but I have to wonder if structured programming and then the current generation of object-oriented development have their own problems. I’ve seen a lot of strangely thought out encapsulation that I think may be the result of not having worked without it.
They’re not so much technical problems as political problems. “Hello World” in Applesoft is simple: PRINT “Hello World”. It doesn’t even need a line number. In Java, you’re trapped into creating an object with a main() routine. It’s ordinary to rely blindly on thousands of lines of library code to get simple things done. Applesoft certainly did things for me - even the Monitor environment and its mini-assembler were there to make life more convenient - but it was a much thinner layer, and I could do all kinds of damage to myself if I wanted to. When I first saw the Macintosh, I wondered why anyone wanted a computer that kept them away from the computing.
In looking back and comparing, my programs run about as well as they did then, and debugging, while a different process with a lot more up-front investment, takes about the same amount of brainpower. I was doing different things, certainly, when I was 13, but the games I was writing weren’t much less complicated than the odd XML parsers I’ve conjured more recently. (I wasn’t a professional programmer then, and I’m not one now.)
One thing I do remember well was the low frequency of unexplainable crashes. It seems like a 128-level stack limit should have ensured periodic disasters, but it didn’t. The commercial software I bought was remarkably reliable stuff, even relative to what I’m running on my iMac today. I don’t think I’m ready to chuck Microsoft Word and go back to AceWriter, even if I can get the disk working, but Word sure has crashed a lot more.
I’ll be playing with this thing for a while. It’s been fascinating reading the old books, which seem a lot easier now, and I need to get back into assembly work. I’ve been having a great time so far on this tour, and hope to do something useful, if perhaps perversely useful (not a lot of people run Apple ][s any more!) with this thing, and I’ll let you know when I have something worth showing.
(I still haven’t found bootable DOS 3.3 disks, but I do now have an Apple ][e, giving me a legitimate set of ROMs. Virtual II has been great. Maybe Apple could start throwing in a copy of the old ROMs with every Mac?)
If you only have 64KB to play with, would you rather use J2ME or an Apple ][-like environment?