Great post, I have been reflecting a lot on where I came from too. Those two books were the primary books I used to create my first programs. Those covers rang true in my memory as soon as they came into view. I started on a Timex Sinclair 1000, http://professionalaspnet.com/archive/2008/03/18/The-Good-Ole-Days-of-my-Timex-Sinclair-1000.aspx. Good stuff man.

Too funny. The 2600 basic programming cartridge to Atari 800 basic constituted my entry into the world of programming as well. At first, I had no tape drive and no disk drive, so you'd type in a program (usually from a magazine), play with it for a while and then press the reset button and start all over again. The best would be when a program listing had a whole bunch of assembly code that you would 'poke' into some address. You'd be typing in a huge string of gibberish and if there was one typo, nothing would happen when you ran program. Or if you were really lucky, you'd get some garbage displayed on the screen.

I wouldn't trade that early experience for anything. :)

Dijkstra's quote does have a ring of truth to it.

My first programming language was VB5, followed by VB6, then only briefly Java until I went into college to study CS.

Looking over my old VB6 projects, and old emails with my first professor (I never delete emails), made me realize just how bad of a programmer I was. I still made cool stuff (it was amazing when I discovered the Microsoft Speech SDK - I totally had that thrill you described, jeff), but I didn't understand OO at all. For a long time, when programming I would actually think only in VB.

But alas, I was saved. I graduated with a degree in computer science, having learned tons of languages and programming paradigms. But, if it wasn't for a university CS education, I know I'd still be stuck in the dark ages with that old VB mindset, even if I continued my hobbiest programming.

(Insert obligatory good-natured complaint about how "Fortran" is being used synonymously with "bad code", when these days it's evolved into a perfectly good structured language that's got some significant advantages over C and C++ -- which, by comparison, have remained largely stagnant since they were invented.)

commadore 64... my uncle had one.

I grew up with Basic, too - back in the good old days of 80286 cpus :-) I started with GW-Basic as a 8-year old and learned to code my first game. Later I moved on to QBasic, Turbo Pascal, Delphi, ... Without Basic perhaps I would never have started programming. Dijkstra is a nice guy - but not always right :D

I couldn't agree more, especially considering I'm one of those "programmers of a certain age".

I remember vividly one of the first programs I have analyzed - a phone book that was included in the (5 1/4", of course) floppy that came with my first computer, an Apple II.

Since I was learning my way into BASIC, I couldn't understand how the software could keep the entries between boots, since there was no data file!

Then I looked the code, and it had some lines like these, in the beginning:

10 REM ......................................
20 REM ......................................

After insterting an entry, next time it would look like this (I'm oversimplifying here):

10 REM Altimari, Rubens 257-9637 ....
20 REM ......................................

In other words, I've learned, right in my first weeks as a developer, still in high school, the concepts of memory as a single repository for data and code, as well as several dirty tricks related to direct memory access, saving things on disk programmaticaly, and so on.

I wonder how Dijkstra would feel about *that*... :-]

Rubens

Yes, a lot of us began learning to program with BASIC, but that doesn't make it a good language. I learned to ride a bike with training wheels, but you won't see any of those on my bike now.

I'm in high school and looking to start programming. I have the Programming for dummies book (it was a gift) and it includes tutorials in Liberty Basic and a disc for it. Is basic in general a good language to start with, with so many other languages available now? I don't want to get stuck with the problems understanding Object Oriented programming that other people have described...

Great post. And just curious, did anyone get started with programming through Texas Instrument Graphing Calculators (TI-82, TI-85, etc.) like I did? I can honestly give credit to TI-BASIC for sparking my interest in programming.

Great post, brings back a lot of fond memories!

I first learned BASIC on a machine (confusingly) called the BBC Basic, which was the only computer in my primary school. Consisting mostly of "guess the number" type games, and the occasional screen full of brightly coloured text I also felt the buzz of this "brave new world" and was hooked. Next came the ZX Spectrum, and the weird and wonderful experience of cassette tapes, but then came the Amiga 600... I soon left BASIC behind and became an ARexx lover, before going on to learn Pascal, which taught me the fundamentals of OOP - useful concepts that I still carry with me today.

I can see where Dijkstra is coming from, but without BASIC there wouldn't be nearly as many hobbyist coders as there are. These days I work in a school, and see kids in the IT room getting their first taste of coding with VB scripting in Excel - not something I'd want to be doing myself, but everyone has to start somewhere. Those of them that are determined enough to take it further _will_, just like our generation did - and these are the developers of tomorrow. As much as I dislike BASIC, I believe it's a crucial first stage for a huge number of coders, and for that reason alone shouldn't be entirely dismissed.

I grew up with GW-BASIC in the mid-80s. I loved programming, and I actually made some reasonably complex software. I’m convinced the accounting software I created was what landed me a scholarship to a prestigious private school here in Sydney. Other software: a graphics program, many, many games (culminating in a loderunner type game with *a level designer*), a text editor and many others. I even built an interpreted language *IN BASIC* (these days the cool kids would call it a DSL, and yes, I was crazy and young).

Ah BASIC, like you said it was the first language I programed in (good ole TI-83) Thats why I am here now studying Computer Science Network Security. I fell in love with programing because of BASIC.

Aren't you supposed to be working?

Yep, it is a bit of nostalgia there. I was programming in BASIC on my Apple IIe when I was about 6 years old. Haven't stopped programming since.

I think the thing that Dijkstra was getting at had more to do more with the notion of knowing how to program in BASIC does not really demonstrate one's mental ability and maturity of thought processes to program more sophisticated solutions demanded of harder problems only realistically implemented in more sophisticated languages.

ie: Just because you are in command of the BASIC language and perhaps can even use it so solve some potentially useful problems, does not necessary demonstrate you have the inherent skills needed to solve more complex problems. Of course, somewhat contrary to Dijkstra's exact word choice, just because you only know BASIC doesn't necessarily mean that you don't have that ability once truely enlightened by a superior language.

Joel, I think, addressed this bent on the topic well relative to his comments about Java in the following article:

http://www.joelonsoftware.com/articles/ThePerilsofJavaSchools.html

I never got around to code in BASIC, i see it as a reserve for the oldies (programmers who started in the 90's).I guess you didn't need to know OOP then, concluding from your title.

"If anything, BASIC opened the minds of millions of young programmers. "

Yes, that's all good and well. But young kids grow up, move past a language for Beginners and move on to something else.

The whole IDE "method" of software development introduced by Microsoft (with Visual Basic) got too deeply in some people's heads, allowed too many bakers and butchers to "program", and were never able to dig their way out. Plonking controls on a form is fine - but hooking up datasets and controls on a form, text boxes, dropdown lists, etc. to datasets on the form is a horrendous way of doing things. Not to mention polluting all the code in the forms with database connections, SQL statements, etc. - you end up with a massive ball of spaghetti. This way of doing things, at least for anything but the five minute Microsoft demo showing off Visual Basic, some article or anything even remotely more substantial, it's just not kosher. Sure, great to get you started, and you can improve as a developer with BASIC, but a lot of people don't move on and stay with corrosive habits learned early on. And I don't necessarily mean move on away from BASIC, I mean to move on with learning new and better skills. Basically, BASIC has a lot to answer for - especially Visual Basic 6.

I grew up on Spectrum Basic and was very surprised to find out recently that it had support for functions. Amazing.

I'm not sure what's up with the VB6 bashers. Sure many dreaded Morts learned from it and continue to be coding monkeys because of it, but it was one of the best options during its time, just like BASIC was during the early 80s (well, BASIC was the *only* option then come to think of it).

Thing is, a programmer wallowing in Visual Basic 6 and deciding to step up and do serious learning of things like OOP and functional programming and TDD and the rest of the agile stuff is <em>a conscious effort by the person</em>, not a limitation set by VB6. I came down that path, and I do not have a CS degree, and I can say that today I have a fair understanding of some of the above concepts.

Again, if anything, <em>it's the people who refuse to learn</em> that is the problem, not the tools.

You certainly won't blame an nail gun if your carpenter doesn't want to use hammers anymore, would you?

I owned the Atari 2600 BASIC cartridge when I was about eight and taught myself how to "program" on it. The only thing I ever really used it for was writing programs that would play little songs I'd write in BASIC. I still hum one of my mutant compositions to this day. :)

The good that came out of it is that my parents saw how enthusiastic I was about it and bought me an Atari 800, which I used to teach myself Atari BASIC and write a bunch of silly applications and games on that.

The first *program* I actually wrote was in Qbasic. Boredom set in after the first few minutes of "typing class" and I needed something better to do with my time. Halfway through the semester, most of the class joined me in my multiplayer q-basic rendition of the arcade game Spy Hunter. I have fond memories of the ridiculous routine I wrote for the collisions, shooting out random polygons and such. Makes me miss the days when it was a hobby instead of writing business objects & the like.

OMFG I'm having such crazy flash backs. I had one of those. No way.

@gogole

Basic for programmers starting in the 90's!

Try the 70's. By the mid 80's there were Pascal flavors for the PC, and C compilers.

got to say even for a young programmer like me BASIC was still being used as a teaching tool at A-Level (UK exam type taken 16-18). This was QBASIC through windows then later visual basic. However most of us taking the computing class already had experience in other languages so it seemed a bit backwards but you can demonstrate some algorithms easily like different sort methods so it was good to get everyone on the same language.

Perhaps a better teaching tool now would be a web language.

I became interested in programming in around sophomore year in highschool when I learned I could write a program to take in values and do my repetitive math computations for me (compound continuous and compound interest formulas)

...not sure how strict of basic this is but sorry I can't resist to post this little program I wrote a little while ago on the TI-83+ which I think is loosly BASIC

0->X
Lbl A
X+1->X

If ((X/3-(int(X/3))=0 and (X/5-(int(X/5))=0)
Disp "FIZZBUZZ"
...(other code here)
If (X<100)
GoTo A

you know how this ends

As far as compilers on 8-bit computers go, there were actually a few BASIC compilers for the C-64. I know because I used at least two of them. They were very slow at actually compiling the code, but they did actually create reasonably fast versions of the original BASIC program. One of them (I think it was the official Commodore product) produced what they called "p-code", which is similar to Java or .Net byte code today, and that one only produced a mild speed-up. The other one put out something close to true assembly code, and thus made much faster executables. Still, like most people who programmed for the C-64, I ended up moving to hand-coded assembly language, since it was the only way to get real speed out of the machine.

I think it shows a lack of understanding here -- people's minds aren't *only* shaped by the programming language and its flaws and finesses. If people aren't agile thinkers, it won't matter what language they start with -- they won't be agile programmers.

That's a really interesting viewpoint, I actually hadn't thought much about that aspect of things.

For me, BASIC actually turned me off from programming. If BASIC was all that had been available to me, I probably would have been bored and maybe never gotten into development. I had a bit of fun programming in TI-BASIC (the calculator language), but that's because you don't expect a calculator to be very powerful, and it was a very domain-specific language with an "IDE" that made it very easy to write.

I think you're right that BASIC doesn't fundamentally mutilate the mind. I would never laud it with praises as a programming language, but perhaps as a cultural phenomenon, it was valuable.

-Max

I started off by writing scripts within [m]-I-R-C. Very procedural kinda stuff. Everything mashed into one alias. It was ugly - it was horrible. Then I moved on to Visual Basic and wrote up some very simple 'business apps' as assignments in school. I learnt a little about functions and encapsulating parts of code. It was still very procedural and event driven stuff.

I continued with my [m]IRC scripting and wrote a few more simple scripts that were much tidier than the previous ones but still nothing special by todays standards.

Then I went onto uni and learnt some java and c/c++ coding. This taught me the basics of OOP and then eventually the advanced OOP. I returned once again to write an [m]IRC script that interacted with a website and discovered I could write it in such a way that slightly mimicked the OOP principles I had learned.

The point if you're wondering is - you can start with whatever language you like. Once you learn the principles of programming (or of a particular methodology), it's easy to transpose those ideas into whatever future project or language you choose to use. It's also easy to put aside previous things you learn if you discover they are no longer relevant, or there's a better way of doing something.

heh [m]I-R-C is filtered!

It's also easy to put aside previous things you learn if you discover they are no longer relevant, or there's a better way of doing something.

- If you're worth anything at all.

I have a different opinion: Everything I know about what to forbid in programming, I learned in BASIC.

Goto statements: since I learned basic 20 years ago, I have not found a single case where a goto is acceptable. This INCLUDES web services that return 302 redirects by the way.

Global variables: Since learning to avoid Global variables in Basic, I have learned a refined rule that all variables should remain in the innermost scope possible.

If statements: good programmers can avoid if statements. Your function should not need to ask whether the red button was clicked or the blue button was clicked. The code should be event based so that you have a different function running depending on whether the red or blue button was clicked.

Basic is a good way to contrast the way programmers did things back before they knew any better.

Austin: Any programming language can teach you the basics of programming, but you probably want to learn something with a larger community and more practical application.

I would recommend Ruby or Python, if you want to write useful little personal applications for your computer; PHP or Ruby (on Rails) if you want to write small to medium websites; C# or Java if you want to write more formal applications or websites and take immediate steps toward paying work; or Scheme or Lisp if you want to get a serious theoretical introduction to computing theory.

Ruby or Python would be the most fun, and would stay useful even if you don't stick with programming. Each language has a legendary guide: the one for <a href="http://www.poignantguide.net">Ruby</a> is infamously surreal and cutesy, which makes me love it, but your mileage may vary if you are a heartless curmudgeon who hates all beauty and fun.

I somehow missed the giant red "no HTML" sign! http://www.poignantguide.net

Will there be a BASIC section on stackoverflow.com?

Ah yes, the Atari 2600 BASIC programming cart. One of the few that I didn't actually have (and don't own now).

I actually started programming on a Sharp MZ-700 Series (http://en.wikipedia.org/wiki/Sharp_MZ) that used a tape drive (audio tapes, btw). I got so good at BASIC that by the time I got to the BASIC programming semester for Maths II in High School, I was banned from talking because I knew more than the teacher.

Ah, yes, fun days.

I think I agree with some of the previous comments. Any programming language can teach you the basics and get your mind receptive to programming, but most people can't get their brain out of that first way of thinking. You need to be agile enough to change your way of think as appropriate to the task/language you're dealing with.

Check out this Basic http://en.wikipedia.org/wiki/BBC_BASIC

I started with this 1982. Procedure names, local variables, inline 6502 assembly, it was amazing.

As an introduction to programming, I remember eagerly typing in BASIC programs into the Vic 20. I hated searching for the typo or 'paper debugging' the article source. I was always frustrated that there was no possible way I could write a decent program like the ones you could load from disk. The only interesting program I can recall was getting a sprite on the C64 to bounce around the screen, or doing a choose your own adventure style text game. I realized it was more fun to play spy hunter or impossible mission than wallow in that mess.

Upon reflection, I think a better 'first language' is LOGO with Turtle graphics. You can understand enough to make a simple shape in 10 minutes, and soon you're naturally wondering how you can replicate other geometric shapes. Fundamentals of math, geometry, variable assignment, looping, recursion, functions, etc. All easy to demonstrate and get tangible, visible feedback. Brilliant.

http://en.wikipedia.org/wiki/Logo_(programming_language)

My 2 cents.

Since when is VB actually BASIC?

Anyway, I wrote my first piece of code when i was like 6 in basic on a ti99-4a. It was my first experience of creating something... just a few simple lines that solved a problem I needed to solve. Because of that I'm a lazy CS major who enjoys to code. I'll agree, I was "mentally mutilated beyond hope of regeneration". Before I was content to do nothing but play games and sleep, and now I want to do something productive as a hobby. Is this regeneration such a good thing, no hope that I'll regenerate cause I don't even wish to.

I don't go round coding in basic though. I need to take a year off or something and actually write a sizable chunk of code. Early years of CS as a major seem to just make you busy with general stuff and you never seem to actually do that much code-wise.

apple][, GWBasic, TS/1000 (aka ZK81) & Sinclair QL were my early exposures.

I grant you that my first few reads through a pascal book left me with no freaking clue how to do anythingin pascal - the concepts were mighty foreign and I learned how to use forth long before I did pascal.

Not because Pascal was hard, but because the person who wrote the book failed to explain the fundamental differences between basic development and pascal - mainly the lack of an interpreter & editor. Once you understand why all the line numbers are missing and how you get code in and run it, the rest of the differences go away.

I had the strangest interpreted C for my old 8086 system as well - if you wrote something like strcpy("abc","def"); and ran it, the source would magically change to strcpy("abc,"abc");

Obviously, with no experience in pointers - I was baffled. Time in 6502 and 8086 assembler cleared that up problem.

Basic doesn't really warp the mind, in fact, I still think its a great starting point for programmers. The problem is there are so few good bridges for the conceptual differences once you move on to other languages like C and Pascal etc. I believe that chasm has actually grown since plain basic all but died of neglect years ago.

Sad really. A good basic interpreter can really get you started in a hurry in ways that C and Pascal just can't.

For some reason I have the following, my first line of code EVER, stuck in my head. I think I was about 8 or 9 and was walking by a Radio Shack and they had a machine near the front entrance. I watched some guy type his name and it scrolled up and down the screen then he added a semicolon and it repeated until they hit the break button. This is all from memory from almost 30 years ago so it may be a little off but this is what I remember the line to be.

print "Brian";

which resulted in something like this:
BrianBrianBrianBrianBrianBrianBrianBrianBrianBrianBri
anBrianBrianBrianBrianBrianBrianBrianBrianBrianBrianB
rianBrianBrianBrianBrianBrianBrianBrianBrianBrianBria
nBrianBrianBrianBrianBrianBrianBrianBrianBrianBrianBr
ianBrianBrianBrianBrianBrianBrianBrianBrianBrianBrian

it was the coolest thing I'd ever seen, anyone else do this or remember what machine and language?

Great post! You inspired me to dig up my old TI-83 BASIC days:
http://www.simsbox.net/2008/04/21/rapturedans-the-name-ti-83-basic-is-my-game/

A lot of the VB bashers are horribly unfamiliar with the language and seem to think somehow that it is still the same language as MS Basic (down to coding with line numbers).
Java might optically look a lot like C++, but effectively it is a lot closer to VB.Net or even VB6 (yeah yeah, inheritance and constructors are missing. But still...), even down to the way it is implemented (one class per module file, p-code compiler, references but no pointers, no way to kill objects yourself, etc).
My father always told me: there is no bad language, there are only bad programmers. Altough my sister begs to differ after learning RPG.

Great post. I'll recommend it to somebody I know will be interested in it too!

Hey Jeff,

Looks like most of the comments are in the "+1" topic, so I'll not deviate:

I started my programming addiction with a Radio Shack TRS-80. Pretty dandy thing if you ask me!!
The programming manual that I could grab was an edition to teach Basic on teletype terminals... That's right: Typewriters with a wider toilet roll as a Screen :)
That was all I needed to get my mind around the basics of programming: Decisions, Loops and Assignments.

Next stop was an Amstrad CPC6128 and that gave me more addiction.

After the Amstrad I entered Uni and stumble upon a Turbo Pascal Filedisk( or something ) Book that introduced me to Turbo Pascal 5.5 and the wonder world of OOP.

So what I have to say is simply that, yes, Basic was the foundation of my programming career but I'm glad I had the opportunity to get into OOP in that early stage cuz if I would remain on a functional only language, I could get that hindering to my brain that the other guy was complaining about!!

What I perceive of this issue is that someone is complaining that someone that rode a horse chariot would be mentally challenged to learn how to drive a car, forgetting that, at the time the guy was born, the only thing available was a chariot. It's also true with us programmers: At the time we discovered the computers we only had Basic. But like most of you that prospered on the programming career it was a mean to a goal, so you have not been hindered by Basic!!

Just my 2 pence, with a bit of inflation ;)

Cheers,
Gus

To Harry G: All paradigms have limits.

How's that for universal truth?

Oh my gosh I spent innumerable hours nerding about in BASIC on the Color Computer 3 and Tandy 1000 computers. I typed in or made my own games, screen savers, you name it. Then I got Turbo Pascal 4.0 or something. Finally I found a copy of Visual Studio 98 and learned C and C++ right before I started college. The last two definitely took a leap of faith out of the comfort of languages that didn't require (or have!) things like pointers. Nowadays I can't get enough of C# 3.0 and its embracing of functional programming idioms with lambdas and extension methods. Although those lambdas can really tie you into a knot if you aren't careful -- nest them at your own peril!

I still have both of the BASIC computer games books, as well as my old VIC-20. I moved on to PASCAL and FORTRAN soon after those days, and still have a working Amiga 500 that I played with as well.

Since the advent of the web I moved ahead to Perl, and now work primarily with PHP. I'm of the opinion that programming is like speaking. It doesn't matter which language you use, as long as you're able to get the information through in the way in which you intended. Programming skills and the thought processes involved can be taught using any language.

My uncle was one of the people that actually created BASIC back in the 1960s. Carried a teletype machine around in his car and connected from people's offices and homes using phone couplers (better wiki that, kids) to demonstrate how you could write programs from remote locations.

I actually took BASIC in high school, then Pascal for several years. But I didn't touch a computer for 10 years after that until I realized I had to do something with my life and taught myself Java. Now I do .NET at work, Rails and Cocoa at home.

What I remember most about learning BASIC in 1982 or so was the teacher teaching us how to bend it into something resembling functional programming. Then Pascal came along and it was like a breath of fresh air. But if I were to teach kids programming today I would skip all of those and start with Smalltalk. It's not terribly "useful" in today's business world but it's a wonderful way to learn programming.

I started programming from this book:
http://maben.homeip.net/static/S100/video%20genie/manuals_basic_manual.pdf

It was on a then ancient TRS-80 in my Grandmother's basement. I rode my bike for about 3km to get to her house just to program! From that, I typed in that lemonade stand program. Inspired by that program, created my own stock market emulator. (Minus the stochastic differential equations, because I was 9 years old.) Fun! That stock market program, stored on a cassette tape, was most likely taped over with C+C Music Factory recorded from MTV.

I even went on to create an almost finished version of Tetris on a Commodore 64 using BASIC.

http://www.shawnleslie.com/code/c64_TETRIS.html

Then Pascal, C++, COBOL, C, PHP, Java, etc...

I started doing assembler on a 4k Univac. Yeah, four thousand bytes of octal. Then there was Fortran, Cobol, RPG, PL/I, 370 assembler, debugging native hex from unknown sources, and lots of other weird stuff. I don't think any of it ruined me. What it taught me is most languages have some basic similarities: moving and comparing data, branching, and loops. I wrote lots of Basic on my first home machine, and I still dabble in it today.

The exact language you write isn't half as important as the care you use writing it. The most important part, in my opinion, is leaving something maintainable for those who have to work on it later.

So please, people, no matter where you are in your career, write stuff that's straightforward and not obfuscated. Let your successors know what it does and what it was supposed to do. You're professionals and you should be proud of your work.

Great post. Brings back fond memories of my first experiences with programming (had a TRS-80). Judging by the comments, it seems that many of us came from the school of GOTO. I for one am not embarrassed by my BASIC heritage because despite its flaws, it was accessible in a way that Lisp, Fortran, etc. were not.

Even though I code in C++, C#, Java, etc, when I want to throw something up quickly for algorithm testing, I use Blitz Basic (Blitz + or Blitz3d, depending on the application), since you can get something up and running so quickly and not deal with projects, solutions, header files, resource files etc., of course I also am a long-time BASIC guy from the days of the vic-20, apple ][ and trash-80.

Ah, a nice trip down memory lane.

Thanks for the nostalgia, it gave me some great memories of hacking away in Basic on my Amstrad.

Brian, that was actually basic, and it was probably a TRS-80 :)

I remember buying discs that were nothing but basic programs that made line and pixel art on the screen, sometimes with sounds. Examining those was interesting as a neophyte.

To the kid wanting to start programming:

DO NOT TAKE UP ANY FORM OF BASIC, VISUAL OR OTHERWISE. If you want something less complex and hardcore than C/C++ to start with, and want to learn a popular general purpose language, look to Java, C# (pronounced "C-sharp"), or Python. If you are mostly interested in web applications, look at PHP, Python, or Ruby. Again, AVOID visual basic at all costs.

My first language was Applesoft-Basic. Shortly after i had to learn and use 6502-Assembler in order to have a nice input-routine, which allows the usage of the arrow-keys and other editing feature for nicer text-input.

The next big jump was the transition to UCSD-Pascal, which was a nice language, but had a very bad IDE - you had to switch (floppy)discs for every compiling.

After a little bit GFA-Basic on the Atari ST, Turbo-C on the Atari ST was the next advancement. It was really great, like turbo-pascal, but C. You could build neat GEM-applications, with mouse-usage, windows and all of this - in times where MS-DOS was dominating, and windows 3.x was in far future.
I smiled at the IBM-PC Users with their crap-machines, very expensive, but less strong than the Ataris of that time - and even the monitor was so much more advanced (SM124).

Actually i'm happy with C#, and i'm very thankful for the latest innovations there, like Generics, Extension Methods, or LINQ.
Cheers to Anders Hejlsberg!

Now we could use great IDEs, with Versioning, Profiling, Debugging, great Database-Layers, and very rich and mighty libs!
But there is much work ahead, and i'm greedy to experience the next advancements!

Wow, lovely post, brought back a lot of memories.

I learnt a major portion of my programming with BASIC on the C64. I used to love those books where you had the source code that you could type out (like the ones you mention in the post) and run and voila, you would have a game or a simple application. What magic that used to be. And there were these listings in computer magazines that you could just type out and watch the magic on the screen. You really get the programmers high when that happens.

There is a lot to be said about learning programming by just typing out stuff that is over your head and then figuring it out over time. Sadly, this seems to have become extinct :(

I saved my pocket money for four months to buy Blitz Basic for the Amiga.

Basic started my programming career and like you, I am appreciative of the fact it was the first language I wrote.

Thanks for giving Basic a much needed shout-out.

Simon

I remember going to the library to photocopy 'Compute!' magazine listings, featuring cool BASIC games like "Roadar" (a racing game) and "Worms" (nibbles in Quickbasic). I also have a children's book called "Island of Secrets", which has a complete BASIC listing of an adventure game. I remember well the exhausting task of typing those listings into the computer and the pleasure of typing run and playing a real game.

And you know what? If it wasn't for the nostalgia, we'd all be saying what an abomination this BASIC is. It's next to impossible to learn anything at all from those listings. I just got out my copy of "Island of Secrets", and it's utter gibberish. Even more than Perl, traditional BASIC is a write-only language -- at least the way real BASIC programs were written. I certainly learnt nothing about programming from early exposure to BASIC. Indeed, it was almost child abuse. Tell a kid he can write real programs with his computer, and then watch him struggle vainly to reimplement "Buck Rogers" in a language that is barely worthy to implement "Hello World." The most typing in BASIC listings ever did for me was slighly improve my transcribing skills.

Things are just better now. Like blatant sexist advertising, glam metal, flickering low-resolution green text-mode terminals, and office workers chain smoking at their desks all day long, BASIC is one of those things that deserves to be consigned to the dark ages of the eighties where it belongs.

Rhywun:

>If I were to teach kids programming today I would skip all of those >and start with Smalltalk. It's not terribly "useful" in today's >business world but it's a wonderful way to learn programming.

Try Python. It's not quite as beautiful or pure in concept as Smalltalk, but it's Smalltalk's legitimate heir, and a real working language with lots of libraries and a big community behind it (so you can get real work done with it.)

(In fact, Python, Smalltalk and probably Lisp are the only languages I can think of that I would classify as "not child abuse" if taught as first languages in primary/secondary school. Smalltalk was of course initially designed for use by children. Granted, extraordinarily bright children, but children nonetheless.)

"Since when is VB actually BASIC?"

Ever since they put "Basic" in the name I guess. It's a lot more powerful than the BASICs of yesteryear, but it's a flavour of BASIC all the same. If it was anything else, it would be called "Visual [anything else]".

http://en.wikipedia.org/wiki/Visual_Basic

Of course everybody started with basic.

but the statemetne "everything i needed to know about programming" + basic gives a bad perspective on outsourcing with regard to the needed qualifications for it!!!

YOu started with basic - as all of us did
You learned the basic things - as all of us did

Guess what ... LANCE ARMSTRANG started with a simple bike..

and learned EVERYTHING he needed to know about biking..

come on...

I grew up learning Basic, in the UK here we had this programming magazine called Input. Last week I was testing my new scanner and thought I would try it with an old issue of this magazine.

http://www.flickr.com/photos/unmajestic/2380625785/

That is a page for a C64 & V20 program. Just thought I would share the basic.

Good post Jeff my man!

Except that I did learn to compile Pascal on my Apple //c, but not before dabbing with both "The Woz"'s Integer Basic and a bit later Microsofts (yes really) AppleSoft basic (of wich I believe your Apple //e screenshot to be a fine example).

Nowadays its pretty much all c# but I sure didnt suffer any from starting with several dialects of the good old beginners all purpose symbolic instruction code.

Regards, Kris

There's a difference between playing around with BASIC, and writing full-scale applications with it. One is good for you, the other teaches you bad, bad things that are hard to unlearn later on.

Heh .. Commodore 64 programming... This always sticks in my head...

10 For X = 1 to 255
20 Poke 53280,X
30 Poke 53281,X
40 Goto 10

:)

I am quite certain that there were compilers before the PC area, since I am quite certain I still have PASCAL and C compilers for the C64. I never used them much though, they were quite a pain compared to the standard BASIC and even when compare to direct assembly - especially if you had one of those extension cartridges, assembler programming could be quite comfortable.

Great post Jeff! Me too started with 'Basic' on an X386 at school. Initially with reluctance but later got hooked to it and realized what my 'vocation' was. Am thankful to Basic for giving the initial playground for launching me into this career path.. It was then I realized that I could 'learn something and apply it'..

5 REM FIZZBUZZ IN C64 BASIC BY JASON STOKES
10 FOR I = 1 TO 100
20 GOSUB 100
30 IF D3 = -1 AND D5 = -1 THEN PRINT "FIZZBUZZ": GOTO 70
40 IF D3 = -1 THEN PRINT "FIZZ": GOTO 70
50 IF D5 = -1 THEN PRINT "BUZZ": GOTO 70
60 PRINT I
70 NEXT I
80 END
100 IF I - (INT(I / 5) * 5) = 0 THEN D5 = -1: GOTO 120
110 D5 = 0
120 IF I - (INT(I / 3) * 3) = 0 THEN D3 = -1: GOTO 140
130 D3 = 0
140 RETURN

Man, was that hard. I'd forgotten so many gory details about the language. Like how there's only an IF construct, not an IF... ELSE construct. Oh, and in C64 BASIC variable names are only significant to the second character, so CO, COL and COLUMN are the same variable.
The apparent lack of a modulo division operator or function threw me for a while, but I improvised with a GOSUB - which, in true BASIC fashion, communicates via global variables, since there are no function arguments in BASIC -- unless you want to use DEF FN, and who the hell ever did that? Not to mention that if we declare I to be of integer type (done with I%) we can't use it in a FOR construct -- and since variables are stored internally as floats and converted for integer arithmetic, an integer in C64 BASIC is actually slower than a FLOAT anyway.
There's no booleans either -- apparently the convention is to use -1 (hex FFFF) for TRUE, and 0 for FALSE.
That brought back a lot of memories. Painful ones.

I learned BASIC for the Sinclair ZX Spectrum when I was six, and I also knew quite a bit of BBC BASIC (school had them), but the only remotely useful BASIC I encountered was Mallard BASIC, a commercial flavour of it that shipped with Amstrad PCWs.

It was reasonably close to BBC BASIC with the distinction that it included a set of tools for interacting with the file system, disk drives, peripheral interfaces and the like out-of-the-box, called JETSAM, which made it considerably more, uh, pythonic:-) I mean, with Mallard you could hop from "hello world" to actually pulling real data off the 3" drive, interacting with the operating system, and sending stuff to printers, serial ports and the like.

I wrote an application to wrap the CP/M command line in something less 'orrible for managing files, but my dad wouldn't use it. (He had more sense, and used the file manager functions in PROTEXT.)

I started with BASIC, sure, who in the same demographic cannot say the same.

But my first real code was in Turbo Pascal, and later Turbo C/Assembler.

What I cannot understand is people, who to this day, still *like* BASIC.

I like it in the sense that I am nostalgic for those simple days, but I much prefer, well, any other programming language really.

I grew up learning Basic and Visual Basic, but my first real taste of
real programming was with 'Learn to Program Basic' from InterPlay nearly
11 years ago which I soon moved to QBasic and finally Visual Basic.

After programming for over 10 years now I agree that if you plan on
writing a large program that you should do it in a curly-bracket language
like C#, C or C++ simple because, from my personal experience, they are
a hell of a lot easier to read and maintenance but never the less BASIC
is a great introductory language, particularly to children.

You can still get LtPB on Amazon and eBay, I'd suggest everyone look at it
as its a lot of fun, sort of like edutainment:
http://www.amazon.com/Learn-Program-Basic-Windows-Macintosh/dp/B000N3W2L4

> It's true that if you wanted to do anything remotely cutting-edge
> with those old 8-bit Apple, Commodore and Atari home computers, you
> had to pretty much learn assembly language.

I learnt BASIC on the Dick Smith TZ300 (a rebadged Radio Shack number I imagine) and then with Visual Basic on the PC and AMOS on the Amiga.

AMOS did allow you to do some pretty cutting edge stuff including providing an interface to the blitter chip and an animation language so again BASIC was a pathway for many of us growing up in the 80's.

> Basic is a good way to contrast the way programmers did things back before they knew any better.

The point is that programmers already knew better, but BASIC was available for almost all micros and early PC's (Thanks to a small company called Microsoft who wrote most of them)

Microsoft evolved Basic into a fully featured programming language that is now VB.NET but it considered by many including Dijkstra that they started with the wrong language ... C# is based on C and Pascal/Delphi ... Perhaps if they had started with C or Pascal we would have more "good" programmers today ..?

My first programming was QBasic. Loved it! Who remembers Gorillas? Then I went to Fourth Forth, which is a bit like programming in Haiku if you follow common good style.

I resisted HLL for a long time after that. I spent about three years writing Win32 API programs in x86 assembler, including some DirectX! There's something amazing about writing a Hello World COM executable in (about) 26 bytes.

One day I rediscovered my old Forth code and wrote an interpreter in... wait for it... Perl!

Hahaha I crack me up.

Nothing like perpetuating outdated stereotypes.

VB wasn't the Basic Dijkstra was talking about. I consider Hejlsberg one of the most destructive individuals in computing.

Most programmers eschewed VB either out of hatred for Microsoft or to hide their own poor coding among the curly braces - or both. But VB's been dead for many years now. Can't you people come up with another whipping boy to excuse your failures?

Let me introduce you to the Sapir-Whorf hypothesis:
http://en.wikipedia.org/wiki/Sapir-Whorf_hypothesis

It's relevance to programming languages is left as an exercise for the reader.

For long time I've thought of VB as a culprit why so many mediocres and idiots decided to do programming for a living. Before VB came to scene, C and C++ were too hard for them to learn so they stayed away from programming career. 95% of VB-VBSCript people I knew produced horrible, unmaintainable coding horror.
It took me some time to realize it wasn't their fault but it was failure of management to weed out such types by enforcing good policies like quality control, code reviews, conventions etc.
Feel free to visit my site and read some stories from the programming trenches, VB rants etc.

Bojan Markovic, Croatia

I totally agree with Hejlsberg. "Original" Basic IS retarded!
Like many others I have started programming in Basic on ZX Spectrum. I did pretty cool things for that time but I always wanted more and had that feeling that I am being limited by the language.
Only years later when I got introduced into Borland C++ for DOS, then I got that feeing of unlimited possibilities, and truly in command of hardware. So C++ effectively started my carrier, not Basic. And I thank all gods frequently for that fact.

Great post Jeff.

Learned BASIC in 1976. First language; 110-baud hard copy terminal in high school Math Lab, dialed into the mainframe at the Board of Education.

I remember programming WUMPUS, BASKET, etc. from Ahl's books... and being blown away by the sheer scope of a friend's project to type in all of STARTREK.

I was also blown away in 1980 by introduction to the Structured Program Theorem. Here was everything, in 3 basic building blocks! This was elegance, and programming would thereafter be elevated from merely fun to thrilling.

Years later I came to understand the broader truth about programming languages: while they all *permit* programming elegance, brevity and clarity, not all directly *support( and *encourage* it. BASIC doesn't prevent programming elegance, but it certainly never showed anyone the way.

Guess what?
I started out with Fortran, Applesoft BASIC, 6502 assembler, Pascal, Ada, C, C++, 60000 and 808XX assemblers, Lisp, C#...

A now what do I program in professionally, Visual Basic.

A the wheel keeps turning...

Oh by the way, if all you have is a hammer, ... I think you get where I'm coming from.

Alex,

"the only remotely useful BASIC I encountered was Mallard BASIC, a commercial flavour of it that shipped with Amstrad PCWs."

It was a nice version.

I remember it supported index-sequential storage (rare in BASIC) and I coded some album/track management software that would allow me to optimise my use of blank tapes.

I grew up with Benton Harbor Basic and Microsoft's MBASIC on a Heathkit H89. But the real eye-opener for me was when Heathkit made the source code available (in printed and bound form). They had everything in there, the OS (HDOS), assembler, basic interpreter, system tools. It was a stack almost one foot thick of 8080 assembly language written by J. Gordon Letwin (of OS/2 fame) and I pored over ever single line trying to figure out how it all worked. No wonder my eyes are so bad!

As a younger programmer I wish that BASIC or some form of it was written into the operating system. My first encounter with computer programming was with BASIC, but it was really bizarre. My younger sister got one of those kid laptops that has games and math puzzles and what not on it. Since I liked computers so much I would get it when she wasn't playing with it and mess around with it. While digging through the menus I found a BASIC program. I asked my dad what it was and he told me it was a computer language. I got out the book for the laptop and it had lessons on how to write basic code. I got about as far as the book could push me and then I had to go on my own. Trying to find a BASIC interpreter on the net is getting harder and harder and I wish that there was an easy way for kids to learn about computer programming, because without that little laptop I probably wouldn't be programming today.

Good post.

If anything, I think learning BASIC made me appreciate good programming practices more than anything. I consider myself a very elegant programmer and I owe a lot of that to my experiences with BASIC programming languages.

I started programming using STOS BASIC for the Atari ST (can't remember the model number) and I can remember how frustrated I got having to cope without the ability to write my own functions, create my own data types, work with polymorphism or inheritance etc. I think you can't truly appreciate the features of more "advanced" languages until you've tried programming without those features.

Atari 800XL, how I loved thee.

Your BASIC, I loved to program, but nowhere could I save you!

You were so volatile.

And then we got that shoe-box sized 5 1/4" external disk drive. Though, at the age of 7, I still don't think I figured out how to save to you. At least I could program beeping musics and flashing, techni-color screens!

Ah, those were the days :)

Jeff, you say BASIC doesn't mutilate the mind. But then you mention being gung-ho about .NET. Those whose minds are mutilated often don't recognize it. ;-)

I started with BASIC on my Atari 1200XL and a bit on the Apple II, learned a little 6502 assembly, then some Pascal on a Mac, then Modula-2 in college, and finally C, after which I never looked back to the pre-C stuff. Perl, PHP (talk about mutilating the mind!), and Ruby followed, along with bits of C++, Java, and Lisp/Scheme interspersed.

Dijkstra was perfectly correct. There is no such thing as a good version of BASIC; they are all evil. And when he made that remark, it was even more true. It practically forced you into bad habits.

My first job was working with BASIC programmers. Dijkstra may well have had those particular ones in mind :-)

I learned BASIC on a CYBER 6400 mainframe my freshman year of college. I became so enamored with my ability to bend the machine to my will that I changed my major to CS my sophmore year. Unfortunately for me, BASIC wasn't part of the curriculum; my first formal programming class was in PASCAL. That might not have been so bad, but my PASCAL prof was one of those that insisted on 'linear programming'--no goto statements. There was a way to do that in the language, just not in his class. Which might not have been so bad if I hadn't grown so dependent on them as a self-taught BASIC prgrammer (for lack of a better term). Still might not have been so bad, except that he delighted in giving us exercises in which the obvious solution was to break the linearity of the code, but expect us to write much more complex code in order maintain efficiency. I just didn't have that kind of agility of thought. I grew to really hate PASCAL. I sometimes wonder where I would be now if I learned PASCAL first, but I wouldn't have taken the PASCAL class if I hadn't gotten interested in programming through BASIC...

Unreleased Atari 2600 Game Found At Flea Market
http://blog.gism.net/2008/04/20/most-legendary-haul-at-the-flea-market/

All of my peers starting programming in BASIC, a good 30 years ago now. Those who kept at it quickly migrated to FORTH which was one of the best languages available for the early 80s PCs. I had an Atari 400, and I was able to write some pretty plausible, reasonably fast games without having to write assembler.

Of course, I also 6502 assembler. It's amazing what you could do with 64k.

My high school had a VAX 11/780, so we also got to see Pascal and C.

Seems like the elitist bashing of BASIC is still alive and well, judging by the comments above. Dijkstra had a number of stupid things to day, and this quote is one of them. There are quite a few others, however.

Too many folks here don't seem to understand the fundamental truth of programming - the language is irrelevant. "It ain't the paintbrush, it's the artist".

And now that the only difference between C# and VB.NET is the syntax, the whole attitude makes even less sense. If you need to have *something* to look down your nose at just to feel better about yourself, maybe you're just too insecure to be doing anything in the real world.

> I'm in high school and looking to start programming. I have the
> Programming for dummies book (it was a gift) and it includes
> tutorials in Liberty Basic and a disc for it. Is basic in general a
> good language to start with, with so many other languages available
> now? I don't want to get stuck with the problems understanding
> Object Oriented programming that other people have described...

I've always had a lot of respect for Dijkstra, but you have to be really careful with his quotes. Most of the more famous ones are both a bit over the top and rather out of date.

In the case of BASIC, judging from my own experience, the main problems you will have moving to other languages occur through two issues. The first is that the language has crappy support for control structures, which means you have to use totally unstructured branches (GOTOs) to get anything done. I suspect newer versions of the language fixed this.

The other big issue is that once you learn the language well, you may get the idea in your head that you know all about programming. That's what happened to me as a youngster. Of course, I really didn't know a damn thing. This can happen to you with any language though. You have no idea how many C and C++ progammers out there with this same attitude.

So I'd say if you have a good learning environment with BASIC, please go ahead and learn. That beats the crap out of never learning at all. But take great care to keep yourself humble. When you move to a new environment, you have to be open to its new way of doing things. More importantly, you have to be open to learning to think about problems in completely different ways.

Learning is the one constant in this industry. Anything that impeeds it is the enemy.

I was doing some thought on BASIC yesterday, that I've been an "open source software" user since I started with computers in 1979. In school I would fiddle with the BASIC source of cassette programs to try stuff out and share my changes. Later I got source code in printed format (magazine type-ins) to type in, learn and enjoy.

As for the quip abut brain damage from BASIC some may find the easy style of BASIC enough for them, others move past if for the sake speed and better coding for larger projects. I think in this day you could say the same for just any programming language that isn't the one YOU prefer.

Once again the religious argument emerges. Isn't this really just VB versus C++ or VB vs. Java all over again? Windows vs. Unix vs. Mac.

I've programmed in probably 20 different programming languages, and I can confidently say that anyone can write really crappy code in any language.

What no love for the Tandy CoCo 3?

Oh thank god "Old Guy" I thought nobody was going to say it. It has been posted before, by Jeff no less, that it doesn't matter what the language is, they are ALL training wheels TNBT (the next big thing).

Of course BASIC would be horrible today, but the fundamentals of structuring and the base concepts of programming are in EVERY language. No, you don't have to use global variables anymore, but you know what a variable is now. No, you don't have to use if/else anymore, but you know now that computers can be made to execute different commands based on user input.

Elitism gets you nowhere in the real world or otherwise :)

My dad brought home a new Apple IIe in the late 70's. He taught me how to write the very simple 10 print Wayne 20 goto 10 stuff and then gave me a book that had some sample programs. I typed them in and thought it was a blast.

Then in my 8th grade computer lab, we had to make a graphical game of sorts. Low Res Graphics and mine was just 2 planes with a moving background. Pretty craptastic. But that summer one of my friends came over with a Turbo Pascal 3 disk. I never touched basic again.

Turbo Pascal carried me through High School, then Oregon Pascal in College (with some C in my later courses), and back to Turbo Pascal 6 or 7 for my first professional job. That morphed into Delphi 1-7 and then Delphi for .Net in my last job.

Now, I program in Java or C# for most things. I miss my Pascal since I had 20+ years using it, but sadly there just wasn't a calling for it. It was a great learning language and Delphi is a powerful tool, but too many people treat pascal like they treated basic: good for learning intro stuff but not good for real programming...

I started programming in BASIC too, that was the only available option on the really old computers at my school !
When I got my CS degree I programmed in JAVA and worked on a linux server and a couple of open source projects.
Now I am doing .NET development all the time.
If it was not for basic, I wont have been posting this comment now :)
Great post btw.

Something must be in the air. I spent the weekend in nostalgic longing for my C64 days, so I ended up blowing most of my economic stimulus rebate on 64 stuff, included a couple programming books. http://mynerditorium.blogspot.com/2008/04/commodore-64-tax-refund-revival.html

While scrounging around for vintage gear, I came across those Atari programming controls. I had never seen those before. I’ll admit, they are pretty cool, but programming must have been a real pain.

I too got my start programming in basic. Although I think learning procedural programming long before I learned OO created a mental barrier that was difficult to break through, I do not disparage the BASIC language as the cause because I’m sure the same barrier would have been built if I had learned C first. BASIC definitely serves a functional purpose, and maybe more importantly, it teaches the concept of how a computer executes instructs in a very simple and understandable way.

Austin’s question about how to learn OO (implied), got me to thinking. Your typical “damaged” coders who come from the procedural world see OO as this: The syntax of the meat of OO code is made up procedural instructions, however the main difference between OO and Procedural is code organization and how different pieces of the code are brought together at run time. I dare say this pretty accurately describes how programmers think about OO when the barrier is still up. I’d also say this more of an Object Based programming mindset (classic VB is pretty close to this). Once the barrier is down and the programmer is truly thinking in objects, the programming views OO as being about loosely coupled entities interacting with each other in a dynamic and loosely coupled way. Sets of instructions are an afterthought in OOP IMHO.

Unfortunately, I’ve never really seen an introductory OO book or curriculum that doesn’t start off teaching procedural programming inside objects (or within a main method). There has to be a better way, maybe approaching OO from the top-down rather than the bottom up. You’d think something like .NET Terrarium would make the perfect sandbox for teaching and learning OO.

10 sin
20 GOTO Hell

Now I feel OLD. I started on a PET 2001 (it is in my basement, and may be headed for Digibarn.) I agree that there are some constructs in BASIC that are bad, but that is with any language. You could even say that Pascal was designed for academia, and never should have left, but in the end, it is the programmer, not the language.

It also surprises me how many started about the same age I did, 6. Maybe that is the real key, not the language, but getting started, and thinking logically very early.

Jeff:

Thanks for the memories. My first computer was an Osborne 1, with no hard drive, 256K ram and 2 SSSD diskette drives. The programs I used, such as Wordstar, Supercalc, DBase (1) all fit neatly on one diskette, booted quickly, ran quickly, crashed very rarely and were remarkably powerful for their time.

When I look at todays programs, with their huge footprint on disk and in memory, their instabilities and mediocre speed, I cannot help but wonder whether (at least with respect to programmers) Darwin was wrong!

I still use VBScript for all my scripting needs and stick to procedural code. In VB.NET I try to avoid creating new class files and methods for every little thing. I cram as much code into Page_Load as possible. Oh, the coding horror!

Seriously though, I waste too much time hunting through hundreds of class files and thousands of methods which none of you OOP geniuses ever bother to document. In my code you'll find everything in the event handler for the button click. In the code I've inherited I need to trace my way through who knows how many class files and methods to figure out where something is being done. I've seen methods that just call other methods and methods with just a few lines of code that could have been directly used where they were required.

Mentally mutilated.

It's like saying learning Arabic, Navaho, or English would turn your mind to mush.

Hmmm... maybe he's right.

FORTRAN was to engineers and scientists (i.e., "real (wo)men") what BASIC was to hobbyists -- their first foot in the door to programming. So don't diss it, hobby boy ;-P The first FORTRAN compiler was named by IEEE in 1998 as one of the ten best algorithms of the 20th century.

Nowadays Matlab (or Octave, Scilab, R, ...) largely fulfills the role that FORTRAN used to play, for prototyping numerical codes. But FORTRAN still is faster than C for many applications, mainly because its compiler doesn't have to reason about pointer aliasing.

Sadly, I'm a BASIC kid too... The linked Atari BASIC manual is priceless.

From the manual:
"Let's do a simple program. Make sure the left difficulty switch is in the b position and turn your console unit off and then on again."

Hey wait, that's just like Visual Studio... :)

My first programming language was Solder ....

Oh, and people actually used to write OSs and other systems code in Pascal, before C compilers were widely available. So people actually did practical low-level stuff in Pascal.

One more thing -- I also learned on BASIC -- C64 and Apple ][e. Fun stuff :-)

My first was a Heathkit H-8 (Intel 8008 processor). I had to build it before I could program it. My first programs were entered in octal machine code from the front panel keypad until I could afford a serial I/O card kit. I finally got it up to a whopping 24K of memory.

I miss Heathkit. I built radios, stereos, walkie-talkies, and test equipment besides the computer. I think the company is still around, but they do continuing education now, rather than hardware.

Nice post. My first days of programming were in the mid 80's writing Applesoft BASIC on the old green-screen Apple IIc's. It was a "downhill skiing" game that essentially involved moving characters on the screen around an "I" that was the player.

</EndNostalgiaWaxing>

I started out with HP Instrument BASIC in 1995, a BASIC dialect to control scientific instruments, which my dad brought home for me one day on a floppy. I envied these people with their mysterious QBasic, which didn't seem to exist on my new Windows 95 machine, and I kept wondering where I could get it...

Anyways, being 11, I was mostly interested in writing programs that spat out the word "spaghetti" on infinite loop. My most ambitious project was a text adventure / role playing game of sorts, but I had no idea on how to structure my code to do what I wanted - imagine an RPG-style battle scripted out linearly with fixed choices at every step. Ouch. Fortunately I didn't get too far into the combinatorial explosion, before giving up on the game.

I'm a software engineer today. What did I learn from BASIC? The basic concepts, and that it was fun to write computer programs, and that it was hilarious if those computer programs printed out the word spaghetti.

while true do
print("Spaghetti, spaghetti, spaghetti, spaghetti")
end

I hate Dijkstra, he cost my 3 points in my Data Structures test just last week. Damn Dijkstra algorithm for shortest path in a graph. Never listen to anything he says.

I owe my entire IT career and computer interest to BASIC. I got my first taste when I was eight or nine back in 1993 on my dad's XT Turbo (before we bought a "family" computer). I knew from that moment I wanted to be a programmer, and I stuck to it. I went from BASIC to Pascal, Java, VB .NET, C# and many scripting languages and went through college (and was subsequently hired by them) in a computer science program. I love programming, scripting and hardware alike, and I owe it all using BASIC.

Software engineer, programmer, computer scientist ... I think in the end your delimiter should be 'what do you want to do'?

If you are looking to be the next Google -- then you'd better start digging into some low level shit.

I'm never going to do that. And I don't care about writing/working on an OS. Maybe it's because I'm not that smart, maybe it's just because that doesn't interest me.

In the end, I think it just depends on whether or not you can 'do what you want with what you've got' -- or whether you decide that you need to explore using different tools to build different types of buildings.

I need a faster button on my keyboard.

The obvious correlation that the C++ snobs are missing is that Basic was a *beginners* language, simply because it was the first one widely available to the masses.

Had a C-form language been equally available at that time, you would have had exactly the same amount of lousy code being written in C.

As always, the language is irrelevant. It's a text interface to the system, nothing more. Braces are not inherently superior to End if statements. n = n + 1 is not inherently superior to n++. Readability matters. Short is not always better.

I grew up programming in vb, moved to C++, and now code mostly in Vb.net. I get along in c# without any problem. I just don't see the point. As for C++? Useful sometimes, but as any test engineer can tell you, a disaster when it comes to reliability, much less readability.

One minor historical note: there was a compiled basic available in the 8 bit era. Digital Research CBASIC was available for Z80 based computers and was included with the Osborne 1. Jerry Pournelle used to promote it in his BYTE magazine column.

BASIC was also my first programming language but on a time-shared DEC machine. In 1970, we used a teletype machine connected with a 300 baud acoustic coupled modem. Storage was on paper tape. I consider the experience enlightening not brain damaging.

I bought a version of C, Deep Blue C if I remember, on floppy for my Atari 800. It was compiled, but it offered only ints and chars.

This post, combined with the "choose your own adventure" posts, leave me with the feeling that you know me a little too well.

Around the age of 12-13, when I first ran qbasic on the command-line of my parents' 386... I wrote "Choose your own adventure" adventures in BASIC. To be honest, it's probably because the only things I knew how to do at the time were print statements and goto statements. The whole "variable" thing didn't happen for me until I started ripping into VB4 later that year.

I remember learning BASIC around 1981-82, the same time I learned to read, with none other than that very book, BASIC Computer Games. I was 3 or 4 years old at the time, and it sparked my interest in computers.

My opinion was that I learned BASIC so early and so easily because it was so simple. When I was 8 or so, I was aware that C existed, but it was still over my head in terms of complexity.

In high school, I transitioned easily from that old BASIC to QBASIC and DOS Batch, then in college I tackled C++, Java, and C#.

Newer languages carry new structures, and you learn the structure at the same time you learn the syntax. The logic is the only thing that stays the same. If you can wrap your brain around newer ways to do old things, then you don't fall into the rut that Dijkstra talked about so long ago.

BASIC was the learning language of our generation. The current generation has newer things like Python to play with. Languages evolve just like the people who create them.

Oh wow - flashback. I had an Atari 800 (the one with the keyboard), and my mom used to program games for me on it. I was 6 - not quite at the level to start programming myself, although I could write simple programs. At any rate, there was no way to save them (except for a tape drive you had to buy separately), so you pretty much could play with your programmed game until you had to turn off the console - then goodbye cool game!

Anyway, I always think that I had a way-cool mom for that reason. She's not even a software engineer, so extra credit for being a marketing manager and learning to program games on an atari 800 for your kid.

Several commenters have brought up the question of how to best go about introducing a young child to computer programming in this modern day and age. Jeff, I'd love to see you address that question sometime.

And yes, a "me too": I started programming at age 5 or 6 on an IBM PC 5150 that my Dad brought home from his job at IBM. Like the Apple, Commodore, and Atari machines of the era, it booted to a BASIC programming environment if you turned on the machine with no diskette in the A: drive!

I remember that the SAVE and LOAD commands (for saving your program to a diskette, and loading it back later) would only work if you started BASIC by booting to a DOS diskette and then running BASIC (or BASICA -- both were available) from that!

As a 30something programmer, I first learned the basic concepts of programming via my trusty old Commodore VIC-20. I remember begging my parents to buy me the "Zap! Pow! Boom!" book of type-in games. By entering in the code, I learned several basic programming concepts and then made little changes to things here and there to customize the game as I wanted. Along the way, I learned a lot about debugging, too.

(nostalgic sigh)

That's hilarious, I totally had those Basic programming books you show. I started on an S-100 computer, with a 2mhz Z80A processor, programming in Basic, and here I am, 30 years later, still going on a 3.4ghz quad-core in C++ and C#. So, it didn't quite mangle my mind.

I do remember getting Turbo Pascal and thinking at first, how cool is this! Then, thinking, WTF? Pascal sucks!

Haha, wow, even as a 23 year old programmer... before I was 10 I checked out that yellow Basic Computer Games book from the library faaar too often. Thanks for bringing back some incredibly dorky memories for me.

Yep, I was in 3rd or 4th grade on a TI 49/9A when I made my first "program" (typed it out of the How to Program book that came with the computer) that bounced a ball and played a random beep when it hit the edge of the screen. I was hooked ever since!

For those nostalgic folks out there, I found this image courtesy of Boing Boing that is my current wallpaper. A full fledged Atari setup, probably more suited for the programming too 8^D

http://www.boingboing.net/2008/04/03/atari-users-desk-cir.html

BASIC is a excellent first programming language when you're 12 years old.
However, the second language should be assembler, preferable PowerPC or MC680x0. It makes sure that you - as a programmer - actually knows what a computer is all about. 80% of the programmers I spoke with don't even know what BCD is (Binary Coded Decimal). An introduction to processor design and digital circuits is also helpful. Boolean algebra is a must-know. The next step would be C (because it's an abstraction of asm). From there on learn OOP and pick your language of choice, java, C#, C++. And don't forget to type with 10 fingers, otherwise you look like a g@y.

I started with GW-BASIC on my Tandy 1200, am a C# dev now.

10 PRINT "Long live BASIC!!"
20 GOTO 10

Hunt the Wumpus!

BASIC (and machine language) was all that was available when the Commodore 64 came out. My first science fair project compared access times of cassette and disk drive on the Commodore 64.

Then I moved on to Pascal, C, C++, VB4/5/6, SQL, Perl, VB.NET, C# and whatever will come in the future.

VB.NET is really not bad at all. It's roughly equivalent to C# in capability and there is only some non-OO baggage. Apart from the half-dozen real feature differences, VB.NET is really just a more verbose version of C#, which is certainly a first-class OO system (for people who like strongly typed OO systems).

The main thing I've steered clear of is weakly-typed systems - I really prefer the compiler to do as much work as possible in ensuring bugs are not allowed to go into the program.

Wow. Thanks for this (too short) article. Never knew about 2600 BASIC but your mention of Turbo Pascal brought back memories. What a great compiler and IDE (for the mid-eighties, that is)! To your point though, Apple II+ and TRS-80 BASIC quickly taught me to move on to assembler--but could always be trusted to be there when needed. It was a great launching pad. Thanks BASIC! Those were the days.

(Wish we cared even half as much today about optimization and tuning as we did then. If we did, think what we could do with these billions of bytes of RAM.)

It was the TI-99/4A BTW.... My bad 8^D

Try programming an 8080 with a 16-button keypad.

http://oldcomputers.net/heathkit-h8.html

That was programming. I went to BASIC a few years later.

BASIC did allow tinkering that compiled languages didn't:

I remember playing "Temple of Apshai" on my Atari 400.
http://en.wikipedia.org/wiki/Temple_of_Apshai

It loaded from a cassette tape. One day I hit the break key by accident and got a READY prompt. For the hell of it I typed LIST and got the whole program listing in BASIC. I started reading it and had no idea what I was doing but was terribly proud when I discovered I could change the names of the weapons and then run around the game with a "gimmer stick" or a "two-handed butt whapper".

I suppose it was inevitable that I would grow up to be a chronic game programmer.

For me, I learned basic on a TRS-80 coco ( http://oldcomputers.net/coco.html )

I learned file operations by loading and saving data to a cassette tape. Later, I moved on to PC's with the 8086 processor. Starting with GWBasic, then later I moved to Turbo Basic (a compiled version of basic from Borland). When Turbo Pascal came out, I got a copy of it. As a matter of fact, I wrote my first contract application in Turbo Basic.

Personally, I think anything that allows you to get up to speed quickly and start exploring machine control is a good entry point to programming.

To be a good programmer, it doesn't matter what languages/methodologies/whatever you know. A good programmer is one who can think quickly and logically, has good problem solving skills, and understands planning. Anything else can be learned as needed.

Chris.

As a much earlier generation, I learned programming using Turbo Pascal when I was 15 and I'm very happy with that, I advocate that Pascal should be used in University as an introductory language. I see all too often my colagues from CS course to struggle in their first semestre to compile _anything_ using those awfully complicated IDEs like Dev C++. They don't get #include <> or int main(arg...) that the IDE puts in there when you start a new project.

Edsger Dijkstra comment is one of those things that is often repeated and is totally wrong.

I remember programming in BASIC. The first line was always:

1 GOTO 10000

That's because the interpreter always looked for GOTOs and GOSUBs starting from the beginning of the program, one line at a time. So you put the program's initiation code next-to-last (the comments where always last). Since initiation was done only once, putting all your subroutines near the beginning of the program made sense; it ran faster.

Programming in BASIC made me think about what I was doing and gave me the willingness to experiment. Mr. Dijkstra comment is the total opposite of my own experience and I can help but think he was was more concern about some intellectual abstract (and by that I mean impractical) purity of code rather than getting the job done.

I learned programming by doing twelve exercises in BASIC, then repeating the same exercises in Pascal. Oh the pain.

Then I was totally into Turbo Pascal and became a undergraduate graduate research assistant for the university I attended.

I have seen VB code which is total spaghetti at (unnamed original silicon valley instrumentation company) on their laser-interferometer software, which I had to straighten out for them so it would run the same way twice in a row. Simply horrible.

I have seen C/C++ code which is equally spaghetti with numerous unneeded threads which had to be thrown out because it was essentially incapable of being expanded or debugged.

The problem with Basic is that it allows people to get in far above their heads, as these electrical engineers did. But VB 6.0 could be used to develop relatively well-structured and sophisticated programs in a fairly rapid fashion - as I hopefully did on my last large project where I used VB 6.0 to develop the user interface, equipment object model and OPC interface to real-time components and hardware for a large LCD flat panel manufacturing equipment. The application would have taken twice as long to develop in any other language available at the time IMO.

I hated VB until I used it, and now think it is certainly a useful tool for certain parts of certain applications when done the proper way - as with all languages.

"oldies (programmers who started in the 90's)"

Ouch. Then what am I, having started coding in '80 or so? On this (http://images.iocl.org/z80board.jpg) thingy, no less?

My first foray into programming was on a TI-83 Plus, building text games in BASIC. I also wrote an annuity calculating app and amortization table generator. I used them on my Algebra II final (with permission) and completed the final a full 30 minutes ahead of everyone else.

P.S. - Only one small quote in this post, you're on the up&up.

I started programming with QBasic. I know it's not as old, as "cool," or as respectable as the older BASICs, but thanks to QBasic I ended up with the developer career I have now.

I started making games with QBasic in grade school and shared them with friends. Eventually I had other things to do besides make games, but then later in life a situation presented itself where I had to learn ASP. I didn't know ASP. At that point in time, had you asked, I would have said, "I don't know any programming."

As I started to read about ASP, I realized the stuff I learned during my QBasic days would be a huge help. I dug out my old QBasic notes and programs and with that confidence and understanding I learned the ASP, which then lead to PHP, which eventually ended up landing me a full-time job right out of college.

Now thinking about it, QBasic probably played a more important role in my life that I'd probably admit. Go figure.

My programming experience has a similar beginning to Mattkins'. It started in Algebra I class with a TI-81. I automated the steps required for a lot of our problems with BASIC. When I graduated to my TI-85, I actually wrote an ASCII based RPG, with battles, magic, and everything. Heck, my first PC-based programming experience was VB 6.0. A friend bought me the Sams Teach Yourself in 24 Hours book that came with a debug-only version of VB Studio; I actually used it to write nice front-end to manage a Microsoft Access database for a final project in high school. Most of it was already automated by the ActiveX controls, but so what? I was learning!

Now I use C++ and, looking back, coding in VB seems sort of like poking myself in the eye with sharp things, but I wouldn't take it back for the world. It's just like Jeff said...it made me who I am today.

My first programming was in commodore pet basic, but the first computer the family owned was a Timex Sinclair. No RAM to speak of, makes you choose your commands wisely. Then we moved on to a Vic-20 with basic and Forth! So exciting, then the C-64 which eventually someone had a Basic Compiler for so you can just get your basic programs to run faster -- not quite a fast as assembly, but well worth the ease of programming in basic, even though much of it was PEEK this and POKE that...

Man, that dialectic of Atari BASIC is pretty odd looking. Apparently this is all you need for a game of Pong:

1 Hor 1!Hor 1+Key
2 Hor 2!Hor 2+8
3 Ver 2!Ver 2-3
4 If Hit Then Ver 2!99
,Note!7
5 Goto 1

I think I would have indeed been mentally mutilated beyond hope of regeneration had I tried to learn programming on that! Good thing I started with QBASIC instead, which was good fun even if it did involve a GOSUB every once in awhile. Somehow, alas, I regenerated.

Ha, I taught myself the beginnings of programming in BASIC on my ZX Spectrum 48K. I still remember the day I figured out arrays - boy did that make things easier...

As much as I dislike BASIC now, I don't believe it stunted me.

Well, when I was a kid, we didn't even have computers. We had to implement our algorithms the hard way: by hand. We didn't have any of your fancy transistors, or vacuum tubes. We didn't even have slide-rules; slide-rules would have been a luxury. All we had were sticks and dirt. And rocks. And we were thankful! We had to scratch our assembler instructions into the dirt with our bare hands, even when it was twenty below zero. And did we complain? No! We were thankful because the blizzard made our hands too numb to feel the pain. If we wanted to write something to a register, why, we had to carve the bits into stones, and if the value changed we had to carve a new stone. And if we wanted to push or pop code we had to carry the stones 20 miles to the Stack. On our backs. Uphill. Both ways. But did we complain? No! Because that was all we had and we were thankful for it. These young whippersnappers like Dijkstra with their "functions" and "compilers" and "linkers" make me want to puke! They've probably never done an honest day's coding in their lives. If you want to really understand the performance differences between Quick Sort and Bubble Sort, it takes hard work and honest sweat, not some fancy-pants PDP-10...

Aaah, the screenshot of GW-BASIC on Wikipedia takes me back to a misspent youth... :)

QBASIC...man I remember reading the source for Nibbles and Gorilla. It was beautiful.

Dijkstra point was that although in most languages it possible to write badly, in BASIC (the early versions most people used) it is hard not to ...

You can write badly structured programs in any language and you can write well structured programs in any language, but some languages encourage well written code and some don't ...

VB.NET is far far removed from the early Basics the same as C# has very little to do with C and Delphi.NET has very little to do with early Pascal

But Microsoft stuck with Basic because that is where they started, how much better would xxx.NET have been had it not been based on Basic ...?

I think Basic was a good start to learn about Statements and Expressions. But when it comes to structure and other concepts one is in the cold in Basic. I wish I had learnt Forth with the Jupiter ACE instead of the Sinclair Basic from the ZX81 ;) But, at that time it was more of an exploring adventure, and not much else todo where I lived 1981 :D

Great! It reminded me childhood. I have had an Goldstar MSX with Z80 CPU.

I started writing software when I was 11 and now I am a industrial software engineer.

Still using BASIC in both PC (VB 6.0, VB.Net ) and non-PC devices such as robotic applications (Trio-BASIC) and embedded devices.

I have thosands lines of code which runs for assembliy lines automation, quality control test devices (even thermal image processing) and all were done by BASIC.

BASIC may evolve, but I believe it will never die.

Old Guy said:

> Too many folks here don't seem to understand the fundamental truth
> of programming - the language is irrelevant. "It ain't the
> paintbrush, it's the artist".

That's because it's not a fundamental truth. A bad programmer will be bad in any language, but that is less true for average developers and some languages. And the bad ones will be worse in some languages (the gold standard here is APL, IME - you can't write readable code in it at all)

The point seems to be a version of "a poor workman blames his tools", but actually, tool quality *does* matter.

> And now that the only difference between C# and VB.NET

Dijkstra wasn't talking about VB.NET - you can't take his remark out of its historical context. Early BASICs *did* force you into bad habits, and it was difficult/impossible for many people to break them.

started with logo, go to batch scripts and only half a year basic in shool in the 80s. Pascal rules ;-)

Those books remind me of the fact that I tried entering in 3 different BASIC programs from books just like those when I was 11 years old or so. After the 3rd one wasn't a video game, I didn't touch a computer again until my second semester of college, where I eventually got a BS and MS in CS. Strange how first impressions are not always correct -- or are they? :) Even funnier that I've only ever done 1 other program in any form of BASIC besides those first 3... but I don't think that first experience had anything to do with it.

My first program was to calculate solution of a system of linear equations using Casio Programmable Calculator. It built a solid basis for understanding my next programming language FORTRAN.

I'll agree that most of us nearing 40 learned using some form of BASIC, for me it was the Timex Sinclair 1000, but I also must agree with the Dutch guy. While BASIC got me interested in programming it also hampered me by making C and C++ look harder than it is.

This is why I was so disappointed that Microsoft made VB.Net. There's no need for it. C# is the way to go, it's the best of both worlds.

Clocking in at almost-29 here.

Instead of buying me Chuck Yeager's Advanced Flight Simulator for my 7th birthday, as I'd begged for months and months and months, Mom and Dad grabbed me a Tandy BASICA programming book instead. It's been downhill ever since.

BASICA and GW-BASIC an QBasic taught me a TON. Basic structured programming, controlling flow, logic. They also taught me a lot about what I NEEDED but they didn't OFFER -- like encapsulation, events, all that other OO goodness.

In the 22 years since, I've programmed those flavors of BASIC, a little ASM, got into JavaScript in the mid 90s, was introduced to C++ in the later 90s, along with Visual Basic. I went on to teach myself Java, VB.NET, moving into C#, where I happily live now.

If it weren't for BASIC, I wouldn't be where I am now -- senior software engineer of a major managed care provider, CTO of a promising , socially-responsible startup, and all-around kick-ass consultant. Sure, it took 15+ years from my first taste of BASIC to start grokking OO -- and it's a continuous learning process still -- but I firmly believe BASIC was, and maybe still is, a valuable tool.

Had I known about Smalltalk, had I had access to C++ tools, would I have gone another route? Maybe. I certainly would now, if I had my druthers -- I'd love to be immersed in the raw power of C++. But am I unhappy with where BASIC has led me? Not in the least.

TI? Apple? Vic???? I learned BASIC-PLUS in Jr. High & HS on a *REAL* machine with 588K of honest-to-god *CORE* memory (magents and wires, kiddies, none of this RAM chip crap), hard drives bigger than my washing machine, up to 48 other users plugging away on the same machine, and sucking down more electricity per day than most 3rd world countries consume in a decade!

</sarcasm>

Christ, I'm getting old.

No joke. I leared BASIC-PLUS, BASIC-PLUS2, and Pascal on a PDP-11/70 in the mid- to late-1970s. I later became the sysadmin for the machine which ran like a champ until decommissioned in 1988 and replaced by a Prime that was about 1/8 the size, took regular 110 current, and didn't need an AC unit with a dedicated 2" water line to keep the room cool.

Today I carry around a USB drive in my pocket that has more storage than all of the disk drives on the 11/70 put together over the 13+ years it was in service and have fluency in something like a dozen different coding languages. We've come a long way, baby.

Fantastic post, Jeff!!!

flickrstolemymoney1?

just by reviewing some of the code of co-developers I'm quite sure that unfortunately the knowledge about programming paradigms and constructs did not increase since the good old basic days... all they know for sure is how to:
use a flag
use if-statements
use some looping construct

with this simple constructs it's almost impossible to depict current software problems efficiently and in a maintainable way, yet all they do is exactly that: basic coding in basic. (just the file ext are .cs or .java)

ask developers what an IF-statement does, all will know and understand
ask developers what the visitor/factory/command pattern does
or what the diff between Interfaces and Abstract Classes is, or how and when to use virtual methods, and you'll be surprised.

I'd really like to see stackoverflow to increase the common knowledge level in that area! ;)

I HAD THAT BOOK!!!!!!!

My introduction to BASIC was none other than the yellow "BASIC Computer Games" book you show in the post. I probably typed most of them into my trusty Apple ][+. That's hysterical.

Brilliant,

This takes me back. I used the fact that I could get BASIC with an Atari 400 to convince my parents that I could make my own games if they bought me one, and they did.

I think that BASIC was a great place to start. At that time (1984/85) our high school had a number of different systems, Apple II and IIe's, a pile of Commodore PETs, some TRS-80's and KayPro Luggables running under CP/M (Anyone remember that?). Though each of these system had their own flavour of BASIC, it was still BASIC and I could move from one system to another and confidently write programs.

I've since moved on to Java, PHP, and Perl but the foundation of my interest in coding came from a simple little program in BASIC.

10 print "Hello World!"
20 goto 10

I liken the effect of BASIC to that of Charles Shaw. Both provide an intriguing initialization to the vast world of programming/wine. While there is much to improve upon in both cases, it is ultimately the accessibility and affordability of the these options which sparks the interest of the budding programmer/vintner.

I essentially grew up on an Atari 800xl. There actually were a number of compiled languages for that old machine. There was a "Small C" implementation that I was actually able to use while learning C as an undergrad (when I didn't feel like heading to the computer lab to use the universality's VAX). The Atari 8-computer actually had a number of languages implemented for it in the 80's: Pascal, Forth, Logo, and a number of machine specific languages.

There was also a really cool language called "Action!" (circa 1982) which was really like an "ultra assembler". It took the idea of macro assembly a large step forward by introducing variables, loops control structures, functions, a primitive function library, etc. It sat somewhere between C and Assembly in terms of syntax and could generate standalone executable programs.

But I did learn "Atari BASIC" as a first language then dabbled in 6502 assembly. I wouldn't say that I was "mentally mutilated" by the experience... Though Java is my current favorite language, so some may disagree. :)

I remember spending many, many hours on my Atari ST with GFA Basic.

While reading this, I couldn't help thinking that BASIC was the original inverse Turing test. A Turing test determines whether a machine understands humans. For a lot of programmers-to-be, BASIC was the first confirmation of an innate ability to understand machines.

Personally, though, my first program was written in COMAL. As a Dane, I find that entirely fitting.

I can't express how fondly I remember growing up with QBasic. I have one of those books, too (the yellow cover one). :) This makes me want to dig out all the old programs I wrote and bask once again in that familiar blue glow.

This is an obvious plug, but I've written a book (it's in final editing stages) based on the book that taught me simple game programming in BASIC. My version is in Python (which makes it much easier to teach).

This book gives source code examples for games, much like the Atari books you linked to. I've found those most books on programming for kids either read like mathematics textbooks or don't teach programming so much as how to use "game creation" software.

I'm open to comments.

http://pythonbook.coffeeghost.net

Great article as I too learned how to program using Basic, I think I had the book on the right on programming Basic games. Without getting hooked on programming early, I doubt I'd be where I am today...which is why I loved working on the Non-Pro team building things like Visual Studio Express and Popfly to enable the *next* Anders to get hooked on programming early.

-Dan

+1 on the TI99/4a with Extended Basic Cartridge. Alas the *hours* I spent locked up in my room in the early 80's at the tender age of 13 figuring out how to write a space invaders like game with sprite graphics (I could only ever get the laser to take out an entire column of invaders at a time). The image of the little stick figure generated by CALL CHAR 995A3C3C2424 will be forever and indelibly etched in my brain. And long live the Pirate Adventure cartridge. Give fish to crocodiles. Say Yoho!

The article brought back fond memories of my TRS-80, and the things about performance, speed, and virsatility in development that it taught me. I never believed (and still dont) that I know everything I need to be a great programmer/developer. I still study new techniques, new languages, and try to bring everything together to build the best individual product that I can. I'm also not unwilling to revisit old code... and improve on it. I write mostly thin client now, and I find that ASP has many of the same issues with it as early basic had ... performance = 1/(size*speed). Perhaps the guys who write MS Office and Vista should be required to spend a year writing software for the TRS-80 Model I. If it can't be stored on the tape drive and loaded into 4K ram, it can't be released!!

The BASIC Dykstra knew "in the day" bears about as much resemblance to VB-dot-anything as does an ox cart to the automobile. They both have wheels, and both can get you into accidents if you aren't careful.

I learned about "real programming" which at the time meant "structured programming" after learning TRS-80 BASIC, a dialect somewhat better than Dykstra's, though not much.

What was interesting about the structured programming course was that while it Taught structured programming, the FORTRAN dialect (FORTGI under IP/CMS iirc) didn't really support it. This lead to lectures along these lines:

"This is a while loop...."

"And THIS is how you implement the while loop in FORTGI..."

That involved inverting the test condition and an unconditional goto to get back to the initial test.

Several years later I was using QuickBASIC, which supported all the structured programming constructs one might want, while hearing about this new language called "C" ...

There was a Pascal compiler for the ZX Spectrum. I remember seeing a compiler advertised, but didn't every see a copy of it.

From http://usuarios.lycos.es/scratchupload/spectrum/ it appears that the manufacturer was HiSoft.

August 1985 ... Scientific American; Martin Gardiner's "Mathematical Recreations" carried probably the first popularization of Mandelbrot sets and all that. That's when I learned to do what I did so often later: on my C=64 I wrote a "microscope" in BASIC, using it to call BIOS and hand-crafted assembler routines. A coupla years later I did the same using the original QuickBasic 4.5 on an XT: use BASIC to string together Fortran routines for the math and C routines for mouse and graphics.

It's quite possible to write good code in BASIC ... it just ain't likely!

thanks for this walk down memory lane

--bentrem

I'm surprised no one has mentioned the Micro Adventure books!
http://en.wikipedia.org/wiki/Micro_Adventure
These were essentially a beguinner's guide to BASIC, with a fun storyline to boot. I think I had most of them as a kid; I wonder if my parents have thrown them out already. I loved trying out the programs in them. Those were the good old days.

> And long live the Pirate Adventure cartridge. Give fish to crocodiles. Say Yoho!

Oh my God, I hated that text adventure! I don't think I ever got out of the first room, with the rug nailed to the floor..

http://www.gamesetwatch.com/2006/07/gamesetinterview_adventure_int.php

Dijkstra doesn't backup any of his statements. So I see him as just another religious nut who thinks his way is the only way.
A piece from Code Complete comes to mind. We write WITH a programming language, and not IN a programming language. Meaning that we should use languages as tools and not as a distraction.

I guess kids of this generation ( that includes me ) are lucky because we have Python ! The first time I saw basic, it was in a computers class in school and I hated every bit of it. It looked disgusting. Python was excellent. The indentation, the readability.... paradise. Python has excellent documentation and a community that loves teaching first-timers. I believe I saw a comparison once:

"Python is to Basic as Optimus Prime is to a truck."

At least GOTO doesn't let you jump to a location that is outside your program or doesn't contain an instruction. Infinitely more damage has been done by improperly used strcpy() and pointer arithmetic than by GOTO.

Great post Jeff. Like most here, the memories... thanks.
The first time I saw that comment by Dijkstra, some time close to getting my CS degree, I felt a wave of guilt, confusion, almost hopelessness. I didn't know at the time, when I was 9 and I got tired of playing the Star Raiders game that came with the Atari 800 and my dad told me after dropping all that money on a computer I had to write my own games using Atari Basic, I was crippling my mind and coding ability and future. And after expending every keyword, learning how to peek and poke memory, digging even a little into assembler, I didn't know I was dooming myself. And through the nights of GW-Basic, then QBasic, I didn't know I was sentencing myself to...
Hey, wait a sec, I picked up OOP the same way, code C#, C++, Java, PHP, VB.NET, vb circa 5.0 & 6.0.....
As much as I respect Djikstra and his contributions, Basic is what it is ... A GATEWAY DRUG :)

you don't necessarily gain much by looking at things dijkstra slagged off. you can find a quote from him dismissing virtually any technology of the data with much venom and vitriol.

Major flashbacks here too. I had that Atari cartridge too. Got bored pretty quickly when I realized that no persistent storage=waste of time.

I guess I qualify as one of the ancients too. I wrote basic code on:
The Atari 2600 Cartridge.
Commodore 64
Apple II, II+, IIE, etc.
ColecoVision Adam
GWBasic/QBasic on a 286, 386, 486.
VB4 through .NET.

I guess that pretty much means my mind is permanently warped.

I also had every one of those books you showed. I used to also like typing programs from magazines too.

It's amazing what you can find at the back of your bookcase:
http://theamicableprogrammer.blogspot.com/2008/04/my-old-basic-programming-books.html

Jeff,

I started reading your blog not too long ago, and I enjoy it. You've got a fresh approach that's more personal than most technical blogs and more technical than personal blogs. I like the fact that you give thought to the IT industry and approach them from an intellectually honest perspective.

Usually, I find myself nodding in recognition when you talk about experiences growing up as a technically oriented kid. I wasn't quite on board, though, when I started reading your blog entitled “Everything I needed to know about programming I learned in BASIC”. BASIC was a long time ago for me, and my my memories of it do not exude a rosy glow. I was thinking that maybe Edsger Dijkstra's position wasn't all that outrageous. I didn't count BASIC as the foundation of my career.

My attitude changed when you reprinted the graphic of the covers of the “BASIC Computer Games” books. The effect was somewhat akin to finding an old scrapbook and discovering that I had spent my childhood in China, but that I had forgotten about it. If you had just cited the books, it would have meant nothing to me. But seeing the pictures of the cheesy computer/robots brought a visceral reaction.

I read the post again. This time it came right at me. It reminded me of writing BASIC on the Apple II's at my high school's computer lab. It reminded me of when one of my first girlfriends asked to me to “teach her how to program computers” -- so I wrote her a BASIC program on my Commodore 64 that put her through a battery of questions that seemed super suave to my hormone-addled brain. The relationship didn't last, but the program was the least of it. Although, the experience snuffed out any small hope I had that programming skill would impress girls.

The most startling memory, though, was about a sequence of events that happened when I was in grade school. My school got a Commodore PET – the first computer I ever got to touch. They put the computer in the library, so all the kids saw it – but some administrator had the idea that only the kids in the “gifted” program would be able to use it. This, of course, was an act of breathtaking stupidity by the faculty. Not only did it reinforce the notion that we kids were different, but it rubbed the other kids' noses in the fact that we got a privilege that they did not. Any time I wanted to use the computer, I sat in the middle of the library, surrounded by kids who could not. Put that unpleasantness aside, though. I was happy to use the computer, under whatever terms I needed to.

The Commodore BASIC that it ran felt natural to me. Line numbers, GOTOs, GOSUBs – loved it. I recall some quantity of stilted documentation, but I couldn't tell you whether it was in a spiral binder or something more permanent. It wasn't long until my interest turned to creating games. I had an idea for an outer space game. The details are lost to me, but I remember it being conceived something like the modern version of minesweeper. You had a series of spaces on a grid that you “explored”; sometimes there would be enemies and sometimes there would be treasure. Or something like that. There were no graphics, of course. Just a command line and feedback, based on your choice of quadrants.

I remember working on it when a teacher got interested. He was the adviser to the gifted program, and probably the one who had a brainstorm about restricting the computer's use. We talked a lot about it. Went over the code, the algorithm, etc.

At some point, the teacher gave a demo of the game to one of my classes. I kept expecting him to mention that I wrote and “produced” the game. He never did. He took credit for the whole thing. It was disturbing and confusing to me that an adult, much less a teacher, would do something like that. Even thinking about it now, with a lot of years between then and now, it's a difficult memory. Something like this is impossible to analyze rationally. Maybe in the teacher's mind, giving me the opportunity to use the computer was just as important as what I did with it. I never talked with him to find out what he was thinking. Maybe there was a perfectly good reason that I can't tease out. Maybe I've distorted it in some way.

It's also difficult to put the memory into context. Even though I programmed throughout my youth and loved it; it took me several years in the workforce before I gave serious thought to making a career of software development. Did the intensely negative experience have any contribution to that? Or did it not really matter? Until I read your column, I hadn't even thought of the issue for – I don't know – 10 years, 15 years. Maybe longer. Maybe I would have a similar gut reaction if someone wrote a piece about youth swimming, and it brought back a memory of being DQ'd after winning a race.

Wow. Kind of strange this much heat came from a technical blog post, not strictly on this topic. But those robots, man. Those crazy, cheesy robots on the cover of those books.

Keep up the good work.

No new blog today (April 30th)? Someone must be playing GTA4 on their home theater.

Wow! I had not heard that quote in 10+ years. I think I heard it from my C teacher in college for the first time. I personally want to thank the creator of BASIC. It has netted me a career for 20+ years now. I still work in BASIC. (Ok, VB.NET.) But still a warped and twisted form of BASIC.

I spent years on TRS-80 mod iii and my Timex-Sinclair with a lousy 12 inch BW tv punching in code. Although, BASIC lead me to assembly because there was some stuff I could not do in BASIC.

I always considered BASIC a gateway drug.

Great article.

Dan...

C64, Ti83+ BASIC, Javascript
That was the order in which I learned my first three imperative languages for dominating the machine.

Anyone that had more that 4K of memory is a pussy, 'nuf said.

Maybe I am the only one person alive that thinks BASIC is not worse than any other language. Think of it: you can write crap in PERL, Java, C#, Lisp, FORTRAN, you name it. Ever heard the expression "write-only code"?

Fact is, BASIC as an intro to programming is awesome.

With kids it is about getting them "hooked"... BASIC did that for me starting with an Atari 400 and then an Atari 800. I actually started coding at around 6 years old... when I got to 10, I'd spend hours reproducing the code from magazines.

From there graduating up through the versions of BASIC (GW, Q, etc).
On to VB3 and 4 which I found fascinating, if not difficult for making valuable software. Still very cool for the groundbreaking concepts of "Visual" development and the IDE.

Then VB6, which while often produced spaghetti code, really could make some useful stuff. OOP... no... useful, yes.
Ignored VB.net until asp.net 2.0... .net 1 was awful, but I guess it did have some OOP oportunity.

Finally OOP in VB. (asp.net 2, 3, 3.5)

I respect C#, and can code in it, but why???
Why relearn syntax I already know like the back of my hand just to use braces and save a few words?

In the end, the code will be parsed by the .net runtime anyway, so there is not an appriciable difference in the cusotmer's product or performance.

VB.net is NOT the same as BASIC used to be. From where I sit, VB, C#, is just which syntax you prefer. You can use the same techniques in VB as C#.

BASIC as a beginners language does teach the most fundamental concepts of programming; MOST importantly it opens up the idea that "I" can actually make a computer do what "I" want it to.

That is powerful stuff... and I think more important now days when kids are just used to googling to find what they want.

To me coding is a creative effort, and if BASIC lets people express their creativity, why knock it?

Are there more efficient (even necessary) programming methods, you bet... but let's at least give BASIC the credit it deserves!

BASIC.. oh, the nostalgia. I had a program called "Learn to Program BASIC" by a company called Interplay, in 4th grade. I've since become a C# developer for web applications. I don't really see how learning BASIC could hold one back.. if nothing else, it gave me the initial passion for development.

http://en.wikipedia.org/wiki/Learn_to_Program_BASIC

I grew up in India long before anyone there heard of IT. I used to go to 'Digital Computers' when I was 12 dragging a water bottle where a man in his 60's used to teach BASIC. Beyond programming, I got to BASIC graphics from there.

I must admit though, that BASIC was my second step to programming. LOGO with the obedient turtle was the first language I got to.

As I graduated from Engineering, my friends were all into VB, VC++ etc. and were quite shocked when I used GWBASIC to interface to a 320x240 LCD display through the printer port. Ah.. good times.

I learnt to program with BASIC, but it's not enough. See my recent blog post:

http://www.justsoftwaresolutions.co.uk/design/c-basic-and-real-programmers.html

I still have my Basic Computer Games: Microcomputer Edition book (the one with the yellow cover) that is shown above. In fact, it isn't in a box... it sits up on a shelf next to my desk along side a "Best of Creative Computing" book.

While a lot of people were not looking, Basic grew up. Those who judge Basic by what it was years ago are showing their ignorance. What other programming language has not only lasted as long as Basic, but also has the popularity of Basic?

When Basic is compiled, the compiled code is no different than if had been written in C# or C++. Granted, other languages have some capabilities that are lacking in Basic. Each languange has its advantages and disadvantages as well as its place and purpose. Elitist snobbery reveals immaturity, no matter how many degrees one may hold.

Patrick - while it's true that compiled VB.NET code is MOSTLY the same as compiled C# code (there are actually a few counter-intuitive differences), C++ is an entirely different beast.

Also, when you refer to Basic in this context - please say VB.NET. There are several BASIC dialects that have nothing to do with .NET, thereby potentially making the C# comparison invalid.

But I agree, there's no point in bickering about which is better between C# or VB.NET.

Thanks for pointing out those facts, KG. My amateur status as a developer is showing.

Yes, I had forgotten that C++ was designed to drive developers into absolute incurable madness, or so I am told. <grin><Just a joke I am not picking on C++. It is just my way of acknowledging the hard work and skill it takes to program in C++>

Most programmers I know work with several programming languages and have to work hard to keep up with the changes in software development. The days when one could program in one language alone appear to be over. It would be rare to find a developer who has not had the need to work with HTML, XML, Javascript, and SQL(pick your brand) as well as a number of other programming languages.

BTW, if someone wants to persuade me of the virtues of a particular brand of code, tell me about the great features and capabilities of the code. Bashing some other code is not appealing.

Please note that my comments about C++ was an attempt at well intended humor. The Website mistook my "grin" enclosed in angle brackets as HTML!

The truth is I admire those who have the dedication and ability to use C++. That comment was removed from my last post also.

Qbasic was the first programming language other than HTML that I wrote a actual usable program. Though I could only write programs that made sounds and basic text RPG's, press 1 to do this and 2 do that. I got my compiler off my Windows 98 CD.

I started programming in BASIC on an Apple II 8 bit computer when I was about 11 years old. Because BASIC was slow I learned Assembly. Later I learned Pascal, C and C + +. Now I am a PHP, MySQL, JavaScript Web Developer but I graduated not in Computer Science but in Electronic Engineering.

BASIC is as it suggests beginners code and there is nothing wrong with that. What I like in BASIC is that it is basic and simple. That's the fun in it. You can create hobby programs in minutes and teach someone to program in no time. And there is no need to compare it to C/C++ type languages (or Pascal type) because that is not the purpose of the language. It is not invented with the purpose of creating Operating Systems like C.

If you begin programming as a teenager BASIC is a good choice. But also it is very bad to get stuck in it only. Today to simply learn one language is not enough. I use about 5 (PHP, SQL, JavaScript, HTML, CSS, XML and etc.) to do my work and I also try some code in Java, Perl and Python.

There is no such thing like a Best Computer Language. Every one of them is stronger in one area and weaker in another. I thought C/C++ would be great to program until I realized it behaves so differently from compiler to compiler and from OS to OS. I had a very difficult time debugging it.

My advise to someone who wants to begin in programming is to learn a widely used language like Java, C/C++, PHP, Python and etc. And if you would like to develop web applications then HTML is a must. You should dream in HTML. However there could be no serious programming without some use of C/C++ or Delphi.

Thank you very much for this post. It reads so true.

For me, the journey started with the Atari 2600 and approx. 10 games I bought with my saved money(Adventure being my favorite - that DOT easter egg was the best).

Then thanks to my suppotive parents, who put their faith in me and believed in my dream, purchased an Apple ][+ with floppy drive and green phosphor monitor III for me ($2000 back in 1982, I think). Here I spent most of my youth, not playing only video games (I loved video games), but learning through programming. First in Applesoft, and later (when I could not get my written games to run fast enough in Basic, in Assembler).

Amiga 2000, and later PC's followed, but none with the intensity of the Apple ][+. I had become a WIZ, fluent in computer logic, even thinking in Base16 arithmetic when needed. So what if I had to drop GOTO later on; it was not such a hard habit to drop.

This computer experience helped me through Turbo Pascal, Cobol, Fortran, Assembly, and all other forms of computer courses that I took through my schooling. I breezed though every singe related course thanks to this (high school, college, and university).

Now at 40+ years old, senior Electical Engineer in a company I've worked at since 16+ years with Electrical Utilities, I look back with nostalgia and am so thankful for my Atari 2600, my parents support, the Apple ][+, War Games, and Tron; all key factors that formed the person I am today.

Borrowing the words from Skinner above, "I wouldn't trade that early experience for anything". Period.

May our children find as much magic in their youths.

Thank you for listening,
TZ.

After learning Sinclair BASIC and doing loads of poking, peeking and typing in reams of code that never worked from ZZAP! magazine, I used to write simple games in GWBASIC on the 8086 on long nightshifts at work. Following a brief sortie into AmigaBASIC I went to nightschool to learn "C".

Now I can't stand the sight of a programming language, and besides, you can get most software you want written a lot better than I could do it nowadays.

I guess I'm a Shoat.

the key controllers reminds me of a hp?8 calculator ^^ ( which is lisp enabled , something i didnt understood until 10 years after buying it ¬_¬ )

REAL programmers use: COPY CON > PROGRM.EXE

But seriously, I have lobg felt that the biggest disservice that Microsoft did to professional VB programmers was to promote VB as "easy". That brought out the folks who didn't know how to anything but plop down controls & wire them up (and that badly).

I played around with BASIC in high school on a PDP-11, then didn't do much with computers 'til years later. Started the mainframe program at a trade school with BASIC on Commodore Pets, then moved over to the IBM System/360 for COBOL, Assembler (fun!) and RPG (yes, there is at least one BAD language...). A few years in ops, then more in restaurants before I came back to software with VB 3. Skipped 4, worked extensively in 5 & 6. Now I'm getting my feet wet with VB.NET and following along in C#. All versions of VB with which I've worked have been fine languages (for their time) IF you had the conceptual framework with which to build a proper structured (not necessarily "Structured") program.

How far the discussion has gone! The point was that BASIC isn't the "goto hell" language as some have suggested. Sure the home computers back in the day had limited capability, and the need for a programming language to make them accessible was dire; thus BASIC was what was best for the job. Any evils for "spaghetti code" done in the way are way compensated by the availability for young people to actually code on a machine.

Sure some people who weren't serious about it in the first place write spaghetti code today, but that's hardly because BASIC was their first language, it's because they're lazy. The 1980s home computer revolution was the forerunner of todays computer in every home. I did learn the wrong way of programming with Commodore 64 Basic, but I learned not to do the "goto hell" stuff pretty quick.

Clarification for my previous comment: I quickly learned to use subroutines for doing all the stuff that is done again and again, and the spaghettification (i.e. goto statements) went to the minimum. My programming on the Commodore 64 tended towards object oriented stuff. Using kernel (OS) calls was a must to do any real stuff too.

I gotta end my comment spree with an anecdote:

My first program when I was about 6 years old consisted of print and end statements, in the style 10 print "If you want to do this, type run 50" etc. I tried to save the program on tape. My elder brother whose computer I was programming on came to help me to troubleshoot why the program wouldn't load again. He finally asked did I press the record button together with the play button on the Datasette. I was embarrassed. And he said "user error." User error is still the culprit in most problems. :)

you can still make basic stuff in Liberty Basic, and do awesome things like cut paste copy you couldn't do before. I use to make all kinds of tiny role-playing games, i don't know why, but i made another one on the link above and am finishing up another one to put up soon as well. those 2 books stuck out in my head instantly, i had totally forgotten about them, i used to program basic on a TI-99 with those books. one of the programs that i still remember was a virtual psychiatrist named Liza i think, she would ask you all kinds of questions and what you answered would move her on to the next question. There were also some huge programs that were fun (hunt the wumpus?). anyways thanks for the memory rehash! =)