Belated BASIC Birthday

Posted by Rampant Coyote on May 6, 2014

I didn’t realize that last Thursday was the 50th anniversary of the release of BASIC. Wow. And I thought it was pretty old when I was first introduced to it when I was twelve.

BASIC stands for “Beginner’s All-purpose Symbolic Instruction Code.” But not really. I think they just came up with whatever words fit so that they could be abbreviated BASIC. It was intended to be an easier way to program than assembly language and the few, higher-level languages of the era (like FORTRAN and COBOL). And it was… at least kind-of, if you stuck with the standardized version of the language, fairly cross-platform. But mainly, it was easy-to-learn.

At least in the original specification, it was nice and procedural, with numbered steps. Branching and loops were handled in a fairly intuitive way… “Skip to step (or line) 12,” or “go back to line 5.” Except, of course, we rarely ordered the steps in contiguous numbers like that. This is because – when we inevitably had to edit the code and insert new instructions, most BASIC systems didn’t have a handy-dandy way to re-order everything to insert a new command. Instead, we tended to write programs with steps incremented by 10, like:

10 PRINT “THE RAMPANT COYOTE WAS HERE.”
20 GOTO 10

That would cause an infinite loop of it printing a stupid message over and over again, forever. Admit it, if you ever programmed in BASIC, you wrote something like that at least once. It’s like the next step above “HELLO WORLD.” There was a rush of power in writing that stupid program… the machine would obey you exactly, forever, at least until you used an interrupt sequence or turned the power switch off. If I wrote that program in 1984 and left it going, and suffered no power interruptions and no hardware failures, that computer would still be dutifully printing an endless column of the words “The Rampant Coyote Was Here” today, thirty years later.

My introduction to BASIC was from an incredibly stripped-down interpreter in the Sinclair ZX80 computer – obsolete the day it was released, but unbelievably cheap in its time – and the “BASIC Computer Games” and “More BASIC Computer Games” books edited by David H. Ahl, editor of Creative Computing Magazines. These books were kind of old by the the time I got them, but the games could be used on many different machines (sadly, only the smallest could fit on my ZX80), and they were entirely text-based. But within those limitations, the games were of so many different styles, and by so many different authors, that in studying them I received an education both in game design and in approaches to problem-solving in code. For example, the game space – the “map” so to speak – was handled so many different ways in all of the programs that I really came to understand how to approach data representation differently depending on the needs of the application.

BASIC was how a generation of us learned to program. Oh, we may have started very young with something like LOGO, and we may have moved on to bigger and better things like PASCAL early on… but if you were a young computer geek in the 1980s, BASIC was probably your gateway drug.

It’s silly to compare it to modern programming languages. Even Microsoft’s VisualBasic, which probably extended the life of the language a good ten years beyond its naturally allotted span, can’t really compete in the modern world. I’m not sad that it has been surpassed by better languages, but I am concerned that it doesn’t really have a successor as a “beginner” language. I’ve frequently thought Python might be a worthy heir to the throne, but it hasn’t ever gotten the traction and support. These days, C# seems to be the programming language of choice, and I don’t think it’s that hard to learn, but my vantage point is a long distance from that of an absolute beginner.

But if it weren’t for BASIC, I might still be an absolute beginner. Its virtue was being easy to understand. It was powerful enough for simple games, on the machines of the era. And perhaps it was the single greatest factor in bringing the world of computers out of the lofty heights of the engineering priesthood and into the hands of the common man. Most computers of the 1980s shipped with a copy of BASIC, and with that, the expectation that software creation was expected and encouraged of end users. While programming wasn’t for everybody, it did seem like it was for anybody. At the very least, it was for anybody to take advantage of. After all, anyone could type in some code in BASIC from a printed page in a magazine and suddenly have a checkbook manager, a planetary environment simulation, or a game of checkers. Not as convenient as grabbing a download from the app store, but it also helped demystify the machines.

Nowadays, we use, tote, and even wear computers of unimaginable power compared to those early days when BASIC was first introduced. Computers are far more “personal” than the era when “Personal Computer” was a marketing buzzword. Computers are for everybody. I like to think BASIC had something to do with that.

Filed Under: Programming - Comments: 13 Comments to Read

Bad Sector said,

There is a TON of BASIC dialects out there, including Microsoft’s Small Basic which is oriented towards new programmers (and has some books written for it). Although TBH it doesn’t *really* look much like a BASIC – f.e. instead of “PRINT foo” you write “TextWindow.WriteLine(foo)”. I suppose it makes for an easier transition to VB.NET and C#…

But there are other dialects, although almost all of them are written by hobbyists (…for instance… :-P). Having said that, BlitzBASIC (and its relatives, like BlitzMax and Monkey) is probably the most known BASIC dialect in the indie world since a lot of indie games are made with it.

Personally i have a fascination with BASIC, mostly from the interpreter writer’s point of view. I have made many BASIC-like languages (most of them never saw the light of day though) and one of my current active projects is a VBScript-like BASIC interpreter for FreePascal/Lazarus (actually the compiler and VM are pretty much complete, but i want to expose some GUI functionality so i can create extensions for my 3D world editor with it).
McTeddy said,

BASIC was my gateway too. I’d picked up an old book “How to write your own computer games”. That night, I wrote my first game… a godawful, horribly designed, but technically functional game.

I actually remade my first game a few months back using my improved design/technical skills. That was quite an experience.
Felix said,

The problem with a modern programming language playing the role of Basic is that the mindset of computer users has changed radically. Python is preinstalled on any Linux or OS X machine. Javascript is built into any web browser — and you can always hit Ctrl-U to see how the game was coded. If it’s simple enough, that is. As I wrote in my latest newsletter (shameless plug):

Incidentally, I’ve been thinking about the old practice of publishing Basic games in magazines, and how we should encourage people who play Javascript games on websites to peek at the source code and experiment with it. But even JS games are generally too big and complex for that nowadays — my own being an exception I’m proud of. Where are the Zen masters of game development?

But the real problem is, modern computer users just won’t do that. They’ve been raised to think command lines, never mind programming, are highly arcane stuff laymen like them should stay away with on pain of releasing demonic forces. Or something.

And that’s a tragedy, because like you I started out on a Sinclair machine (a Speccy in my case). Then I pulled a similar stunt when learning web development (back in 1999, when a web page wasn’t megabytes of scripts and CSS). But nowadays most people don’t even understand, much less listen if I tell them to do like we did. And as I pointed out above, they’d have a hard time even if they tried.

Still, the more I think, the more it seems like a good idea to do some activism in that regard. Make people look at source code. Get them to realize it’s not nearly as arcane as they think. Awaken their curiosity.

That’s easy to say though. I don’t know…
Xian said,

I never progressed much past BASIC. I learned it on Atari 800, then when the Atari ST came out I programmed quite a bit on GFA Basic, the first version I can remember that eschewed line numbers and guided you towards more structured programming. The Atari ST was particularly easy to program, and I could create some pretty amazing effects for the time by utilizing it’s memory mapped display. On the Amiga, I made some simple games with AMOS Pro, which similar to today’s Blitz Max, was BASIC optimized towards game creation. When I first got a 386 PC in 1991, I found Qbasic to be a huge step backwards, and the implementation of GFA BASIC for the PC wasn’t nearly as good as the earlier Atari versions. I dabbled with early versions of Visual Basic, but by that time I was being pulled more towards networking than programming.

I really do think that my earlier exposure to programming helped in my career even though I went a different path, as programming taught me a lot about logical thinking.
Noumenon72 said,

Just as an example of how kids today have it easy, I think the modern equivalent of BASIC is Scratch. I have six-year-old nieces writing programs with this. (Link is to a game I made by “remixing” someone else’s art and game idea.)
Noumenon72 said,

I forgot to mention that you click “see inside” to see what the actual programs look like.
Anon said,

The three Eschalon games are written in BlitzMax BASIC, for example and this should be enough to convince people that BASIC can be powerful enough for many types of games (perhaps not for the next Call of Duty).

It’s a pity, though, that such anniversaries practically only consist of reminiscences of the usual old, clicheed programming experiences: 8-bit home computer, typing in programs from magazines and books, PEEK & POKE because there were no powerful instructions, slow program execution etc. etc.

All of this is true – but it’s the past.

BASIC was always meant to be a low hurdle for the budding programmer – and why shouldn’t it? It should be true for any type of application just like lots of computers with GUIs are being sold as “intuitive” (Apple anyone?).

However, modern BASIC variants get belittled all the time because people still think that BASIC more or less stayed the same like they remember it. They assume that it still allows for the same old mistakes one makes as a new programmer that create bad programming habits.

But BlitzMax to “SuperStrict” and see how far you can get with bad habits!…

True, BASIC is less cool and especially less “hipster-friendly” like the newest Java variant but when you don’t have to program what others tell you with tools that you get dictated then why not using something that lets you get quicker results?
Rampant Coyote said,

I haven’t used Blitz, but I did program (professionally) in Visual Basic for a couple of years. Which – in my view – wasn’t *really* BASIC, but a hybrid language. Not a bad hybrid, but when Microsoft started dropping support for it, the writing was on the wall.

It’s really cool that old software & languages don’t usually die. While I’ve not done it too recently, I have loaded up the ol’ Commodore 64 emulator and even written some BASIC code for it. It was funny how much I remembered.

BASIC is still around, and even useful. But it’s definitely in the “long tail.”

Even Java, nowadays, has been losing steam. And C++, which was the industry darling when I was in college and seemed like it was going to be the gold standard forever, has definitely fallen out of favor. It happens. It doesn’t invalidate software written in those languages… the only thing a loss of popularity really means is a loss of support.
Adamantyr said,

I’m still writing in BASIC, using an emulator for my old TI-99/4a computer. In fact, I’ve taken to trying to convert programs written in other BASIC languages to the TI just for some fun. It’s interesting identifying the areas that slow down BASIC so you can write better optimized programs. (For example, TI BASIC and Extended BASIC are notoriously slow, even for the era. I found out embedding function calls into a check routine actually was so horrible on performance I ended up removing it.)

I do lament the lack of a good “BASIC” language for the software engineers of today. Part of the problem is as Felix said; modern day computers hide away all the internals and people are intimidated by the idea of programming at all.

Plus, anytime someone tells me that a teenager in middle school could learn Java/C#, I just wince. These languages are NOT imperative languages like old BASIC was. They require too much thinking and design, and what almost every kid WANTS to do is write games, and there’ just no clear and easy path to do this. I’ve heard good things about Blitz in this regard, but until schools start pushing it as a learning platform, it’s just not going to happen.
Anon said,

It’s a pity how the TI engineers killed the power of the 16-bit CPU with the TI99 architecture (memory access through video controller).
But that the BASIC itself sucks was new to me.

As for Blitz:

Realistically, there is only one active “Blitz” product:
BlitzMax, which is stable, quite speedy (both compile and run time), mostly complete (even OO programming), supports 2D graphics out of the box and a GUI library is included to write your own desktop applications. While it supports Windows, OSX and Linux it can’t crosscompile.

As much as I like BlitzMax it’s commercially pretty much dead, most of the developer community died off over the years and a 64-bit version won’t happen as all development on it halted (only fixes are being supplied).

The “successor” (next product from the same company/developer) is called “Monkey” and the problem already starts with its name and the cute monkey logo (the system library is “mojo” and the programs are “bananas” – oh yes…).
It’s meant for programming games on many(!) platforms (including mobile) using the same language. But while it’s BASIC-like in many aspects it’s more like a converter into C-code so you put your source through the converter and then through the supplied MinGW-C-compiler. If you don’t use a SSD you will notice the difference in compiling times… (you can use other, faster compilers, though, like Visual Studio).
In other words: It’s apps run about as fast as BlitzMax, it appears to be a bit less stable and less complete (no GUI apps at the moment) – but it supports iOS, Android, Windows Phone, XNA and more, at least in the paid product “Monkey X Pro”. The entry version “Monkey X” is free and supports desktops and HTML5.
If the amount of posts on their community forum is an indication then it hasn’t gotten a bigger part of the market in the four years since its launch…

While the included IDEs are very spartanic one can get inexpensive professional ones for BlitzMax (“BLIde”) and Monkey (aptly called “Jungle IDE”… :-O ), though.
With these IDEs the programming is much more comfy and fun.

The big problem with both BlitzMax and Monkey, though, is that they are very poorly documented, IMHO. The help files are extremely terse and you have to rely on forums (there are some “gurus” but most are only enthusiastic) and the supplied examples (demos and some very basic game skeletons showing techniques). I found that some examples in the BlitzMax help files didn’t work on my desktop and I had to alter them…

But still, I consider Monkey a better alternative for learning real (games) programming than products like Clickteam Fusion which are fully integrated game editors or other proprietary stuff like GameMaker that incorporates some Java-like code for program logic.
Kruno said,

I am surprised no one mentioned PureBasic.

PureBasic is still receiving updates and is long lived, recently it has become modular, has excellent documentation, and is quite fast to run and compile.

The other BASICs no one mentioned is QB64 and GLBasic.
Anon said,

For a list of BASICs look here:
http://en.wikipedia.org/wiki/List_of_BASIC_dialects

So now everything has been mentioned! 😉
Anon said,

Just an addendum to “Monkey” I described above – from the Monkey-developer himself on his blog on April, 26th:

http://marksibly.blogspot.co.nz/2014/04/slightly-depressing-update.html

Realistically, that means one less option if you want to do multiplatform development including mobile.

Go Unity Go! 😉