How a good business deal made us underestimate BASIC

Feature A generation of gray-haired IT folks learned computing using BASIC on 1980s home computers. Every pro since then holds it in disdain. What happened?

Fifty years ago, the Altair 8800 computer from Ed Roberts’s MITS was the cover star of the January 1975 edition of Popular Electronics magazine. The appearance inspired two college students to write a BASIC interpreter and a few months later, start a company to market it.

The MITS Altair 8800 – click to enlarge

They didn’t invent BASIC. That was co-developed by Professor Thomas Kurtz, who died aged 96 in November. (His colleague and boss, John Kemeny, departed in 1992.) We saw widespread gratitude for his work and nostalgia for BASIC – not just the many comments on The Register. BASIC changed the course of many people’s lives.

And yet for so many others, especially those who entered the world of computers after the 1980s, BASIC is seen as a toy. As the great Dutch computer scientist Edsger Dijkstra put it:

(To be fair, he also really did not like FORTRAN, PL/I, COBOL or APL, either.) We are pretty sure that his short paper “How do we tell truths that might hurt?” was at least somewhat tongue in cheek. What’s often missed, though, is that it was written in 1975, before the era of the microcomputer. The original Dartmouth BASIC was a compiler, and very different from later versions.

The thing is, though, that BASIC grew up into something much better. Even early on – the 1979 Acorn Series 1 and 1980 Acorn Atom had an interesting BASIC, as Wikipedia covers in detail, with DO… UNTIL loops, vectors, bitmap graphics commands and more.

By 1981, the Atom’s successor, the classic BBC Micro came with BBC BASIC. This boasted luxuries such as named procedures with local variables, enabling beginners to experiment with recursion, as well as inline assembly language. BBC BASIC is still around today, maintained by Richard Russell, author of the original 1983 port of the language to the “legendary” Zilog Z80.

This was a capable language. New computers were expected to come with some form of BASIC, and it was included with almost every micro in the 1980s. The Macintosh offered the swiftly-discontinued MacBASIC; Atari’s ST [PDF] and Commodore’s Amiga [PDF] included their own versions. It was built into every IBM PC, in ROM no less, while PC clones got GW-BASIC, which Microsoft open sourced in 2020.

Microsoft, of course, built its business on BASIC. It supplied the original MITS Altair 8800’s BASIC, and indeed The Register interviewed that version’s co-author Monte Davidoff in 2001. Microsoft still offers Visual BASIC .NET 16.9 today. Microsoft Office’s macro language is still VBA, Visual Basic for Applications.

After every rise, a fall
In Britain and Europe, Acorn was very influential. Indirectly, it still is, worldwide. It designed the Arm processor family. “ARM” originally stood for Acorn RISC Machine. Acorn’s software, not so much.

Commodore 64 UK advert – click to enlarge

In the vital US market, a different company dominated. In 2012, The Register called the Commodore 64 The most successful 8-bit micro ever. The C64 came with version 2.0 of the same Commodore BASIC as Commodore’s first big hit, the Commodore PET 2001 way back in 1977.

Commodore knew its market: the C64 was primarily a games machine. It had good graphics for 1982, with eight hardware sprites in 16 colors thanks to the VIC-II chip, and three-channel sound from its famous MOStech 6581 chip, also known as SID.

At launch, the C64 was $595 ($1,945 in 2025, or over £1,600). It was not cheap. Using the same old BASIC offered a considerable cost saving: the C64 had just 20 kB of ROM, split across three chips: eight kilobytes for BASIC, as much again for the Commodore KERNAL OS, and a four kilobyte “character ROM”. Compare with the BBC Micro’s 32 KB of ROM, taking fully half of the 6502’s memory map. (That’s why the classic Elite game, while leaving space for the display, had to squeeze into 22 kB.)

The other factor was that Commodore didn’t have to pay for it. Its then boss, the late Jack Tramiel, drove a hard bargain. It was the 1970s – as the Register put it in 2007, when Commodore ruled the world – and as we quoted Tramiel then, recounting negotiating with the young Bill Gates of Micro Soft:

Youtube Video

Thanks to Tramiel, Commodore got a very sweet deal. The company didn’t even pay royalties – but that also meant no updates, so the result was that CBM used pretty much the same BASIC in the PET, VIC-20 and C64. It got only trivial adjustments for the hardware, even though that hardware changed substantially: the PET had no graphics or colour, and only a beep; the VIC-20 had 3.5 kB of RAM and limited 176×184 pixel graphics; finally, came the all-singing all-dancing C64.

Commodore BASIC was poor on the VIC-20, and positively lousy on the C64. There were no commands to set colors, or to draw, load or save graphics; no sound commands to play music or sound effects; nothing.

In effect, the unchanging BASIC became a worse and worse fit for each successive generation of computers, ending up positively terrible on the C64. Owners had no choice but to use PEEKs and POKEs to access any of the hardware’s facilities. That, in turn, led anyone interested in writing their own games to move on to assembly language.

The C64 also had a very expensive floppy disk drive, the Commodore 1541. Costing $399 at launch ($1,300 today, or £1000), it had its own onboard CPU, ROM & RAM, but a serial interface to the computer, so the drives were both dog-slow and very pricey. They also held just 170 kB.

These were legitimate choices for what was primarily a games console with a keyboard. Games would be written in machine code for speed, and so a small, simple BASIC was a reasonable saving: a corner the company could afford to cut.

In other markets, especially outside of the domain of the almighty dollar, this opened up opportunities for competition. It led to machines like the equally multimillion-selling Sinclair ZX Spectrum, not to mention its many clones, most unauthorized and unlicensed. The Spectrum had a poor keyboard, and its graphics and sound showed where its costs had been cut, but its BASIC wasn’t at all bad.

Having a better BASIC was a significant selling point for Commodore rivals in the early 1980s, such as Tangerine’s Oric-1, the MSX range, the Camputers Lynx, the Amstrad CPC 464 and its relatives, and the gorgeous Elan Enterprise.

Some thrived, some sank, but whether successful or not, their marketing owed a debt to Commodore deciding to cheap out and use a late-1970s BASIC in an early-1980s machine with, for the time, quite high-end graphics and sound.

In the short run, it was a good choice. The Commodore 64 sold about 17 million units, which meant that a lot of 1980s kids knew nothing else, and they all thought that having a cramped and feature-poor BASIC was normal. Some former owners are positively nostalgic for it. Although it was one of the worst BASIC dialects of its day, Commodore BASIC V2 has even been reimplemented as FOSS code.

On one hand, this means that one of the worst BASICs ever lives on in the 21st century, while far better versions, such as the ZX Spectrum’s Beta BASIC, which led to the SAM Coupé’s MasterBASIC, or QL SuperBASIC, languish in obscurity, with no implementations for modern kit.

Twelve… classic 1980s 8-bit micros

Zilog to end standalone sales of the legendary Z80 CPU

Microsoft drops a little surprise thank-you gift for sitting through Build: The source for GW-BASIC

We feel that Commodore BASIC is largely responsible for a lot of the bad reputation that BASIC has to this day. Jack Tramiel got a killer bargain, but its victim was the language itself. Commodore made a lot of very strange business decisions, some of which we looked at back in August, but we reckon its bargain-basement BASIC had the widest repercussions.

Before the microcomputer, BASIC was a serious language, used for business software development on minicomputers. Hewlett-Packard had HP BASIC; Digital Research offered the CBASIC compiler for CP/M, written by former Symantec CEO and general-purpose industry guru Gordon Eubanks; Digital Equipment Corporation offered several variants, including the 16-bit BASIC-11 and the 32-bit VAX BASIC, which today is the 64-bit VSI BASIC.

Calling all the BASIC glitches…
When the Reg FOSS desk started working in the late 1980s, serious business software was still being written in BASIC, as well as RAD and 4GL tools,

As Windows rose to prominence, BASIC enjoyed a brief resurgence thanks to the fading force that was Visual Basic, and thanks to Borland and Delphi, there was a brief resurgence for Pascal – the most famous creation of the late great Niklaus Wirth

But generally, since the 1990s, the computer industry moved towards programming tools from Unix, especially C, C++ and other curly bracket languages.

About a third of a century, the result is an industry centered around vast OSes and applications composed of tens of millions of lines of code – much of it in not-entirely-type-unsafe languages, notably C and some of its relatives. Some of the more safer offshoots rely on virtual machines or runtimes which aim to contain the nastier side-effects, and some (notably Rust) are designed with safety entirely in mind. These solutions tend to add at least some degree of complexity and sometimes inefficiency. Chromium, for instance, is up to nearly 45 million lines now, over half of it in C++.

Now, we have daily and weekly mandatory updates in the order of hundreds of megabytes. There’s a thriving industry centered around keeping obsolete versions of these vast code bases, which nobody fully understands any more, maintained and patched for a decade or more after release.

Not all of this is down to Commodore BASIC, of course – but we welcome suggestions of any more significant single factor than the C64.

Reconsidering BASIC
We felt it worthwhile to take a step back and look at the bigger picture. C++ was designed by Bjarne Stroustrup, whose PhD advisor was David J Wheeler. Although it’s often attributed to Xerox PARC researcher and one of the fathers of the personal computer Butler Lampson, in fact in Lampson’s 1993 Turing lecture, he quoted Wheeler as saying:

This is now often called the fundamental theorem of software engineering. In the preface of his own book The C++ Programming Language, though, Stroustrup offers a fuller version:

Today, it’s very easy to forget just how many layers of software are between us and the hardware. That also includes the many assumptions and historical details our systems include for backwards compatibility. As Wheeler also said:

Those mistakes, that devotion to compatibility, runs much deeper than most people realize… and an easy demonstration of this is a feature of those 1980s BASIC interpreters in the language’s heyday, one which is missing from later, ostensibly professional variants, from QuickBASIC to Visual BASIC, as well as all the putative replacements such as Python or Ruby.

It is a vast towering assumption that underpins all of modern computing, so in order to see it, we have to walk some distance backwards.

When someone starts to program a computer for the first time, they sit in front of the machine and they enter text. In all but some deeply arcane languages, they type words – ones resembling English, because between its alphabet and its grammar, English is one of the easiest human languages, both to read and write as well as to understand.

So, you sit at a keyboard, even a virtual one, and you type words, numbers and punctuation on it. That is all the beginner should need to know: how to enter text, and how to correct it when they get it wrong.

But BASIC adds an extra layer to that interactivity: it integrates a storage model, too. If the user types a command, the computer tries to follow it. But give that command a number, and the computer does not perform the instruction immediately: it remembers the instruction for later.

This is a profound and important metaphor. It eliminates all the legacy nonsense about “files” and “folders” and “editors” and “compilers” that we have been lumbered with since the 1960s minicomputers which inspired all modern operating systems. Beginners don’t need that baggage. Let them learn that later, if they prove to have real aptitude and choose to pursue programming.

Type a bare expression, the computer does it. Number it, the computer remembers it for later. That is all you need to get writing software.

It eliminates the legacy concept of a “file”. Files were invented as an indirection mechanism. They were a named index, a pointer to locate the desired pieces of data in secondary storage – in other words, on disk rather than in memory. A novice does not know the difference between RAM and disk, and they should not have to. That’s an implementation detail. It deserves to be as invisible as the memory address of the drive controller.

This is one big problem with today’s common recommendation of Python as a modern replacement for BASIC. Python is a scripting language, an interpreter that runs on another OS. Yes, you can use it interactively – it has a REPL – but to write programs, you need a text editor to create a file to hold your Python code.

Beginner programmers should not have to know what a “file” is, or what an “editor” is, or that they need an “editor” to manipulate their “source code” in “files”. This is pure undiluted technical debt: these are implementation details, which should be invisible.

This goes double for “compilers” versus “interpreters”, and for “source code” versus “binary code”. These are legacy implementation details, ones that had been hidden from view by systems decades ago. Both ordinary users and beginner programmers shouldn’t have to know about them.

Python sorted the problem of whiny C programmers whinging about preferred indentation patterns by making indentation significant in a particular way – admittedly like FORTRAN and some BASICs – so everyone had to comply. In the same way, line numbers in BASIC are a vital simplifying and unifying mechanism, so don’t try to eliminate them: instead, to help beginners, BASIC makes line numbers syntactic. This is a good thing. It is a simpler and more obvious system than “files” in “directories” and using programs to write programs. That should be left until later, for the advanced students.

We should not attempt to force children and beginners to learn professional-grade tools such as filesystems and editors. Educational toys are good things. Training wheels are helpful. Give kids construction toys so that they can learn to build.

While they are learning what a program is, let rookies structure their code with line numbers, because it’s simple and immediate and visible. It also teaches forward planning: it’s helpful to leave space between those numbers. Then, later, give them tools to manipulate those numbers: a RENUMBER command, ranges so they can LIST x TO y, and stuff like that, because things have moved on and none of us use the Commodore 64 for this any more.

Let’s just spare them GOTO. Dijkstra had a point there. Like BBC BASIC, let’s give them IF… THEN… ELSE, and WHILE… WEND, and REPEAT… UNTIL, and named procedures, so they can smoothly move on to structured programming.

Never mind the Go to statement considered harmful. Look at the bigger picture: multilevel storage is legacy technical debt. It’s time files were considered harmful. Until we do, we should postpone dealing with that 60-year-old metaphor as late as we can. ®