Reminiscing, Part 3

Compute! Magazine

Cover of 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.)

“Superchase”, by Anthony Godshall, on Atari 8-bit, October 1982, p. 66

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…

“Closeout!”, by L. L. Beh, on Atari 8-bit, March 1983, p. 70

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

“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.

 “Worm of Bemer”, by Stephen D. Fultz, on Atari 8-bit, April 1984, p. 74

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.

“Acrobat”, by Peter Rizzuto, on Atari 8-bit, February 1985, p. 56

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

“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.

You can find the following issues here.

Commodore 64 version, March 1985, p. 124

Commodore VIC-20 version, April 1985, p. 100

Atari 8-bit version, May 1985, p. 103

Apple II version, June 1985, p. 116

“Biker Dave”, by David Schwener, on Atari XL/XE (8-bits),
November 1986, p. 38

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!

“Laser Chess”, by Mike Duppong, June 1987, p. 25
Atari XL/XE translation by Rhett Anderson, Assistant Editor

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.

I referred to this game in another post on learning Squeak, since Stephan Wessels had published a tutorial whose end product looked similar to it.

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.

Edit 5-13-2012: I couldn’t resist this. Here’s a hilarious scene from “The Big Bang Theory” TV show where the gang plays “secret agent laser obstacle chess.” 😀 It’s from Season 2, Episode 18, called, “The Work Song Nanocluster.”

Crossroads

“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.

Laser Strike, by Barbara Schulak, December 1986, p. 44 – A clone of Battleship.

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.

—Mark Miller, https://tekkie.wordpress.com

Advertisements

24 thoughts on “Reminiscing, Part 3

  1. I was 18 at the time the Byte magazine article was published. I only entered due to the repeated urgings of my Mother. It’s lucky for me that she was so persistant; the proceeds paid for my Atari 800.

    Marvin Bunker ported QuintiMaze to the Comadore and contacted me about submitting both versions to Compute! By then I’d gotten the Atari so I quickly ported it and we submitted all three versions.

    Amusingly enough, the “algorithm” to generate the maze in QuintiMaze didn’t guarantee a path from the start to the exit.

  2. The Compute cover you have scanned here is actually the *first* computer magazine I ever bought. I played Acrobat, Chain Reaction, and Goldrush on the 8-bit Atari not knowing they were Compute! games. Acrobat was especially well done. I played Laser Chess on the Atari ST with some sort of Compute! Compendium type diskette.

    I loved those days. Just think… you could get a magazine like *that* at a *grocery store*. Incredible. Now it’s rare for me to see anything in stores that I particularly want. I hate the “serious” programming magazines we have now… that have editors that go on record as not having room for “fun” stuff. Bah.

    I was too young to ever get around to mastering 8-bit machine langauge. I did my share of Display List Interupts and custom character sets. I thought I was hot stuff with 256 colors compared to my more well-to-do green screened Apple ][ owning brethren. I did more programming on the ST with GFA Basic making buttons on the screen for a spaceship control panel and a window showing graphics of the stars hurtling by….

    It’s kind of heartbreaking to think that the generation of type-in programming was at the core of the “popular culture” that Alan Kay talked about entering the scene to destroy the chances of the Next Revolutionary Computer Language…. Upon seeing that Basic was the automation language for MS Office, I immediatly began buying books and learning to be a corporate code monkey. The fact that code was in nearly the same language I wrote in as a kid made me think I could handle professional development no problem! Heh.

    (Of course the VB6/VBA IDE was an order of magnitude worse than the GFA Basic editor. GFA Basic was *fast*. It auto-indented your text. It was a pleasure to use compared to the idiocy of the modal dialog box in VBA that pops up every time you enter a line with a syntax error. Argh!)

    The generation of gamer-geeks that followed me were all Nintendo kids. They had no concept of the glories of a “READY” prompt. I just couldn’t relate. After that came the first-person shooter generation and the multiplayer-online-rpg addicts. That’s a long ways away from M.U.L.E. and Archon. Unix and C are similarly scary too me. More than Microsoft, those platforms represent the evil “Master Control Program” to me. I can totally see myself waking up one day and finding myself being forced to play video games against conscripted Linux programs.

    I was subscribing to Compute! when they made the change to dropping all of the type-in programs. That was a sad day. At the time I didn’t realize how temporary, how fragile was the computing scene of the times. It’s very much like how a movie like Tron could have only been made at the moment that it was. “Because somewhere in one of these… memories… is the evidence!” Ah, those precious days before spam, spyware, and ubiquity. If I could do it again, I would go back and finish my pet projects and get them published– but I had no idea what kind of time constraints I was under and missed my chance. Writing short Lisp programs and publishing them to a modest audience via blogging is as close to that as I’m likely to get, now.

  3. @Tsuk:

    I’m so tickled you happened past this post! It’s great hearing from a Compute! author! Thanks for coming by. 🙂

    @Lispy:

    I chose that cover because I feel like it really captured the spirit of why I loved the magazine.

    I almost didn’t include this as the 3rd part. I was going to focus on the Atari ST (which is coming up next). I got inspired by a conversation I had with Justin James in Part 2 of this series, where I talked some about my attempts to get my own programs published (I failed). I realized that Compute! should be included in this.

    I didn’t write this series to bash that period of time. I really enjoyed it. What I realize now is that it could’ve been better.

    Looking back on it now it feels amazing that what happened occurred at all. I mean, think about it. People were inspired to try to learn programming. The culture was everywhere. Schools in the late 70s and early 80s considering programming an important part of “computer literacy”. This changed in the mid-80s to “learn word processing, spreadsheet, and database”–the present Office suite, basically. My guess is the reason programming was pushed at all was that at the time the software market hadn’t matured. There were still a lot of things that people felt they needed to get done on computers. The software for it didn’t exist yet. I think by the time this changed in schools the software market had matured sufficiently that schools felt safe about shifting the focus to computer use, rather than computer programming. There was more of a demand for understanding how to use computers, not make them do exactly what you want. I think we can see this in the decline of the technical/programming magazines. People had tried it. Most of them probably found out they didn’t have the patience to try to learn what programming was about, and just gave up on it. Computer science teachers struggle with this today. Mark Guzdial, a CS professor at Georgia Tech was just talking about this recently: “What makes programming so hard?” In teachers’ experience there are always a certain number of students who “get it” easily, while the rest struggle to a certain degree.

    I didn’t notice this until several years ago, but what happened to the programming languages that used to come with the computers? It seemed like in the early 1990s PC vendors stopped including languages (BASIC) with their machines. GW-BASIC used to come with IBM PCs and its clones. That stopped, too at some point. I remember when I got my Atari 130XE it came with a brief beginner’s tutorial on BASIC. All of that went away, and with it any chance that people would just become inspired to try it because it was there.

    It seems like this is coming back some. Compilers for C# and VB.Net are installed by default on Windows Vista, though I have no idea if Microsoft is making any attempts to tell people about them, or why they should be interested. Microsoft has made “express” versions of its .Net IDE tools available to hobbyists for free, but since there are no venues I know of that focus on “programming for fun” I don’t see how too many people are going to get inspired, except if they perceive that this is a growing field again that can make them a lot of money. HA!

    I’ve heard about Ruby being installed on Macs by default. I don’t know about their Objective-C/Cocoa development package. I assume that’s easy to get. But again, I don’t know if they’re telling computer owners that these things exist. You would think that with all the complaining about a shortage of programmers these companies would get on the ball and “seed the market”, if you will.

    Re: machine language

    Yeah, I didn’t want to touch that with a 10-foot pole either. Somehow the knowledge of “pointers” sunk in though. A lot of the programs in Compute! talked about “addresses” and such, so I had a clear view of the memory model. When I was taught pointers for the first time in Pascal in college, it didn’t feel like that big of a concept. I was already “prepped” for it. The same was true when I took a course that taught assembly language. I was mortified that I was going to screw up so badly in it, but it was fine. I really surprised myself. We were working in Motorola 68000 assembly, and my programs would run correctly on the first, second, or third try. It was amazing. I hardly ever had that kind of success in the higher level languages. I think the reason was that we had the M68000 programming manual, and it explained exactly what each instruction did. There was absolutely no ambiguity. So things became very predictable. In contrast with the HLLs I was used to there was vagueness in documentation, more complex structures, and inconsistent semantics.

    Re: Tron

    Tron is one of my all-time favorites. What I think is amazing about this movie in hindsight is it has a storyline that people can still relate to today vis a vis Microsoft, particularly the part about the corporate entity “stealing software”, like you were saying. There was a movie made in 2000 called “Antitrust” that followed the same storyline, which was more clearly aimed at Microsoft, except without all of the eye candy. 🙂 What wowed me about Tron was the computer graphics. I remember the first time I saw it my mouth was hanging open almost the whole time. I couldn’t believe what I was seeing! They blew every other graphics system I had seen out of the water. I felt like I had been transported into the future in a time machine, to some other time when computers were capable of this stuff. I couldn’t believe they were capable of it then, because nothing I had seen even came close to comparing to it.

    I doubt the storyline in Tron was based on Microsoft at all. It was still a young company. It hadn’t even gone public by then. My guess is it was modeled on the corporate image of IBM. It was the “big bad boy” of the computer industry then. That’s why Steve Jobs went after them with a passion.

    Re: Unix

    I got my first introduction to it in college. It took some getting used to, but I had help. I fell in love with it for a while, mainly because of its capabilities. It could multitask, run tasks in the background (unlike most systems I’d seen at the time), and it had a flexibility about it which allowed it to adapt to different situations easily. What I came to dislike about it after using it for several years was that it got to be tedious and boring. So much had to be done on the command line. There was X/Windows but the apps. for it weren’t that great. There wasn’t enough GUI software to make it something I could use all the time. I still had to work with a command line most of the time, and batch files. I’m sure this has changed with Linux since then. A lot of open source apps. now run in a GUI.

  4. Mark –

    A few blanks needing flling in…

    Windows came with QBABIC for a while, but not any more. 😦

    Mac’s come with XCode right on the OSX CD (easy install), and Apple trumpets this on their site. I would imagine that Ruby, Perl, Guile, and gcc (therefore, C, C++ and Pascal, I beleive) are also installed, given that OSX is BSD underneath, and requires many of those items.

    Something has definitely changed in the industry. Trade shows have virtually stopped. The excitement is gone. The “journalism” has largely been replaced by “bloggers”. Remember when David Berlind was a credible source for factual information? Now, all he does is blather opinions about “Web 2.0”. Even on TechRepublic, it is much easier to get “fluff” pieces published. I have been told that they are cutting back on the reviews, in favor of things like the”How do I?” and “10 things…” pieces.

    The “industry” is dead, and is replaced by something both significantly more “amatuer”, yet less helpful to the “amatuer” at the same time. It is a strange paradox.

    J.Ja

  5. Regarding the Tron graphics:

    There were three different companies that each had jury-rigged 3D graphics systems. Each system could do different things well or poorly depending on their design choices. For instance, the Tron assemblage sequence in the opening credits is a totally different system than the solar sail and kaleidescope systems.

    The french comic strip artist Moebius (Jean Giraud) assisted the creators of Tron with some of their designs.

    Regarding the message of Tron:

    I think they had a real feeling that the home computer systems were going to set “the users” free from the tyranny of the egotistical Unix admins that parceled out time and access in a very stingy manner.

    It turns out that that was a freedom the masses didn’t really want:

    http://www.xxeo.com/archives/2007/10/15/ken-olsen-was-right-we-dont-need-computers-in-the-home.html

  6. Another thing:

    It blows me away that so few programming geniuses of the 8-bit era continued on into the later generations of computing. My hero, J D Casten, had a very rude awakening when walked into his first computer science class:


    1983 Moving back to Eugene, I was delighted to have my first computer game accepted to be published. Having few friends, and some luck already, I dedicated myself to programming, to some measure of success….

    1986 Failing to enter Stanford (I blamed it on a teacher of mine who forgot to submit the recommendation form he was supposed to fill out for me), I entered the UO. My Computer and Information Science advisor was unimpressed with my claims to computer knowledge, and I drifted towards the journalism route….

    http://www.jd.casten.info/Personal/Bio-Time_line/auto-bio-time_line.htm

    http://www.jd.casten.info/Atari/Atari_Page.htm

  7. @Justin:

    Alright. It’s good that Apple is telling people the dev. environment exists. I’m wondering if they have any instructional materials somewhere, or if they at least point people to why they might want to learn about it, and how they can go about doing that.

    Re: the technology media

    Yeah, I’ve been noticing a change. I used to be very interested in the goings on at ZDNet. When I’ve checked back from time to time I can’t relate to most of it.

    I remember Berlind, mostly for his advocacy of open source software and the destruction of DRM. I liked his articles occasionally, though there was something about his attitude towards technology that rubbed me the wrong way. I guess I trusted that his information was accurate, but maybe not precise. He always seemed excited about stuff that related to “technology freedom”, and he’d tend to “warp” his articles towards making that stuff look good, and anything contrary to it look bad.

    This’ll relate to Lispy’s comment. One of the things that used to puzzle me a lot was Berlind would say things like, “Because of adoption of web apps. we won’t be needing PCs anymore,” and that this was a good thing. The question that always came to mind was, “What the heck are you going to access the web through, then?” He never answered that. I think what he was getting at was web terminals. He was salivating lustfully at the idea of a “Google PC”, which never materialized to the best of my knowledge.

    Others have tried and failed at web terminals. A couple companies in the 1990s tried selling them. Even Microsoft got into it with an MSN terminal. None of them panned out. They failed because they weren’t flexible enough when new media came on the web, and they couldn’t run stuff like MS Office. Most home users want to be able to install games on the the computers they buy as well.

    The advantage PCs still have with the web is you can install new plug-ins on them when new web media shows up.

    Besides Berlind, what I’ve seen talked about on ZDNet is Microsoft (mostly about “Live Services”), digital video, international politics, enterprise stuff, SOA (I don’t remember if they’re still talking about this), VOIP, Google, Office, PC systems (dabbling with Linux, but never quite accepting it…), travelling abroad, “business in the internet age”, RIAs (Rich Internet Applications), and some news on the science front. John Carrol used to talk a lot about programming and software development platforms. He’s totally switched away from that, last I checked. There was another guy on there I read for a while who talked about Java and Eclipse all the time.

    Re: the stuff from Microsoft

    It’s been discouraging. ZDNet keeps talking about “Live Services”, but I don’t have a clue how software developers can link into it. It’s supposed to be a new platform, a “new Windows”, but where’s the programming interface and tools?

    In general, what’s coming out of Microsoft now seems to be more IS-centric, not developer-centric. They keep talking about servers, and services. They’re releasing APIs, and soon they’ll be releasing a new CLR and such, but it feels like they’re hardly paying these things any attention in terms of educating people about it.

    I frequent Paul Murphy’s blog when he’s talking about programming, IT history, or the problem of the adoption of a more enlightened system architecture. Between you and him sometimes I wonder if what he proposes is really a better system architecture or if he’s just stuck in the past. I wouldn’t really know. I’m not into IT architecture, but I can now relate to his frustrations at least.

    @Lispy:

    Re: Tron

    Yep. I’ve heard about all that stuff. The effort they had to go through to make that movie was amazing. The creators of it have said “No movie will be made like that again,” but what they meant were the techniques like rotoscoping, backlighting with gels and filters, all with live action and such. They said all of that can be done on computers now.

    There’s been the re-emergence of a rumor that Disney is working on a sequel to Tron. They were planning on releasing a sequel about 4 years ago, but it died. All we got was the videogame, “Tron 2.0”. There was supposed to be a movie to go with it…

    You can read about the new rumor here. It sounds credible, but I’ll believe it when I see it. The current arrangement apparently has Steven Lisberger as Producer, not Director.

    I got the collector’s edition DVD of Tron several years ago. They have a “making of” piece in the extras. It’s a series of interviews with the creators. Really neat. Towards the end they talk just a tad about the sequel they were working on back then. A quote I remember from Lisberger went something like, “People are evaluating where technology has taken us. They’re kind of taking a step back and looking at it,” and I think this was the best part, “Now that we have the internet it’s time to take another look at the scene. We have this wonderful new technology and the question is now what do we do with it? It’s got to be something more than a glorified telephone system.” Amen to that.

    Re: the message of Tron

    I think you missed the message a little. It wasn’t about Unix. It was about the mainframes, the IBM 370s and such. Back in that time mainframe access was restricted. No one could network into them. They were big systems that required a large staff to run. They didn’t run Unix, but typically an OS called MVS. Unix ran on minicomputers like the DEC PDP (not the same as micros).

    Back in the 60s and 70s most programmers used mainframes by submitting batches of punch cards to a “priest”, who would take the batch, schedule it to be run, and then you’d get a printout back showing what happened. There was no direct interaction with the computer. The PC was a radical departure from this notion. I talked about this extensively here with Alan Kay’s vision of personal computers in the early 1970s. It looks remarkably like the laptops we have now. He even anticipated that people would hook them up to the internet (called the Arpanet then) and what they would be doing on it. He really got it. Just about everything he described, we’ve been doing since the mid-1990s. Check out what he said about the “billboards” online. Can you say “pop-up blockers”? 🙂 At the end of my post I have a little blurb on Tron, in fact. A little trivia.

    The conflict played out in the story was hashed out in the argument between Dumont and Dillinger.

    Dumont: “Our spirit lives in every program we create!”, and, “User requests are what computers are for!”

    Dillinger: “Doing our business is what computers are for!”

    Re: The world needs only about 10 computers

    Yep. People have been getting that idea, “Maybe that guy was right all along.” You’re the second person I’ve heard talk about it.

    The web as it is now is the reification of the mainframe architecture, though it’s more distributed and democratized. Now the “mainframe” is networked and people have more open access to it. The web browser is just another version of the VT3270 terminal, like Dru said. I remember working with a 3270 when I took a COBOL course in college. I was hooked up to an IBM mainframe. The interaction went like this. The terminal received a “batch” from the mainframe. It was a form to fill out. The display was completely text-based, and the form was laid out using formatting commands the terminal understood. The terminal recorded what I typed into the form. I’d select “Submit”, or something equivalent when I was done with it. It was submitted to the mainframe, and then I’d get a batched response back, another form which may have had something more for me to enter, or it may have just been a message. Sounds just like the round-trip model between the web browser and a web server.

    Alan Kay imagined that the personal computer, or “Dynabook” as he called it, would connect up to servers on the internet, but that it would also have a P2P component, where people could share information directly between machines without an intermediary. This has kind of happened, but only with file transfers as far as I can tell.

    Re: Casten’s story

    Hmm. It doesn’t sound like he was entering CS, but CIS (Computer Information Science), which is typically in the business college. I’m surprised the advisor wasn’t impressed with his knowledge. Maybe he asked him if he’d had any experience with COBOL, JCL, MVS, or working with a database system, and Casten said no. He should’ve tried entering CS instead. I’m sure he would’ve gotten a warmer welcome.

    When I was younger I expected that most of the people who entered this profession would be people who loved it as much as I did. For a while it seemed this was true. When I was in college it seemed like most of the CS students were there because they loved this stuff. It was difficult to get through the program if you didn’t. In places where I’ve worked I’ve generally been with people who are the same way, though as time passed I’ve found they’re not quite as into it as I am. It’s only been by reading articles of late that I’ve been hearing about how a lot of places hire people who aren’t that skilled, and who are likely in it only for the paycheck. I read about this in hindsight about the 1990s, though I didn’t experience it. That might’ve been because I only worked for relatively small companies. There were a lot of people in the business, and still are, who never got a CS degree. Maybe they got a degree in something else, like physics, or never went to college to begin with. Apparently the same trend is back.

    I’ve talked about this before on this blog, that it’s a struggle to stay in this business. People are deceiving themselves if they think it’s a path to riches. For a relative few it is, but for most people it isn’t. It’s rocky. In the past it’s been like living inside someone with bipolar disorder. It would reach euphoric highs, and depressing lows. People saw that in a BIG way in 2001. IMO that’s one of the main reasons why CS enrollment has dropped off in such a big way. So many people got into it in the 90s, and then saw any prospect of a long-term career fall apart. It doesn’t pay as well as it used to, from what I hear. Engineers out of college can make much better money becoming financial analysts on Wall Street.

    This kind of addresses something both you and Justin are saying. Earlier in this decade I read a couple different people saying that what they saw happening was similar to what happened in the computer industry in the 1970s. In that decade the computer industry as it existed (mainframes and minicomputers) stagnated. There was a new phenomenon growing up then (PCs), but it was still a very small cottage industry. I anticipate we’ll see that again. It’s hard to say what that is though. Maybe something like the XO laptop, or something related to it. Maybe it’s taking the form of software instead, like Ruby on Rails.

    One thing I am hearing about is that people are using desktops/laptops less and less. Since about 2000 20-somethings have been using cell phones exclusively. They use computers for writing papers for school, but they think e-mail is archaic. Maybe one way to revitalize the interest in programming is getting young people interested in programming their cell phones (Hey, it’s the new “8-bit” platform! 🙂 ). BTW, have you seen LOLCode? A perfect match for the new generation, eh? BASIC with different packaging…

    There’s been exploration of the idea of getting students interested in programming via. computer media, which still holds the interest of young people. Science professors have begun to introduce programming into their classes, since computers are being used a lot more in the field today. Well see.

  8. Enjoyed reading your experience with Compute! I found your blog searching google images for Compute!, where I illustrated articles, ads and book covers back in the ’80s – my first full-time job out of school. There were some great fun peops working there in Greensboro NC, like the incredible artist Harry Blair, who could knock out a cover drawing like the one shown, in an HOUR. Interesting to hear, for the first time, from actual readers. Wow, what a long time ago!

  9. @Larry:

    Thanks so much for coming by! I really enjoyed the art in the magazine. It was a significant part of what made it so fun to read. I saw the art change as time passed, but I assumed it was the same artist just developing a different style. As I was writing this I went looking for the artist’s name in some of my old magazines, but came upon several names. In the end I couldn’t remember who it was exactly who created the whimsical images I enjoyed so much as a teen, and first drew me in to the magazine. Now that you mention it though, it was Blair.

  10. Hi Farid. I checked out your articles, and wow. You were prolific! It’s great meeting Compute! authors. I was puzzled though by the timing of your published programs. My strongest memory is that Compute! stopped publishing type-ins in 1988, but I have a vague memory that they came back later via. pulp paper inserts (felt like cheap paperback book stock) in the magazine. In other words, you’d have the regular magazine with its high quality glossy stock, where the user-oriented articles went, and then bound into the magazine were some type-ins (none for the Atari, all/mostly C64) on lower quality stock.

    BTW, I still have a large collection of Compute! magazines going back to March 1983, all the way through to 1988 (I let my subscription lapse when they stopped publishing type-ins). I pulled out a few of them because I wanted to spruce up this post a little with a few more videos, rather than stills (haven’t gotten to it yet). I decided to type in the programs again (in an Atari emulator) since my current living situation hasn’t allowed me to do the setup so I can transfer my old Atari disks to disk images so they can be run in the emulator. It brought back some fond memories, but at the same time I was like, “My goodness, this stuff is cryptic!” I’ve looked back at some of the old Applesoft BASIC programs I wrote and wondered how I did it. There were so many limitations back then about how long variable names could be. I had to keep track of where different sections of code were and make sure I branched and returned properly. I had to keep track of all my variables, which were global–no scoping. Yagh! And the code was totally non-descriptive. REM comments were essential if you ever wanted to understand your code again.

    Anyway, thanks again for sharing.

    You’re welcome. And thank you for sharing as well!

  11. Thanks for your comments about Compute!. I worked as an programmer/Assistant Programing Supervisor for Compute! Magazine from 1981 to 1985. Writing programs for multiple machines was really fun! People didn’t realize that we had only a month to do many of those games and sometimes we had to do multiple versions in a month’s time.

    It was incredible fun though and it was good to remember those times.

    Gregg Peele

  12. @Gregg:

    It’s great to continue getting comments from people involved with the magazine in some way. Keep ’em coming!

    I didn’t really think about it until I wrote this post how much effort must’ve been involved in porting programs for multiple machines, and you had deadlines to get them ready for each issue, which came out monthly! Like I said, I don’t know how you guys did it. It’s impressive. So many programs had machine code for optimization, and each machine was very different in configuration. In the later issues (probably after you left or changed positions), a lot of the programs were pure machine code. So in my estimation each port pretty much had to be written from scratch.

    I recall that you worked on issues a few months in advance. Maybe I’m wrong. I thought maybe that gave you a cushion for how much time you had to get ports ready.

    I really enjoyed the fact that there were usually versions of programs for multiple machines. It helped me see what each was capable of. In those early years it was all about the capabilities of the hardware, in my eyes anyway. Even though I could’ve just used the Atari version, for example, sometimes I tried typing in and using the C-64 version. I had a friend with a 64. Since I had access to an Apple II as well, sometimes I’d do the same with the magazine’s Apple II versions.

    Thanks for stopping by!

  13. It’s fun to see all of these comments. I wrote features and reviews for the magazines from 83-87.

    The real stars were the programming staff and the submissions readers sent in. And Tom Halfhill, who chronicled the rise and fall of the 8-bit machines so eloquently.

    Someone mentioned having old copies of COMPUTE! and the Gazette. Tom Halfhill is collecting those for the computer museum in San Jose. I can’t give out his e-mail publicly, but I’ll ask him to stop by.

    Kathy Yakal

  14. @Kathy:

    Good to meet another person from the Compute! days. 🙂 I think a couple of us mentioned that we had old copies of Compute! I’m one of them. I still refer to them from time to time, so I’m not willing to give them up quite yet. 🙂 It’s good to hear that Tom Halfhill is archiving them. I recently checked a couple of local libraries that used to have most/all of the issues. They’re long gone now. You referred to the computer museum in San Jose. Would that happen to be the Computer History Museum in Mountain View? I’ve heard of it, but haven’t gone there yet (I’m in Colorado).

  15. Hi Mark,

    Thank you for a great tribute to Compute! Magazine. Charles Brannon, former ace programmer of Compute!, has circulated excerpts from your blog among our alumni community. (Yes, we still keep in touch with each other!) We all enjoyed it.

    Regarding the ports of programs submitted by readers: As my former colleague Gregg Peele said, we had a full-time staff of crack programmers who ported those programs to other computers under the pressure of monthly deadlines. Those folks did an incredible job. Usually they wrote the “ports” from scratch, after observing how the program worked on the original platform. As time went by, our programmers became so adept that they commonly wrote significant portions of the programs in fast machine language instead of slow BASIC.

    BTW, our in-house term for the ports was “homogs,” pronounced “HOE-mogs.” This odd term was shortened from “homogenizing.” Visitors and new hires were often baffled to hear an editor ask a programmer, “Is the Apple II homog of Laser Blaster done yet?”

    Your analysis of Compute! evolution is pretty accurate. As time went by, fewer readers were interested in the educational aspects of programming. They just wanted type-in software to run. Our published source code became less commented and more compacted. Even fewer readers were interested in assembly language. Our machine-language listings were reduced to groups of numbers with line-by-line checksums, to reduce the probability of typos. We learned early on that most “bugs” were caused by user typos, not publishing errors, although we certainly had our share of errors, too.

    You are also correct that the museum with a collection of Compute! publications is the Computer History Museum in Mountain View, California. I’m a volunteer there, and I work mostly in the museum library. I donated many issues of my old Compute! magazines (including Compute!’s Gazette, Compute!’s Atari ST Disk & Magazine, etc.) to fill the gaps in donations from other people. We still don’t have a complete set of Compute! publications, however. If anyone wants to get rid of their old magazines, I can check to see which issues we still need.

    There is growing interest in “vintage computing” as a hobby. I was recently contacted by a programmer in Italy who wanted an Atari player/missile graphics animation package that I wrote and published in Compute! in the mid-1980s. When I replied that I didn’t have a binary image of the program, he tracked down the program listing, typed it in, and sent me a copy!

    Thanks again for bringing back some fond memories.

    – Tom R. Halfhill, former Compute! editor

  16. @Tom Halfhill:

    Hi Tom! Thanks so much for stopping by!

    Thanks for the insight about why the magazine went more and more for machine code. I can understand the performance aspect, but it’s surprising to me that readers didn’t care so much about what they were typing in. I would think that spending hours just typing in numbers would get pretty boring. At least with Basic there was a chance the “lay programmer” would get a better idea of what the program was doing, and would find that interesting. That’s what I appreciated about it, anyway. Of course running the program was the ultimate goal, but I also wanted to understand the thing.

    I wondered if the move to machine code had more to do with most readers opting for the disk edition of the magazine. That way they wouldn’t have to type in most of the programs at all. As I recall the disk editions didn’t have every type-in, just the major ones from each issue.

    I can understand how with a lot of porting to machine code, the editors who ported stuff would become experts at it. I remember when I was in jr. high and high school seeing a couple kids who were so good at programming their Apple II’s in machine code that they could rattle off a set of hexadecimal numbers and make the computer do something coherent. I personally didn’t know how they did it, but they proved it could be done. The hex stuff was just gibberish to me.

  17. It was so good to find this story on the Internet. It’s great to know that so many others have as many good memories of those days as I enjoy. My work at COMPUTE! as Program Editor was both of my finest accomplishments and an opportunity to get to be a part of a wonderful group of writers, editors, programmers, and artists.

    I think I’ll fire up my C64 and Atari 800 emulators to extend this trip down memory lane.

  18. Hi Charles! So nice of you to stop by. I really admired your work at Compute!.

    BTW, I had the opportunity to chat with Tom Halfhill when I went out to Silicon Valley in January. He told me he first met you when you were 17, and you showed him how to program in assembly on the Atari! That blew me away. I was sure you were older with the skill that you had.

    If you want to go down memory lane with me on the Atari, check out Reminiscing, Part 1. I don’t really have anything on the C-64, since I didn’t own one.

  19. Came upon your article and it is great. Compute! was a great magazine and the checksum program for entering basic programs was a great idea. As mentioned it was one way to learn ‘real’ programs without having to spend much money… just time… but we all had time them…LOL!

    My all time favorite game was Chain Reaction. It was a simple game but then that is why it was fun to play. My idea of a game is that you have to use a little of your brain but not enough to blow it to pieces. I was looking at this game recently because I’m thinking of re-doing it in javascript so I can play it again plus just to see if I can do it.

    I never got around to inputing the Lazer Chess. Some day?

    Thanks you for bring back some good memories.

    TTFN… Andrea

  20. Pingback: The 150th post « Tekkie

  21. Pingback: Favorites from Antic–The Atari 8-bit podcast | Tekkie

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s