"If you care a lot about the future, it shows that you believe in what you're doing now and you think it's worthwhile enough to have some lasting impact." – Syd Mead

Menu

Just For Fun

One of my favorite shows when I was growing up, which I tried not to miss every week, was “The Computer Chronicles.” It was shown on PBS from 1983 to 2002. The last couple years of the show fell flat with me. It seemed to lack direction, which was very unlike what it was in the prior 17 years. Still, I enjoyed it while it lasted.

Randy Kindig did an interview with Cheifet. They talked about the history of how the show got started, and how it ended. He told a bunch of notable stories about what certain guests were like, and some funny stories. Some screw-ups happened on the show, and some happened before they taped a product demonstration. It was great hearing from Cheifet again.

I watched a bit of the TV and Radio Correspondents’ dinner this past weekend and saw this routine by John Hodgman. I couldn’t pass it up. I really enjoyed it. We’re all I’m sure familiar with this comedian. He’s been on The Daily Show, The Colbert Report, and all of those Apple Mac ads (he’s the “PC”).

“We are wary, Mr. President…”

As I was watching the thought kept running through my head “Come on! Ask Obama a Monty Python question!” It didn’t happen. I really liked the Dune questions though, because Hodgman acted like he knew the details like the back of his hand. 🙂 Perfect! Though he never gave the answers. I know them, but I’ll leave them for my readers to ponder.

Anyway, when he got to the end my mind raced immediately to one of the most famous sequences in sci-fi cinema, from Star Trek: The Wrath of Khan. It strikes me as odd, knowing what he was referring to, that Hodgman said, “I have been, and always shall be, you friend. Live long and prosper,” is, “the most American of greetings”. It came from Spock’s death scene in the movie! It was his farewell.

Edit 11-22-2009: I embedded a video clip of Spock’s death scene when I first wrote this, but it got taken off of YouTube. So I’ll just provide a “transcript”. Spock has just saved the Enterprise from imminent disaster, but he has sacrificed his own life. He’s dying. Admiral Kirk sees him for the last time (or so he thinks). These are their last words to each other:

Spock: Ship out of danger?

Kirk: Yes.

Spock: Don’t grieve, Admiral. It is logical. The needs of the many outweigh the needs of the few.

Kirk: …Or the one.

Spock: I never took the Kobayashi Maru test until now. What do you think of my solution?

Kirk: Spock…

Spock: I have been, and always shall be, your friend. [pressing his palm to the glass in the Vulcan sign] Live long and prosper.

Kirk presses his palm to the glass as if trying to touch Spock’s hand. And then Spock dies.

There have been rumors of a Tron sequel for several years now. Back in 2003 Disney released Tron 2.0 a video game for PCs, and later a port for consoles. Originally the video game was supposed to accompany a movie with the same title, with Steven Lisberger reprising his role as director. That project got canned. The video game came out, but no movie. Talk about a botched release! Anyway, I think the video game is pretty good.

In the last year there have been more rumors of a Tron sequel, this time with a different director, with Lisberger being involved as producer. Just today I was browsing Brian Cunningham’s blog, and I came upon one posting pointing to a bootlegged test reel/teaser trailer called TR2N, shown at this year’s ComicCon, featuring Jeff Bridges looking bad ass (I assume he’s playing Flynn again), and a cool looking light cycles contest! It’s definitely modern, not some retread of old Tron footage. Tron 2.0 News has a lot of the details of what this teaser means. It looks like it was a test reel created to see how much interest it would generate. The project probably hasn’t been “greenlighted” yet. Anyway, I just had to see this. I watched it and got chills! Wow!

Oh, in case you’re wondering what the dialog is at the end, one of the contestants on the “game grid” exclaims, “It’s just a game!” His opponent says, after a dramatic pause, “Not anymore.”

Since the video is bootleg it may not be up for long. Check it out while you can.

I’ve been extremely busy lately and so haven’t had time to post as much as I’d like. I saw this video a little while back, and I thought, “Okay, cute.” Over time it’s grown on me, so I thought I’d share it with you all.

“An Engineer’s Guide to Cats”

There’s something about this video that when I watch it I have to say, “Hmm. This sounds like me,” except I haven’t been a cat owner in years. My apartment doesn’t allow pets. But I love cats. So this is an easy video to love. One part in it says, “Like most engineers, cats are pretty much willing to eat the same thing day, after day, after day,” and then follow it up with a little part where they’re making toast. This is so me. I eat a fairly restricted diet in the sense that I don’t mind eating the same selection of stuff for quite a while before I get bored with it and move on to something else.

I loved the “feline art” section of this video. The “post-modern cardboard deconstruction” bit is hilarious! 😀 The “corporal cuddling” part was precious. Awww, so cute! Makes me feel all warm and fuzzy inside.

The part about the “I’m-not-paying-any-attention-to-you game” was interesting, because I’ve “played” that game with women (but gosh, I didn’t know it had a name…). From my experience it doesn’t work out like in the video. If you play this game, the gal wins by default, because you’re just too uninteresting.

BTW, I found this video shortly after “An Engineer’s Guide”, and it’s pretty cool too. For an amateur he’s quite a performer and songwriter I’d say.

If you are offended easily, it would be best just to skip the following link. If you want to see an indication of what the pop culture in computing is centered around today, this is pretty good (h/t to James Robertson). There’s a little rough language. It’s a Web 2.0 “catchy-phrase” generator. Amazing how a computer can come up with stuff that sounds just like sales material, isn’t it?

Going Retro

Here are some modern “retro” videos I found that harken back to the 8- and 16-bit era. I just thought they were neat.

“Move Your Feet,” by Junior Senior

A friend introduced me to this music video a few years ago. It harkens back to the olden days of blocky but colorful 8-bit graphics. I’m sure none of these graphics were generated on an actual 8-bit computer. Anyone know what they used?

“Atari Robot Demo,” by Alistair Bowness

This is a clever piece, splicing together video from a bunch of 8-bit games using professional video editing.

In the very beginning you see a demonstration of what Atari users actually had to do to load a binary program. You had to go to a DOS (Disk Operating System) menu, which you loaded from disk, select “Binary Load”, and then type the name of the machine language program you wanted to run, at a prompt. The rapid-fire, high-pitched “beeps” you hear are the actual sound you’d hear out the TV or monitor speaker as the program loaded into memory from floppy disk.

It starts out with video of a real Atari 8-bit demo (video link) Atari used at the trade shows to show off the Atari XE series. Bowness took the music from the real demo and created a remix of it with a modern bass and drum track.

Atari and Commodore 8-bit games are shown, along with some coin-op games. There’s a little Commodore Amiga stuff in there, too.

It surprised me that the video included an Atari 8-bit game called “Dropzone.” It flies by rather quickly. It’s the screen before Dig Dug shows up. I was surprised because my memory is this was a little known game. I tried it out in college. The graphics performance on it was amazing. It was fast–too fast. The movement of graphics around the screen was very smooth. I remember I got killed all the time because I had a difficult time calibrating my movements on the joystick with what was going on onscreen. I’d make dumb moves, crash into stuff and die. Some of the graphics in it were a dead-ringer for the coin-op “Defender” game.

I read how they made this song and video. “Video Computer System” is an actual music title you can get from Golden Shower. What they did was record real 8-bit game sounds, digitize them into their music system, and used them in the song, along with some 8-bit-like synth sounds they created themselves. The graphics for the video were created entirely in Photoshop, and maybe some other modern graphics packages. The 8-bit-like graphics look an awful lot like the real thing, but none of it was generated on an 8-bit machine.

This is a video of a small personal computer museum in Canada. Just about all of the computers that came out in the 1970s and 1980s can be seen, and used by patrons. You see some kids playing some of the old video games.

As you can see, a LOT of different personal computers were created in this time period. It shows you what I meant when I said earlier that everybody and his brother was coming out with their own personal computer in the early to mid-1980s.

I said earlier in Part 4 that this would be my last post. I lied…I’ve got one more coming up.

Atari ST

While in college I got an Atari Mega STe, around 1992. It had a 16-bit Motorola 68000 CPU, and was soft-switchable between 8 Mhz and 16 Mhz. I got it with 1 MB of RAM. I eventually upgraded it to 4 MB, and added an internal 40 MB hard drive. That was kind of the average size at the time.

Some history

Jack Tramiel, the founder of Commodore Business Machines (the maker of the Commodore 8-bit and 16-bit computers), dramatically left his company and bought Atari from Time Warnerdramatically left his company and bought Atari from Warner Communications in 1984. Commodore and Atari were fierce competitors, so he was competing against his own handiwork. After he took over, Atari produced new models: the XE 8-bit series, and the ST series. The first ST models came out in 1985, just a year after the Apple Macintosh was introduced. They ran on the Motorola 68000 CPU, running at 8 Mhz, using Digital Research’s Graphical Environment Manager (GEM) for the desktop interface. It and the Commodore Amiga came out around the same time. Both featured GUIs that had a similar “look and feel” to the Macintosh, with the main difference being they had color displays, whereas the Mac ran in monochrome. An exciting feature of the Amiga was it had pre-emptive multitasking; the first personal computer I knew of to have that, though I recently discovered that the Apple Lisa, which had been released a couple years earlier, could multitask as well.

The ST developed a niche with musicians. I wasn’t a musician, so I didn’t buy one for that reason, but I used to hear about some famous musical artists who used STs in the recording studio and in live concerts. The most prominent of them was Tangerine Dream. The ST also had a 16-bit, 3-voice Yamaha synthesizer chip. From what I understand it was the same sound chip used in the TI-99/4A personal computer that was sold in the early 1980s.

The STe series had 8-bit stereo PCM sound capability as well, similar to what was available on the Commodore Amiga, though the Amiga had more sound channels.

Productivity

At first I used my STe mainly for connecting up to the school’s computers. I finally got decent 80-column ANSI terminal emulation. I also used it to write a few papers, using what was called at the time a “document processor” called “Word Up.” My main accomplishment on it was writing an article for a magazine called Current Notes.

Programming

After I got my bachelor’s degree I did some C coding on it, using Sozobon C. Of all the computers I had used up to that point, I did the least amount of programming on it. I always intended to get into programming GEM, but I never got around to it.

I started into something that really interested me though. A few years earlier I had been introduced to the idea that the solid inner planets in the solar system had been formed by asteroid collisions. I was curious about exploring this idea, so I created a “gravity simulator” in C, using Newtonian physics to see if I could recreate this effect, or just see what would happen. I got some basic mechanics going, creating orbits with dots on the screen, but it wasn’t very exciting. For the first time the speed limitations of the hardware were holding me back. It was able to handle maybe 10 or 20 gravitational objects on the screen at once, and after that it really started to bog down. I continued this exploration in C++ when I got my first Windows machine some years later, to better effect.

MiNTing an Atari

In the meantime I had found out about an open source adjunct kernel for the ST called MiNT (a recursive acronym for “Mint is Not Tos”), written by Eric Smith. The term “open source” didn’t exist back then. There was just GNU, and “free software” with source code available. “TOS” was the name of the ST’s operating system. It literally stood for “The Operating System.” Original, huh? MiNT offered a Unix work-alike environment. It had a complete C/Unix API. It came with a lot of the amenities, too, like Bourne shell, GCC, UUCP, NNTP, rn, mail, man pages, X/Windows, etc. A lot of the GNU stuff had ports that worked on the ST. I remember taking my semester project I had written in a graduate level course on compilers, and compiling it on MiNT using GCC, Flex, and Bison.

It implemented pre-emptive multitasking. This only worked inside the MiNT environment, and it only went so far. I quickly realized that even though I could run multiple simultaneous processes, if I ran too many (more than two or three) it would grind down the machine. Since it was an adjunct kernel, I could still run a GEM program at the same time. GEM only offered a single-tasking environment. MiNT didn’t help there.

GEM had a feature for a special kind of program called a “desk accessory.” The Macintosh had them, too. You could call one up from the “Atari”/”Fuji” menu. A desk accessory called “TOSWin” was my friend. It enabled me to run a MiNT and GEM session simultaneously. For some reason GEM allowed any desk accessory to run side by side, simultaneously with a GEM application, as if it was multitasking, but it didn’t allow you to run more than one GEM application at a time. I remember one of the things I did with TOSWin was I’d sometimes call a BBS that was really busy. Instead of running my GEM terminal program and letting it redial continuously, making it impossible for me to do anything else, I wrote a shell script in MiNT that would redial the number for me until I got a connection. In the meantime I could run another task in GEM while I waited.

The only thing MiNT really lacked was virtual memory. It was not able to page to disk, so I was limited to a maximum of 4 MB in which processes could run. For what I did with it I don’t think I ever hit a memory ceiling. It had virtual memory in the sense that it ran programs using relative addressing. It also had a unique way of handling multiple instances of the same program in memory. It created a new data area, and a new program counter for each instance of a program, and each program counter iterated over the same in-memory program image for each duplicate instance. This helped save memory from redundancy.

It eventually got to the point where I was working in MiNT most of the time, and I was using GEM hardly at all.

Soon after I got into this stuff I realized that MiNT was not unique on the 68000. A Unix-like OS had been around for years on the Radio Shack Color Computer, which used Motorola’s 8-bit 6800 CPU, called OS9. There was also a version for the 68000. MiNT was a lot like it.

Just a note of trivia. Eric Smith came to work at Atari around 1991/92 and worked on the operating system for the Falcon 030. The end result was MultiTOS. MiNT was the new kernel (it was renamed “MiNT is Now Tos”). A new GUI layer was written on top of it, called XAES, which enabled users to run multiple GEM programs at once. The OS was loaded from disk instead of ROMs.

A bit about the Falcon

The Falcon was a pinnacle achievement for Atari. It had some things going for it. Like the TT, their first 32-bit model, it produced VGA-compatible video, though it had 16-bit color. The TT had 8-bit color. One of its features that attracted a lot of developer interest initially was its digital signal processing (DSP) chip; the same one that came in NeXT computers. The problem was it was too little, too late. The market for Atari computers was dying by the time it was released. Atari underpowered the Falcon, forcing its 68030 CPU to run at 16 Mhz so it wouldn’t compete with the TT, which ran at 32 Mhz. Atari made the Falcon for about a year. They stopped producing computers altogether in late 1993.

This video was put up by someone else. This game was a version of Robotron 2084, except you’re a…um, a llama. The game was freeware, though Minter took donations. It was ported to a few platforms. I know it ran on the Amiga, and PC as well. I thought it was incredibly creative. Each level was something new. A great feature of it is Minter knew you’d get beat by it. So he put in several “Do you want to continue?” prompts whenever you lost your last life, so you could get a new set of lives and continue. The point was to have fun with the game, not to lose and get discouraged and have to start all over.

I just had to mention this one, even though I only played it once. Oh my god! This game was SO MUCH FUN! 🙂 It was the first 3D multiplayer networked first-person-shooter I ever played. It was released in 1987. Every player was a round smiley face of a different color. The only opportunity I got to play it was at a computer show at a mall. I can’t remember who set it up, maybe a user group. A bunch of STs were set up, all networked together via. their MIDI ports (hence the name of the game). The early STs had no built-in networking capability, but someone figured out how to use the ST’s MIDI ports as network ports. No special adapters were required. Just plain ‘ole MIDI cables were used to daisy chain a bunch of STs together.

We had to find each other in the maze and shoot at each other. All the mazes were single-level. Scoring was done on the musical staff you see in the upper-right corner of the screen. Once you got up to the G note, you won. 🙂

I only had a demo of this from a disk I got out of ST Format magazine. I played it often anyway. You play a character named “Cool Coyote.” It was an entrancing platform game. The map I played is the one you see in the video above. It kind of felt like you could take your time. Even the music was calming. You’re moving in kind of slow motion through the water, freezing and then smashing sea creatures to get pieces of a key you need to escape the map. Along the way you pick up score items like gems, stars, and dog bones. The audio is a bit out of sync with the video. I couldn’t help that, unfortunately.

This was my flight simulator. It was a port of the version from the PC, so it wasn’t great. Everything was represented by non-shaded, non-texture-mapped polygons, which was how most games did 3D on the ST series. You went on bombing missions of enemy targets, taking off and landing from various locations. Along the way you had to evade SAMs and enemy jet fighters trying to shoot you down. The most “exciting” location you could land at was an aircraft carrier. I hated it. I could land the plane fine, but unless I hit the deck right where the landing strip began, I risked going all the way across it as I slowed to a stop, thinking I had made a successful landing, and then tipping over the opposite edge “into the drink.” I could have a completely successful mission, and then “fail” on the landing like this. I couldn’t tell if this was a bug, or if they made it this way on purpose.

The ones that got away

I always admired Starglider and Starglider II. I saw others play them. For some reason I never got them for myself. Maybe they had gone out of print by the time I got my STe.

Demos

Like I was saying in Part 1, I really liked the demos that were works of art. They were usually created at “demo meets” where coders would get together for annual conventions, and they’d either prepare the demos beforehand, or make them on-site. They were released for free on the internet. I used to download tons of them. They’d usually come compressed into disk images, which I’d have to decompress to one or more floppy disks, and then I’d try to run them. That was the thing. Sometimes they’d use tricks that were so specific to the machine they coded them on I had to be using the exact same model to get it to work.

The demos were about showing mastery of the hardware technology, showing just how much computing power you could squeeze out of the machine. I don’t know what went into creating them, because that was never my thing, but I’m sure there was a lot of assembly coding involved, maybe some C, and a lot of math. To the best of my knowledge there were no multimedia construction sets around for the ST, so each demo was a unique creation from hours of coding. Of course, they were all from Europe.

These are a few of the best demo examples I could either find on You Tube, or put up myself. “High Fidelity Dreams” and the “Synergy megademo” ran on most STs.

High Fidelity Dreams, by Aura, 1992

Edit 5-11-2017: There was a demo I’d mentioned before that I couldn’t get a screencast of because my computer was too slow. Someone else posted a video of it playing on an Atari STe, and I’ve added it here. Fair warning if you are easily offended, there is a little mature language in this video towards the end when the credits roll.

Grotesque demo, by Omega, 1992

You wouldn’t know it by watching this, but in my opinion this is was the best Atari ST/STe demo I’d seen for many years, in terms technical accomplishment. I remember it sounded really cool if I ran the audio through an amplifier! There are some strobe effects in the demo (probably not good to watch if you have epilepsy!).

When the credits roll the author gets into some of the technical specs. for the demo. Right towards the end the author put up a 3D cube that obscures some of the text. So here it is, misspellings and all:

It took me three weeks for the first version. One weeks extra for the final. I made an extra version because I found some bugs in the demo. And to make a new version more interesting, I added the vector objekts under this text. Just to show the speed of my polygon routine. Even I need to boast…

I have even made up some ideas for future demos. But I would be surprised if Omega released more demos on the Atari… Sadly to say, but the new Atari computers doesn’t live up to my ideals. And even more sad is, that my ideals are not unrealistic high… So for the moment I think that the Archimedes is the best choise. It only have 4096 colors, eight 8 bit sound channels, but the Archimedes 5000 model runs on 20 mips! It can move a half meg in one VBL. The Falcon moves about 56K in the same time…

But time will show us what computers (or media…) Omega will turn up next time.

Bye. Micael (TFE) Hildenborg

Brain Damage demo on the Atari STe, by Aggression and Kruz, 1993

Megademo intro., by Synergy, 1993

All of these demos came out in the early 1990s. I think they’re exceptional for the time period. The soundtracks rock! But that’s just my opinion. 🙂

I always enjoyed the Synergy Megademo intro. Members of the group as they introduced themselves flashed words on the screen that were on their minds. I thought this was unique and intriguing. It told you a little about them, but left you guessing. Some of them always gave me a smile, because of the sequencing, like: “hairy,” “Sharon,” “Stone.” Yech! What an image! 😛

I can explain some of the stuff in it:

“No Precalc”: A common trick in demos was coders would put precalculated tables or coordinates into the graphical parts, so it would look impressive, but the computer wasn’t working very hard to show it to you, just rendering data. Coders got more respect if they had their demo calculate the graphical effects, because it showed true optimizing cred.

“MULS”: A 68000 opcode for “signed multiply” of 16-bit integers.

“NO CARRIER”: This was a phrase computer users of the time were intimately familiar with, but you barely see anymore. It’s the message you used to get in a terminal program from an aborted phone call when using a modem.

“YM 2149”: This was the model number of the ST’s Yamaha sound chip.

“DTP”: This is an acronym that could’ve stood for many things. My guess is “desktop publishing.” There were a couple professional DTP packages for the ST.

“Autoexec”: There was a folder you could set up on an Atari disk called Autoexec where you could put executables, and the computer would automatically run them when you booted the machine.

“GFA”: This stood for GFA Basic, a programming language.

“133 BPM”: I thought at first this meant “bits per minute,” but it really means “beats per minute” for music.

“Front 242”: A lot of ST demos put the name of the industrial music group “Front 242” somewhere in their demo, usually in the credits. You see it in this intro. I tried listening to some Front 242 music to see what was so inspiring about it, but I couldn’t get into it. The music in these demos was usually real good, and I kept thinking it was from the group.

There’s also a graphic from an “Art of Noise” album cover, a group that was popular in the 1980s.

Edit 5-22-2015:

Summer Delights on the Atari STe, by Dead Hackers Society, 2011

An interesting thing about this one is it combines use of the STe’s Yamaha and PCM sound chips.

Edit 5/11/2017:

Sweetness Follows on the Atari STe, by KÜA, 2015

All the audio in this demo is coming from the computer.

Edit 3-29-2010: I’ve looked for Falcon 030 material to put here, but a lot of it has been lackluster. I just found the following demos, which were ported to a modified Falcon from the Amiga 4000 a few years ago. These demos play on a Falcon 030 with an accelerator card, containing a Motorola 68060 running at 66 Mhz. They’re some of the best I’ve seen on an Atari computer. I said earlier that in my opinion the best graphics & sound demos are works of art. These take what had been my concept of computerized art up to another level. They were created by a group called “The Black Lotus” (TBL). According to the descriptions, they contain some features unique to the Falcon versions. All the music you hear is coming from the Falcon as the demo runs. Enjoy.

Silkcut

Starstruck

Ocean Machine

Edit 5-22-2015: The Black Lotus does it again. They came out with a new demo for the Amiga 4000, and once again ported it to an enhanced Atari Falcon030 (with a 66 Mhz 68060 accelerator board). It came out in January 2015.

Rift

Edit 5/11/2017: I found yet another good enhanced Atari Falcon demo (run with a 68060 accelerator). Once again, it was originally written for the Amiga in 2012, and was ported by the same group for the Falcon, in 2013.

Kioea, by Mad Wizards

I finally found a couple good stock (unmodified) Atari Falcon demos.

In2ition, by Mystic Bytes, 2013

Electric Night, by Dune and SMFX, 2016

(The part that looks like it’s coming from a VCR at the beginning is coming from the demo.)

Atari popular in Europe

Atari had its success with its computers in Europe, not in the U.S. The ST was able to create some buzz in the computer industry the first couple years after its introduction, but after that its influence gradually faded away.

I went to the UK in 1999. While in Salisbury I visited an internet cafe. As I entered I noticed a shelf unit running along a wall. Piled on the shelves were old Atari STs and Commodore Amigas. I’m not sure why they were just sitting there. I talked to the guy running the shop, saying I was glad to see them. They brought back memories. I think he said people in the neighborhood dropped them off because they were getting rid of them. I can’t remember if the guy said he was giving them away, or what. Anyway, I’d venture to guess this would be an unusual sight in the U.S. The Atari ST didn’t make it big here. It might have gotten to 1-2% market share at most, and even that’s a rough guess. A lot of the people who bought them here were programmers and musicians.

The end of an era

There were 4 generations of Atari 16- and 32-bit computers before Atari (the consumer electronics company) faded away: 1) the original ST line, released in 1985; 2) the Mega ST line, which came out in the late 1980s; 3) the STe line, and the TT (their first 32-bit model), which came out in 1990/91; and 4) the Falcon 030 (the 2nd and last 32-bit model), which came out in 1992.

Atari had a complex history, but the company that was named Atari, which produced the home console gaming machines and computer lines, stopped making computers in 1993. They tried to focus exclusively on their video game systems. Atari faded away to nearly nothing. The company was bought by a disk drive manufacturer, JTS, in 1996. The purchase of the company was really a way to sell Atari’s intellectual property. The company ceased to exist for all intents and purposes. There were no employees left to speak of, and the Tramiels did not come over to JTS. A couple years later the IP was bought by Hasbro, and they brought out updated versions of some old Atari classic video games like Pong and Frogger. A few years after that the IP was bought by Infogrames. Infogrames officially changed its name to “Atari” in 2003. In name, Atari still exists, but it’s not the same company. The only legacy that still lives on from its former existence is its video games.

In my opinion Atari computers were a casualty of the internet, though I could be wrong. The PC was finally surpassing them in capability as well. When the internet began to get popular, Atari was caught flat-footed. You could always hook up a modem to an Atari, but it had no TCP/IP stack at the time, and no web browser or e-mail applications. This was true even on the Falcon. The Mega STe and TT had LAN capability, but that was used for P2P connections, if anything. I remember hearing in the mid-90s that someone had developed a free TCP/IP stack as a desk accessory. I believe it was called “STiK.” I don’t recall hearing about a web browser at that time though. The only browser that may have existed for it was probably lynx, an open source text-only HTML browser.

I kept using my STe until 1997, when I got my first Windows PC.

The passing of Atari and Commodore (they declared bankruptcy in 1994) from the computer scene marked the end of an era.

The first generation of personal computers

Beginning in the late 1970s many companies got in on the “personal computer craze.” By the early 1980s everybody and his brother was in on it, though this mass proliferation of hardware designs flamed out within a few years. When the shakeout was overwith, the only companies still in the business in the U.S. were Commodore, Atari, Apple, and IBM. Commodore and Atari made low-end and mid-range consumer machines, and Apple and IBM made high-end business machines. At some point in the late 1980s, IBM retreated from the personal computing business, largely due to the PC clone manufacturers who undercut it in price. It didn’t completely leave the business until a few years ago when Lenovo bought its PC manufacturing operations.

The era was characterized by an emphasis on what the hardware could do. The operating system was incidental. Different computers had different capabilities. This began to change with the introduction of GUIs and then multitasking to personal computers. The operating system became more visible, and you communicated with it more, rather than some programming interface. In the early machines it was always possible to access the hardware directly. In the 1990s this became less possible. The operating system became your “machine.”

Edit 11/17/2012: I used to like this idea of the operating system becoming your “machine,” but I now realize it gave no semblance of a computing environment, as the older machines did. You still had an “instruction set” of sorts, but it wasn’t as nice.

A common theme in the 1980s was that each system was incompatible with the other. You couldn’t exchange software or data, because each computer stored stuff in a different format. Each computer used a different CPU and chipset. Attempts at compatibility were tried through emulation, but it was rare to see an emulator that ran fast enough to make it truly useful to most people. Computers were not powerful enough then for software emulators to provide a satisfying experience. The best emulators were hardware-based, containing some of the original chip technology, like an Intel CPU, for example.

Eventually standardization set in. IBM became the standard business machine, with Microsoft becoming the standard bearer of the operating system that ran on it, and its clones. The Apple II and then the Macintosh became the standard computer used in schools and creative businesses, such as publishing. The Commodore 64 became the “standard” computer most people bought for the home, though the PC eventually took over this role once it came down in price. The same has happened with the schools, with PCs taking over there as well.

Returning to what I said earlier, what really changed the game in the 1990s was the internet. The computing platforms that have survived are the ones that best adapted to it. The ones we use today are a product of that era, though the GUIs we use are the lasting legacy of the 1980s.

Compute! Magazine

Back to reminiscing! I’m dedicating this part in the series to this magazine, because I think it was that good. Compute! was published from 1979 to 1994. Though it started out focusing exclusively on computers that used the MOS 6502 CPU, or some variant, like the Apple II, Atari 8-bits (400, 800, XL and XE series), and Commodore 8-bit computers (the PET, Vic-20, and C-64), it made a real effort to cover a variety of computer platforms. They added “support,” I’ll call it, (regularly featured articles and type-in programs) to the Radio Shack Color Computer (a Motorola 6800 8-bit model), and the Texas Instruments TI-99/4A (with the TMS9900 16-bit CPU) early on. Later they added the Atari ST, and the Commodore Amiga, which were 16-bit Motorola 68000 models. Last, they added the IBM PC to their roster.

They occasionally had some news items on the Apple Macintosh, but they didn’t cover it much, and never published type-in programs for it.

In Compute!‘s early days they covered a bunch of kit computers. Kit computers came as a collection of parts (boards, chips; possibly coming with a case, keyboard, disk drive(s), etc.) that adventurous consumers could buy. Using supplied instructions, solder, and a soldering iron, they literally built the machine themselves. Some were simple, meant to be educational, showing how a computer worked. Others were full-fledged computer systems. These machines dropped off the radar of the magazine by the time I discovered it in 1983. Eventually the Commodore PET and the Color Computer were dropped from it as well.

Appeal

As you can see, the style of the magazine was welcoming. I’d even call it “pedestrian.” It didn’t come off as an unapproachable technical magazine, but rather a magazine for “Home, Educational, and Recreational Computing.” As a teen it drew me in. The general format within matched this style for the most part. The articles and supplemental sections that were included in each issue guided you step by step on what you needed to do to enter the programs it contained, and use them. The overall feel of the magazine was “user friendly.”

It was literally everywhere, too. I’d often see it in the grocery store magazine aisle. Other computer magazines like Byte and Creative Computing were there, too. My grandmother got me gift subscriptions to Compute! out of the Publishers Clearing House sweepstakes whenever she’d enter.

Type-ins

One of the things I thought was great about the magazine was its type-in programs. The internet existed then, but most people didn’t have access to it. If people were plugged into a network it was a proprietary one, like CompuServe, and it was expensive. People paid for connection time by the hour, and in some cases by the minute. Flat-rate pricing for this kind of access didn’t exist then. So software was distributed on diskettes (floppy disks), or ROM cartridges. In most cases the source code for the software didn’t come with it. You were just expected to use it.

Compute! published the full source code to programs in their magazine. They published utilities, occasionally applications, and plenty of games. If you wanted to use the program you had to type it in first. They eventually added “disk” editions of their magazine, for a premium, which contained the most prominent programs they published, ready to run.

They kept things simple. They published programs in BASIC or machine code. It was rare if they published code in other languages. In many cases they intermixed machine code with BASIC, to achieve optimal speed for something. Machine code was encoded either in bytes in a string (they had notation in the listings to show you how to enter them) to make the code relocatable, or as decimal numbers in DATA statements in BASIC which were POKE’d into fixed addresses. Later they added MLX, a utility that allowed you to type a complete machine code program in decimal without having to write a BASIC program to create the machine code.

Some background

Every computer back then, with the possible exception of the Mac, came with a programming language, usually some form of BASIC. The operating system was almost invisible on most 8-bit computers. More often than not the BASIC language was your user interface, even if you wanted to do something like list the files you had on disk. There were OS-level APIs, but they were minimal, and you had to use machine code to access them. Sometimes the BASIC language you used contained built-in commands that would do what you wanted, adding a layer of abstraction. In many cases you had to POKE values into specific memory locations to get a desired result, like create a “text window” of a specific size on the screen that would word wrap, or custom configure a screen for certain graphics characteristics. On some models you couldn’t create sound without doing this. Compared to today things were extremely primitive.

Windowing systems for 8-bits like GEOS, and Microsoft Windows 1.0 didn’t come along until later. People by and large used these computers in “modes.” There were one or more text modes, and a couple or several graphics modes. It was possible to mix text and graphics. Depending on what you wanted to do, in which mode, you might have it easy, or you might have to jump through a lot of hoops to make it work in terms of programming the computer to do it.

One thing was for sure. If speed was your top priority you had no choice but to program in machine code (just typing in numbers for opcodes and data) or assembly language. Most commercial software for 8-bit computers was programmed this way.

For their time, these machines were rather advanced. They had graphics and sound capabilities that some of the more powerful machines of the day didn’t have, because the people who made them didn’t think that sort of thing was important. The majority of earlier computer platforms were harder to use, and less user friendly.

Compute!’s evolution

In the early days Compute! didn’t publish too much machine code. They mostly published articles in BASIC, because they wanted something that was easy to learn, and could be understood by mere mortals. In the early editions of the magazine they explained the programs to you.

Later on they began to add machine code. Usually it was in little dribs and drabs. Most of the program would be written in BASIC, so not much of the educational value was lost.

As time passed, the accompanying articles got less educational. This didn’t matter too much to me. I could get an idea of what was going on by going through the BASIC code, and learn some new ideas about programming.

For some reason they never got into assembly language. They could’ve gotten the speed of machine code and written something educational at the same time. I think they compromised. It seemed like their main principle was they always wanted to publish programs in the language they knew came with the machine, so that the reader didn’t have to go out and buy another language or an assembler in order to enter their programs and get them to run.

As time passed, they tended more and more to publish programs that were written entirely, or almost entirely in machine code–in decimal or hexadecimal, depending on the platform. They had a short program you could type in and use called MLX that allowed you to type in the numbers in sequence, save it as a binary file, and then run it. This was a real retrogression. Professional programmers used to program in machine code in a manner similar to this as a matter of course in the 1950s. It took all of the educational value out of it, unless you wanted to buy a disassembler and read the code after entering it.

I suspect this happened because more readers were buying the “disk” edition of the magazine, so it made no difference to the reader what language the program was in, unless they were interested in actually learning programming. Maybe Compute! came to see itself as a cheap way for people to get software without having to work for it.

In 1988 their flagship Compute! magazine quit publishing type-ins entirely. I remember I was heartbroken.

I had a subscription to the magazine for years, and getting each new issue was the highlight of each month for me. I read it cover to cover. I would often find at least a few programs I liked in each one, and I would eventually get around to typing them in. The magazine did a fairly good job of giving you enough of a description of the program so you could decide whether it was worth the effort. Often they included screenshots, so you could see what it should look like when you were done. It was always a joy to see it run.

Bugs

When I first discovered the magazine I learned quite a bit about debugging. You would type a line in, the BASIC editor would accept it (it was syntactically valid), but it was logically wrong. I had to figure out what went wrong. That was part of the process at first.

Eventually Compute! added checksums to their type-ins, and they gave you a short program called “Automatic Proofreader” that you could type in, and it would checksum the lines you typed for any program. You would enter the line into the editor, you would get the checksum, and you could compare it to the checksum they had by the same line in the published program. If they didn’t match, you knew you did something wrong. What made life interesting was their checksum program didn’t always help you. The Atari 8-bit version (the kind I used sometimes) wasn’t sophisticated enough to check for transposed characters. So it was still possible to type something wrong and not know until you ran it.

You had to be wary or patient with type-ins. Every month the magazine published code errata in a column called “Capute!” (pronounced “kah-PUT”).

Even though I looked forward to each issue, and would pick out what I wanted, I was often behind. Typing in those programs took a good amount of time, a couple hours at least. I was busy writing my own software sometimes, and I had a life outside of this stuff. So I’d usually get the corrections to something they’d published before I typed it in. It was kind of maddening trying to keep track of this. I literally had a list I updated regularly of programs I wanted to enter, what issue they were in, along with the issues for the corresponding errata. It would’ve been nicer if they had tested their stuff more thoroughly before publishing it, but maybe that was expecting too much.

Compute!’s amazing editors

Programmers who wanted to get their stuff published sent submissions to Compute!‘s editors. Usually it was for a single platform, like the Atari 800, or the Commodore 64. If their editors liked the program they 1) paid the author, and 2) they usually ported the original program to a bunch of different platforms. I never figured out how they did this. If they got a program that was originally written for the C-64, for example, they would port it to some or all of the following: the Apple II, the Atari 8-bit, the TI-99/4A (sometimes), the Atari ST, the Commodore Amiga, and/or the IBM PC. They usually published these versions in the same issue, so it was easy to compare them side by side. And with rare exception they did this every issue! Amazing, particularly since each platform was totally incompatible with the other, and they implemented things like graphics and sound totally differently. The editors didn’t try to make each version an exact clone of the original, either. They tried to keep the overall theme the same, but each would display the editor’s own style. About the only time a program would port easily was if it was just an algorithmic exercise, and its input and output was all text. That was rare.

Compute!’s franchise

The publisher did not just produce Compute!. They had a more popular magazine called Compute!’s Gazette that focused exclusively on the Commodore computer line. It was the same format as the flagship magazine, articles and type-in programs. Later they added platform-exclusive magazines for the Apple II, Atari ST, the Commodore Amiga, and the IBM PC & PCjr (the PCjr was a consumer model IBM produced for a brief time–the magazine was also short-lived), again following the same format. The platform-specific magazines continued publishing type-ins for at least a few years after the flagship Compute! stopped.

Compute! changed its format to focus exclusively on the needs of computer users in 1988. It continued on this path for about another 6 years, when it finally went under.

News & Reviews

Another thing I always looked forward to was Compute!‘s coverage of what was going on at the trade shows: the Consumer Electronics Show (CES), and Comdex. They covered them every year. I think I came upon Compute! at just the right time for this. The period from 1983-1985 was a very exciting time for personal computers. As I think I mentioned before in another post, everybody and his brother was coming out with a machine, though the bubble burst on this party within a year or two.

Reading about these events, and their reviews of newly released computers, I got a sense that I was watching history in the making. In hindsight I’d say I was right.

1984 saw the release of the first Apple Macintosh. Compute! covered the unveiling, describing the event to a tee, but printed no pictures of the event or the computer. For a bit there I didn’t even know what it looked like. For years I remembered some of the description of the event from this article. I was gratified to finally catch some video of it in Robert X. Cringely’s “Triumph of the Nerds” documentary, which was broadcast in 1996.

1985 saw the release of the Atari ST and the Commodore Amiga. My mind was blown by what I was reading about them. It was so exciting. These computers blew the doors off of what came before. Only the Macintosh could compare.

The best of Compute!

Since I’ve talked a lot about why the magazine was so great, I figured I should show you their best stuff. Here are what were, in my opinion, the magazine’s best type-in programs. I wanted to do more video, but I’ve had to struggle to show this much. So most of the depictions below are still images of them.

(Update 9/25/08: I’ve managed to add a few more videos below, replacing the still shots I had, and I added one more old favorite.)

This game was a thriller way back when. You played a treasure hunter, going through caves, leaving tracks as you went. A monster is chasing after you. You try to get all of the treasure before the monster catches up to you. The thrilling part is the maze generating algorithm sometimes forces you to backtrack and hide out in hopes that the monster will go right past you so you can escape behind it. The monster follows your tracks, but my guess is it doesn’t necessarily follow the direction of the tracks. If it sees tracks going in two different directions it looks like it makes a random guess about which way to go. You see this a bit in the video.

There was supposed to be a trick you could use to slip past the monster if it was coming right at you. The article said if you “shook the joystick” back and forth real fast you could get the monster to accelerate, and you could breeze right by it. I tried that at the end of the video, but no joy…

Even though it doesn’t look like it, the game had the feel of Pac Man. The gist was you’re a shopper in a store, picking up “sale items” (the dots on each level) in aisles, and baddies were chasing after you. You have a gun, and so do the baddies. What makes it interesting is the bad guys each had guns of different range, so you could get away from one at a short distance, but not from the others. The bad guys had decent AI, too. Fun game.

“Caves of Ice”, by Marvin Bunker and Robert Tsuk, on Atari 8-bit,September 1983, p. 50

As best I can remember this was the only 3D game they published. It was based on “QuintiMaze”, by Robert Tsuk, written for the Apple II. QuintiMaze was published in Byte Magazine. Bunker and Tsuk collaborated on this version. The goal was to escape from a 5x5x5 3D maze. The maze was randomly generated each time you played. There were no bad guys you had to watch out for, or time limits. It kept track of how much time it took you to escape.

Maze games and maze-generating algorithms were popular around this time in Compute!. A bunch of games of this type had been published before this, all 2D of course.

I liked this game because it had the kind of polish that I typically saw in commercial games at this time. The goal was to eat mushrooms and escape each room. Each time you’d eat a mushroom you’d grow longer. The catch was you were always moving forward, no stopping. You had to be careful not to trap yourself. The game also made it difficult to escape, making the exits very narrow. I don’t know if this was done deliberately or not, but the response time from when you moved the joystick in a direction to the time when it actually responded was slow. You had to literally think one or two moves ahead, or else you’d screw up.

The point of this game was to dodge obstacles in all sorts of ways. You had to jump, flip, and slide to get over and under stuff coming at you. It was a sideways scroller. It was unique because it had a moving background to convey motion, and the action with the obstacles got complicated. It was a “thinking” action game. You had to think fast on your feet.

“SpeedScript”, by Charles Brannon, on Atari 8-bit
(Image from Wikipedia.org)

SpeedScript was originally written for Commodore 8-bit computers by Charles Brannon, and published in the January 1984 issue of Compute!’s Gazette (see the link). It was later ported to other platforms.

They also published “SpeedCalc,” a spreadsheet program.

Years later I got SpeedScript off of a BBS. I wasn’t crazy enough to type in the whole program. It was long. When I got my own 8-bit computer I bought a commercial word processor along with it. I found SpeedScript quite handy for viewing text files, though. It had a small footprint on disk, and was quick to load.

The action in this game reminded me of some coin-op video games I saw at the time, though this was nowhere near coin-op quality. You’re a stunt biker trying to jump a bunch of cars. You had to get your bike up to the right speed to make the jump, or else you’d crash. You also had to make sure you didn’t accelerate too quickly, or else you’d wipe out before you made the jump. Each time you successfully made the jump, another car was added, so you had to increase your speed to the jump each time. Neat game!

The above video is my meager attempt at a demo, playing both sides. It’s not that interesting in terms of strategy (I barely had one for each side), but it shows some of the action. I didn’t play a complete game, because one side’s laser got blasted. I figured after that the end was inevitable, and not very interesting.

Laser Chess was one of the few programs Compute! published that had a lasting legacy. It was originally published in a 1987 edition of Compute!’s Atari ST Disk & Magazine. Mike Duppong had won a $5,000 programming contest put on by the magazine, with this game. He originally wrote it in Modula-2. It was adapted by Compute!’s editors for the Amiga, Commodore 64, Apple II, and the Atari XL/XE, using BASIC and machine code.

Update 12-21-2013: There used to be online versions of this game, but I haven’t found them recently. Other versions of it are out there, if you look for it.

I could see that there was something special about this game, but it was not one that I got into much. I was never that good at playing chess to begin with. Not to say that chess strategy was necessary here, but rather it evoked its own strategy, and it was complicated in its own way. In regular chess you strategize based on the position of pieces and how they can move. Here, you strategize mostly by position and orientation of pieces, though it’s possible to capture pieces by just moving yours on an opponent piece’s square, as in regular chess. The difference here is each player gets two moves per turn, and every piece can only move one space in a lateral direction (forward, back, or sideways) per move. You could move one space diagonally by taking a shortcut that combined a vertical and sideways move, taking up a whole turn. You could also rotate a piece, which counted as one move. This added another dimension, because most pieces have a reflective surface. The reason being that each player has a laser. If you positioned your pieces in the right orientation at the right time you could blast an opponent’s piece off the board! Firing the laser counted as one move. Each side could only fire their laser once per turn.

You had to be careful setting up your laser shots. Your opponent could use your pieces’ reflective surfaces against you. You could also accidentally kill one of your own pieces if you didn’t carefully consider where the laser beam went.

Each side also had a “hypercube” piece. When you moved it onto another piece’s square it randomly placed that piece on an open space on the board. I didn’t use it in the above video. I think it was the hollow square piece.

“Crossroads”, by Steve Harter, on the Commodore 64,Compute!’s Gazette, December 1987

This game was published exclusively in Compute!’s Gazette. I only know about it from a friend who used to use Commodore computers. This game is one of the greats. It’s still remembered by the people who played it.

I’ve played it a bit. You’re a guy trying to pick up “shields” (they look a bit like swirling Japanese flying stars), and meanwhile beasties are trying to chase after you and eat you. Picking up shields makes you more resistant to attack. You have to pick up a certain number to go on to the next level. The baddies can pick up the shields as well, and gain strength from them. You have to kill them to get their shields.

What was unique was that the beasties would go after each other as well (that’s the mayhem you see in the screenshot above). Sometimes you could provoke them to do this, to distract them. It was a pretty involved game. I would’ve liked to have posted a video of this, but no matter what I tried it didn’t turn out well.

“Screen Print,” by Richard Tietjens, April 1988, p. 64 – This was a utility (so there’s no picture for it), but I thought it really deserved a mention. Screen Print was one of the last programs they published for the Atari 8-bit. It was one of the most useful utilities they ever published, in my opinion. I could literally give it any Atari graphics file format, it would decode it properly, and display it on the screen. If I wanted it to, it would also print out a nice copy on my dot matrix printer.

Something was curious about it though. As I typed it in I noticed a couple of code sections labeled “Poker” in the comments. At the time I had no idea what it stood for.

I had gotten my own Atari 8-bit computer and a modem around this time (I explain this in Part 1), and I began to explore BBSes. Somewhere along the line I found that people had uploaded graphics images from the computer game Strip Poker. Duh! I was a teenage boy. Of course I downloaded them! I tried looking at them with a simple bitmap viewer I had written, and all I got was garbage. They were encoded. Made sense. They didn’t want people peeking. You had to win some hands in the game to see the naughtier pictures. It occurred to me one day, remembering back to when I typed in “Screen Print,” “Hmm. There were those sections called ‘Poker’. I wonder…” I loaded it up, tried it out, and sure enough it loaded those Strip Poker images just fine. 😉 I wonder if the editors at the magazine knew about this. They certainly didn’t mention it.

Strip Poker was a computer game that had been out for a long time, made by Artworx. I remember seeing (tasteful) ads for it in my earliest issues of Compute!, going back to 1983. The earliest versions of it ran on 8-bit computers: Atari, Commodore, and Apple, using artistically rendered graphics (no digitizing). Later versions of it were made for the Atari ST, and Amiga, and eventually the PC. Amazingly, Artworx is still hanging on, making the same product!

Honorable mentions

There were other games Compute! published that I enjoyed, but I put them in a bit of a lesser category. It’s subjective:

Outpost, by Tim Parker, June 1982, p. 30 – A character-based (as in, ASCII), turn-based game where you had to defend yourself against computer-controlled attacking ships. It reminds me of the old Star Trek game, but you were stationary.

Goldrush July 1982 – You mined for gold with explosives. You had to watch out for cave-ins, and try not to get trapped with no dynamite left.

Ski! (Slalom), by George Leotti and Charles Brannon, February 1983, p. 76 – You skied down a mountain, went through gates, avoided obstacles, and picked up points.

The Witching Hour, by Brian Flynn, October 1985, p. 42 – It was published for Halloween. It was witches vs. ghosts, kind of like checkers.

Switchbox, by Compute! Assistant Editor Todd Heimark, March 1986, p. 34 – Kind of like Pachinko, but since it was in BASIC, much slower.

Chain Reaction, by Mark Tuttle, January 1987 – A unique turn-based game. You played on a board with “explosives.” It really functioned more like a combination of a nuclear chain reaction and Reversi. You played against an opponent. Each space on the board had a different “critical mass” for explosives. If your space exploded, it would shoot explosives of your color into the adjoining spaces, changing the color of all explosives in that space to your color, and adding the new explosive to the ones already there. This could set off–you guessed it–a chain reaction. You tried to reach “critical mass” with your explosives in just the right places at just the right time to gradually change all of your opponent’s colored explosives to your color. It was an easy game to play. You literally could set up chain reactions that would go on for about a minute. But then, this was mostly due to the slowness of BASIC.

There’s a site dedicated to Compute! articles. They’ve gotten permission to publish many of them on the web. There are many they haven’t obtained permission for, and so you see them mentioned, but no links to articles. When Compute! went under, all copyrights reverted to the original authors. So anyone wanting to republish articles legally has had to try and track down the authors and get their permission. A real pain in the keester. 😦

Edit 5-11-2012: Ian Matthews has digitized every issue of Compute! into searchable PDF format. Now you can read full issues, all the articles, see all the programs with full source code, and see what was selling and what it was selling for (yikes!) Now (hopefully) Compute! will live on in posterity where everyone who wants to see it can find it. He broke up many of the issues into sections, as the PDFs get pretty large to download.

I updated all of my Compute! links in this post, so that you can look at the articles for yourself. This way you can finally see these issues as I saw them. Matthews has requested that if people want to view more than a few issues on his site that they purchase a DVD of the complete set, as downloading a bunch of issues will cost him in bandwidth. So I’m not linking directly to his PDFs.

I envisioned doing something like this about 15 years ago, but felt squeamish about it 1) because of the copyright issue, and 2) when I learned that the best way to do it would destroy every issue I had. I’d have to separate every single page from its binding (using something like a razor blade) and then run it through the scanner. I’m glad someone else had the courage to do it right. 🙂 Here’s a video Ian made, showing every single Compute! cover, from the first to the last issue.

Conclusion

The time while Compute! lived was a happy time. I still have fond memories of it. I guess today young, aspiring programmers are getting the education I got by working on open source software. Compute! was the open source software of the time, as far as I was concerned. It wasn’t the only magazine that did this, but in my opinion it was the best. There were other magazines publishing type-ins for Atari computers, like Antic, and A.N.A.L.O.G. I switched to Antic when Compute! stopped publishing them. I can’t remember, but I may have kept on with them until they went under. I found out about Current Notes in college, and came to really like it. No type-ins, but it had interesting articles on all things Atari.

Compute! was a key part of my education as a programmer. The thing I loved about them was they always had a focus on making computing fun. Sure it was frustrating to spend hours typing in a program, and debugging it, but when you were done, you got what you wanted, and you learned some things. Secondly, they had the notion that everyone could share in the experience. They hardly ever published a program for just one computer. They made sure that most of their subscribers could enjoy a program even if the original author only wrote it for one platform. That was mighty generous of them. I imagine it was hard work.

In closing I’d like to thank the editors of Compute!: Robert Lock, Richard Mansfield, Charles Brannon, Tom R. Halfhill, and anyone else I’ve forgotten. You helped make me the programmer I am today, and my teen years something special.

Apple ][

The most commonly found computers in public schools in the early to mid-1980s were the Apple ][ plus and //e. These were 8-bit computers, running MOS 6502 CPUs (or some variant), running at 1 Mhz. They typically had anywhere from 48 to 64 kilobytes of RAM. They were the models Apple made before the Lisa and Macintosh.

When they finally installed a computer lab at my junior high school, around 1984, I got myself acquainted with Applesoft BASIC, which was a version of Microsoft BASIC. What was kind of unique about it is in addition to being an interpreter used for program development, it functioned like a command line for the computer’s operating system. After booting with a floppy diskette, which contained Apple DOS, you could do every disk management function by typing commands into it, rather like the MS-DOS command line.

Programming

I mostly used BASIC with the Apples, though I got into Apple Pascal my senior year in high school. Like with Atari BASIC (which I mentioned in Part 1), each segment of Applesoft BASIC code (which could contain several commands) had to have a line number for sequencing and labeling.

Fortunately over the last several years I’ve been able to scrounge together some images of my old Apple II disks that I can run in an emulator, so I can show some of the stuff I did while I was in school.

The music you hear for the next two videos is just some MODule background music I picked, playing on my PC. The first for the video below is called “Leave the brain at home.” This video is of a computerized version of Mad Libs.

Ad Libs

Since I was in about 5th grade my friends and I loved to play Mad Libs. The problem was we’d always write our substitution words in the books we’d get. If we wanted to play them over again we’d have to erase what we wrote in before, eventually wearing out the paper. I thought this was wasteful, so I tried to computerize the game. I wrote a suite of programs when I was in junior high school: Ad Libs Creator, Ad Libs Displayer (what you see in the video above), and Ad Libs Editor. Creator and Editor were rudimentary. I didn’t have a very sophisticated concept of text at the time. The best I could do with the skills I had was to have the user enter each word and blank of their Mad Lib one word/blank at a time, at prompts. Not user-friendly. Displayer was rather popular with my friends. When I was in the computer lab I’d sometimes hear them laughing off in some corner. One day I went over and asked them what was so funny. They said they were playing with my Ad Libs program. How gratifying! 🙂 That was the idea, to make the game fun to play.

Trying to get published

Compute! was my favorite magazine. I had a subscription to it for years during the 1980s. I looked forward to each issue with bated breath, and I read it cover to cover. The most exciting things for me were the type-in programs. Each issue had programs people had submitted to the magazine. The editors would pick some and publish them in BASIC, with complete source code. The original idea, I think, was to create an educational vehicle. Readers were expected to type in the programs, and when done, use them. The early issues had articles that explained how the programs worked, part by part. I found them very educational.

I updated my Ad Libs programs some in high school. I felt as though I had finally gotten them debugged and in a form I liked. I decided to try to get them published in Compute!. I spent what felt like months writing and editing my article that would go with them. Once I felt that was done, I took my shot. I put my programs on disk, printed out my article, and sent them to the magazine. Some months later I got a rejection letter. I vaguely remember one of the things it said was they did not take unsolicited material. It also said that regardless, my article and programs didn’t fit in with their editorial focus, or something. Sigh… Anyway, that was one lesson learned: Pass the idea by one of the editors first. Give them a summary of what your submission will be about before you go through the trouble of writing it. That way if they don’t like it you haven’t wasted the effort. I didn’t write these programs to get published, but I figured I’d try.

Trying again, or…not

The background music for this video is a MODule called “Earthquake”.

Week-In-Advance, written in BASIC, compiled using Einstein BASIC compiler

In the 1980s it was common for computer shows to take place at local malls, about once a year. I looked forward to them every time. I could spend almost a whole day at those things. One of those times I saw an Apple Lisa on display. It was around 1985, or later. I had the opportunity to try it out. I remember I was running a calendaring application on it. It would show me a month in the traditional calendar layout. I could click on individual days in the month, and it would bring up a form where I could enter new events for the day. This was so it could post reminders about upcoming events for the user. It made quite an impression on me. I must’ve thought, “Gosh, I could use something like this!” When I was in junior high and high school I often wrote down due dates for assignments and tests in a pocket notebook I carried with me. It got confusing and messy sometimes. I wanted something that was better organized. The only computers I could program on in the school were Apple IIs. I don’t remember when, but at some point while I was in high school I resolved to write my own scheduling program. Inspired by the way the Lisa worked, I wanted to create my own windowing interface. I made an effort to make it easy to use. From the outset I wanted to try (again) getting it published in Compute!.

Not being that great with graphics, I decided to do it all in text mode. It’s hard for me to remember how long it took. From the time I started on it, I was done with it anywhere from 6 months to a year later. I’d spend 1 or 2 hours a day on it if I didn’t have a heavy homework load. It was a real learning experience. There were some hard skills I had to learn in order to accomplish what I wanted.

I tried out a couple different interface designs, which I threw out, before I finally figured out how to create expanding and shrinking windows. The main problem I had with the other two designs was they were too slow.

One of the things I realized was the only way I could manage the amount of code I was creating was to break it up into “procedural” chunks that I could GOSUB to and RETURN from. If I had done it in a language like Pascal it would’ve been easier, I think.

The next realization I made is I needed to be able to edit events, not just add and delete them. So I created my own little text editor, which you can see a couple times in the video. It shows up as a subwindow inside the larger events window, where events are listed for a day. I don’t show all the features of it in this video. You see me just appending text to an event. I could put it into “insert mode”, or delete characters, through a couple of key combinations.

The last realization I made is I couldn’t use the program all the time. I didn’t have time to make it to the lab every day so I could view the things I had coming up. I needed a way to print out my schedule. So I added that (which I couldn’t demonstrate in the video). Finally, in February 1988 I got it all done.

I used it for real scheduling for about 5 months, until I graduated. It worked well. It was my first experience in creating something that was actually useful. Too bad I didn’t start on it sooner.

By the time I was done I had sworn off trying to get it published. It had grown way beyond the size I was anticipating, to about 800 LOC (program lines on the display, not in line numbers). The print columns in the magazine were narrower than the columns displayed for a listing on the screen. I figured it would be too large to publish. It may not have made a difference. Compute! would stop publishing type-ins in May 1988, though I think their platform-specific magazines (they had one for Apple IIs) continued to publish type-ins. Anyway, that’s water under the bridge.

Looking back on it now the interface design had some flaws in it, but I felt very satisfied with it at the time.

Apple II music video

I thought this video deserved an honorable mention. Someone wrote a BASIC program in text mode to create a computerized music video for a song. The music you hear is not being output by the computer (it didn’t have the power for that), but the computer’s display is synchronized to the music using wait loops.

At the end you see some of the code that was used to generate the display, and the Apple II computer itself. The square box to the left of the computer is the 5-1/4″ floppy disk drive for the machine.

Games

There were many classic games for the Apples. These are some that made an impression on me. I put up the next 3 videos on YouTube. Karateka was put up by someone else.

Star Blazer, by Tony Suzuki, Star Craft, Inc.

You go on 3 missions: 1) bomb a radar dish, 2) bomb a fast tank while ships fly at you, and 3) bomb a radar dish while balloon-launching ships try to blow you up (the balloons have bombs attached). It’s been years since I played this game, so my technique is not so good as you can tell. I remember what I used to do with the tank is I’d get some “yo-yo” action going with it, back and forth, and then I’d fly up and forward, get a little bit in front of the tank, then drop down fast and launch a bomb. This would cause the bomb to drop faster than usual, hopefully on the tank. Timing was crucial.

One of the challenges is going after your objective while also picking up fuel packets that are dropped by parachute by an orange craft that flies across the top of the screen every once in a while.

Drol, by Aik Beng, Broderbund Software

Choplifter, by Dan Gorlin, Broderbund Software

Karateka, by Jordan Mechner, Broderbund Software

This was one of the few adventure games I saw on the Apples. It has some properties that appear in today’s fighting games, like a real-time health indicator for each fighter. The goal was to kill all the fighters, including the “boss” character at the end, and rescue the princess. Getting past the fighters was pretty straightforward for me, though as you see in the video, you had to remember to get into the fighting position to defend yourself, otherwise you get killed in one punch. There were a couple tricks in the game. One was a razor sharp doorway that looked like a set of vertical bars (like in a jail). You had to figure out how to get past that. Once you get past the “boss” you had to be careful how you approached the princess. If you went into her cell in fighting position, she’d kill you in one kick. You were supposed to stand up straight and run in. Once I figured these things out the game was pretty easy to beat. It was challenging enough that it was fun, but after a while it got boring except for the graphics and sound effects.

As you’ll notice most of the games I cite here were from Broderbund. On the Apple they were quite the game company. They had many excellent titles.

There were some other games I played, like Sabotage, Russki Duck, Apple Panic, Canonball Blitz (a game like Donkey Kong), and Horizon V. I’m familiar with Aztec, Robot Wars by Muse Software, Castle Wolfenstein by Muse Software (the inspiration for Wolfenstein 3D, and Return to Castle Wolfenstein on the PC), Bilestoad, and the Ultima role-playing series, because I used to watch other kids play them.

In terms of graphics a lot of these were not high quality, but I think all of them really utilized the hardware to its potential, and had interesting gameplay. Even though the sound quality was not good (all you had was the internal speaker), a lot of times these games had sound effects that did not appear in the Atari 8-bit versions for some reason. Not as much effort was put into them.

Here’s a long video of me playing Robot Odyssey.

Robot Odyssey, by Mike Wallace and Leslie Grimm,The Learning Company

This was a sequel to another educational game called “Rocky’s Boots,” which put the learner through a series of challenges, one per room. You solved them by building circuits in the rooms out of logic gates. This game is similar, except the player is programming robots, and they work autonomously. The interiors of robots are really like “rooms.” Even though they’re all the same size, you can put robots inside each other. The player has to pick up certain items and go through mazes throughout the game. S/he is usually prevented from doing so by “sentries.” In these cases the player needs to program a robot to go get items or take him/her through mazes.

I don’t show you all the action. I tried to just show the interesting stuff (not always succeeding). The audio gets behind the video towards the middle. That’s the fault of my screen capture software.

When I was a teen I found this game fascinating. It was the most advanced gaming environment I’d seen. Things happened in real time. Even if you walked out of a room, it didn’t mean everything had stopped. This was often the case with other 8-bit games of this style. Things only happened in a room if you were in it. In this game you can get a robot going doing something, leave the room and go do something else, and then come back. Everything will have happened as if you were in the room with the robot the whole time. I learned a lot about building logic circuits through “Rocky’s Boots” and this game.

Graphics resolution was a problem. It was hard building anything but basic circuits, because if you built something complex you’d get a jumble of gates and connections, and it was difficult to sort out. Fortunately the game gives you a “chip lab” where you can build your circuits inside a prototyping chip, “burn some EPROMS” from it, save the chips, and use them in the game. This keeps circuitry manageable.

My high school had this game and I played it every chance I got. I never finished it. Since I have an emulator now I’ve taken time to play it from time to time. The gameplay is not so nice anymore. I’m used to better environments, but I still hope to finish it. 🙂 There’s nothing else like it out there today.

The original Flight Simulator, by subLogic

This was the predecessor to Flight Simulator II, which was bought and developed further by Microsoft. Flight Simulator was extremely simple. It had no sound effects. The only graphics you had were wireframe. You couldn’t hit anything except the ground, and you could land anywhere. You could “declare war” and “enemy planes” (dots) would come up to fight you. I found this mode more frustrating than fun. You could shoot at them (I think), but you had no targeting crosshair or tracer bullets, so you had no idea where you were firing.

I could never get used to FS II, particularly on the 8-bits. It was too boggy. You would start into a turn, and realize 5 seconds later how deep a turn you went into. I found it impossible to maneuver. Even though this version is also slow, it ran at a fast enough speed that I didn’t get too surprised by what I saw happening. The instrument panel made more sense to me, too. The graphics were crap. Most personal computer users of the time probably didn’t realize it, because it was the best 3D graphics people knew how to do on such a limited platform.

I had a lot of fun with the Apples. I did some of my most creative work with them as a teenager.