Most people’s memories of programming in the 8-bit era revolve around BASIC, and not without reason. Most of the time, it was all we had. On the other hand, there were other options if you sought them out, and [Paul Lefebvre] makes the case that Goto10Retro that Action! was the best of them.
The limits of BASIC as an interpreted language are well-enough known that we needn’t go over them here. C and Pascal were available for some home computers in the 1980s, and programs written in those languages ran well, but compiling them? That was by no means guaranteed.
For those who lived on the Atari side of the fence, the Action! language provided a powerful alternative. Released by Optimized Systems Software in 1983, Action! was heavily optimized for the 6502, to the point that compiling and running simple programs with “C” and “R” felt “hardly slower” than typing RUN in BASIC. That’s what [Paul] writes, anyway, but it’s a claim that almost has to be seen to be believed.
You didn’t just get a compiler for your money when you bought Action!, though. The cartridge came with a capable text editor, simple shell, and even a primitive debugger. (Plus, of course, a hefty manual.) It’s the closest thing you’d find to an IDE on a computer of that class in that era, and it all fit on a 16 kB cartridge. There was apparently also a disk release, since the disk image is available online.
Unfortunately for those of us in Camp Commodore, the planned C-64 port never materialized, so we missed out on this language. Luckily our 64-bit supercomputers can easily emulate Atari 8-bit hardware and we can see what all the fuss was about. Heck, even our microcontrollers can do it.
I fondly remember that orange Action! cartridge. I used it more than any game that I had. It even supported in-line assembly language and allowed you to create interrupt service routines. I wrote a printer spooler in Action!, which I had hoped to sell to the Antic! software library. Unfortunately, my submission was rejected because they wanted all submissions to be in Atari Basic. Oh well…
It nearly broke my heart when my wife sold all of my Atari gear in a garage sale. I had a PC-XT clone by that time and had pretty much moved on from the Atari. Still brings back memories!
Come on back! E-bay is your friend. Get a FujiNet as well!
I like what Brad has to say. The 8-bit World of Atari and even Commodore is experiencing an awakening. A rebirth. Maybe because we’re all getting older and thinking about retiring, but something is happening. I think about the good ol’ days when I was a kid and the media didn’t do what they are doing. I need to simplify my life. Go all 8-bit again.
I think that the revival of 1980s hardware is misguided. Sure we dream of going back to a simpler way of doing things, but going back to ’80s hardware is not the way. With their ancient IC technologies, they use way too much power to be doing everything way too slowly.
I have long argued that the development of protected memory (i.e., the i386) and later, USB, made the PC world a quasi-walled-garden, but more recent developments in microcontrollers (i.e., embedded systems on a chip) is the direction of progress. There has certainly been a corresponding explosion in hobby embedded computing. It may be that some of the software projects that were limited in the resources they could consume were the big accomplishments of the ’80s, including the subject of this article.
Just the same, I won’t knock anybody who gets a thrill from doing something new on old hardware.
I’m so happy to hear that people, anyone remember the “Action!” cartridge for the Atari 8-bit line. I usually used BASIC to program games and then I learned some sort of bare metal programming and then stumbled upon that cartridge later. It would’ve solved me so much time and effort and sped up my games.
Nice anecdote! Not to gloat, but I still have all my original Atari gear tidily packed up in a box. My 800, a Trak drive, a 1030 drive, touch tablet, joysticks, my Gemini 10X printer, modem, and yes my Commodore 1702 monitor (with re-capping kit that I haven’t installed yet). I also recently got a Sophia 2 DVI adapter for the 800 but also haven’t installed it.
In the ’90s I wrote an assembly-language program to convert my Touch Tablet drawings to Windows BMP files. Then I set up some BBS software on my work computer, and transmitted the resulting BMPs to it from my Atari at my parents’ house. Some of them made their way into documentation for multi-million-dollar manufacturing-software manuals at a Big 6 consulting firm.
Ah yeah, back when computing was fun…
If you like ACTION! I recommend to have a look on COMAL, which was available for a variety of platforms.
FORTH
I was waiting for that.
I think Forth was the best language for 8 bits. On the ZX Spectrum, White Lightning was amazing.
Action! For Atari and HesForth for CBM machines was my go-to back in the day. still remember the joys of debugging lines of code to get simple games running that blew members of my computer club away.
HesForth was German, wasn’t it?
Action was my first experience with a compiled language. One of the most astonishing programs I used as an example to others was when I converted an anti-aliasing psudo code listing in Byte magazine.
I wrote a version for Atari Basic and a version for Action. I could take a single image in graphics mode 9 (16 shades) and anti-alias the edges. In basic that would take well over a minute and a half to do the entire screen, in action it took all of 7 seconds.
When my friend saw this, he coded the same thing for his Mindset PC in machine language and got it down under a second. 1984, Good times and bad times for Atari. Great times for me.
The Atari 400/800 often relegated to a blip in computer history over shadowed by the cheaper (and more popular) c64 that came years later or Jay MIners other computer the Amiga (the next generation from the 800) but so much of what made the Atari 800 unique in the late 70’s we take for granted today like custom graphics and sound co processors, the SIO (serial input output) port on the Atari 800 was literally an early form of USB and of course the first first person shooter on a home computer Star Raiders…. all started on the little Atari.
I’ve still got a PL/1 compiler for CP/M somewhere . The generic languages used for early 8 bit programming on Intel and Zilog machines were PL/M and PL/Z respectively. I’ve also got Prolog, Lisp and and a couple of FORTHs to round out the interpreted/semi-interpreted group.
Of these, the languages I’ve used for real — as in ‘real live product’ — are PL/M, PL/Z and FORTH. Plus assembler, of course. Whether you were using a compiler or not was more about whether you were using a ‘proper’ — as in expensive — system. An Intel MDS-2, for example, the system I used PL/M on, cost well over fifty thousand UK pounds, or about 5 houses at 1980 prices.
I used PL/M on an Intel MDS in my first programming job, back in 1981. Most of the development I did on the system, though, was using a 6800 cross-assembler to write control software for traffic light systems.
I was an Action programmer back then, I started with assembler on various CPU, BASIC was not my thing, Action opened the door to high level languages to me. 40 years later it is still fresh in my memory, I have the cartridge in a box somewhere.
You know, Lua was written as a means of interpreting configuration files for games and applications. Its main feature was that the interpreter was small enough that you could just link it into your application and then have the application call it to interpret your configuration file. But now this has me thinking: nowadays we use a Python interpreter to get big-application capabilities from microcontrollers, but what if we compile programs on an MCU that could then run natively on the same MCU? Action! appears to be almost a subset of C, so what about just making a subset of C to do this with? The compiled code, even if slower than hand-crafted machine code or even GCC or Clang generated code would probably run circles around Python. And you could run it through a “big” compiler if that would generate more efficient code. And honestly, Micropython was just full CPython shoehorned into the amount of Flash memory available on typical microcontroller-based systems, probably bringing a lot of baggage with it.
Just thinking out loud, here.
By the way – I’m talking about 32-bit microcontrollers here, like Cortex-M series, not 8-bit. There are already program loaders for ESP32 that let you load executables from SD card, so this would just be a way of doing that without a host computer.
I think MicroPython was pretty much clean-room. Plus is has 4 ways to speed up, from making values used in loops locals to embedding some assembly code, which makes it pretty versatile for embedded.
I don’t know the history of MicroPython, but I’ll take your word for it. I think my point is valid though: they took a complicated language and shrunk it to a size making it possible to run on microcontrollers, but only MCUs with plenty of resources.
Of all of the languages mentioned in the comments, most are interpreters. My first experience with a computer was an SDS Sigma-7 timeshared 32-bit mainframe that included a BASIC compiler. You typed in your program in editor mode, and when you typed “RUN” it took a bit of time (depending on the complexity of your program) to compile, then ran it.
My point is that this was written in the late ’60s and required something like 16k words of memory to run, or 64kB for you 8-bit folks. And it performed like a compiled language. Many, many people designed languages and developed interpreters for them, but never took the next step of developing a compiler, so I’m really glad to see an example of one that DID. I look forward to digging into the source code (https://atariwiki.org/wiki/Wiki.jsp?page=Action) to see how it ticks.