Guest Post: Atari Origins
I recently wrote My First Atari ST and reader Mark Miller chimed in with his own story in a comment to that article, which was both long and interesting. With his permission it is now a main article here on Goto 10 for all to enjoy. Check out Mark’s Tekkie blog for more of his writings. — Paul
Oh man, memories!
I got my 130XE in 1988 just before going off to college, with 1050 disk drive, and an ICD P:R: Connection and Panasonic dot matrix printer. I used it for writing most of my school papers, using AtariWriter Plus, and it did that well enough for my professors. I didn’t use the computer itself for doing my programming assignments. As you saw, most everyone else who had a computer had 16-bit PCs or Macs. I knew several other people who used other computers; a few had 8-bits, like Ataris, Commodore 128, but mostly upgraded Apple IIs (to turn them into IIGS equivalents). The guys I knew with Ataris just used them to play games. The other outliers had Atari STs and Amigas. Using an 8-bit didn’t get much respect, but I didn’t really care. It felt like a challenge.
I was already some ways into my Pascal class. We were running a compiler on the campus supercomputer, a CDC Cyber. We shared processor time with atmospheric researchers who were running models on it. I knew about a full-screen editor we could run on the Cyber, called FSE, that made writing our Pascal code easier, but it used function keys on lab terminals for editor functions. I went to freshman orientation, and learned from our student advisor that there was a compatible terminal program we could get from the campus IT department that would allow one to run FSE from our computers at home, called Kermit. It only ran on PCs and Macs. I asked if there was a version for my Atari, and got a curt “No,” with a bit of a chuckle. Still, this did not deter me. It finally occurred to me one day that those function keys must be sending character codes to the Cyber, but I just didn’t know what they were. I’d bought a terminal program called Chameleon, and my roommate showed me how to use ftp on Unix, and how to download binaries from the Unix systems to my computer. (I used his Unix account, since I didn’t have one yet.) I’d learned about the Atari Archive at the University of Michigan, and (IIRC) found an 80-column VT-100 emulator there that worked pretty nicely with no 80-column card, called VT10Squared. It did soft emulation in Graphics mode 8. So, one day, I tried logging in to the Cyber with this VT-100 emulator, and made sure to set the emulator’s character bit width to 8 bits, no parity. As I remember, this VT-100 emulator worked flawlessly, which helped a lot. I fired up FSE on a scratch file, and started trying control codes, and using Escape with regular characters and control codes, and I was able to get most of the features to work! I wrote down the codes that worked, and started using it from my dorm room. This was one of my proudest achievements at school! :)
I knew about Pascal compilers for the Atari, and I recall kicking the tires of the PD ones after I’d completed my Pascal class. I tried porting one of my assignments to them, and it didn’t go well. About ten years ago, I heard about Kyan Pascal for the Atari, gave it a try with the last Pascal assignment from that class, and it ran perfectly! So, Kyan was quite capable. Funny thing. As I looked at the Kyan setup, it reminded me a lot of a Pascal compiler I saw one of my later roommates had on his Apple IIGS. As I remember, he wrote his Pascal assignments with it, and it worked out fine. Many years ago, I learned that Apple had bought Kyan Pascal, and shipped its compiler as standard on the IIGS.
While I was still in school, I remembered back to when I heard about C compilers for 8-bit computers, such as Lattice C for the Apple II. I got curious if there were any for the Atari. I read up on the commercial ones, but their features were pretty limited. I’d learned C at school, and had gotten used to the K&R feature set. However, once again, going back to the Atari Archive, I managed to find a PD C compiler called CC8, written by someone who wanted to make improvements on the PD Ace C compiler. I was impressed with CC8’s features. It wasn’t a complete implementation, but it wasn’t bad. To use it, you had to set up Ace C on a disk, and just replace its compiler with CC8. I downloaded Textpro as my text editor. There were so many files involved, I felt like I needed subdirectories. So, I downloaded a copy of MyDOS, and used it to set up a disk for this compiler. I set it up to autoload the RAMdisk with both the compiler and the text editor, so these would load fast. I just barely got everything to fit on one enhanced-density disk, which was important, since I only had one disk drive! I had a little room left for saving source code, and generating object files, and executables.
One summer, I decided to try to port all of my Data Structures assignments from Pascal to C, using CC8, just to see if it could do it. I quickly realized the only way I could get this to work was to write my own heap manager, since no 8-bit C compiler had one. I decided to set my heap up in Page 6, just 256 bytes! Nevertheless, *all* of my assignments worked! No exceptions, and in 256 bytes of heap! The only major difference I had to account for was that Ataris didn’t have {}’s. So, every C compiler used an alternate syntax for blocks, $( to start a block, and $) to end it. I knew right away this meant I couldn’t use it for schoolwork, but I didn’t care. I was just tickled that my little computer could do what I thought only worked on the powerful campus computers!
I wrote about this compiler, and included complete source code for my heap manager, in a two-part article for Atari Classics Magazine. I think it was called “Advanced C Programming on the Atari 8-bit.”
An odd thing about 8-bit C compilers was none of them generated native machine code. They all generated what they called “p-code,” which ran in a VM, or runtime. I learned many years ago about the history of this, and it dates back to Intel 8080 computers, where a compiler called Small C was written. All of the 8-bit compilers were derived from this, and generated Intel 8080 machine code, which they called “p-code.” The VM we ran was essentially an 8080 emulator. This made compiled code shareable, but also made it so that compiled code didn’t compete with assembly for performance. I tried a speed comparison, and C code from my compiler ran noticeably faster than an equivalent on Atari Basic, but the difference wasn’t dramatic.
I got a Mega STe in 1992 from a computer retailer that was right near my college campus, and used it for my last year of school. I still have the invoice for it somewhere. I think it cost $1,100-1,200 ($2,600-$2,900 today). I tried something I heard from a friend who was going to a different university. I took out a student loan. He was able to take it as cash to buy his Mac SE-30. I tried to do the same thing, and...didn’t get cash. The university required that it be put toward either tuition or room and board, or both. I didn’t find this out until the loan came through. So, I used it for the semester. I worked it out with my grandparents who were largely funding my college costs. I promised I’d pay back the loan, but I wanted to use the money they meant for tuition for that semester for the computer. It took some explaining, but they agreed.
Even though I probably could’ve compiled code for school assignments on it, I didn’t. I didn’t even have a C compiler for it at the time, as I recall. I used ANSITerm for accessing my Unix accounts. I got around to porting some of my semester projects to my ST after I graduated, which didn’t require much in the way of code changes.