After writing my recent article on utility cartridges and checking out the extensions to BASIC they offered, I was inspired to go have a look back at Commodore BASIC V2.0. While it may be (very) slow and may lack any real support for the Commodore 64's advanced graphics and sound capabilities, it was the very first thing I encountered when I powered up my Commodore 64 for the first time ever. It also was the first programming language I used and it ultimately fueled my life-long interest in computers, programming and 'general ICT stuff'.

As such, I thought it no more than fitting that I write a few words about the best worst programming language I've ever had the pleasure to use.
Stacks Image 5
Above: a more colourful version of the first program everyone wrote in Commodore BASIC.
And boy, did I use it! I tried everything from simple example programs found in the manual as well as many, many type-in programs, simple games, sprite/character/bitmap editors and much more. I even dabbled in making a windowing system of sorts - though it didn't control so well with my 'mouse pointer' being controlled by the joystick and using BASIC.

In fact, when you look past the speed and lack of graphics and sound support, I'd say that Commodore BASIC is actually rather good. Not only does it have pretty good precision* in its floating point routines, it also has a fairly big chunk of memory available to it and the built-in 'PETSCII' character set allows for some very interesting graphics. PETSCII also supports both mixed case and upper case + graphics, which can be switched between by pressing SHIFT+COMMODORE. This requirement to switch character sets may seem insane these days, but back in 1982 many computers just didn't have lower case characters *at all* - so it was actually a rather nice feature.

I also always liked the way the PRINT command allowed for the adding/changing of colours and screen locations without using PEEKS and POKES. Even though the lack of a PRINT AT was sometimes rather annoying and the control codes made typing in listings quite a bit harder.

One thing I especially liked about the Commodore 64 and it's built-in BASIC was the immediacy of it all. Turn the computer on and you're immediately confronted by BASIC. Which not only is the gateway to most other programs (because you load in stuff through BASIC), but also immediately allows you to do stuff and experiment. Whether by using the C64 as a big calculator, an impromptu dice roller or a name reverser (or any other thing you can think up).
Stacks Image 11
Above: an animation showing some of the things you can do using the immediate mode in BASIC.
And then, obviously, there are the many more things that making an actual BASIC program allows you to do. While it may seem like a limited language, Commodore BASIC allows almost anything you can dream up can be programmed - setting aside the speed issues. Nowhere is this more apparent than in the many type-in listings that appeared in computer magazines. From graphics editors and sound editors to light databases, lotto number 'predictors', games, disk and tape utilities, banner printing programs and many more. The list was nearly endless.

True, a lot of these programs where limited in scope, slow and often not nearly as good as commercial software written in assembly, but they did offer a gateway into getting started programming yourself.

After all, if a magazine gives you the source code for some neat program, you might go and tinker with it to see if you can make it do other things, or you might see how something is done and decide to try for yourself. And then you might create some programs and see that it is not only doable, but also rather fun. Eventually, you might even 'graduate' into machine language - at first using it as support code for BASIC, later as the core of what you create.
Stacks Image 17
Above: the famous Commodore Balloon sprite example from the manual.
Lastly, I even like the many PEEKs and POKEs you'd inevitably end up with if you wanted to use any sort of non-PETSCII graphics or any sound at all. Now, these PEEKS and POKES were very inconvenient for beginners - I do admit that, the learning curve was quite high. However, once you got to grips with them, you'd realize that you also just got to grips with important facets of the Commodore 64 hardware, which made the translation into machine language a lot easier.

In fact, I'd go so far as saying this requirement to know the hardware in order to show sprites or make sounds was a blessing in disguise for budding C64 programmer.

Case in point: by the time I started programming in assembly I already understood how sprites worked, how characters could be plotted in memory, how to make a new character set and how to set up the bitmap modes (and draw to them). I even roughly understood the C64's memory setup and how to make the SID chip, well, play simple sounds.

Even though modern computers are vastly more convenient, powerful and easy to use - I still sometimes miss the old days when you turned on your computer and were greeted by a simple blue screen telling you BASIC was ready, that you had 38911 bytes to play with and that the computer was ready. That blank slate, ready to go, really was at the core of my reasons to try out all these things that led to my career and path in life.

And it's all (in no small part) thanks to the C64 running a cut down implementation of a programming language for beginners as it's "operating system".

*) compared to other forms of BASIC out there at the time.