True BASIC by Kemeny and Kurtz

When I was young, and I enjoyed learning to program, I thought everyone could learn to program, and they would enjoy it.

Many decades later I've come to understand that programming is an intrinsically shitty job [1] which can only be done well by people who really love doing it. You cannot force people to learn programming. You can offer opportunity, but those that enjoy it will enjoy it. The language is irrelevant - joy trumps difficulty.

This is true for so many well-paid jobs. Smart kids get pushed into medicine, but good doctors are those that like being around sick people (and making them better). Sure it pays well, but often that's a sign that its a shitty job with a high skill level, and high societal value.

I'd still be programming even if I didn't get paid. It gets my motor running. But I understand now that its not for everyone.

[1] go on, describe your job to a middle schooler. Hours behind a desk, staring at a screen, spending hours to find out what a comma should have been a period... it's their very definition of a nightmare.

I think Shen (fancy Lisp) has a similar model

For just $4 more you can buy the Atari ST version!

I started writing software as a child, in the eighties. I only had access to various forms of BASIC and machine code. I switched to C in the early nineties, when I got access to Turbo C in middle school. Later, I got access to Minix, BSD, and Linux. I turned out fine.

I'm a fan of Dijkstra, but it's best to take his opinions with an appropriate dose of salt. He liked to be provocative.

The version of BASIC I learned (Applesoft) had little support for functions and no concept of scoping. Every variable was global. GOSUB acted a little like a function, but barely (no function parameters, and without variable scoping a parameter is meaningless anyway). Without these features, it was very hard to write a program of any size without it becoming a mess. I wouldn't go so far as to say BASIC breaks your brain, but it is almost antithetical to structured programming, and eventually you need to learn structured programming if you plan to write maintainable code.

There is also an argument against learning programming with languages that have no concept of a heap. I agree that a C pointer is a weird thing at first, and some people never get it. But I've softened my stance over the years. People can be productive coders without being bit twiddlers.

I learned Dartmouth BASIC on a timeshare in 1981. Variable names are single letter, or a letter and a digit. All variables are global. No function headers. Branching by GOTO. It means that modularity and structure are virtually impossible.

It practically forced you to write obfuscated code, and programs larger than a few dozen lines become exponentially harder to manage. Imagine the worst code you've ever seen.

People who got good at coding in this way tended to develop mental habits that had to be un-learned when they moved to a more advanced language such as Pascal, as I did. With that said, beginners in any "scripting" language can evolve in the same way, if not taught some better habits. I've seen some Python programs that were as bad as my BASIC programs.

I disagree. I've lived through various levels of programming languages and it makes me appreciate features in languages that, these days, are just taken for granted.

I've got a few vintage BASIC machines now and some of the code for those machines is almost unreadable. What struck me now that didn't when I was kid was kind of how much like assembly language BASIC can be in some of these computers. On machines with very limited RAM but plenty of ROM, BASIC acts like compression allowing you to write much more complex programs than you could actually fit in RAM if you did everything in machine code. And, like assembly, being terse and clever can result in better performance and smaller code.

I'm considering writing a BASIC-to-BASIC compiler for these machines that works something like a JavaScript minifier.

I disagree with that comment about BASIC, for a few reasons.

First, you can say that about any language when trying to learn another. The classic “writing Fortran in Lisp” concept. Learning to write idiomatic BASIC doesn’t prevent you from learning to write idiomatic anything else.

Is there some, perhaps, unlearning necessary? Of course there is, as with anything. But it’s not fatal.

Second, it’s hard to appreciate how good something is until you’ve fought through something else that could have benefited you, if you knew it.

Early BASIC is not very expressive, and therefore limited. When you move on to something more modern, you don’t necessarily take it for granted. “Oh boy, this is so much better!”

Now you know WHY it’s better rather than just accepting it as rote. That leads to just a better, and deeper understanding of the whole field. When you were implementing your first B-tree, or hash table in raw C, you learn to appreciate why the one in the utility library, that you get for “free” may well not only be better than the one you copied from your “Data Structures 201” book (since it just may well be a more advanced algorithm), but you’ll realize how it works as well.

In contrast just blindly drag and dropping one into your project because you found a link on the internet.

Similarly, while it’s easy to condemn these older systems, if you ever go back and try to do work on some of these vintage systems, at their vintage speeds, you may well appreciate why something like BASIC was limited in the ways it was.

Are the more advanced language features worth the expense they incur? Maybe, but also maybe not.

Maybe for some the habits they learn have life long impact, but I don’t think being exposed to different idioms and methodologies of software development is a bad thing. Let’s folks learn and understand where those sayings and “best practices” they blindly apply (and not always necessarily for the better) come from.

I have zero evidence that this is true.

My personal experience is that after having fought with the limitations of BASIC, I enjoyed the power of C: pointers, that most students struggle with, were fresh air for me.

On the contrary, I was exposed to Pascal after C, and hated it: haw can you tolerate self- inflicted limitations when you know that there's something better out there?

What I learned is: always go from simple to complex, never backwards. So yes, BASIC is a great choice for absolute beginners.

He is wrong. It is an infantile view on learning which assumes that your first contact with an area of knowledge creates a lifelong habit that can't be improved with further learning. I started programming with BASIC and easily switched to C, Pascal etc without a trace of BASIC's programming practices.

Dijkstra was a brilliant man with big opinions that were often garbage.

The fact that there are many great programmers that started with BASIC disproves this quote.