Suppose you decide you want to become a novelist. You enroll in the Hackaday Famous Novelists School where your instructor announces that since all truly great novels are written in Russian, our first task will be to learn Russian. You’d probably get up and leave. The truth is, what makes a great (or bad) novel transcends any particular language, and you could make the same argument for programming languages.
Despite the pundits, understanding the basics of how computers work is more important than knowing C, Java, or the language of the week. A recent post by [lackofimagination] proposes that we should teach programming using BASIC. And not a modern whizz-pow BASIC, but old-fashioned regular BASIC as we might have used it in the 1980s.
Certainly, a whole generation of programmers cut their teeth on BASIC. On the other hand, the programming world has changed a lot since then. While you can sort of apply functional and object-oriented techniques to any programming language, it isn’t simple and the details often get in the way of the core ideas.
Still, some things don’t change. The idea of variables, program flow, loops, and arrays all have some parallel in just about anything, so we can see some advantages to starting out simply. After all, you don’t learn to drive by trying it out in the Indy 500, right?
What do you think? If you were teaching programming today, would you start with BASIC? Or with something else? You can modernize a little bit with QB64. Or try EndBasic which just recently had a new release.
I have always thought that BASIC makes more sense to Arduino beginners than C++.
I started out programming PicAxe microcontrollers before pivoting to Arduino when they became dominant. I found the PicAxe easier to approach as a layperson.
I totally agree, but I think the version should be Visual Basic. Not having an interactive environment where you the programmer can run code line by line, check variable and see how the program is dropping in and out of subroutines is ridiculous in this day and age. If the processor is not capable of doing so, change the design! Beginners would learn so much more if they could actually see what’s going on!
QuickBasic allowed you to step through code like that. It even allowed you to run your program backwards (!) which was rather neat.
So, it allows you to go back in time?
B^)
Only a basic that has peak and poke and some bit operations like rotation and logic.
And for the love of whatever keeps you up at night, don’t make it dependent on some gawd awful IDE
Parallax seems to think the same, and provide PBASIC support for their micro-controller range:
https://www.parallax.com/go/PBASICHelp/
Almost anything makes more sense than C++. That’s a low bar.
That being said, Python is probably the better BASIC.
Circuitpython is convenient and relatively easy to learn, micropython is slightly harder but more versatile.
It’s 2024, everyone ‘does’ python, basic is from the previous century.
If performance is needed: C(++)
BASIC today is spelled P – Y – T – H – O – N.
I thought the exact same thing! Nowadays python makes a lot more sense than BASIC.
Python would easily be my first choice as well, and I cut my teeth on mainframe BASIC in the 1970s.
Exactly! Python is the new basic. It runs everywhere including microcontrollers and GPUs.
Python is not as friendly as BASIC.
The point isn’t to just have an old, non performant, language with a horrible dependency on indenting of all things (and let’s not forget all the opinionated ‘advanced’ aspects of the language.) Heck, we might as well teach Java at that point, just as much 💩
Look, nostalgia for 💩 languages (PHP, Ruby, Python, JS, C, C++, etc) is one thing; but let’s not kid ourselves by saying they’re friendly \ easy to learn, because is grey beards did since there was no other choice.
As someone who’s taught and professionally developed at all levels, there is a place for a simple & easy to understand BASIC language. But after that first period, there’s no reason to not use a modern high level language where you don’t have to explain away all the crud of an old language, just because your a lazy teacher who doesn’t want to update their skills\course.
There is no such a thing as 💩 language, Language is what makes us human. It is how people communicate. By learning a language, it means you have mastered a complex system of words, structure, and grammar to effectively communicate with others. But wait! 💩 is not even a word!
You just used the poop emoji as a word. So how can you say it’s not a word?
In any case, I’m glad you never seem to have met PHP.
Interesting. when I copy and paste : ‘💩 language’ I only see 1 word. Same case as ‘Hello !’ see? 1 word. Anyway, my point is that any language is good by itself, it is an effort,it is an interface between brains or between machines, and any language is better that none. And we still have to bring into debate the non-written language, but nah!
“There is no such a thing as 💩 language” .. lmao 😂
Not 100% sure why I’m responding to this statement, other than to perhaps stop some impressionable n00b from thinking that all programming languages are created equal and that their desire to program in Brainfück (a ‘real’ language) or RedStone or any of the old 💩 languages (PHP {+1 👍 @Matthias}, Ruby, Python, JS, C, C++, etc) is equally justifiable.
First, the article’s main thrust is that there’s a place for BASIC (not ‘Language’ and it’s place in human society); and relevant to that, I’m objecting to the use of Python (and the other 💩 languages) as an alternative to BASIC. That’s the context. If you want to learn/work in data science, the current zeitgeist is Python (most likely due to academia {perpetual lovers of crappy languages to teach, because most of them don’t work in industry .. Java I’m looking at you}) even though it’s not a great (or arguably even good) language. So if you want a jump-start in data science & to be able to leverage the community, you’re stuck with it; just like JS & the web. But that community doesn’t make up for it being a 💩 language, any more than following a popular TikTok challenge makes it safe.
Whether it’s BASIC or a no-code visual programming ‘language’; there is a role for a simple, non-confusing language as an introduction to programming. Python is simply not one of those.
Ditto. Also, 99% of the criticisms against BASIC assume BASIC has always been the same terrible line-number-using, GOTO- requiring mess that was on a lot of 8-bit machines in the 80s, but this simply isn’t the case and hasn’t been for decades. Dialects inspired by Microsoft BASIC (QBasic/QuickBasic, Visual Basic, the open source options QB64 and FreeBASIC) are fully modern languages that have other branching and looping features, subroutines, don’t require line numbers. But even FORTY YEARS after the fact, most people assume that using BASIC implies using line numbers and being forced to use structures that require you to write spaghetti code. It’s silly.
Or you could try a modern BASIC such as the new twinBASIC programming language which combines ease of use, power and VB6 compatibility.
Friendliness, learning curve, availability is mostly unimportant for beginners. What they need is examples.
There are hardly any examples for programming a microcontroller in basic, java or whatever. C(++), and (micro/circuit) python are the reasonable choices.
I very strongly disagree. Python has some serious shortcomings as a beginner language. Blocks delineated by white space and list comprehensions jump immediately to mind as being particularly troublesome for beginners. The inconsistent syntax is also troublesome. Compared to other popular modern languages, I’d even say that Python was downright hostile to beginners.
BASIC got a lot of things right, even if some of it was accidental. You might not think about direct sequencing when you think about control flow, but I’ve noticed that a lot of beginners have trouble with this as they tend to view code more like configuration than a list of instructions. When modifying example programs, they often have trouble understanding why their changes don’t have the effect they expect, even when it’s obvious to someone more experienced. Line numbers, clunky and awkward in this modern age, reinforce that basic concept, along with some others, nicely.
This problem is compounded by blocks being delineated by indentation level. It’s not that easy to explain to a beginner that nothing they can see tells the computer to, say, jump the top of a loop. Even in newer structured BASICs that don’t depend on line numbers, where a block begins and ends is obvious. NEXT I, WEND, LOOP are not only visible, they might not need any explanation.
BASIC is unmatched in how readable it is to people who have never seen a computer program before. In contrast, just about everything in Python will require a lengthy explanation.
Really, the only think Python has going for it is its interactive mode, but it’s well-behind what various BASIC implementations were doing in the 1980’s.
Python is no substitute for BASIC. I’m with the author here.
It’s has been a bit difficult to explain data types to new programmers. Python doesn’t really hide them very well, even if it more consistent than JavaScript.
Why do you need to hide your data types?
Well, some can be quite embarrassing if seen out in public.
Python is a trash language, comparing it to the venerable good old Basic is extremely insulting.
Python is trash, so was basic, so is modern basic.
They are all 100x better choices for first computer language then JS and it’s steaming pile of libraries.
COBOL is a 10x better choice.
IMHO they should ALL learn 6502 assembler first. KISS, but close to the metal.
Then they’re ready for C.
Then C++.
Then SQL (never the MySQL dialect though), JS and other niche but needed languages/steaming piles.
The real problem starts when coders learn to code in the browser.
Then the fools install Tomcat or similar.
Then you can only wish them ‘Better luck next reincarnation.’
Like a chronic paint huffer, they’re mind is wrapped around a pole.
Are too damaged to know it, like a senile politician.
Yes, fully agree! Python is quick and easy to write and can do most of the things you need.
Basic, to me, feels like a less formal environment than languages like C. Using Qbasic in the early 90s does remind me of using Python today, its approachable for beginners. There is a democratizing effect on coding for the simplicity they offer. In CS101 with Freebasic i earned an A. In CS102 with C++ I got a C!
where in the name of god, to they teach cs101 using freebasic?
In India till 2020 they taught people Turbo C++. Questions about were common.
QBasic is already one of the more advanced BASICs.
Indeed. It’s a cut‐down version of Quick Basic 4.5, minus the compiler and additional features.
QB45 can run and compile all QBasic programs.
Python. It’s been around a long time, isn’t going anywhere, is easy to read and intuitive.
I wouldn’t call Python intuitive. List comprehensions, for example, are completely opaque to the uninitiated. So is meaningful white space. Someone with some programming experience might understand immediately, but a beginner has no hope. Python’s inconsistent syntax is also troublesome. You might not even notice it, but it can really be a stumbling block for beginners.
Contrast this with BASIC, which someone with no programming experience at all can usually understand. At least, they could tell you what each piece was doing, even if they couldn’t tell you what the program was doing.
I agree, many features in Python, or Visual Basic for that matter aren’t appropriate. We teach high school students to program in Python. We don’t use list comprehensions or many other features, notably classes. The Python that our kids write is a lot like Basic and it doesn’t have null pointer exceptions like the Processing environment. It does have a repl and an IDE which are better teaching tools than the BASIC I learned on in the 80’s.
Semantic whitespace only violates the intuitions of people with programming experience, who have always assumed that whitespace was meaningless. (Including the occasional graybeard with PTSD from Fortran IV or before.) Programming beginners have experience with semantic whitespace since grade school English, where they learned about outlines, which are also conventionally semantically indented. And anyone who starts teaching beginners by explaining list comprehensions first, doesn’t get to blame the language for their troubles. (Although the world might be a better place if people learned functional programming first, instead of always starting with the ALGOL dialects we have been addicted to for sixty years or so.)
While I don’t think that Python is “the best” programming language (since there is course no such thing), I have repeatedly found that those who harp on semantic whitespace usually have a shallow understanding of the language. Why? Because there are other, much better critiques of the language, yet they pick something trivial.
20 years ago the argument pythonistas made for semantic whitespace was a good one: that it made impossible the kind of infuriating bug that misindentation in other languages occasionally caused. Today, that point only benefits someone fool enough to not use a semantic code formatter in their IDE (and who therefore deserve what happens to them.)
All that said, whatever gets beginners early successes, and gets lexical complexity out of the way, makes things better for someone who doesn’t yet even understand what a program is. For that, IMO BASIC is fine. Inspired students will quickly move on to something better. The rest can become “prompt engineers”. Assuming we all don’t.
Inspired students unfortunately (in my school) couldn’t move to anything better because every other language cost $$$ the school didn’t have. This was ages ago of course, well before most computers had a mouse. So much more stuff is just WAY more accessible now. We didn’t have the luxury of choice.
“PTSD from Fortran IV”
More likely from having to use punch cards to write it than the language, even more likely from growing up in the 60’s and 70’s.
I found it to be a great first language to learn in ~1982
basic a few years later not so much (though admittedly I was trying to learn it in conjunction with trying to program a modem to do something beyond my skills)
I think the structure of the training and prerequisites are probably more important than the particular language. Most intro educational classes use simplified cases or explanations at first and correct them later.
I also learned Fortran first (summer short program at 14, with punchcards!)
They didn’t teach us about calculated GOTO.
GOTO Intvar.
Where Intvar contains a line#.
I ran across that 15 years later.
Fools were using Int NextIterEntryPoint. Ending loop with GOTO NextIterEntryPoint.
Then doing things like NextIterEntryPoint += RecalcHydroShadowPrices (But in Fortran).
They should have made all the offsets powers of 2, then bitwise OR or NOT.
They should have set flags…
What can you say about PhDs? Deeper…
Modern Fortran needs a calculated COMEFROM.
COMEFROM Intvar.
There’s your PTSD.
Semantic whitespace is fine.
But stop using space characters!!! Use tabs!
One tab per level of indentation. Then everyone gets to configure the displayed tab-width of their favorite editor to whatever works well w/ their personal combination of eyes, display and taste.
Now, with that out of the way… let’s talk about how switch/case statements get indented…
You know you don’t *have* to use list comprehensions? Just use a for loop if you’re so against them.
There are plenty of things a beginnner won’t be able to do and has to learn. There is simply *no* language in existence that is both trivial to learn and also makes every task trivial to write. If you think BASIC does that job then you’ve never had to use it for anything complicated.
But you don’t need to teach EVERYTHING of python. List comprehensions aren’t mandatory to work with lists, you can do it “the old way” and it works perfectly. In a course to learn how to program, you would use the “classic ways”, and only in a specific python course you should explain “advanced syntax”.
Hilarious how Python fanboys keep repeating their mantra about “easy to read and intuitive”, hoping that if they believe hard enough it will become true one day.
Of course I’m a python fanboy, it is that good.
I have programed (from what i can remember now) Amos Basic, QBasic, Visual Basic, C, C++, Turbo Pascal, Java, C#, Python, Bash, various web languages.
Qbasic and C++ and Turbo pascal I studied in highschool. C, C++ and Java i have studied at the university.
Now i work with hardware R&D and I use python every day. Some projects demand for C or C++, but if i can I’ll use python.
Python is pretty easy to use but if you get stuck somewhere you have infinite help on the internet in examples and forums. That is where its main power is, you will always find help when you need it.
It’s the first language I reach for when i need to program something fast, to make a prototype or test a concept. After that i can go to something more close to the hardware if I’m speed or size constrained.
I agree there is an advantage to teaching a simpler language. The first language I programmed in was Commodore 64 BASIC. That said, I would recommend snek ( https://sneklang.org/ ) over BASIC if you want a simple programming language.
No step on sneak
All these years later, I still think “shift 2” whenever I hit quotation marks on a keyboard
While I was always skeptical of Djisktra’s comment (I was part of a generation of programmers who indeed learned BASIC, but somehow overcame the “fatal disease”) I cannot see any actual advantage from teaching BASIC over more modern alternatives such as Python. Classic BASIC lacks even the most basic structured programming constructs, lacking the ability to create meaningful function or data abstractions. It also lacks the ability to utilize standardized libraries to provide significant/interesting functionality. BASIC may have made sense when running with an 1 Mhz, 8 bit computer where the interface to the user was imagined as just a keyboard and floppies, but it’s just not that useful when (say) you want to implement web servers or services. Even an implementation like https://micropython.org/ would be a better choice.
Good. Not being able to hide stuff behind abstractions and libraries cures the Arduino disease where the beginning programmer doesn’t know or understand what’s going on, and treats the program as a sort of alchemical recipe where reciting the correct mystical incantations makes stuff happen.
If all you have is basic arrays and loops etc. and GOTO/GOSUB for implementing “functions”, you’re much closer to how the computer is actually doing stuff, and you’re forced to think about programming by the basics rather than just downloading a library and going “special_function();” to make stuff happen.
Starting from the abstractions confuses people and delays actual learning – like trying to teach set theory before you teach children to count 1 + 1. The abstractions are advanced tools that allow you to think about the task in larger pieces that are easier to manage, but you still need to know a great deal about the basic operations or you’ll be practicing “magic”.
This is often forgotten by people who did start from the ground up and then progressed to more abstract forms of programming, and then forgot how difficult it was to grasp even the very basic concepts since it’s just so easy now.
BASIC is just as rife with abstractions that hide the real processor from the programmer. For example, the PRINT statement, behind the scenes, accesses the memory of strings sequentially without an explicit per-character loop, and presents the characters on the screen (much more often than an actual PRINTer) without involving the programmer in formatting the characters in a dot matrix, encoding the video pixels sequentially for each pixel in each line to be displayed on the screen, and driving the hardware of the video output.
And obviously you can see the merit of not teaching systems programming and hardware design first, and not having young programmers build their CPU before programming it. Although it wouldn’t be a bad thing for later in their education.
Cliff Stohl, at a ham radio conference a while ago, presented that he taught using an analog oscilloscope because a digital one had a good deal more abstraction between the input and what it presented, and that the student would have to take on faith what the digital scope presented while the analog scope was faithful to its input. I contend that the analog and digital scope are each equally unfathomable to the student, who is unaware of the complexities of the construction of either, and that student takes what they see on faith regardless of the digital or analog nature of the instrument. You can probably get a beginning student to understand a d’Arsonval meter movement, and transparent implementations are available for that purpose.
>hide the real processor from the programmer
That’s taking the point too far. A PRINT statement is the kind of “magic” that requires far greater understanding than the beginner can hope to have, so it has to be taken on “faith” at this stage. You cannot do away with every abstraction of this sort and still remain useful. The point is not to build abstraction on top of abstraction, to the point that the entire act of programming becomes mystical. Programming for beginners should be mostly concrete.
For example, if you say A = B in BASIC, you’re taking the value of B and putting it in A. This is concrete and easy to explain: variables are simple containers of data. If you do the same in Python, you’re actually pointing two variables onto the same object – not simply moving data around – and this takes far more to explain. This is not concrete, and it has the side effect that changing A now changes B as well. There’s something magical going on behind the scenes, and it has to be hand-waved away because otherwise you’re down to explaining memory pointers and identities. You get mired in the theory and concepts of object-oriented programming which is an advanced topic.
If you throw objects and structures and unions on a person who is just struggling with the concept of simple variables and arrays, you’re going to sidetrack and mystify them. If you introduce libraries on a person who doesn’t yet grasp functions, you’re trying to make them run before they can walk. It’s far better if they do their first bubble sort algorithm or lottery number generator etc. using a language like BASIC and then you can start explaining why objects and structures make sense.
Early, simple, computers were better for learning how things worked under the hood.
You could just look up the screen memory map and poke characters onto the screen.
Write your own ‘Print’ subroutine.
Just because you were bored. (Best not blow up anything else for a while.)
Eventually figure out where the characters bitmap was stored. Get first EPROM programmer, add lower case.
Today ‘under the hood’ is overwhelming.
I don’t want to see the awful JS that runs this place.
You can’t make me.
>I contend that the analog and digital scope are each equally unfathomable to the student
This is true, but the analog scope is far easier to explain in a concrete manner so the student can form a mental model of it rather than rely on a magical “black box” that does stuff when you press the right buttons.
If you don’t explain your tools, your teaching will become like training monkeys to jump on cue. That’s not education. In order to explain your tools, they should be concrete enough that you CAN explain them without going in the weeds with a whole bunch of peripheral information that is more complicated than the matter you’re trying to teach.
You realise that natural numbers are an abstraction over set theory, right? See Russell et al.
So… teach arithmetic to children starting with Russell? Better give them Goedel, too, so they understand the limitations.
Do you actually apply set theory when you count how many fingers and toes you have?
It requires more abstract thinking to recognize a concept like “a set” over simply counting, because you have a whole different language with set theory that you have to learn before you can handle it.
A close analog is in the way which schools traditionally teach human languages.
Rather than teaching a language directly, the students learn a meta-language that is used to describe languages, so they can understand what the textbook is saying when it says a word is “a genitive case”. Though usually they don’t teach the meta-language but simply assume the students already know the concepts by some sort of “absorption”, from something that was taught five years prior in an English class.
The end result is that the students barely learn any language, because they spend most of their mental efforts trying to decipher what they’re even doing. The teachers are too clever. They’ve spent their time learning linguistics, so that’s how they think about the matter, easily and fluently, while the students don’t.
Some of the comments have commented on comments (such as the above) that are based on original BASIC, rather than compiled QuickBasic 4.5 and later.
What I loved about QB4.5 was exactly its “basic structured programming constructs, meaningful function and data abstractions.” I loved that, by DECLARE’ing subroutines, invoking them looked like I had added a statement to the language, extending QBasic into a domain specific language for my application. I loved the convenience of WHILE and UNTIL with the test at the top or the bottom, as I chose. I used user defined data type structures.
By using DEFINT, DEFLNG, DEFSTR, etc. and declaring the specific exceptions, I didn’t have to get involved with %, &, !, #, and $ suffixes
The concepts in a first language set the student’s mind set forever. The problem with python as a first language is that all variable names are pointers to objects. In most other [low level] languages variable names are aliases for a memory location, and maybe with a data type and size for what is there.
To me, that doesn’t make python a bad language. It is a very good high level language for a domain professional who wants the results of running programs to get work done. It is not a good first language for someone who needs to understand computers and other languages.
Well since it’s Beginners All Purpose Scientific Instruction Code, it might be well suited for beginners ;)
I started my programming journey with BASIC, a very very long time ago. We recorded basic programs transmitted on a radioshow which could run on different computers because of BASICODE https://hobbyscoop.nl/the-history-of-basicode/
Actually it stands for Beginners’ All-purpose Symbolic Instruction Code
Yeah, beat up all those don’t write BASIC as BASIC. ;-)
Six of one, half a dozen of the other. I don’t know if everyone else is like this but the more different languages I learn, the easier it is to pick up a new one. So I say have them learn everything.
It’s to the point now that asking if I know a language doesn’t even make sense as a question. Even if I don’t know it yet, I can be as proficient as a new graduate who studied it in school inside a week and up to running projects in it inside a month. Twice as long if it’s especially arcane.
Totally agree. It’s usually easy enough to pick up on common idioms. (Though I personally find Python especially obnoxious in insisting on ignoring every other language’s design decisions… it takes me way to long to understand what the heck is even going on)
Python’s not hard for me to understand, I just can’t stand writing it because I object to formatting tyranny.
I pity any team that has to work with you on a codebase where the existing style guide contradicts your personal beliefs.
Styling and formatting can be fixed at any time; insisting on style as a functional element of the language is inconvenient and solves a problem that doesn’t exist anymore.
The best time to fix style and formatting is at check-in.
Just have the source control check-in process convert spaces to tabs (for example).
Eventually the twits will conform or quit.
Either works.
BASIC was the first thing I learned, but things like line numbers make it obnoxious when you really care about program flow. I think Python is a better option these days.
line numbers mean you don’t have to teach a beginner how to use an editor.
Learning the basics of programming (pun intended) is more important than the language. Being able to identify and implement an effective solution to the problem to solve is more than counting nanoseconds in the cpu. It is expedient resolution of the problem.
Years as a hiring manager in the business world, upper management always prioritizes time to solve the problem. While we will always need old school bit crunchers for some low level work, cpu cycles are cheaper than programmers now.
BBC Basic should be considered. It has been updated over the years, and versions are available for literally dozens of platforms.
https://www.bbcbasic.co.uk/bbcsdl/index.html
I started programming in BASIC back in ’81 or so in High School … but that was because of what was presented by the teacher at the time. When I entered college for a CS degree, the language was Pascal. Never missed programming in Basic after that… Today I would use Python 3 as the beginners language. It forces you to structure your code correctly visually which will carry over into other languages as a good habit… And of course it has a lot to teach from the basics to OO. Really can go as far as you want with it. Carry over to even programming SBCs and micro-controllers. Plus it is interpreted, for easy debugging, immediate feedback, much like the o’ Basic, but much much more without the gotos. No, Python is what I would use if I was a teacher for the basics for a ‘first’ language.
i started with c myself. it gives you better low level fundamentals than basic does. there seems to be a desire to teach easy languages first, but it seems backwards to me. when you start math you have to add manually and get a calculator later.
“there seems to be a desire to teach easy languages first” . Why not? Seems like a good way to introduce people to the wonders of programming before diving into pointers, bit shifting, stacks, and all the ‘fun’ stuff in C :) . And with Python, it will stay with you the rest of your life as a very useful language even if you decide to further one’s education with a CS degree or whatever. We use it a lot at work. Engineers love it, and us professional programmers use it where-ever it is appropriate which turns out to be ‘most’ places. Automate the boring stuff… Python is the language.
I would say you should learn a useful language first. A language that you can use solve your tasks without banging your head against a wall but that also is powerful enough to not hinder your progress . That is why i always say Python to newbies.
You can get all the help you need from the web, forums and examples. You will almost never get stuck!
I work with electronics R&D and python is by far the most versatile tool i use. Of course some tasks need a special tool like C or C++ but if you need the proverbial hammer good old python can be your hammer …. and your wrench …. and your axe.
I learned BASIC in elementary school 53 years ago. I’d much rather have a new simplified training language that seamlessly incorporates unit testing. That way kids would be able to give themselves immediate feedback when they got something right.
The goal shouldn’t be “learn these particular instructions” or “learn this particular syntax”, it should be “learn these concepts while learning how to do them well”.
Exactly. The syntax and instructions may change between languages but the core concepts are limited to a much smaller set of types. Pick them up and learning a new language is 95% memorization of the trivial differences in syntax and instruction names, with a few new bells and whistles unique to the new language. It’s more like going from NYC English to Atlanta English than it is English to Arabic.
And that is where Python comes in today. It allows you to learn all those concepts with immediate feedback. And make programming fun. Start you down the right trail out of the gate.
Then in college if you want to take it further as a career, you can learn computer architecture, debugging at the register level, stacks, pointers, data structures, linear algebra, numerical analysis, Fourier, solving differential equations, etc. to round out the education process using C/C++, Assembly. That’s if they teach any of that in CS degrees today …. I wonder though from what hear about our educational systems today…. Back when I was hiring kids out of colldge (15-20 years ago now), some could not even add hex numbers, or convert back and forth between binary, octal, hex… Made me wonder…
Nah. Python is a terrible language to start out on. Learning it first causes almost any other language you try learning to give you code formatting headaches right up front, instead of only Python making you want to kick the whitespace-nazi language devs.
Disagree. Again good code structure technique upfront generates dividends down the road. Good habit. I use 3 spaces for indenting (same with c/c++, java, pascal, Perl). Python forces good indenting for a very good reason … called readability. No braces all over the place as I see in other peoples code. No code willy nilly between the braces. Wonderful when you have to go back and actually read the code months down the road.
And down the road, how many times have you had the error in your code be caused by missing {}s because so many other languages use them to denote scopes? If you’re the only language doing extremely fundamental things differently just because you think you know better, you are wrong. Yes, even if everyone doing things your way from the start would be better.
>called readability. No braces all over the place
Braces are explicit. Omitting them doesn’t actually improve readability – it just hides information by making it implicit.
No, but ‘blocking’ your code does whether with/without braces:
Example (wish could use Courier font in comments)
func()
…{
…code
…if (x == y)
……{
……code
……}
…code
…}
“Back when I was hiring kids out of colldge (15-20 years ago now), some could not even add hex numbers, or convert back and forth between binary, octal, hex… Made me wonder…”
I always said “If the hiring process cares about my typing speed I don’t want the job.” Sounds more like a field sobriety test than a job interview. I would offer my declination in a respectful manner and move on.
Maybe. Speed had nothing to do with it (initially). Just so they could do it. Also depends on the job. Part of the job I was hiring for was technical…. They would be analyzing binary protocols for example which required you to know what you were looking at as the information flew by in hex. Digital inputs would be in a binary word. Debugging/stepping through z80/68xxx/PPC code also in hex Bytes/words/longs. Anyway, kids that didn’t know ‘basic’ computer concepts probably weren’t able to handle complex problems either… No hire.
CS is a very mixed bag.
It’s down to the college.
Generally, CS is taught out of 3 schools:
Engineering.
Math. (Arts and Sciences now, but came from Math)
Business.
You are looking for CS out of Engineering. (so is everyone)
You are definitely not looking for CS out of business. (same as everyone)
CS out of math is most of them, beware the theoreticians.
CS grads that don’t code and never have.
It’s not all A&S CS people, but far too many. 23rd normal form databases! Calculus for business majors.
It is all business CS people.
Never hire them. Hire a philosophy/physics major instead. They will learn to code _far_ faster than the business major will learn to think.
I also learned basic in grade school.
I would reach Python instead of basic today though. It fits the bill for basic concepts, easy to grasp but also usable for current needs imo.
I had much to unlearn after learning BASIC.
It was an easy step from BASIC to Assembler to C and Pascal for me. Adding structures on top of what I already understood about conditionals and loops really clicked for me and opened up some additional ways to solve problems that weren’t previously available to me.
Ditto. Almost the same path I took (but with some PL/1 after Assembler). Most of the core programming courses were taught in Pascal back in the early 80s.
You’d be amazed how many professional coders can’t write even one flavor of assembler.
It is the key skill early.
Everything else is syntactic sugar.
I too cut my teeth on Altair and Imsai BASIC and I have strong sentiments for it, and I’ve always been annoyed by all the disparaging comments made about it. Usually it was that BASIC allowed such awful and unstructured code. As I see it, the fact that it does, and yet still works, is a testament to how good it is! It’s not difficult to write _good_ code in BASIC. And as Python popularity started to explode I was annoyed again because I don’t think it’s all that different from BASIC. I still haven’t fully learned Python.
That said, it’s time to move on to more modern (and structured) languages for students. But rather than full-blown Python, I would suggest Micro-Python on some cheap microcontrollers.
I’ve no idea about the WinDO(w)S world, but on Unix you can have MicroPython too and IMO it make sense to use the same tool under Unix and on micro-controllers. PkgSrc has packaged an older version, Voidlinux has a fairly current one and building it is easy if you’re able to read the instructions.
I learned “original” BASIC before I got that 8 bitters’ CrippledBASIC into my home via a TRS-80. It was a culture shock! Using the same name without attaching a warning for that dialect really should have been forbidden!
Teaching original BASIC still is fine.
Teaching today’s full featured BASIC dialects that deserve their name is fine.
And forgetting the dark ages of the 8 bitters’ CrippledBASIC is fine.
Their use should count as torture.
Agreed with the other people who have asked, why not just teach Python?
My nephew started learning it when he was around 10, entirely on his own volition. People claiming the necessity of going with BASIC are indirectly saying that they might be less intelligent than a 10-year-old kid.
My kids started using Openscad when they were in primary school.
Nothing like being able to code up, then print, the old meat and two veg, which was about the second thing they did.
It is simultaneously a very simple programming language, and introduces and develops practical understanding of important school mathematics like transforms and geometry, while having an actual point to it (making things).
It also fosters understanding of functions in a more mathematical or functional programming sense than the open ended subroutines of basic and c
Most programming does not have any functional purpose for kids – it’s just one more thing the “should” learn because it will be good for them
There is nothing particularly good about it as a language, but that is also true of basic. What is wrong with C++ and Python too, is their excessive clever-arse ness. “Nothing special ” is a quality all of it’s own.
Probably like a lot of others here I started out for “fun” in the 70’s when (1) I learned Microsoft’s notorious Commodore PET Basic — teaching me appalling habits, (2) disappointed with performance I quickly moved on to 6502 assembly and even machine code when the only commercially available PET assembler was proved to be full of bugs (it was written in BASIC), then (3) Pascal which taught me some of the “right” way to do thing and undid some of my damage, then (4) back to assembly – IBM 360 this time, which totally ruined my habits for years, until (5) C which marginally restored some sanity until (6) C++ made the whole thing a farce and I completely hung it up and found some other way to torture myself until (7) Python when I decided “hey, this might be fun again”.
Teaching BASIC, when Python, Processing and Scratch are all freely available, pretty much identical across machines, heavily documented and provide excellent foundations (in their own respective ways) and run on *everything* is IMHO a very very very very very very very very very very very very very very very very very very very very very very very very BAD IDEA.
Also, I kinda feel like this whole article is trolling HaD — e.g., “Still teach Vim or EMacs and Which One is Better?”
Started off with BASIC in 1978. Evolved to VB and now mostly Python. Should of learned something about C/C++. But my 46 years of being a coding hobbyist paid huge dividends in my non-technical career as it put me on a whole different level with most of my co-workers when it came to problem solving.
I learned basic in grade school, did a couple C, C++ projects later in life, found and loved python, currently doing a hw and software project involving fw from scratch.
You are 100% right about work though. Nothing in my education suggests I’m a developer and my current job wasn’t initially for development, yet as soon as I completely automated a 12 hour reconciliation, my job title immediately changed and I build tools full time.
* should have
*shoulda
coulda
woulda :)
Thank you for pointing out my typographical error. You must be fun at parties.
BASIC partially retains some of it’s original problems: People want to make useful things and games and it’s slower than a VM or compiled language for that. Also it tends to have crappy access to the hardware.
I think at least some of that could be solved with a more advanced basic that was secretly a new type of assembler. So many of the BASIC structures match up well with assembly that it would make sense to build a BASIC around it. It should also toss in support for subroutines/functions so students don’t have to learn different calling conventions depending on the platform.
I was thinking the same. I mean who among the experienced hasn’t thought about the similarities between a goto basic statement and a JMP in assembly. I bet you could hash out a basic language on your own with chatgpt. it’s not a big language, even smaller than C imo.
There is a text “the little lisper” that was done for a “programming for poets” course. (In the same spirit as “the Fortran coloring book”).
Yes, you can start with lisp. its cousin, LEGO was done as a kid friendly dialect, originally built in MACLisp, before moving onto a timeshared pdp-11/45, that made attaching extra hardware (actual robotic “turtles”) easier.
Of course the problem with teaching lisp as a first language is that those that went that route will be pissed off with all the bookkeeping that memory use in more conventional languages sticks you with.
Dont really matter what language or OS you learn on. I learned on Business Cobol back in 71, DIDN’T stop me from learning Algol, Fortran, Basic, Pascal, C, DBMS, Lisp, WHATEVER. Learning recursion was a big deal, I’m a stepper.
Each language has it’s plusses and minuses and you don’t generally have an employer that is a multi language house.
I started with basic. What Id recommend to beginners depends what they want to do. If they want to program on PC, then python or java. If they want to program MCUs, then C. The great thing about C is that it has all your basic program flow structures, while also translating more or less directly to machine code. Its also the current industry standard, which doesn’t hurt.
We should teach a language that’s about as simple as an 8-bit BASIC, because modern languages are just horrifically complex with a zillion libraries we seem to have to use, before we can do anything. We need to bring programming education close to the metal so that layers of abstraction don’t make everything magical.
Also, there’s a lot to be said for low-resolution video with limited colours. I mean.. Lego seems to do OK with about 8 colours; learning to program computers with a limit of 4-bit colour would also be educational.
I’d go further: we need to teach kids to program using *slow* computers, so that they can see how things work and only when they’ve grasped these things they then get to move onto more sophisticated systems. My rationale would be that, just because degree level literature is ‘better’ than introductory reading books, it doesn’t mean we teach kids to read using “War and Peace.”
One thing I would do though is eliminate GOSUB and GOTO along with line numbers. Instead have classic REPEAT.. UNTIL or WHILE .. WEND loops + IF THEN ELSE conditions and at the very least parameterless functions.
Having said that, it brings us back to the question of whether, plain and simple 8-bit LOGO, again is a better language for children to learn.
“One thing I would do though is eliminate GOSUB and GOTO along with line numbers. Instead have classic REPEAT.. UNTIL or WHILE .. WEND loops + IF THEN ELSE conditions and at the very least parameterless functions.”
These are exactly the reasons I liked to work with Quick Basic and VB DOS over GW‐Basic many moons ago.
It had most, if not all of these available, so the users (programmers) could use them if they wanted to.
And to be fair, GOSUB wasn’t as bad as GOTO. ;)
It did at least allow for sub routines and structured code, thus.
Good point. Quick Basic was fairly friendly for newbies, my line manager at the first proper programming job I had in late 1989/early 1990 used it to write DOS applications. Even so it was fairly limited, could only handle 64kB of code, but supported overlays.
From my Brit perspective we’d look to BBC Basic, which had full procedure support with parameters, even for the 8-bit Acorn BBC micro and Acorn Electron, and by the end of the 80s supported array parameters: mind you, Sinclair SuperBasic (1984) also supported all of this and was a 68000-Basic which could in theory handle up to 4GB of an address space (even though it ran on a 68008 QL).
I might go a bit further and advocate Sinclair-style Single-Keyword-Entry with built-in syntax checking. That way you can’t even enter a line of code if it has a Syntax error (the computer would refresh the line you’re trying to edit and mark the start of the error with an inverse [S]). Also MacPascal did something similar, but turned code into an outline font where the syntax broke down (MacPascal also automatically indented code).
+1
QB45 was limited to a single 64KB segment, that’s right.
It could also be switched for another one, though. It involved some manual work, though.
The QB community wrote XMS and EMS libraries, too, I vaguely remember.
There were even Super VGA and VBE libraries..
Turbo Pascal 6/7 had less default limtations, I think.
PDS 7.1 was an alternative to QB45 but not as friendly to use.
Direct replacements rather were Turbo Basic or PowerBASIC.
Compiled Quick Basic 4 supported the HUGE memory model. My application had arrays of user defined type structures. Each array was larger than 64KB. I made sure that the structure for each element was a multiple 8 or 16 bytes in length, so no array element spanned segments.
Even python seems very olde command-linery. Maybe something like Scratch that could produce little graphical apps that run on your phone easily? (Producing Android apps seems v.complicated.)
Scratch has quite a number of fans, but it seems rather baby-like even compared with an early 8-bit BASIC. It also suffers from too much ‘magical’ abstraction.
I started with BASIC, but would not recommend it to anyone in any form. It’s a bit condescending to think that a lot of kids cant get to grips with most of the essential parts of C,C++ or python straight away without a pointless ‘gentle’ intro that needs to be un-learnt later. But maybe it’s just me since I was perfectly comfortable learning about matrices, number bases and other obscure maths stuff aged 9 …. then ran out of books and all maths learning stopped from aged 10 to 11.
Basic is a poor choice for a first language (or as a language to waste time on, period). Nearly everything you learn in basic needs to be un-learned when you move on to other languages.
I think an ideal intro to programming class would teach a Lisp/scheme alongside a simple assembly language like Z80. A good understanding of both low-level and high-level will result, and the lessons from both can be expanded upon and applied to contemporary languages and styles, while being very approachable first languages. I’d teach the second half of the course in Rust alongside C or C++ and emphasize locality for efficient use of caches, and branchless data structure implementations to emphasize how horrible modern hardware is on branch mis-predictions.
With these, a very strong foundation would be laid for any future languages/concepts.
Perhaps one of the exercises would be to implement a regular expression library in each language, mastering REs will occur as a pleasant side effect, while teaching lexing, parsing, state machines, etc. Also, it would be more approachable, while still introducing many of the same concepts, as the two quarter course in writing optimizing compilers which would follow, if the student decided to continue on this path.
“early everything you learn in basic needs to be un-learned when you move on to other languages. ”
I do agree in parts here. It’s true for most rudimentary home computer versions of Basic, I believe.
” I’d teach the second half of the course in Rust alongside C or C++ and emphasize locality for efficient use of caches, and branchless data structure implementations to emphasize how horrible modern hardware is on branch mis-predictions. ”
The problem with C/C++ is however, that it makes people run away from programming.
It’s incredible unsexy to beginners and alienating.
If you introduce beginners with C/C++, they’ll loose they joy for programming early on.
It’s a very cryptic language and doesn’t lend a helpinh hand.
Delphi or Object Pascal in general is (was) a better alternative, I think.
Turbo Pascal had been used by teachers for so long for a reason, after all.
“Turbo Pascal had been used by teachers for so long for a reason, after all.”
It was cheap! Despite this, I came here to stand up for Pascal. It teaches good habits that are difficult to form after learning BASIC (or, in my case FORTRAN). C is available on just about every platform nowadays, and both Pascal and C have object forms, but (again speaking from experience) the whole Object Oriented Programming (OOP) concept is difficult to grasp and gets in the way of simply learning to write good, maintainable code. Windows Icons Menus Pointer (WIMP) is another confuser.
The Lazarus IDE would be a good starting point, but other Pascals are available.
+1
I agree about Lazarus. A friend had used Kylix before he had used Lazarus..
About OOP. I agree. I miss procedural programming style.
On the bright side, OOP is still less troublesome than Object‐Based Programming.
It’s fine for databases, though, maybe,
What, specifically, do you think needs to be “unlearned”?
Interesting nobody mentioned learning the Pseudo-BASIC on TI calculators… I’m sure it’s a generational thing, but I mean, I’m less than a generation younger than so many of these folk remniscing about cutting teeth in BASIC on Z80/6502 machines… And… well, 8 hours a day bored in class gives lots of teeth-cutting time while looking like you’re working on something class-related ;) Nevermind computers’ having been so expensive!
Oh, and… being that it (programming) was taught, at least touched-on, in math classes while computing classes were teaching typing word documents… (Actually, my first intro to programming was HyperCard, but that was the result of a substitute computer-teacher showing us a little fun for a couple days).
But, my point is, I’m rather shocked my generation doesn’t seem to be chiming in while so many prior and post are…
TI-BASIC is full BASIC, GOTOs and all! Spent a lot of my high school days cutting my teeth on it instead of paying attention in class. I forget the call, but you could even slip in a quick assembly routine to speed things up from inside the basic interpreter, although peeking & poking registers was out.
The grab and go environment of TI-BASIC is what made it really shine for early learning.
Too bad the new gen of TI-Color calcs now come with python.
Spent 3 years becoming really really good at writing those types of programs on TI calcs in the 90’s. No amount of number crunching was out of reach. However I Was always mystified how proper games were made (minimal/no internet) with graphics that weren’t a character until way later in life and learned about jailbreaking and all the effort that went into being able to get assembler onto … I believe the TI83 and TI85
I bought a couple of those TI Lab kits on That Auction Site (TAS) almost 2 decades ago.
I’m referring to the box you attached to the output port on the TI-83 (and such) that allowed one to monitor/log voltages and stuff. But I never did use them.
(Sigh!)
“What do you think? If you were teaching programming today, would you start with BASIC?”
Well, mostly yes. But rather with a modern Basic language,
with a syntax similar to versions such as Microsoft QuickBasic or PowerBasic.
Or something Basic‐like. Visual Basic or dBFast (Windows) come to mind.
In short, a Basic that’s not necessarilly object‐based or object‐oriented, but at capable of being least structured.
QB can use GOSUB, sub routines and nolonger needs rely on GOTO and line numbers (they’re optional).
It also has an IDE, with both compiler/interpreter and an full screen editor with online help.
Turbo Pascal, too used to be an good alternative.
Quick Basic adopted a lot of positive aspects from it.
The very least choice is Commodore Basic 2, I think.
Nostalgia aside it’s the embodiement of a bad Basic, in my opinion.
Even back in 80s, there had been good alternatives such as GFA Basic, Amiga Basic or Locomotive Basic (GEM).
Absolutely not. BASIC was tailored more to the limits of the timesharing mainframe environment than to learning programming. Pascal would be my choice for a first computer language. BTW, for me APL was my first followed by Fortran.
why not learn to speak latin while we’re at it?
Alongside German, too, if we’re at it. 😃
No kidding, German pronounciation is very close to how Latin did sound.
It’s not entirely accurate, though. That ‘R’ sound of Latin isn’t being taken into account by German Latin speakers, I believe. Still close, though.
However, most English speakers do speak Latin with a horrible accent.
I often notice this when US American documentaries about history.
They also get all the Bible names wrong.. sigh.
It’s as if speaking English with French accent.
Former Latin student who’s first language was German.
F U.
(F the damn Jebbies too. Latin was a complete waste of time.)
We pronounce things correctly, it’s just not how it’s pronounced where you’re from.
For example:
Germans will say ‘Fraunce’ (just like the frogs like it).
Americans say ‘FrAnce’.
The correct pronunciation in the USA.
Also:
Dorner is just a Gyro.
It was not invented in Germany.
Currywurst (spit) was.
Also also:
Never every buy a water cooled German car. They suck.
As proven by many of these comments, anyone who does coding as a living or routine hobby today cannot answer this question cleanly as the topic immediately turns into a debate about which programming language is best.
For this article’s question, “best” is irrelevant as it will always depend on personal opinion and not group oriented goals. The purpose of learning a programming language early in education is more about fundamentals than long term preferences. BASIC can easily provide for those fundamentals and in most cases requires very little to understand the syntax, etc. While the end-game may be better with Python or something else, younger minds in general need a simpler language to get them to have a desire to start a foundation.
I learned BASIC on a TRS-80 in junior high (1985) and that established a strong foundation in how I learned several other programming languages. I now only use BASIC for fun whenever I pull out an old Parallax BASIC Stamp to use for a project where I want to only spend a few minutes on the code. However, I use Visual BASIC frequently when I code high level and extensive macros in Excel for things at work. When I started to learn SPIN, C, “Arduino”, Python, Javascript, and even HTML, they all seemed easy to understand because they built upon the foundation laid by BASIC. When I coded some Javascript inside Adobe Acrobat recently to modify field values in a form, I know it was those old BASIC days that made it simple.
Did we read the same comments? I haven’t seen arguments about what is the “best” language because there isn’t one.
The “best” code is the code that does what it is supposed to.
– C/C++ are needed for very time sensitive tasks
Other than that, use what works and is available. I prefer python if time isn’t an issue, but have been heavy into VB because it is what I can run on a particular work system.
The consensus here is there are a lot of general purpose languages in current use today that:
1. Are still relevant (BASIC is not)
2. Can teach a beginner the basics of structure, loops, logic statements, etc
3. Not be overbearing
So a beginner might as well learn one of those and walk away with something that can be used currently.
If you’re going to talk about “very time sensitive tasks”, perhaps consider a language that has actual support for timing, like Ada / Spark. But I assume this is disqualified as “too overbearing” because you have to put the word “is” at the top of your procedure bodies, even if you’re not declaring any local variables.
It does have one distinct downside, in that there’s no interactive mode. For that you’ll want something like RPL, Racket, Haskell, Scheme, BQN, Python or Basic.
Here’s one of those apparently very well kept secrets about Haskell: You don’t have to learn the advanced features of the type system or esoteric technical jargon to use it. It is actually very well suited to developing simpler introductory vocabularies, which is also a primary feature of Racket. It even allows you to write with braces and semicolons if you insist.
Yeah, I came here to say that you probably couldn’t pick a worse group of people to ask. We all learned on terrible, half-baked platforms, because programming is still in its infancy to this day, so the most we can contribute is the coding equivalent of the Monty Python “four yorkshiremen” dialog.
The people to ask would be, you know, teachers. I vaguely remember a talk by a secondary-school teacher who was designing a platform for this very purpose, and the challenges she described were almost completely orthogonal to what coders might imagine. The friction was mostly cultural, not conceptual.
IIRC that project did use Python as a starting point, but I really don’t think that’s important. It’s the wider context that matters – who else is using this platform, what can it do etc. I think picking /literally any/ standard is the main thing. That’s why BASIC worked for 80s kids; it’s what books and magazines and classes used, and it worked(*) on all your friends’ computers. No one was saying “I want to code but the lack of lambda functions is holding me back”. We flatter ourselves by pretending these minutiae are important in the wider world.
You know a teacher that codes worth a damn?
Why would someone make that carrier choice? (I can make much less money, but on the upside I get to deal with snot nosed asshole students in addition to snot nosed asshole managers. Nice hours though.)
Good coders are _born_ knowing how to code…syntax acquired later.
I can identify future coders from their choice of toys at very young age.
The future coders are the logic puzzle solvers (and bomb builders).
They will start coding as soon as the opportunity arises.
Like breathing.
Most teachers get in the way, especially ed school grads that just don’t do math/logic.
They will try to teach code like writing, get stuck on stupid things. (one comment per line!)
The first language doesn’t matter (so long as it isn’t LISPy recursion hell).
But a first coding teacher that doesn’t actually code is doom.
Apart from Bobtato’s response, my point is further proven by the replies and other comments made since my post.
Thanks Bobtato and I agree about teachers. I know several brilliant coders that teach simply to educate and inspire those who want to code for a living. Two of them have six figure incomes from their side gigs doing code, but still choose to make low wages as teachers to get more good coders out there that aren’t so opinionated about the “best” code language.
Bring back BASIC. Get back to a version of simple BASIC for high school students. That is how you can interest them in computer science. That is how you prevent jobs being shipped to India – by creating interest in computers and getting high school students get into computers. Everything else out there is quite complex. Perhaps a browser version of BASIC with a split screen. The left side is where you create your programs and execute them and the right side is used for Input/Output. Not QBasic or VisualBasic but a simple version of MS/GW BASIC.
I started with BASIC but Fortran would have been fine, or anything. Halfwit? Snubhat? Sure, both fine languages. It’s not in the least important to know how computers work. Learning a purposely limited language doesn’t teach that. It shouldn’t. Computers could be mechanical and powered by steam and monkeys but still be a system of rules and files. 靡有窮際。
Why not?
Language doesn’t matter anyway. How to write good code, how to take an abstract concept and turn it into code and how to write efficient code is what matters.
I had a brief start with programming with basic some 35 years ago, and I found it so abhorrent I quit programming and did not take it up until I bought Turbo C++ years later. The ++ was a bit much for me to learn without a course back then (it was still before internet), but I quite liked C. I liked the compact syntax, and you did not have to waste time reading all the words when figuring out what an existing program does.
And I agree that learning to program is something quite different from learning a programming language, but that does not mean that when you start programming you can’t combine it with learning a decent programming language at the same time. And almost anything is better then basic. Even with the horrible whitespace dependent syntax of python, you at least learn a language that is used a lot in scripting and it suitable for small programs. A big disadvantage of python is that it is also all too easy to learn bad techniques. The whole language is built around sloppiness, and that is not a good starting point for beginners.
Basic is also mostly a dead language. I guess it’s mostly used by hobby programmers who learned it on their 8-bitter back in the 80-ies, and there are some who started with things like the basic stamp. I guess that most of the people who liked it back then, was because it enabled them to do new things, and there were not many alternatives back then.
A lot of people learned programming on “arduino”, probably without realizing it’s (mostly) C++. C++ is not a difficult / complex language, as long as you stay with a decent sub-set of it’s capabilities. It’s quite a shame that together with “arduino” also bad habits are learned. And that starts with the setup() loop() and software delays. “Arduino” also makes it horribly difficult to write your own class to use a peripheral (for example a timer, or SPI).
I learned to program before Basic existed.
It was a good starting point when there was nothing better. But not now.
Python is a better choice. (Though I hate it for it’s syntax.)
Any easy to learn language will hide what is going on at the hardware level. Many won’t ever need to know that. For those who want or need to know that, teach assembly language. Starting with one for a simple processor. E.g., a simplified virtual CPU.
So you learned to program before May 1, 1964? Okay. Arguably many other things were “better” or at least available at that time. For example COBOL and Fortran.
“Python is a better choice. (Though I hate it for it’s syntax.)”
So, are you for or against Python?
It would be BASIC or Python, but really, I think when teaching any of them, there should be some emphasis on contrasting them with some other languages, and how they would solve the problem, but without getting too hung up on the syntax, but with emphasis, again on how to read the usage information. It is like should you learn about the 741 op amp or whatever is new this year. Probably the old one, contrast that with the new one so you get an idea of how things have improved, but even more important, how to read the databook.
Basic is a terrible language, utterly unusable and teaches almost no good coding practices. It just needs to die in peace.
It’s not today’s kids fault that you didn’t have anything better when you started.
Really depends on your goals. Are you starting on a college track towards CS or CE – Python or C are good starting points. Are you on a non-Enginering track looking to have advanced tools for business modeling – VBA actually makes a good starting point to learn programming in a context you can use. Are we talking about school children trying to understand fundamentals of computing and possibly spark an interest – Scratch or Processing are great environments to get engaging visual feedback. The language doesn’t matter as much as the goals and environment.
I started with BBC Basic on the Beeb, then (or rather nearly concurrently) 6502 assembler. Later at the university Pascal. And then on my own C, C++ and other high-level languages. Way later some assemblers like PIC, AVR, 8051 etc. and quite recently Python (I also have some obscure experiences with countless other gibberish stuff like JS, PHP and such, but after Basic, Pascal, and C/C++, nothing can catch me stunned). Anyway, for teaching/learning, I still consider Pascal being the best of those. But even more importantly, I believe to learn algorithmic thinking is crucial for to learn to be a good programmer; the syntax is not that important. And that could be done with many languages, if presented correctly. Just with pure Pascal (i.e. not Turbo Pascal and such), one does not think (have to think neither in fact can think) about libraries, OS-dependent stuff etc. as that quite does not make sense there. One focuses on the algorithm. On contrary, with e.g. Python and its ‘use whatever from whenever’ or C++ with String class, without knowing what’s going on there and what that could cause (efficiency, resources needs…) makes new programmers completely unaware of what they produce, even if with their bests intentions.
Let’s take a brief peek at the history.
BASIC was introduced at a time when the main “serious” programming languages were FORTRAN (great for scientific work, meh otherwise), COBOL (great for business applications, meh otherwise) and to a lesser extent, ALGOL. The big advantages BASIC offered at the time were that it was relatively simple (especially compared to the laughable verbosity of COBOL, which incidentally has an even worse bomb lurking therein than GOTO) and it was interactive. You could find out what your code was doing relatively quickly without having to muck about with punched cards and timesharing, especially if your teaching facility thoughtfully hooked you up to a PDP-11 running UNIX with some actual terminals featuring VDUs.
People mention Python as a modern alternative, and to some extent it fits that bill, while introducing some useful modern concepts – you can develop an insight, if you pay attention, to at least a part of the inner workings of objects because Python builds objects out of more primitive entities in a manner that’s reasonably “hands on”. But, it suffers from the malaise of modern languages – to perform seriously useful tasks, you need to import an intimidating number of libraries.
JavaScript (be patient before you all howl!) has the advantage of being massively accessible (anyone with a web browser and a text editor can be up and running immediately, without having to download and install lots of packages), has a reasonable, if idiosyncratic, object model (that some devs actually prefer over the bureaucracy inherent in classes), and you can, again, see results quickly. The debuggers provided in Firefox and Chrome are decent too, if a bit much for the absolute beginner.
But JavaScript now suffers from having a ridiculous number of “frameworks” in circulation, many of which are bloated and come with their own, at times, unpleasant hidden intellectual cost. Frameworks that become “trendy” for a couple of years until the bloat overrides the benefits, as certain frameworks try (and fail) to be “God mode” for JavaScript, as well as being yet more dependencies that by definition introduce potential security holes outside your control.
Oh, and I personally regard fat arrow functions as a hieroglyphic abomination that should never have seen the light of day, but that’s a personal view arising from “callback hell” in Node.js. Functions are first class objects, and if you’re too lazy to bother naming them, you deserve all the debugging headaches arising therefrom. The fat arrow fetish is banned from my code in the interests of legibility apart from more serious concerns.
Yes, eval() needs replacing with a secure alternative as a matter of urgency, and some of the quirks endemic to JavaScript make wonder what the people responsible were smoking when they enacted the requisite decisions, but at other times, JavaScript makes some tasks I perform a joy. It’s flawed, certainly, and at times flawed in ways that a serious language never should be, but the point I’m making here is that a reasonably competent novice can start doing USEFUL things with it and learning key concepts without going into debt on a university CompSci degree, or having to piddle about with EULAs etc.
Being able to dive in and do useful stuff is an excellent tutor.
But, it would be nice to have a proper language for the job. One that permits the curious to get “hands on” without undue restriction, but which is also memory safe, at least partly miscreant proof, and which exhibits some aura of having been thought about and implemented by people with knowledge and expertise. JavaScript scores hugely on accessibility, but most people would probably barf at the thought of it being used as a teaching language. Python is still not good enough in my view, and C++ has become more than a tad unwieldy if you want to do something useful with it during your learning process.
BASIC was, in its day, a serious attempt to produce a proper teaching language. We may laugh at it now, but plenty of students in the late 60s and early 70s learned to be competent programmers using it. There IS a role for it in the modern era, and that role is teaching modern programmers the shoulders that they’re now standing on and enjoying the view. A salutory reminder of what made today possible is a good thing.
Ok CS pros, I’m ready for your reactions, so here:
If the goal is for people to actually learn programming, then the language to start with would be a block-style language like Snap.
I have been told countless times that Snap is ‘based in scheme’ and therefore it can’t be used to teach Python or Java but logic is logic, and Snap creates runnable ‘pseudocode’ that is more interesting than flow charts. This has worked for me at the high school level.
In 2024?
If they haven’t learned to code before HS they are (almost) doomed to mediocrity.
Not any better off then the college kid that decides to ‘learn to code’, based on salary surveys.
The code is the EASY part BTW.
Same as a musician who doesn’t pick up any instrument until late HS.
Odds of ever being a professional musician (outside EDM/Disco)?
Imagine applying a Julliard and playing chopsticks for your audition.
Attempt at constructive:
Mostly the internet is a scummy Rube Goldberg shitshow. Bodged together with random copy and pasted JS (and that’s the libraries).
If you try to teach them THAT, the smart ones will run away.
So Pi pico based stepper/DC motor robotic contraptions.
Language would be C or C++.
C for most kids.
Real world hardware limits. Will be new to them.
Yes IIRC python is possible, don’t do it.
Only use python or Javascript when it’s the _only_ tool available. (Geek rules for life!)
C is just fundamental. It teaches good, basic, close to metal things.
Next: assembler. ++good.
Pi pico is simple enough the smart kids can grasp the whole thing (same with C), has ecosystem that lets it get complicated as the kid can handle. You can’t say that about much.
The kids can build ‘contraptions’. (Parts are cheap, not free though. Computer is $4. Like art class likely fee.)
The other kids will see the things rolling down halls, some will fall over spectacularly.
Next semester, you’ll have a line, most kids already having plan.
Kids will have to figure out groups for project.
Expect robot wars.
Encourage robot violence.
If admin are pussies, robot sumo. But fight that fight, kids love destruction (I might be projecting).
Sooner (not later) one of them will want to buy a $300 CNC or 3d printer to build parts.
Let them figure out how to pay for it.
They’ll learn CAD, without you having to ask.
Kids will bring CAD software preferences to table. Let them install away.
Virtuous circle forms. Kids learn from kids.
Soon your school is nuclear armed world power.
For Pi pico dev on windows. VSCode is OK, once configured. Google and follow instructions. (Put GNU tools near root folder of a drive. Long path breaks things in Windows.)
Backup: the kids will find ways to break the dev environment. All the time.
HS kids so expect:
Universal bra unlatcher robot hand. If success, likely Fields medal for knot theory.
Rover with TP cannon.
4 blade drone with egg cannon.
AI powered rover that follows cutest girl butt. Expect embarrassment when it follows maintenance dude.
Beer buying robot.
Fleshlights/’Cuttlefish of Cthulhu’ on bill of materials for more than one project. Make them write a ‘bill of materials’ as part of planning. Not just winging it!
The learner must have a drive to learn programming, and it should be something that’s available to them easily and they want to do stuff off the shelf stuff can’t do. For me it was the MSX1 and MSX2 computers that I got back in the 80ies. It was BASIC in that case and soon assembly and a bit of pascal. On the Amiga I learned Amos (basic variant like qbasic) and C with some windows management in code thrown in (messaging, callbacks etc). That got me enough knowledge to learn programming in Windows C/C#, PHP and microcontrollers (C).
A modern variant would be a raspberry pi with python, or a windows computer, or a microcontroller board like Arduino or an ESP32 with a camera module etc.
Just learning a language without context, without some kind of interest from the learner it’ll be just abstract and learning will be very difficult.
Interests could be
I want to
– Make a website
– Use a camera to capture and process real world data
– Connect something to the internet and keep track of stats
– Create my own digital music instruments
– Program my CNC
– Move something that responds to a sensor
– Control lights
– Make a game
– Control temperature with fan/peltier element and temperature sensors etc
– etc etc
Some kids learn rudimentary programming fundamentals by creating interactive maps in minecraft for example. People can even start with Excel and do some calculations with references to other cells, then progress to VBScript to add more interaction. They can learn query languages the same way. Cells are variables, references to those variables are pointers so many of the basic concepts are in there already.
Javascript is also a viable option. It’s everywhere, huge amounts of learning resources and can do things visual etc.
I agree: the best language for a beginner to start with is a language a beginner can do something interesting or useful with.
If you have kids in middle school who want to make games, Scratch would at least let them get something to work. High schoolers looking to solve math homework? Python is probably the best option to start with, although I would put a modern version of BASIC or maybe C# as a solid option too. Business school? I’d teach VBA.
I hate business majors as much as anyone.
That’s just cruel.
They won’t get it anyhow.
Excel macro is the Business majors natural coding language, just as PowerPoint is their natural BS tool.
Not Excel VBA, macros.
Think about the other people that will have to be around those twits.
I totally agree, but basically what happens is that there are too many unnecessary abstractions in languages, such as objects or avoiding pointers or the garbage collector or other problems that are added trying to solve non-existent real problems.
I think Chuck Moore pointed this out many years ago when he created FORTH, but there is too much noise in the industry, no one really needs a 500MB development environment when you can program with notepad.
The language is not the point, teach problem solving, lateral thinking, that sort of thing.
Hardware, software, all just tools to solve problems so if you can’t solve problems then you’re gonna be in trouble.
Microsoft’s MakeCode is a good place to start, it’s much nicer than Scratch and allows you to convert your code to Python or JavaScript.
(My first language was logo with a physical turtle, then I learnt BBC Basic)
basic is great. i learned on basic. i would love my kid to learn on basic.
but we used basic because it was a living language. now, it’s a dead language. it doesn’t have tools or practice around it any longer. if i want to see basic, i run qbasic.exe under dosbox. i go to the zoo and i look at it in its cage.
i don’t care what language people learn on but it’s obviously going to be a living language.
I went 80’s Microsoft Basic, QBasic, Turbo Pascal, x86 assembler, C, C++, Java, Python.
QBasic was really fine to learn control flow, structured data and practice it with fairly complex programs. It was a single program, with interpreter and editor integrated together, which for beginner is a convenience. It has good error reporting and a simple integrated debugger.
If you are going to point to qb64 then point to here: https://qb64phoenix.com/
Some idiot declared himself king of QB64 then tried to destroy it. After the original site went tits up. Phoenix rose from the ashes and continued on being improved, supported and expanded.
Do not goto qb64.org.