Slashdot Mirror
The Value of BASIC As a First Programming Language
Mirk writes "Computer-science legend Edsger W. Dijkstra famously wrote: 'It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration.' The Reinvigorated Programmer argues that the world is full of excellent programmers who cut their teeth on BASIC, and suggests it could even be because they started out with BASIC."
A good programmer has experienced many languages and done things in many ways. A good programmer has compared all these various experiences and understands the advantages and disadvantages of each language and programming technique. A good programmer doesn't get bogged down in line numbers and GOTO statements and never move beyond that. If someone does get bogged down they never had the attitude to be a good programmer.
These posts express my own personal views, not those of my employer
I was on Basic from 1986 to 1993, and it was the most meaningful years of my life.
Depends on the BASIC. I use RealBasic at work as an alternative to LabView. It's object oriented, multithreaded and completely "Visual".
as potential programmers they are mentally mutilated beyond hope of regeneration
Am I the only person on the Earth who just writes off hysterical, panty-wetting stuff like this? When did he say this? in the 1960s or something? It's 2010 now, right?
There's something to it. I recently downloaded a ZX Spectrum+ manual from worldofspectrum.org (the colorful one), and was amazed by how simple the language is. The complete reference takes like 10 pages? And it can draw lines and circles..
Now compare it with any modern language, such as Java or Python. The language description itself takes 10x more than that, and the libraries available are vast. I am not arguing it's a bad thing; I am just arguing that simplicity may be a key here.
I started out with QBasic. It was absolutely horrific - the language itself and the code I wrote as well. QB convinced me to never, ever try VB.
So yes, starting out with BASIC helped me tremendously :)
...and I'm wondering: what's with the random sushi pictures?
His argument is kind of funny. He says people who've learned in BASIC have learned what NOT to do when programming. I have to admit he has a point....I learned exactly why spaghetti code was a bad idea after doing it for a couple years. Some people think they know what spaghetti code is, but unless they've written code with line numbers, they probably don't.
Qxe4
I disagree with the premise that BASIC teaches bad habits. I stick with the old adage a bad workman blames his tools. BASIC teaches kids (like I was over 30 years ago) from the ages of 5-6 how to put together simple logic, and gives them the very basics of languages constructs like variables, loops, sub routines, etc. without them having to grasp structures, classes, polymorphism, OO, etc. that a lot of grown ups that have been involved with writing code for quite some time can have issues with.
Not recognising the relevance of BASIC as described in the article, it's possible you're around a decade or two younger than the individuals the article is referring to.
"The true measure of a person is how they act when they know they won't get caught." - DSRilk
As a programmer who started with old-school BASIC (numbered lines, etc), I was overjoyed with better elements of structured programming in Turbo Basic, and totally excited with C when I learned it. It felt like having my hands untied. So I would state the contrary: you cannot fully appreciate the structured programming unless you went through the GOTO hell.
I hear a lot of similar FUD from some people, like "you can't grok OOP if you started with C", or "anyone who touched .NET or Java is lost for C++..." It boils down to "people are idiots, they can't possibly learn anything new, they are either indoctrinated at birth in My True Way, or lost and hopeless." Who in their right mind would take that seriously?
I've gone from MSX Basic to Turbo Basic to Turbo C. Now I can code in all kinds of languages, assembly, PHP, Ruby, Javascript, etc..
I do think that BASIC has value as a first language because it gives back results immediately. Sure, nowadays there are other script languages, so you don't have to go through compiling and all the other complexity. BASIC is valuable because it's just that: basic. You don't have to worry as a first-timer about libraries, include files, functions and everything else. You get down to the very basics like variables and program flow.
And after a lot of years of BASIC programming I knew the limitations of the language (which largely depends on the interpreter). That's when I switched over to Turbo C. And to be honest it didn't took me long at all to learn C because I was a pretty reasonable BASIC programmer.
What I _do_ object against is stuff like Visual Basic. That's taking a limited language which is simple and jamming it into a place where it shouldn't belong. To let Visual Basic work, they stuffed all kinds of non-original basic stuff in there which make it more complex then something like Visual C. Their idea was "lets make making real application easy with Basic, because Basic is easy right?". It doesn't work like that.
I also think that Java is not a language that people should start programming in to be honest. Object oriented programming is NOT something people should learn before they had a taste of procedural programming. Fun fact. I went back to my old school to see about taking some night classes to get my CS degree. (I dropped out at the time and I've learned a LOT more on the job then what they were teaching.) At their open house classes I asked about procedural programming and if they still taught it. They scoffed and said nobody uses that anymore. This when I've been a Linux kernel developer for 10+ years now which is 100% procedural ANSI C. It's all Java they teach nowadays.
In closing. I think a good programmer is somebody who explores. If I have a Windows application that does something cool, I take it through a disassembler to see what makes it tick. I look up DOT NET C# code snippets to see what it's all about. I look through COBOL and ALGOL source code to see what constructs people used in the past. I patch ARM assembly code to fix bugs. I do all those things and not rigidly stick to a single programming environment. A good programmer is a state of mind, not the language he works in.
just great, more sushi, I should block images from that site
I started with Apple BASIC, and I was playing around with peek and poke before the other students even knew how to properly misuse goto.
But that was when I was 13. The first year of college should not teach BASIC.
But why are we not introducing BASIC or the very beginner friendly 'Ruby' to students when they're 13 anymore?
Years before I took any formal course, I was looking at the manual of a BASIC computer and making circles on the screen by programming a dot that kept to the same distance to another and rotated. I still remember the emotion of seeing a real circle emerge on screen. I don't know if BASIC helped me much to program, but the immediacy of the thing certainly did much to keep my interest alive.
Rome taught me patience and assiduous application to detail. Virtues which temper the boldness of great, general views.
Most folks who have learned C++ learned it in a classroom with a real teacher. Most folks who learned BASIC learned by banging away on a computer keyboard at home.
Most people aren't very good at teaching themselves. I've seen this a lot with people trying to learn Morse code and giving up in frustration.
You can pick up a lot of bad habits without someone to guide you.
Like all eminently quotable people, Dijkstra tended to hyperbole and oversimplification.
...but it was BASIC. And the expectations were so low. "10 PRINT "Hello, World!", "20 GOTO 10" and it started doing something. The programming manual was well worn by the time I was 10, would that have happened with any other language? I doubt it. Things like lack of scoping makes the easy things easier and the hard things harder. The point isn't to learn everything from your first language, the point is to get started and interested at all. Moving to DOS was sorta ok, but moving to Windows killed my interest. C/C++ was just horribly complicated, I remember trying to get up a window in the Win32 API and it was like wtf, how hard can this be? MFC was even worse, Java (really early java, on hardware of the time) was slow and unresponsive as fuck, Javascript was a toy language for websites and never really like Pascal or VB much either. I didn't regain my interest in programming until I went with C++/Qt, or maybe more Qt than C++ really. QMainWindow *mw = new QMainWindow(), mw->show(). The hard stuff is still hard, but I very very rarely find I write "overhead" code that I shouldn't have to.
Live today, because you never know what tomorrow brings
Yeah, there were no 'else' constructs. If you wanted an else, you had to do it yourself with a couple GOTOs. Also, the worst part about line numbers was when you decided to add something later, and there weren't enough lines. A program that had been refactored this way a few times could literally move randomly through the source code.
I never owned a Beeb, though I had several friends that did. I used them at school a lot too, and their BASIC was extraordinarily advanced. The ELSE statement was there, as was the standar(ish) GOSUB, but you could also define true procedures which returned values etc. (DIM PROC), and there was a clean way of dropping down to the 'OS' proper (OSCLI statements).
In addition, it also solved the line number problem you mentioned. It had a renumber command so that everything would become properly spaced out again. I remember the style of coding you're describing from my C64 efforts - the C64 was actually MS BASIC and it was dreadful, anyone wanting to do decent high-levle coding used to get the Simon's BASIC cartridge.
As a whole though, the BBC simply had the best BASIC of any 8-bit I encountered. That's not too surprising given its background and use as a teaching tool, but they did it very well indeed.
Cheers,
Ian
easy language first your get-over is
FORTH started I at-all me affected not and
Dijkstra, who taught at Eindhoven Technical University - which is how I superficially came to know him - was mostly a self-declared legend. He cultivated his own myth, even going as far as publishing a little book with his own quotes.
Religous speak to God. Insane are spoken to by God. When all shut up, one can finally hear Shostakovich in peace
Commodore Basic taught me to love programming, have fun making little games and all important binary operations and encoding for sprites and font
QBasic allowed me to take my learned lessons to the 8086 and add much much more visually appealing graphical interfaces (still mostly games, but also editors etc.)
QuickBasic introduced me to libraries and compilation, i've built some great hardware monitoring interfaces with sensors and relay switches
Visual Basic allowed me to explore the win32 API and libraries, i''ve built some of my greatest applications with it ranging from editors and filtering proxies to a graphical music collection interface I could control with a remote
I loved basic, it taught me so much but most of all it taught me to love programming... The days of fun little programs in basic are over and I have no intention of ever going back... but there is definitely meaning there, and I would recommend anyone to try programming with basic... as a self-taught programmer I can say you will learn a lot from basic.
Depends on your age when you start learning. I was 12 when i first met "programming", it was a TI programmable calculator. It was fun to squeeze as much functionality as possible from less than 1K Basic. Then came C64, with its ~38K Basic. Its Basic was very weak, but i learned how to read disassembly when i read the code of various Basic extensions and read books that contained snippets on extending C64 basics. Eventually i made my own Basic extension, cracked games to create trainers, made an own turbo loader that had half of its code on the floppy drive. So, by the time i went to mid school, i programmed device drivers in machine code!
I learned PL/I and other archaic languages in mid school, even punch cards! I learned C on my own and was taught in it only by the time i went to high school.
Patents Drive Free Software as Hurricanes Drive Construction Industry
I think the author is mostly on. He's aware Dijkstra was exaggerating for effect, but also completely correct... if you started programming in the early home computing era, you probably started with a BASIC. I was lucky enough to get some varied exposure earlier to some other languages (LOGO and some shallow assembly), but until I was 15, it was pretty much Basic.
And none of my programming habits now resemble anything close to the BASIC I wrote in when I was that age. Except, occasionally, for the rare cases where global state seems to make sense, and even then, I try to namespace things in one way or another. But by and large, I picked up structured programming, I picked up object-oriented programming, I picked up logic programming, and I'm learning to enjoy functional programming.
I will say... there was a time when I was probably close to being "ruined." It was when I was learning C++, and I only really had Pascal, basic C, and Basic under my belt. And I had a pretty solidly structured-imperative mindset, and really hadn't seen any other way of doing things. C++ married data structures and methods in an interesting way, but it didn't seem like more than a stylistic practice to me. I was pretty sure most languages were alike, you just had syntax and typing differences.
But there was one thing: I'd had to learn Prolog for a very specific job. We were teaching it to high school students in a CS summercamp I worked at for a few years. The first year, I just thought "Man, this is weird," more or less got through all the exercises, and left it behind, and did what most people do: dismiss it as an odd research toy. The second year, I thought "this is weird, but interesting." The third year, I thought "Wow. There are all kinds of intriguing ideas here."
And there are, and I still think it could stand to see more usage in mainstream software, but more importantly, I think I'm pretty lucky I got repeated exposure to a language that forced me to think differently before I got very far into actually working in the software industry.
Because I now think there's either a critical period (or possibly, at a minimum, a critical attitude of some kind) after which a lot of programmers tend to lose either the humility or the curiosity that drives people to think about different programming constructs and habits. I think if a programmer has been minimally exposed before they reach it, they'll keep just enough of one or both of those attributes that they'll be interested in what they don't already know, rather than arriving at the point where "they've already learned the last programming language they'll ever need."
And if they don't get so exposed, they become Blub programmers, where generally $Blub is some industry-leading language that does enough you don't easily bump up against tasks that are near impossible in it.
To tie this back in with a point I think the author missed, I suspect that some of the difficulties with Basic are actually part of the reason why it didn't end up ruining more programmers. Almost everybody who really came to grips with it as a tool probably realized that it couldn't possibly be the last programming language you'd ever need (if it weren't enough that any effort to look into working as a programmer revealed that Basic was clearly not the strongest payroll ticket).
Tweet, tweet.
When I was first learning to "program" I had nothing more than an old computer with DOS. The internet was something I had heard about, but had never experienced myself, and I didn't know what Linux or even Unix was. The only way I had to learn was from some books I found at the library. At first, it was just .bat files. When I discovered BASIC (I thing it was GW BASIC), I was excited to have it. Later, I discovered QB.
There are some advantages. First, I didn't have to set anything up or worry about what includes I needed. A simple PRINT "Hello word" was enough. What was better with QB was that with the press of F1 I could browse the list of commands. Also, it came with a Gorillas.bas and Nibbles.bas. I spent hours injecting lines of code into those games.
Sure, if you have a full Linux environment with gcc, man pages, and web access then BASIC is just some lame toy, but if it's all you have It's a start.
There are 10 commandments: 01)Thou shalt love the Lord Thy God 10)Thou shalt love thy neighbour as thyself.Matt22:34-40
I cut my teeth on BBC BASIC back in the 80's. It was simple, powerful, let you do pretty much anything and best of all came with a built in assembler. Now that was really neat.And it just worked. It was easy to optimise individual subroutines in assembler. This was age 10. At my simple state school with a couple of BBC Model Bs in the corner, I wasn't the only one doing that either.
I make a living writing C++ now and seem to do fairly well at it. The kids coming out of university that I interview these days haven't touched BASIC, or C++ for that matter. We want them to write good C++ when they come and work for us. The intelligent ones adapt easily to working with pointers etc. The less able ones that have somehow made it through the interview process struggle.
At college we started off in Pascal but quickly moved on to C and a bit of Java. I'd say that if anyone is considering BASIC as a first language, they should choose Pascal instead. But to be completely honest, these days OO programming has become so important that it's probably better to start off in Java or C# from the start.
The BBC Model B was released in 1981. It had a nice dialect of basic with named procedures, named functions, dynamic memory allocation, typed variables, proper pointer indirection and a cleverly integrated assembler.
It had pretty much the full suite of structured programming tools.
Maybe the comment had some value before 1981, though I don't think it did. For the last 29 years, however it has been somewhat out of date.
SJW n. One who posts facts.
Surely Python is the language to start with these days? It's straightforward, doesn't force any particular model, i.e., can use for procedural, OOP, functional style. Most importantly it's not a toy language.
The ducks in the bathroom are not mine. [http://www.27bslash6.com]
What intro-level courses use C or C++?
Florida State University -- COP3330, "Intro to Computer Programming". 100% C++
It's not necessarily a bad thing to have done things in BASIC, but bad habits can be formed by that language. However the other side of it is that if you first see the bad sides of BASIC then you can recognize the good sides of other languages.
And BASIC of today is Python.
If builders built buildings the way programmers wrote programs, then the first woodpecker would destroy civilization.
Oh really? And university students should have no prior knowledge to programming? We have full universities of such students, they get degree and go working for some brainless company doing minor tasks.. Or they could continue study until they are 40, then they will probably be able to code.
I started at 12, and BASIC gave me some idea of how computer is actually working. Probably it's time for new languages, but You just can't learn programming at college in few years. You have to grow up with that.
When was anyone introducing languages to students at 13? There's bound to be a significant chunk of us out there who poked around our computers and went to find these things out ourselves. BASIC just kinda sold itself with the name - you knew it was a good starting point. Self-discovery and a curious mind is probably outdated in the corporatised world, in spite of the roots of many of us who learnt by screwing up an autoexec.bat file or two on Dad's computer. Nothing teaches you to pre-check your logic than having to explain to Dad why his computer doesn't work any more :)
Man who leaps off cliff jumps to conclusion.
When programming in Java, I still resist breaking out of loops, or multiple returns, even in small methods. These things seem to be normal acceptable practice with most developers, and really are fine when used in the right places. Because of early exposure to BASIC (and badly written C) I avoid them more than most.
I think the BASIC of today is Javascript. You see more badly written javascript than any other language..
Point taken, but in my experience people who have even marginal idea of what happens under the covers, tend to write better code than those for whom the underlying machine is a complete mystery. I'm not talking premature optimization, but merely knowing in the back of your head what a pointer is, or _why_ this operation is O(log n) and better thus than O(n), can save one from a lot of awfully wrong guesses and writing awful code.
My canonical example is a team whose architect (!) finally read somewhere that when passing an object to a Java method, only the pointer is passed on the string. So he actually decreed -- and none of the lemmings knew better -- that they should use parameters like the wrapper object Integer instead of the primitive int. (We're also talking Java 1.3 times, so no automatic boxing/unboxing either.) Because, I quote, "If you use Integer Java copies only a pointer to it, not the whole int."
Maybe knowing how much space an int takes under the covers would have helped.
Another time I hear my now ex-coleague Wally (not the real name, but pretty accurate;)) repeatedly going, "That can't be true!" and the like. Curiosity gets the better of me and I ask what's the problem.
"Java has a bug!" he goes, "I put a new key/value with the same hash code in a HashMap and it just replaced my old value!"
"Oh, yeah, we've had the same bug at the old company, " Wally 2 chimes in. "We had to manually set the capacity so it goes in another bucket."
(I clench my teeth to avoid screaming at the notion that there's any way to the right capacity to avoid collisions for keys that are random strings.)
I go and look at what he's doing, and sure enough he's got the debugger open and is looking at the bucket array of a HashMap. "Look! There! I had a different value and it replaced it!"
"Aha, " I try to be diplomatic, "can you please expand that 'next' variable there?"
"No, you don't understand! My value was there and now it replaced it!"
"Yes, I get it. But I want to see what's in that 'next' variable."
He clicks and goes, "Oh... there it is."
The whole concept of a linked list was new to him, obviously.
And if you think that's an isolated case, in the meantime I've run into two different teams whose "architect" actually made it mandatory to plaster his broken replacement for the hash-code method everywhere, because of that supposed "bug in Java." Supposedly they can hash a long-ish random String into a 32 bit int without ever having collisions. (Ok, 31 since Java doesn't use the sign.) Consulting can be depressing business, you know?
I could go on with more such WTF examples, but basically let's just say I wish more people would know exactly what happens behind those high level constructs and libraries. Because otherwise I see them take their own guesses anyway, and guessing wrong. I wish they'd know what a pointer really means, and why a LinkedList does _not_ use less memory than an ArrayList, and, yes, what kind of things will cause jumps. Or what kind of things will be optimized into a tail recursion instead of a plain recursion, as a trivial example of where it pays to know the difference between a JUMP and a bunch of PUSHes and CALL generated by the compiler.
A polar bear is a cartesian bear after a coordinate transform.
It forced us to think around corners. It made us think through what the control structures really were, and how they were implemented." is moot - assuming he's not joking, if you really want to train that way of thinking, you're much better off learning Assembler.
Most of the experienced assembly programmers I know started with an old-school basic (gw-basic, basica, one of the rom basics) and today also program in a BASIC derivative (VB, PowerBasic, TrueBasic, etc..)
None of them enjoy C++.
I often hear C++ programmers declare that learning assembly is stupid, that processor are too complicated now to write efficient assembly, and so on.
I do not think that these things are a coincidence. Basic programmers from the 70's and 80's turned into tinkerers, while C programmers from the 70's and 80's turn into architects. Its counter-intuitive when you first think about it, but it seems to be the truth. That Basic programmer had a lot of architecture done for him but had to struggle to tinker, while that C programmer had tinkering handed to him by the language but had to struggle with his own architecture. Each eventually masters what is difficult on the field they play in, while taking for granted that which is easy.
Regardless of the target language, if I need a project lead for a large application I would want a good solid architect, but if I want a library written (perhaps even for that large project) then I would want that heavily experienced tinkerer on the job.
"His name was James Damore."
First of all, you're clearly not an article reader. The point of initially learning with a painfully unstructured language is that you end up appreciating structure more, while being able to tolerate code that has awful structure. IMHO a better choice is assembly, but BASIC does have the advantage of providing faster rewards.
Second of all, many of us dispute the bit about Python not being a toy language. If you build your skills around Python, you'll hit serious trouble if you ever end up needing decent performance or unwrappered OS functionality. If you build your skills around C, whole new possibilities open up to you. You could even write a non-toy OS if you were so inclined.
most of us have been writing software without using goto for the last two decades
Us goto-loving programmers don't take two decades or more to write software. We just go to it.
I agree on all counts. Python has its moments -- especially when the student moves on to lists and classes and especially when they fall afoul of the unexpected consequences of = being a binding operation rather than an assignment. But in general, the simple stuff is simple. And it works. I think that's really what you want in a tutorial language. And it's probably not all that bad in many real applications either.
If Python has a problem as a language for tutorial programming, it is probably in its rather limited error checking.
You can't see ANYTHING from a car, You've got to get out of the goddamned contraption and walk...Edward Abbey
I quite agree. I fire bullets over the heads of my students as they program too. Makes the bastards learn to duck.
echo -e 'global _start\n _start:\n mov eax, 2\n int 80h\n jmp _start' > a.asm; nasm a.asm -f elf; ld a.o -o a;
Surely Python is the language to start with these days? It's straightforward, doesn't force any particular model, i.e., can use for procedural, OOP, functional style.
Most importantly it's not a toy language.
I've been struggling to teach programming to my kids using Python (and other languages), and have never been completely satisfied. I'm thinking that I need to start by teaching a restricted subset that looks a lot like BASIC. Two character variables are missing, but OTOH python doesn't use '$' to indicate string variables. The big thing is to include a GOTO statement, such as http://entrian.com/goto/, to be used until other flow control mechanisms are taught. I wonder if I can extend Entrian's code to include a GOSUB?
Of course, there's always Perl.
Nothing for 6-digit uids?
I learned BASIC as a young kid in the very early 1980's. All thanks go to Mattel (Aquarius) and some little known company called Microsoft! When I got to secondary school they exposed us to Turbo Pascal - I completely failed to wrap my head around this crazy language that had no need for line numbering. Even assembly (micromon on the C64) had what I thought were line numbers at the time. I was 10 years old! I spent close on 4 months looking over shoulders and copying work before it all started to sink in.
I'm not really sure if BASIC was a good thing for me or not. C and C++ were though - that's where I really learned how little I actually knew :-)
While I don't much care for Python, you have never programmed in either BASIC, Python, or both. Comparing BASIC to Python is like comparing the Model T to a Ford Cube. Yes, we get it, you don't like these newfangled languages. But Python is in no way analogous to BASIC.
Python has scoping, functions, good control structures, and a usable set of data structures.
Perl as introduction to programming for kids?
You will be lucky if they put you in prison for life, for child abuse.
If they don't, you'll have the misfortune to spend the rest of your miserable and short life in the grim world you will have created, filled by monstrosities from worst nightmares.
If BASIC was mutilating the young minds, Perl is in the line of Cthulhu summoning with minors.
45 5F E1 04 22 CA 29 C4 93 3F 95 05 2B 79 2A B2
Most importantly it's not a toy language.
That's why it should be kept far away from beginners. What if they accidentally type "import skynet", huh?
That's just nonsense. JavaScript is great for learning simply because it's good at giving immediate results that users can see, in a format they can all relate to (web pages). It's also a very nice language that doesn't throw too much IO stuff or memory addressing at the beginner. It adds a bit of "fun" to the coding process. Something that was sorely lacking when I wrote my first hello world in fortran.
A lot of the older coders hate it though because it's easy and flexible and gives the programmer much rope to hang themselves, but that's just "get off my lawn" nonsense. The reality is, and I'm surprised no slashdotter has mentioned this yet, is we all feel like we cut our teeth on the best programming language. And those other guys who do stuff differently must be wrong.
I swear I hear Foghorn Leghorn's voice when reading some of these comments. "I say, I say, a those new-fangled curly braces languages are an abominations boy! An abominable snowman, I say!"
This attitude is pervasive in the developer world and if you dont believe me, re-read all these comments. Developers need a bit more self reflection about what it means to be a good developer. It's not just about what crazy hard language you started with, or what perfect cohesion, or design pattern mastery you have. Rather nowadays, it's also about teamwork, problem solving, readability, modularity, and user experience. I know a few guys who might be masters of the command line, wizards at writing regex, and zen-like in their ability to do bit shifting math. But, for most projects, I wouldn't want them anywhere near my team/code.
People forget that learning isn't all about what the "right way" is. Learning is about accumulating knowledge in steps, and then retaining it. Making the process fun means better retention. I'd hope that more of the developer world groks this soon, as the machismo bullshit that comes out of these conversations is what drives smart and nice people away from developing.
meep
I'm curious about what kind of "bad habits" can be learned using modern dialects of BASIC today?
Then again, the current incarnation of Visual BASIC and other similar implementations of the language are such an abomination that you can hardly call them BASIC either. Well, I should note it isn't the earlier implementations of Visual BASIC, but rather when some C programmers got ahold of the language and threw out some of the exceptional power that BASIC holds over other languages.
I'll admit that the traditional "Dartmouth BASIC" can result in some unnecessarily complex spaghetti code, but then again it also shows who the sloppy programmers are when they try to do tricks to save a couple bytes of code that ultimately makes code maintenance almost impossible. I've always hated "clever" programmers anyway, and this can be a pitfall in any language. Then again, this version of BASIC was designed to be used on a line printer terminal.
I don't want to admit to how many or how large of a program I've written using that software editing system, but it is more than a few and some fairly large programs.
BTW, I don't consider Python to be today's version of BASIC. Instead, I would consider Scratch to be the true philosophical descendant of BASIC. If you've never tried this programming language out, you are missing out on a very unique experience, and something that is certainly going to influence software design over the next century or more. For my own children, this is the software development environment I've been using to introduce basic software development concepts, and it teaches object-oriented design and event interrupts right from the beginning. Who knew that an introductory language could introduce multi-threaded design so easily? My only major complaint is that it encourages the use of infinite loops not as something to avoid but even implements a specific construct to push its use.
Yes, Python is pretty good, but it isn't an introductory environment.
Sometimes I wished `break` could take argument of how many levels it should break out of
It can in PHP. Java and Perl have a different solution: label the start of a loop and then use that label as the argument of break. In C, it's just a matter of discipline to use goto only to replace a throw or labeled break.