Why Teach Programming With BASIC?

chromatic writes "To answer the perennial question 'How can we teach kids how to program?', we created a web-based programming environment. As we began to write lessons and examples, we surprised ourselves. Modern languages may be powerful and useful for writing real programs, but BASIC and Logo are great languages for demonstrating the joy of programming."

Comments

Use C#

[Anonymous Coward]

I've never loved programming as much as I do now that I use C#.

Re:Use C#

[Haffner]

Agreed. As a former Java coder who had to move to C++, moving to C# after those two makes it so much simpler.

Re:Use C#

[Sam36]

Java VM is written in C idiot

Re:Use C#

[shutdown -p now]

C# forces one to think in OOP terms - you can't write a hello world app without "class" in it. Now learning OOP is definitely the important part, but it's not the one that should come first - before that, one has to understand the basic blocks of algorithms. Conditionals, loops, recursion - that kind of thing. A language that lets you deal with those without bringing any unnecessary stuff into picture is the language you want to use for teaching programming. BASIC is one such language. C# is not.

Re:Use C#

[togofspookware]

I thought he was making fun of reporters when they try to talk about computers.

Re:Use C#

[Ethanol-fueled]

You are now a n****r. Deal with it, n***a

But may I be a Gay one From Outer Space?

Re:Use C#

[Anonymous Coward]

C# forces one to think in OOP terms - you can't write a hello world app without "class" in it.

It amazes me how people think you're doing OOP just because you're forced to do procedural programming in a class the few times you have to do it.

Re:Use C#

[shutdown -p now]

You're not "doing OOP" when you're writing a hello world app in C#, of course. But you still get all the extra syntactic and semantic baggage that comes with C# being an OOP-centric language. And when you're teaching someone to code, you have to either explain it, or ignore it - the latter not being a particularly good education technique. It's like teaching basic arithmetic on equations, telling your students to "ignore that X thing for the moment".

Re:Use C#

[FrootLoops]

My first* programming language was Visual Basic 6. For those who don't know, it used "OOP-lite"--you never had to define your own classes, but you had to use some objects (controls/widgets, for instance). I remember following a short tutorial and teaching myself from there. It wasn't awful for me to learn UI design, basic code blocks, and basic object oriented programming simultaneously by random internet examples and the documentation. (This was back in middle school, and nobody I knew knew how to code so I couldn't ask about it.)

So, I think some level of OOP in a learning language is fine. C# is probably too much. Python in an interpreter might be about right. One thing VB6 encouraged me to do was start my own projects and learn through them. If I was using a simpler but less powerful language I wouldn't have cared enough to get very far.

*I had experimented with MS-DOS batch programming a little bit, including some rudimentary If's and GoTo's. No loops or functions, almost no variables. I'm not sure how much I learned before starting VB6 anymore.

Re:Use C#

[shutdown -p now]

My first* programming language was Visual Basic 6. For those who don't know, it used "OOP-lite"--you never had to define your own classes

Actually, VB6 did have classes (class modules is what it called them). It didn't have inheritance, but it did have interfaces, and you could use delegation (manually coded) to simulate it. Most importantly, it had true OO polymorphism. So it was technically an OOP language.

On an unrelated note, one nasty thing about learning on VB (or Delphi, or a similar RAD environment) is that it lets one write really nasty code - the "magic button" syndrome is often acquired at that stage - while the output looks conspicuously like a "real program". It's quite easy to fall into the trap of thinking that you already know quite enough for real-world programming. For those who can avoid it, yeah, it's a good introduction to component-oriented / "lego bricks" development.

Re:Use C#

[SanityInAnarchy]

I think Ruby fits that bill better than BASIC. Starts out without needing the baggage, but when you're ready for structured programming and objects, it's all right there.

And you avoid learning GOTO. I don't care how easy it makes initial learning, it's building bad habits that you're going to spend years killing.

Re:Use C#

[shutdown -p now]

Agreed, but I think Python is even better for that purpose - less things to deal with. And it has a decent turtle graphics library, which is a very good learning aid.

Re:Use C#

[nzac]

Ruby is a terrible language to teach programming, there is so much stuff that needs to be used responsibly. While the language is nice to read, monkey patching and other stuff should not be an option for someone learning programming basics.

For teaching general programming in my opinion is the best language by far. The 'Zen' structure provides consistency when learning the language. The only thing i don’t like about python is the using indenting instead of end or ;.

Re:Use C#

[Anonymous Coward]

The problem with C++ is that it has to run in a slow interpreter, which adds overhead and makes things slow.

Ur doin it rong.

Re:Use C#

[kthreadd]

And you avoid learning GOTO. I don't care how easy it makes initial learning, it's building bad habits that you're going to spend years killing.

Now what's wrong with goto? It's a perfectly valid statement when used appropriately, just like any other statement. What's wrong is this old dogma that tell young people to not think for themselves and instead just repeat what everyone else says.

Re:Use C#

[plopez]

Agreed. Based on bitter experience much of the "OOP" I have seen over the years has just been "COBOL in drag". I even tried to tried to teach a class on it where I was working and with in 15 min. my manager, who considered himself to be an OO programmer shut me down. He didn't get it when I started talking about leveraging patterns, aggregation, base class calls, MVC, among other things.

This pretty much undermined my position as a team lead and senior staff at the place. I left about 6 months later.

Re:Use C#

[shutdown -p now]

Python treats whitespace as syntax.

Yes, and that's one of its stronger side. Using whitespace to delimit blocks of code is very natural to someone with no programming background.

That was demonstrated to be absolutely stupid 30 years ago.

It was?

At least the FORTRAN fucks had an excuse with punchcards

The way FORTRAN used significant whitespace has nothing in common with the way Python uses it, except for the fact that it's significant.

No offense, but take a breath

Judging by the overall tone of your post, you should really take your own advice.

Re:Use C#

[SanityInAnarchy]

Yes, and that's one of its stronger side. Using whitespace to delimit blocks of code is very natural to someone with no programming background.

...yes and no. Yes, it does help that it visually looks close to what it should...

But a tab is different than a space, and that's going to confuse some newbies.

Re:Use C#

[SanityInAnarchy]

Ruby is a terrible language to teach programming, there is so much stuff that needs to be used responsibly.

In what way is it different than any other language?

Basic has GOTO. Java has ==. C and C++ have pointers, pointer arithmetic, memory allocation, etc, on top of goto and similar == problems.

monkey patching and other stuff should not be an option for someone learning programming basics.

Practically, it isn't. Someone learning programming basics likely wouldn't run into monkey patching.

Re:Use C#

[SanityInAnarchy]

I actually did think for myself when I rejected GOTO. I actually went back and read the "GOTO considered harmful" essay.

Can you provide an example of when goto is appropriate -- in particular, when it's appropriate to use a goto rather than actually structured programming, or even a safer option like break, return, or throw?

Re:Use C#

[shutdown -p now]

But a tab is different than a space, and that's going to confuse some newbies.

Personally I think they made a mistake in that regard, and should have outright prohibited a mix of tabs and spaces for indentation within a single file. In practice, though, it's not a big deal - everyone sane just uses spaces anyway, and most (all?) Python IDEs are configured that way out of the box. There's simply no way you can easily insert a tab in the middle of the code there.

Re:Use C#

[narcc]

I actually did think for myself when I rejected GOTO.

Did you reject GOTO as a way to forever avoid writing anything in assembly?

I actually went back and read the "GOTO considered harmful" essay.

Yeah, Dijkstra was *pissed* that Wirth changed the title. -- You know, because it misrepresents the content of the letter. (letter with original title)

Can you provide an example of when goto is appropriate -- in particular, when it's appropriate to use a goto rather than actually structured programming, or even a safer option like break, return, or throw?

Why, Yes, I can. How about an example from the Linux kernel which is very well defended by Linus Torvalds? Good enough for you?

Re:Use C#

[AndGodSed]

Its Caucasian.

Way to try and be a white supremacist and spelling your race wrong.

Re:Use C#

[AndGodSed]

And then I type its instead of it's.

Have at it. I deserve that.

Re:Use C#

[Hognoxious]

One, to avoid repeating cleanup/logging code when an error occurs within a deeply nested conditional. There are many who disagree with the use (or overuse) of exceptions, especially when used to control normal flow rather than catching true errors.

Two, when you're writing in assembler.

P.S. reading an essay, especially a polemic one, hardly counts as thinking for yourself.

Re:Use C#

[FrootLoops]

I was careful to say "you never had to define your own classes", instead of "VB6 doesn't allow you to define your own classes". I've used class modules (though they suck, compared to other language's classes). By "OOP-lite" I meant the programmer could avoid dealing with most of the complexity of OOP very easily, not that it was entirely absent from the language.

Nasty code was certainly a problem of mine. Some of what I wrote was just awful. I think a whole bunch of that was because I taught myself and had nobody to review my work, which isn't the case in the classroom-style setting of the original question.

Re:Use C#

[mwvdlee]

If within 15 minutes of teaching OOP you're already discussing patterns, aggregation, base class calls and MVC, you're probably moving too fast. Okay, perhaps not base class calls, which are pretty fundamental.

All those concepts follow only after you discover that OOP isn't a magical bullet either, and can get you in just as big a mess as procedural code. COBOL has structured methods and patterns, so does OOP, but that doesn't mean you should start out teaching those before teaching what those methods and patterns actually apply to.

I'm assuming this was "OOP for beginners".

Re:Use C#

[mwvdlee]

Yes, and that's one of its stronger side. Using whitespace to delimit blocks of code is very natural to someone with no programming background.

...yes and no. Yes, it does help that it visually looks close to what it should...

But a tab is different than a space, and that's going to confuse some newbies.

Which, IMHO, makes it bad.

Whitespace should be used to make sourcecode easier to read. Forcing a specific way of using whitespace makes it harder as I'm unable to line up things to show relationships or patterns in code.

Should a programming language give you the flexibility to creaty both true beauty and utter shitpiles or should it force mediocrity all the time?

Re:Use C#

[nzac]

Monkey patching is probably a bad example when i think about it.

The main reason i was thinking of is that there are multiple ways to do the same thing. Some generalized example would be:
Different syntax for writing blocs one or multiple lines
For/while loops can use *.each, num.times ... can be use to generate the same resault (where to use each one is not immediately obvious if your witting your first program)
Procs and lambdas

These make the code readable as English with poor syntax but hide basic coding structure.

Mainly python is a similar language but just so much better for teaching programming, i can see no reason to pick ruby. I prefer ruby as a language because of the choices but they are not beneficial to new programmers

Re:Use C#

[smash]

The thing is, BASIC encourages use of GOTO, rather than being an unusual thing to use when unusual circumstances call for it. If they call for it.

Using goto everywhere creates code that rapidly becomes an unreadable, unmaintainable mess for anyone else trying to follow it.

Re:Use C#

[Yetihehe]

State machines in embedded processors? I've actually had to use GOTO recently just for this one thing so that program would fit in memory, using functions would be too wasteful.

Re:Use C#

[serviscope_minor]

And you avoid learning GOTO.

What the hell is it with the BASIC detractors just making stuff up? BASICS with full structure have been available since 1982. That's 29 years ago. Seriously, loose the mullet and the walkman and join the present day.

Re:Use C#

[badpazzword]

Whitespace is only meaningful when it separates statements (newline) and it structures code (spaces/tab for indentation). Although the Python coding style suggests against lining it, you can line things up to your heart's content.

This is legal Python:

def my_func_params_let_me_show_you_them(
            foo = 1,
            bar = False,
            egg = None,
            spam = [][:],
        ):
    pass

Re:Use C#

[badpazzword]

Yes, I know mutable objects are a no-no as a default parameter; copying doesn't help. I said it was legal python, not good python.

Re:Use C#

[Anonymous Coward]

Anyone who says goto is always bad has never had to write a significant C program that needs to do resource cleanup on error conditions.

Re:Use C#

[SanityInAnarchy]

Did you reject GOTO as a way to forever avoid writing anything in assembly?

Perhaps. I certainly reject it when I'm not forced to write assembly.

it misrepresents the content of the letter.

I'm not sure how the original title makes it any better.

Good enough for you?

Probably not, but let's see:

they are often more readable than large amounts of indentation.

Solution: Use two spaces to indent.

But I think the most telling bit is this:

That said, I have used exactly two "goto" statements in all the lines of C,
C++, Fortran 95, and (yes) COBOL I've written since leaving BASIC and
Fortran IV behind. In one case, a single "goto" doubled the speed of a
time-critical application; in the other case, "goto" shortens a segment of
code by half and makes the algorithm much clearer. I would not use a goto
willy-nilly for the fun of it -- unless I was entering an obfuscated code
contest ;)

So, I take it back -- there are cases where a goto might be nice. However, they do seem to be about that rare, so I wouldn't want them in an intro to programming any more than I'd want pointers.

Re:Use C#

[SanityInAnarchy]

One, to avoid repeating cleanup/logging code [c2.com] when an error occurs within a deeply nested conditional. There are many who disagree with the use (or overuse) of exceptions, especially when used to control normal flow rather than catching true errors.

Why is a goto better than an exception in this case? Seems to me that things like break, return, and exceptions are effectively goto, but somewhat more structured and safe.

Two, when you're writing in assembler.

Fair enough.

Re:Use C#

[digitig]

Yeah, ideologically Python is all wrong and should be terrible. Trouble is, when you actually come to use it, it's great. So religiously you're right, scientifically the post you replied to is right. Evidence beats dogma.

Re:Use C#

[digitig]

Personally I think they made a mistake in that regard, and should have outright prohibited a mix of tabs and spaces for indentation within a single file. In practice, though, it's not a big deal - everyone sane just uses spaces anyway, and most (all?) Python IDEs are configured that way out of the box. There's simply no way you can easily insert a tab in the middle of the code there.

And Python (optionally) warns you if you mix them anyway. Just teach that as a mandatory option.

Re:Use C#

[cstacy]

And you avoid learning GOTO.

What the hell is it with the BASIC detractors just making stuff up? BASICS with full structure have been available since 1982. That's 29 years ago.

I think it's a little longer than that: the BASIC on the HP3000 had structured programming (and other modern features), in the 1970s.

Re:Use C#

[serviscope_minor]

I think it's a little longer than that: the BASIC on the HP3000 had structured programming (and other modern features), in the 1970s.

OK, I guess he needs to loose the flares and ghetto-blaser, then.

I'm not an expert on BASIC history. I was thinking of BBC basic, which I used a lot. It debuted in '82. It doesn't surprise me much that it wasn't the first BASIC with structure.

Re:Use C#

[BeanThere]

And you avoid learning GOTO. I don't care how easy it makes initial learning, it's building bad habits that you're going to spend years killing.

This is a common criticism - that you will spend 'years' killing the 'bad habits' you learned from using GOTO. I don't buy it. When I learned programming (on BASIC, back then, as a kid, that was 'the' language to learn on), and I progressed from GOTO's to subroutines, it didn't take me "years" to undo the "bad habit". On the contrary, the moment that I understood I had a better tool for so many jobs, I immediately started using that instead. Why would a programmer keep using a tool if it's much worse for the job? It just doesn't really happen. As soon as your programs get longer than a few hundred lines, or you want to start re-using code, you need something better than GOTO anyway ... it's really only useful on a very small scale, it is naturally self-limiting in use.

Also, I think GOTO's have one advantage for a learning language aimed at small children: It's easier for a child to learn and understand, as a building block / stepping stone toward more complex things. For some reason, I even remember this learning process (using basic, that was popular then) when I was a small child, on our 48K ZX Spectrum ... GOTO's were easy and obvious, but I recall seeing these weird GOSUB things that seemed more abstract somehow. But, once they were explained to me, it wasn't that bad.

Finally, any good programmer needs to do significant amounts of assembler at some point in his life, and you're gonna be doing lots of JMP's there anyway, and yet nobody considers that 'learning bad habits', because most people agree that learning assembler makes you a better high-level coder too, and there are reasons for that.

The criticisms against GOTO are largely exaggerated.

I have spent probably years cleaning up and maintaining other peoples really bad code. And yet, of all the horrors in the code I had to maintain, I don't recall once ever encountering a "GOTO problem" in the real world, where any programmer had made a big mess because they had learned GOTO's. Never. I've never seen it, and I wonder if anyone here has actually seen this mythical disaster that learning GOTO's supposedly leads to. There are many other bad habits that cause FAR more damage in real-world programming, and yet nobody even cares to teach those in formal Comp Sci or Engineering programs.

Re:Use C#

[BeanThere]

The thing is, BASIC encourages use of GOTO, rather than being an unusual thing to use when unusual circumstances call for it.

But that doesn't matter, because programming itself naturally self-limits the use of GOTO. Why? Because they are only 'easy and useful' when your code is on the scale of hundreds of lines. As soon as you start writing "real" programs, with proper code re-use, GOTO's naturally fall flat all on their own and you NEED to use subroutines.

Nobody in the real world naturally encounters large numbers of programs that are only a few hundred lines long. This is something that by definition happens only in schools teaching programming n00bs.

If you are going to spend the rest of your life developing and maintaining several-hundred line programs written by children, then sure. But in the real world, this mythical threat simply does not exist.

Re:Use C#

[ta bu shi da yu]

Someone mod the parent up.

Re:Use C#

[arth1]

Lining up the LHS is one thing.  How about lining up the RHS?  Or components of a statement?  Like the below pseudocode?

int  x      = 0;
int  furple = 1;
long foo    = onevariablename
            + anothervariablename
            + athirdvariablename
            ;

How would you do something like that in python?

Re:Use C#

[Glonoinha]

When the language is designed to have code run primarily in a linear fashion and doesn't (generally) nest the code into more than one layer deep, then a conditional GOTO is just the ticket for flow control. It's not 'harmful' any more than a hammer is 'harmful' - give either to a ten year old boy and he's going to make a mess, but used in proper context neither is particularly bad.

The funny thing is - all the GOTO bashing by the same people that salivate at the opportunity to throw random exceptions in their code, have them bubble up the call stack and get caught three calls up the stack. Guess what folks : that's the most gnarly and evil reincarnation of the GOTO most of us seasoned professionals have ever seen.

As for why BASIC is such a good beginners language - it has nothing to do with any of the above. It's about instant gratification - when newbies don't know the first thing about what makes a computer tick, being able to copy-type a few lines of text from a book and run it, then start tweaking it and seeing what the changes do - THAT is what hooks the new developer and gets his mind working. All this talk about OOP and high level languages - just scares them off. Get the fundamentals (the way, way low level fundamentals like what a variable is, that it holds a value, that the values can be changed and displayed on the screen, that you can do math on the variables) out of the way first - like showing a kid how to hold a hammer, that you only use it to hit nails on the head to drive them into wood, how the nails hold pieces of wood together - and BASIC is perfect for demonstrating those concepts without all the infrastructure surrounding bigger languages.

(And I can't believe I just defended the use of GOTO. Damn.)

Re:Use C#

[arth1]

Can you provide an example of when goto is appropriate -- in particular, when it's appropriate to use a goto rather than actually structured programming, or even a safer option like break, return, or throw?

There are many examples, but my favourite is when program execution is nested so deep that you save a LOT of time by cutting the gordian knot with a well-placed goto intstead of having to roll back hundreds of levels.

Another good reason is to avoid unnecessary indentations. If I had a dime for every time I saw code like

if (testopt("-h")) {
    showusage();
}
else {
    rest
    of
    program
    here
}
return;

I'd be bloody rich.

Then there's compound tests where combinations of !, && and || give you a headache. Splitting them up and using a goto can make it much clearer.

It's also worth noting that "break" is a scope-limited goto, yet few have issues with it. Possibly because it wasn't invented when the essay against GOTO was written. But nothing prevents you from replacing the break with a goto and a descriptive label, which can often make it much CLEARER what was intended. If the break is kosher, then how can a goto that replaces it not be?

Re:Use C#

[yomammamia]

GOTO is basically jmp. Don't learn GOTO, you can never learn assembly.

Re:Use C#

[Bengie]

He was a "team lead" doing a talk about OOP to other professional programmers at this work. I think 15min is plenty time for his audience.

I made the assumption that he was doing a presentation to other programmers at work because I doubt he was doing an OOP presentation to Sales/IT/Admins.

Re:Use C#

[gl4ss]

understanding goto is essential, so sure it should be taught. it's a pretty understandable concept too. and you should know probably at some point down the career that someone else might modify your delivered product to do goto style jumps.

and nothing wrong with basic, I started with qbasic and some decade old basic books I loaned from the library(this was probably around ~92-93). also what's fantastic about qbasic is the built in help of all commands(some of them could have had better use cases documented there though).

once we managed to copy a c compiler, it changed everything of course. you see, if you do a line drawing algo on a 386 with qbasic and then with c the difference is so obvious that you don't want to go back to basic.

now what happened later to me was that in the university the coding classes focused way too much on late c++ features and the universitys own hastily invented best coding practices, which in all practicality weren't that practical(whilst the advantage I had when moving to paid coding, was that I actually had to use older frankenstein compilers). which is actually a lot of what in my opinion is wrong with how programming is taught, too often inqualified teachers just teach a certain way of doing things, usually because that's in their teaching material and they don't have that "can do" hacker attitude towards it, also, in the case of the university here, too much was put into what the world would be in couple of years, so they taught bleeding edge c++ features that nobody was actually using or which nobody actually has good opinions if they're useful or not - but teaching of the history would have painted them(faculty) as losers, but it's the stories like how basic was first done that inspired me into getting more into programming and computers in general, that CAN DO attitude and then just doing it and providing a real, useful tool.

what basic is fantastic though for is coding on paper with a pen! and then later typing it in or parts of it. it's also quite easy to follow from source. which I guess was nice back when you might not have had your own computer.

Re:Use C#

[T.E.D.]

Goto provides for the natural expression of a state-machine. The most common example of that is in lexical analysis. Look at the output from LEX sometime; it is chock full of gotos. Most lexical analyzers are done the same way. So every time you invoke your compiler, you probably are exercising goto-laden code.

Some of the more dogmatic try to get around it by using a case statement in a loop (with an enumeration or something controlling the current state). But really the internal structure of the code flow there has nothing whatsoever to do with that loop, and artificially imposing that on it just obscures the state machine underneath.

Re:Use C#

[V for Vendetta]

I think Ruby fits that bill better than BASIC. Starts out without needing the baggage, but when you're ready for structured programming and objects, it's all right there.

Well, just because the BASIC dialects you know don't do that, doesn't mean they don't exist. Have a look at PowerBASIC, for example. It lets you either do it the good old "structured" way or the OOP way.

It also has tons of other, nifty features, like inline assembler, pointers and all the stuff you'd expect from a full blown compiler.

And you avoid learning GOTO. I don't care how easy it makes initial learning, it's building bad habits that you're going to spend years killing.

Again, PowerBASIC gives you the choice. Either you go with the traditional BASIC error handling (On Error Goto) or you can use exception handling (Try/Catch/Finally).

In my opinion a key point which makes BASIC great as a beginner's language is readability. It's more or less plain english and stays away from all that curley bracket/semicolon stuff. An If/End If-block in BASIC is way easier to spot and understand for a beginner than hunting down a closing "}" (or missing ";").

And no, I'm not affiliated with PB in any way, I'm just a happy and satisfied user who often smiles when typical BASIC cliches come up.

Re:Use C#

[rayd75]

I think it's a little longer than that: the BASIC on the HP3000 had structured programming (and other modern features), in the 1970s.

If a tree falls in the woods.... Seriously, are there any real first-person witnesses to a HP3000 with BASIC actually installed? Granted, I came into the MPE game pretty late, but as I recall, getting BASIC running involved a trip to a far away land, climbing to the peak of a mountain to get tape reels blessed by monks, and forging disc platters in the fires of a volcano. I might be forgetting a step, but I remember it wasn't on the machines by default and getting it running wasn't something you'd care to do.

Re:Use C#

[grumbel]

Can you provide an example of when goto is appropriate

Just go and look at C code, such as the Linux Kernel, it is full of gotos. The way it is used there is simply as form to avoid code duplication for cleanup after errors, kind of like a 'finally' or 'throw/catch' in Java. Something like this:

{
    fd = open(file);

    if (stuff_goes_wrong)
          goto close_file;

    if (other_stuff_goes_wrong)
          goto close_file;

    mem = malloc();

    if (other_stuff_goes_wrong)
          goto free_mem;

free_memory:
    free(mem);
close_file:
    close(fd);
}

In C++ you could RAII to accomplish the same thing, but in C you don't really have many other options that lead to such nice code.

Re:Use C#

[V for Vendetta]

The thing is, BASIC encourages use of GOTO ...

[Citation needed].

Seriously, I started programming in BASIC in the mid 1980s and besides the AppleBasic of the Apple ][, I've never encountered a BASIC dialect that encouraged the use of GOTO or lacked the ability to create/use subroutines.

Re:Use C#

[Anonymous Coward]

Maybe you're great at OO but not quite the teacher you imagine yourself to be, Mr plopez.

Good luck with your future endeavours,
The Manager

Re:Use C#

[mcgrew]

GOTO is BASIC's version of assembler's JMP command. Tell me how you would write an operating system without JMP?

Re:Use C#

[lysdexia]

Lining up the LHS is one thing. How about lining up the RHS? Or components of a statement? Like the below pseudocode? How would you do something like that in python?

http://pastebin.com/GjvLbhxZ Almost exactly like you did it with your pseudocode. :-)

Re:Use C#

[Xyrus]

In almost every instance, if you're using a goto then you're doing it wrong. In all my years of programming in higher level languages, I've used goto at most a handful of times, and only because efficiency outweighed elegance.

What's wrong is this old dogma that tell young people to not think for themselves and instead just repeat what everyone else says.

It's not dogma. It's experience. There is nothing wrong with imparting wisdom to students in an effort to prevent them from making the same mistakes and errors that others before them made. Unless you're doing low level programming that requires the utmost in efficiency, then goto should not be used.

Re:Use C#

[lysdexia]

I was recently forcibly dismounted from my high horse by Douglas Crockford's comment vis. JavaScript: "It's the only language in the world that people think they can use without learning it first." (from memory, I'm lazy).

Ouchie.

I love python myself, and have always thought "those choads puling about whitespace need to *learn* the language first!". . .then went right on to badmouth JS, Perl and Ruby as utter garbage. Of course they are utter garbage in their own ways, as is python. Of course, all of them are possessed of absolutely fantastic features, otherwise they would not inspire love.

In short: you are all a bunch of douchebags and idiots. I know this, because of my long and storied existence as a douchebagging idiot. Come let us reason together. And drink tea. Pop-Tart?

Re:Use C#

[The End Of Days]

Javascript

It has a simple syntax, supports a number of paradigms, and practically everyone has an interpreter for it already installed. It also has a simple, robust UI framework in that interpreter.

Re:Use C#

[mcgrew]

loose the mullet and the walkman

You mean, of course, to take the rubber band off your mullet, but what would unscrewing a walkman case accomplish?

Amazing how a single extranaous letter can completely change the meaning of a sentence.

Re:Use C#

[thoromyr]

and how is GOTO different than exception handling? You can put lipstick on a pig, but it is still a pig.

I haven't programmed in BASIC in many a year and it was my first programming language so I didn't know much about it. From what I can recall the main issue with GOTO was that it was a crutch for not having user defined functions.

I recently employed "goto" in a Perl application. You put a label and can then jump to the label. Its just a more generalized version of using break, continue, etc. In this particular case it was clearer to use the label and jump to it (as part of error handling) than trying to kludge some nasty code up for the sole purpose of avoiding a goto.

Its also the first time I've used such an explicit jump in many years because, generally, there *are* cleaner syntaxes. But those other syntaxes aren't always the best syntactic sugar.

And break, return, throw -- these are all goto statements. Gussied up and renamed, but goto nonetheless

Re:Use C#

[omnichad]

And seeing the mess teaches the need for more structure. As long as the teaching doesn't stop there, I find this perfectly acceptable. You don't want to start learning programming with every possible pitfall in mind - you want results, NOW!

Re:Use C#

[SanityInAnarchy]

Another good reason is to avoid unnecessary indentations. If I had a dime for every time I saw code like

I know return is effectively a goto, but I do prefer it, along with break, continue, and exceptions, as a more structured approach. So I'd do:

if (testopt("-h")) {
  showusage();
  return;
}
rest
of
program
here

Pretty much the same as:

It's also worth noting that "break" is a scope-limited goto, yet few have issues with it.

Well, precisely because it's limited in scope and much better defined. I also have far less of a problem with, for instance, the way Java handles references than with the way C++ has stack objects, references, and pointers, complete with pointer arithmetic. It may be the same thing in some abstract sense, but there's far less opportunity to screw it up.

Re:Use C#

[SanityInAnarchy]

and how is GOTO different than exception handling?

Exception handling is structured, and it does things GOTO can't, that I know of. For instance:

if (world is ending)
  throw IDontKnowWhatToDoException

This puts the actual error-handling code somewhere up the stack where it's actually relevant.

Its just a more generalized version of using break, continue, etc.

Well, in the same sense, it's also a more generalized version of a loop, but you still use structured loops, don't you?

Break, continue, return, etc, are all limited in scope. They do one thing, and do it well. Aside from being clumsier for the things I'd use a break for, goto can take me anywhere else in the program.

Re:Use C#

[SanityInAnarchy]

Have a look at PowerBASIC [powerbasic.com], for example.

DOS/Windows and proprietary? No thanks.

In my opinion a key point which makes BASIC great as a beginner's language is readability. It's more or less plain english and stays away from all that curley bracket/semicolon stuff.

So does Ruby. More so, I'd argue.

Re:Use C#

[SanityInAnarchy]

Why would a programmer keep using a tool if it's much worse for the job? It just doesn't really happen.

You're lucky, then, or exceptional. Or at least, speaking only for myself, I do have to spend years building habits like version control (killing the bad habit of commenting tons of stuff out and in to make it work), automated testing and especially any sort of test-first development, and so on.

Also, I think GOTO's have one advantage for a learning language aimed at small children: It's easier for a child to learn and understand, as a building block / stepping stone toward more complex things. For some reason, I even remember this learning process (using basic, that was popular then) when I was a small child, on our 48K ZX Spectrum ... GOTO's were easy and obvious, but I recall seeing these weird GOSUB things that seemed more abstract somehow.

I remember that, too. But I also remember that when I first saw functions, they made sense. Maybe the GOSUB syntax was just unhelpful?

Finally, any good programmer needs to do significant amounts of assembler at some point in his life, and you're gonna be doing lots of JMP's there anyway, and yet nobody considers that 'learning bad habits',

I would say that's mostly because assembly generally isn't taught as a first programming language. By the time you learn assembly, you already understand structured programming and why it's a good thing, certainly by contrast to assembly.

There are many other bad habits that cause FAR more damage in real-world programming, and yet nobody even cares to teach those in formal Comp Sci or Engineering programs.

I'd certainly like to hear about those. I'm in an odd situation where instructors in my formal Comp Sci program actually listen to me. (Of course, it's academia, so even if they took me as seriously as I'd like them to, it'd still take years to change...)

Re:Use C#

[SanityInAnarchy]

That's pretty stupid. If you can learn GOTO, you can learn jump. But until you need it for assembly, why would you want to?

Re:Use C#

[SanityInAnarchy]

The main reason i was thinking of is that there are multiple ways to do the same thing.

And why is this bad?

For/while loops can use *.each, num.times ... can be use to generate the same resault (where to use each one is not immediately obvious if your witting your first program)

Same problem exists between for and while. Every language is going to have some sort of choices built in.

I don't know if I have an intelligent response, other than to suggest you go to tryruby.org and type 'help'. It actually makes the idea of a "block" feel natural, and they're covered before any actual loops happen.

Re:Use C#

[nzac]

Tryruby.org is for people with knowledge of another language not for teaching basic programming principles.

Though i have no first hand experience at teaching ruby, people who were to learn ruby would either learn to stick to small subset of the language due to experience of felling like a complete idiot for not getting some of the difficult concepts require to understand the fun stuff in ruby. Or in case of self learning and searching for example code to solve problems will also encounter these concepts. I learnt C in a course where people had the option of not taking further programming courses and took it because they chose to bullshit there way though it rather than struggle to get there head around things, trying to get ruby would be much harder.

I guess it would not be bad if you just wanted to teach the basics of ruby, but they would then have to completely relearn everything to move to other mainstream languages and not also understand the stuff that makes ruby a good language.

Python as other people have said is the best possible replacement to basic. While you could use ruby there are a number of pitfalls and problems that i don’t think python or other more consistent languages would have. Read the 'zen of python' i keeps confusing parts of the language to a minimum.

Re:Use C#

[SanityInAnarchy]

Tryruby.org is for people with knowledge of another language not for teaching basic programming principles.

If you say so. I've seen people who don't know anything about programming follow that tutorial well enough.

they would then have to completely relearn everything to move to other mainstream languages and not also understand the stuff that makes ruby a good language.

Maybe. But some of that stuff is pretty accessible. Try going back to setters and getters in Java after using attr_accessor.

Re:Use C#

[nzac]

Im saying that for teaching 'programming 101' to a large group ruby would be a poor choice, to teach the whole class (including the students with little natural talent) basic programming, when you consider the other possible languages.

Just guessing (!!!) that you talking about an enterprise situation (with ruby and java) where you have code already written with smart people who know what the code is suppose to do using the tutorial to learn the syntax of implementation. If you are teaching people to just learn ruby to modify or write scripts for a specific purpose then teaching ruby directly is a good idea.

Re:Use C#

[tombeard]

He is probably concerned about teaching such a limited form of GOTO. While the simplest version should be demonstrated the student should be encouraged to investigate the far more powerful and interesting Computed and Assigned GOTOs.

Re:Use C#

[Richard Russell]

The thing is, BASIC encourages use of GOTO, rather than being an unusual thing to use when unusual circumstances call for it.

I wouldn't agree that all BASICs encourage GOTO. The dialect of BASIC which I know best - BBC BASIC - was one of the first structured BASICs (possibly the very first) to make the use of GOTO completely unnecessary, and its use was positively discouraged from the start. In nearly 30 years of programming in BBC BASIC I can honestly say I have never used a GOTO except in programs written to test that the GOTO statement works!

Re:Use C#

[SanityInAnarchy]

Just guessing (!!!) that you talking about an enterprise situation

Nope. I'm talking about taking my mother, sitting her down in front of Try Ruby, and watching her figure it out pretty much on her own. I'm not saying she was a good programmer by the end of it, but it wasn't hard to follow.

No, she wasn't a programmer.

Re:Use C#

[plopez]

This was for supposed seasoned programmers, who I discovered were writing "COBOL in drag". I didn't get past how classes, inheritance, abstract classes, and base class calls were invoked. I was trying to get them to understand the language features and then how to leverage them. You can't do patterns as presented in GOF and others without understanding these topics. I was still on the basics. The "manager" had certs in the technology in question. I was trying to first familiarize with the basics and then expose them to the more advanced topics.

Re:Use C#

[Dwonis]

x      = 0
furple = 1
foo    = (onevariablename
       + anothervariablename
       + athirdvariablename)

Re:Use C#

[Dwonis]

<quote>Personally I think they made a mistake in that regard, and should have outright prohibited a mix of tabs and spaces for indentation within a single file</quote>

<p>I think that's the case if you use "python -tt".</p>

Re:Use C#

[shutdown -p now]

They actually fixed it in Python 3K, sort of - there isn't an outright restriction on mixing tabs & spaces, but it's invalid to have a mix that would give different results depending on tab size.

Re:Use C#

[Anonymous Coward]

You're replying to a racist idiot. You get a pass.

Re:Use C#

[Anonymous Coward]

Um, because C doesn't have exceptions.

Re:Use C#

[SanityInAnarchy]

All the more reason to avoid it.

But that's basically the same argument as assembler -- this practice might make sense in a language that lacks certain features which effectively replace it. In assembler, there aren't actual loops and such, but there are jumps. In C, there isn't actual exception handling, but there are gotos.

At this point, though, I have an honest question: Would a preprocessor hack be worse than a goto?

BASIC

[Anonymous Coward]

10 print "hello"
20 goto 10

Re:BASIC

[plover]

10 print "hello"
20 goto 10

This is why we can't have nice things.

Re:BASIC

[buddyglass]

1 NEW

Re:BASIC

[Anonymous Coward]

No,
10 print "fuck you ";
20 goto 10

At Radioshack, Sears, Wards, and anywhere hobby computers were sold.

Re:BASIC

[forkfail]

*peeks at the comment*

*finds nothing to poke*

/dated

Re:BASIC

[bmo]

10 INPUT "Who is poster?";A$
20 IF A$="plover" PRINT $A;" is a jerk" else 30
30 PRINT A$;" is not a jerk"

There are literally millions of programmers that cut their teeth on little 16K machines with basic in ROM. It stopped nobody from going on to OO languages. Dykstra was wrong.

--
BMO

Re:BASIC

[iluvcapra]

Dykstra was wrong.

I suspect a lot of people, maybe not Dykstra, would point to the failure of Lisps to take hold in the marketplace as evidence that Basic has corrupted minds.

Re:BASIC

[smash]

in hex editor

1. cd 20h
2. write to x.com
3. insert into autoexec.bat

Re:BASIC

[smash]

uh... cd 20h = 0xcd 0x20, i mean.

Re:BASIC

[simcop2387]

0x19 was more fun.

Re:BASIC

[Anonymous Coward]

Excellent.

Why is it so surprising that a language that was designed to teach programming principles (BASIC) acheived it's goal?

Re:BASIC

[Abstrackt]

This reminds me of the joke about the programmer who died in the shower: "the shampoo bottle said lather, rinse, repeat".

Re:BASIC

[bmo]

No, it probably means that most people think procedurally instead of functionally. And while that's just a guess, I'd be willing to bet a case of beer on it.

It also probably means that most everyday problems are procedural/imperative. I'd be willing to bet a case of beer on that, too.

The beatings in academia that people get over the head with functional programming turns off a lot of people. Emphasis on functional programming in academia seems like mental masturbation instead of getting shit done. Kinda like what goes on between pure and applied science and math factions.

"Lisp is superior to everything" - oh hell no. That's like saying a hammer is superior to a screwdriver.

There is space in the toolbox for all kinds of tools. Not everything is a nail. If a problem can be solved easier in a procedural/imperative language, then use that. Similarly, if a problem can be solved easier in a functional language, by all means, use Lisp.

But don't tie your brain in knots trying to fit the problem (or the way you think) into the language.

That's just stupid and masochistic.

--
BMO

Re:BASIC

[camperdave]

Lisp failed for the same reason that HP stack based calculators failed: Most people don't think that way.

Re:BASIC

[bmo]

As the owner of an HP calc, I have to say that what you say is not really the problem. The problem is and was inertia in the way math is taught. This inertia has led to "one way or the highway" with recommendation by HS math teachers everywhere for the TI-30 and its descendants.

Couple that with the *much* lower price point of the TI-30 compared to the HP "equivalent" (the 10 and the 15), the choice for a HS student to pick the TI-30 style calc is a no-brainer. The love affair with TI then extends into higher education.

Thus, millions of people never *ever* consider RPN. It has led to a stranglehold on the academic market by TI over the decades.

It took me to be out of school to even think of going to HP.

Personally, I won't go back to algebraic calcs. I even use a HP48 simulator on my desktop instead of the regular calculators that come with Gnome, KDE, or Windows.

HP has come up with algebraic calcs over the years. They are always inferior.

YMMV.

--
BMO

Re:BASIC

[Anonymous Coward]

Dykstra was wrong.

I suspect a lot of people, maybe not Dykstra, would point to the failure of Lisps to take hold in the marketplace as evidence that Basic has corrupted minds.

Not being named after a verbal pathology that gay men are known for would go a long, long way towards helping Lisp become more popular. At least among non-Apple users.

Oh, YOU! *bends wrist*

Re:BASIC

[Jeremy Erwin]

Who is poster? plover
plover is a jerk
plover is not a jerk

Re:BASIC

[jollyreaper]

10 print "hello"
20 goto 10

This is why we can't have nice things.

Oh, that's small potatoes. What we'd do is take all the computers in the lab and write music for them. These were IBM model 25's, monitor and disk drives in the same box. So we'd turn the screen contrast and brightness down to nothing to make them look like they're off while the countdown timer is running in the background. Fifteen minutes into the next class, the computers in the back row start playing the William Tell Overture in unison. We lost our nice things right after that.

Re:BASIC

[bmo]

well, it's been a few years.

Insert an "end" or "stop" in there after the if statement. :-P

--
BMO

Re:BASIC

[Billly Gates]

My favorite was

10 dim x = 1,000
20 if x= x mod 2
30 sound 30,20.15
40 color 45,20
50 print "I am super GAY!"
60 else
70 sound 40,20,35
80 color 55,15
90 print "No really I am GAY!"
100 goto 10 ... and make sure you save it under work3.bas or something so it gets mistakenly run. The joys of being immature at highschool. The good old days.

Re:BASIC

[plover]

I think you proved my point eloquently.

Re:BASIC

[mfnickster]

You had me at 10. :)

(Not mine, I'd give credit for this one, but can't remember who came up with it...)

Re:BASIC

[dbc]

Clearly, he provided his own buggy handler for the 'out of shampoo' exception. If he had simply failed back to the OS, he'd be alive today. 'MOOOOOMMMMM!!!!....'

Re:BASIC

[Anonymous Coward]

That's because the modern languages seem more like math than instructing a computer to do something. Basic's simple syntax does allow the programmer to instruct the computer to do something. UML and such just takes the straightforward flow charts and adds inverse thought such as arrows that point up to the base class rather than down to the derived class. Gosub/Return is no different that return x in a C-style function and break/continue are just goto with another name. Goto in Basic can be misused but often that is because Gosub/Return is not explained adequately enough.

10 GOSUB 80
20 PRINT "Returned from subroutine 1"
30 GOSUB 100
40 PRINT "Returned from subroutine 2
50 GOSUB 120
60 PRINT "Returned from subroutine 3. End of program."
70 END
80 PRINT "In subroutine 1"
90 RETURN
100 PRINT "In subroutine 2"
110 RETURN
120 PRINT "In subroutine 3"
130 RETURN

Not hard to follow, really, and it's also possible to write the same program this way:

10 GOTO 80
20 PRINT "In subroutine 1"
30 RETURN
40 PRINT "In subroutine 2"
50 RETURN
60 PRINT "In subroutine 3"
70 RETURN
80 GOSUB 20
90 PRINT "Returned from subroutine 1"
100 GOSUB 40
110 PRINT "Returned from subroutine 2
120 GOSUB 60
130 PRINT "Returned from subroutine 3. End of program."
140 END

Also, procedure oriented is the normal thought process. I think about opening a door or closing a door, I don't see a door and then think open or close. Thus, it is more straight forward to write Open Door or Close Door than the inverse thinking Door.Open or Door.Close. I command the object at the same time because I know the object, I don't see the object and then try to figure out its functions because some are hidden from me (as OO does with making things of type private).

OO has, time and time again, led to more bloat and more confusion due to so much abstraction rather than direct commands. Want to reuse code, here's a thought, use copy/paste. Having to find objects and then discover their methods is a waste of time, a rich api with built-in ready to run statements and functions that only require simple plug-in values is the way to go.

Personally, I am sick of OO and now functional programming, let's get back to sequential procedural programs thank you.

Re:BASIC

[RaymondKurzweil]

While "right tool for the job" is a nice sentiment, it is actually one of the easiest things to say for those that know close to nothing and actually have very little knowledge of the available tools. That you would go on about Lisp, and state that it is a functional language and yet NOT a procedural/imperative language pretty much demonstrates you don't know shit about it. Few Lisp dialects are purely functional... and this is exactly why there was actually quite a bit of real world programming done in Lisp (no matter how uncommon in the grand scheme of things).

Re:BASIC

[Pogue Mahone]

I think the fact that high school maths teachers are recommending calculators at all points to what's wrong with maths teaching, but maybe that's just me.

Re:BASIC

[Urkki]

10 comefrom 30
20 print "hello"
30 rem this line is for compatiblity with different comefrom implementations

Re:BASIC

[Merls the Sneaky]

If all you have is a hammer everything looks like a nail.

Re:BASIC

[Hognoxious]

Clearly, he provided his own buggy handler for the 'out of shampoo' exception.

Maybe it was just a really really big bottle?

Re:BASIC

[Anonymous Coward]

No, it probably means that most people think procedurally instead of functionally.

Most people learn to program procedurally instead of functionally or logically. Actually, now it's shifted to OOP and hybrid languages with functional features. Funny how once upon a time OOP was in the same boat as functional, logic, stack or array-based languages. Goes to show that people can change how they think about programming. Actually, it's funny how people used to write in machine code, without any higher level abstractions.

It also probably means that most everyday problems are procedural/imperative.

Or it means that there is more than one way to solve most everyday problems.

Kinda like what goes on between pure and applied science and math factions.

Wait, so applied science doesn't utilize math or theoretical science?

"Lisp is superior to everything" - oh hell no. That's like saying a hammer is superior to a screwdriver.

Right, but it's interesting how many languages have been influenced by Lisp. Including the imperative and OO languages of today. Most languages are now hybrids with features initially found in Lisp. For example, It was funny when Sun bragged about Java being a garbage collected language. The first Lisp implementation had that in 1960. For that matter Smalltalk had everything Java had and more in the 70s.

Re:BASIC

[TapeCutter]

Output:
Who is poster?plover
plover is a jerk
plover is not a jerk

Re:BASIC

[Linker3000]

Surely the important question is whether to edit your BASIC code with vi or emacs?

Re:BASIC

[Anonymous Coward]

>That's like saying a hammer is superior to a screwdriver.

No, it's like saying having a Star-Trek replicator that can create you any tool you want at the click of a button is superior to a screwdriver.

Re:BASIC

[digitig]

So those who are insecure about their masculinity can use Scheme.

Re:BASIC

[digitig]

Editors are for wimps. Real programmers use Hollerith cards.

Re:BASIC

[ta bu shi da yu]

OO has, time and time again, led to more bloat and more confusion due to so much abstraction rather than direct commands. Want to reuse code, here's a thought, use copy/paste. Having to find objects and then discover their methods is a waste of time, a rich api with built-in ready to run statements and functions that only require simple plug-in values is the way to go.

Oh that's right. Copying and pasting is FAR more efficient. Cause when you find a bug in the original code, there's nothing easier than locating all the spots where you copied and pasted that code to make similar modifications.

Re:BASIC

[Anonymous Coward]

Thceme.

Re:BASIC

[ta bu shi da yu]

LOL! love it

Re:BASIC

[Anonymous Coward]

Fail. Star Trek replicators are voice operated.

Re:BASIC

[Viol8]

"While "right tool for the job" is a nice sentiment, it is actually one of the easiest things to say for those that know close to nothing and actually have very little knowledge of the available tools"

Either you're a piss poor troll or you're full of a boatload of arrogant crap.

"quite a bit of real world programming done in Lisp"

Compared to languages like C++, C#, Java, Cobol etc the amount of real world coding done in lisp doesn't even register. I'd suggest you take a tour into the real world occasionally. In the meantime I think the lift back up to your ivory tower is waiting...

Re:BASIC

[mswhippingboy]

Ummm... make up your mind.
This code would print (if "plover" was input)

plover is a jerk
plover is not a jerk

I agree with your statement however. To submit that if someone learns BASIC their doomed and can never learn anything else is just, well "stupid".

I started out with BASIC and the maligned GOTO style of programming helped ease my transition to assembler. From there I moved on to structured programming in Fortran and COBOL and eventually C, then OOP when C++ and Smalltalk were available.
No knowledge was wasted and I think it's just as hard for someone starting out with Java/Python/Ruby/(your fav HLL) to fully understand what goes on at the level of the bare metal.

Re:BASIC

[rayd75]

This isn't dissimilar to what I did to the Apple II machines in my 7th grade math and computer classes. (The math room doubled as the "computer room") I loaded all the machines up with a short program that would perform a countdown to get it a few minutes into the next period and then randomly produce a high-pitched beep every 60 to 600 seconds. If I recall correctly, the speaker was internal to the Apple II so the monitors stayed off. There were about sixteen machines in the room so you can imagine the results.

Re:BASIC

[bmo]

This is late but...

I really haven't touched BASIC in over 20 years. The last time I did, it was a one-off "security" login for my mom's PC at work using a language called "ASIC - It's almost BASIC" because I wanted to try it out (it's still available on simtel.net if you want to dig it up)

Yes, BASIC can make you do stupid shit. But that's part of the fun of it. But Dykstra was wrong saying it poisons young minds so severely that they are forever ruined. I went on from learning BASIC on a TI to other languages later on. Millions of other kids did too. There really wasn't anything else for kids in the 1980s besides BASIC and Pascal (or typing in games from magazines in Hex, saved to tape, uphill in the snow, both ways). Dykstra's snide remark paints an entire generation of coders with the same broad brush. It's stupid.

--
BMO

Re:BASIC

[DannyO152]

Well, most every day problems being procedural/imperative is akin to saying most every day physics is Newtonian. Very true, but the vexing computing problems of the day relate to scale, concurrency, and parallelism.

Now people are very much single-threaded, so perhaps the program-as-cooking-instructions analogy and procedural languages provide the best entrance point for many. My first language was BASIC from the days of numbered lines and GOTO. It wasn't the language, but what I could do that hooked me.

Re:BASIC

[mikael]

Chris Crawford's (of Atari) articles on writing modular BASIC programs in Personal Computer World were the first introduction to design that I read about ... Keep line numbers 10 .. 999 for the high level order of function calls. Keep different blocks of line numbers for the different types of functions with lines 1000 to 2000 to set up page 6/player-missile graphics, 2000-3000 for the titles, 3000-4000 for main-loops and menus, 4000+ for data, and lines 10000+ for auto-renumbering...

10000 ST=PEEK(136)+256*PEEK(137):INPUT S,E,F,I
10010 L=PEEK(ST)+256*PEEK(ST+1):IF L>=S AND L=E THEN A=INT(F/256):B=F-A*256:POKE ST,B:POKE ST+1,A:F=F+I
10020 IF L=E THEN ST=ST+PEEK(ST+2):GOTO 10010

Re:BASIC

[JohnnyLocust]

10 INPUT "Who is poster?";A$ 20 IF A$="plover" PRINT $A;" is a jerk" else 30 30 PRINT A$;" is not a jerk"

There are literally millions of programmers that cut their teeth on little 16K machines with basic in ROM. It stopped nobody from going on to OO languages. Dykstra was wrong.

-- BMO

I've met countless people over the years who say they started programming in basic on 16k machines, and NEVER made it to OO languages. For some, they lost interest, but others simply weren't able to make the jump from spaghetti code to structured programming, much less OO.

Re:BASIC

[razzam21]

10 print "hello" 20 goto 10

This is why we can't have nice things.

So to prove a language is bad you do something dumb. How about: while(1) { echo 'hello'; } Languages aren't dumb they are a set of rules. Both examples are dumb and should be avoid just because you can doesn't make it right or the language bad. Just the programmer.

Re:BASIC

[Anonymous Coward]

Actually it's a syntax error in line 20 (THEN is required unless it's a GOTO, also $A should be A$), there's a double question-mark on the input prompt, and it's case-sensitive (it fails on inputs like Plover). If the user entered " plover", "plover ", etc. (including quotes and spaces) it would also fail.

This would work:

10 INPUT"Who is poster";A$:WHILE RIGHT$(A$,1)=" ":A$=LEFT$(A$,LEN(A$)-1):WEND
20 WHILE LEFT$(A$,1)=" ":A$=MID$(A$,2):WEND:B$=A$:FOR I=1 TO LEN(B$)
30 C=ASC(MID$(B$,I,1)):IF C>64 AND C<91 THEN MID$(B$,I,1)=CHR$(C+32)
40 NEXT:PRINT A$" is "MID$("not ",1,4+4*(B$="plover"))"a jerk"

Re:BASIC

[Machtyn]

My high school received a number of HP 48G calculators. They gave three to students to try out and report on its findings. I was lucky to be one of them. I thoroughly enjoyed the RPN style. Since everyone learns A+B=C style, figuring out AB+=C; or more advanced: AB+D*=C versus ABD*+=C, makes you really think about order of operation and what it means. It also forces you to think about how a computer logic with push and pop.

Yes, the HP-48G and HP-48GX were too darn expensive. It wasn't long after that, that HP took a nose dive in my respectability column (consumer computers loaded with crapware and overly expensive printers and ink). I still love the HP-48 series, though.

Re:BASIC

[clone52431]

I don’t think you actually tried that.

Re:BASIC

[Lennie]

You are partly right, partly wrong.

Javascript is one of the most used languages in the world, and Javascript is a functional programming language.

It just hides it, most people don't see it at first.

Re:BASIC

[cfulton]

You either have never used OO correctly or don't know what you are talking about. Copy and Paste to reuse code is the worst possible idea. You simply spread maintenance work and bugs through out your code base. Good OO lowers line count, maintenance time/cost and bugs. Bad OO like bad anything can be bloated and the ruination of a project. Modern IDEs and documentation tools allow you to find object and discover methods quickly and as you code. (Think CTRL-SPACE). Large systems with many developers cannot be built in the simple way you suggest. Some larger form of design and control is needed. It does not "need" to be OO but, OO can provide the necessary structure.

Re:BASIC

[Jeremy Erwin]

True; I was assuming that

20 IF A$="plover" PRINT $A;" is a jerk" else 30

was reasonably correct. The Applesoft emulator suggests that

20 IF A$="PLOVER" PRINT A$;" is a jerk" else 30

is closer to being correct, but Applesoft lacks an ELSE statement. At which point I realized that hacking the code to excise the ELSE statement would also correct the error I identified originally:

once line 20 is parsed, control falls through to line 30, unless there is an intervening end statement like so.
 
10 INPUT "Who is poster?";A$
20 IF A$="plover" PRINT A$;" is a jerk" else 30
25 END
30 PRINT A$;" is not a jerk"
35 END

No guarantees on whether this will parse on any given machine.

It's the equivalent of writing a C switch statement without break; statements.

Re:BASIC

[scubamage]

Lol, I remember doing that in middle school programming class with qbasic, and running it on every one of the library computers. Then standing off in a corner chuckling as the librarians scrambled to fix the problem. It only got funnier when I learned how to disable the scroll lock key (the only break sequence the librarians knew was ctrl+scroll lock). It was hilarious to a teenage kid, even after I got sent to the principal.

Re:BASIC

[scubamage]

(There (is (nothing (wrong (with (lisp (damnit(!))))))))

Re:BASIC

[plover]

It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration.
  Edsger W.Dijkstra, 1975

Like you, I first learned BASIC at a tender age; actually a decade before you did. Back then, it was all self-teaching, of course. That's the ease of BASIC, and was also the start of the problem. We had no schoolteachers who knew programming, so they let us work alone on terminals in the back of the math or science rooms. We taught ourselves programming in sequential steps, because that's what we saw, and it's what the language gave us to work with. We never learned to think about or recognize "discrete units of work," unless it was something so big and often repeated that it would save line numbers if it was turned into a GOSUB call. Every variable is a global. No code is named, except by line numbers. The closest thing to a reference was an array index. We didn't have code reviews to learn from each other. And nobody graded our code; if there was any academic look it was only to "ooh and aah" at the results our teachers could never hope to duplicate.

And external learning opportunities were awful. The programs printed in Creative Computing were horrible examples. Even programs that could have been OK to learn from were then scrunched down to save on line numbers and column inches or to fit inside a 16K machine; any elegance they may have had was lost to compression.

Sure, you can accomplish a lot of stuff in BASIC, but everyone reaches a wall where the programs were no longer maintainable. We didn't even recognize why; just that there were many line numbers to juggle, and variables named A, A1, B$, and C7 to keep track of, and never enough extra space between line numbers where we needed them most -- which caused odd little subroutines to sprout from the most awkward of places.

BASIC can be done well with effort and training, but it can be done poorly much easier. When people learn on their own, they don't get feedback or corrections for their bad habits. And BASIC lets you get a lot further on your own than the syntactically thick languages of the C family, or the new concepts required to learn about object oriented programming. You spend more time ingraining bad habits before someone comes along and says "here's a better way to do it."

And then you hit the hard part! You then need to fight the internal pride that says "screw you, I already know how to program well enough, look what I can do in BASIC!" and actually accept learning the better way. Far too many people are so arrogant that they never get over this hurdle, and those are likely the students Dijkstra was condemning with his words "practically impossible".

Part of the problem was the era in which Dijkstra wrote his sentiments. Not enough people outside of academia (especially in industry) were writing quality code; even inside academia there was still a lot of research to be done, concepts waiting to be discovered, and curricula to be written to explain them to students. Another part of the problem was the BASIC language of the time did not encourage or even support concepts we now hold to be common best design principles: modularity, high cohesion, low coupling, etc.

Dijkstra was a visionary who not only understood these concepts back then but framed a lot of what was to come that would improve programming. He recognized this badness the same way we do now, only 35 years earlier. He saw first hand the damage that was caused by self-taught programmers, and saw BASIC as the crutch that enabled them to get too far down that path.

And did you read the points leading his list of uncomfortable truths? Let me repeat the key one here:

The tools we use have a profound (and devious!) influence on our thinking habits, and, therefore, on our thinking abilities.

Re:BASIC

[bmo]

Consider that the only seriously considered structured programming language available for home users in the 80s for microcomputers was Borland's Turbo Pascal. If you had an Atari ST in the late 80s, you could have Modula-2 (heh, heh) and good luck finding people to help you with either of them. I didn't know *anyone* who used Turbo Pascal, even when i got into BBSes and such.

I'll agree with your key point though. Outside of 50 minute classes at school we were all self-taught and finding resources and tools was a real pain. Without guidance, everyone develops bad habits. But even your last message proves that these bad habits can be unlearned because we *have* advanced over the past 35 years. Better tools, better resources, and with the availability of the Interbutt, the ability to shout "help me!" worldwide and get a decent answer has definitely helped the art of programming.

And yes, what you stated is one of the reasons why pride is a sin.

--
BMO

Re:BASIC

[Anonymous Coward]

For plover, your output would be:
      plover is a jerk
      plover is not a jerk

FIX:

10 INPUT "Who is poster?";A$
20 IF A$="plover" THEN PRINT $A;" is a jerk" : GOTO 40
30 PRINT A$;" is not a jerk"
40 END

Re:BASIC

[Tablizer]

10 print "hello world"
20 goto 10
This is why we can't have nice things.

And here's the equivalent in an OOP language:

protected class helloWorld() {
    helloManager hello = new helloManager();
    hello.setMessage("hello world").toString;
    repeatManager repeater = new
system.controlStructures.looper.infinite.repeatManager();
    repeater.exitHandler = new system.controlStructures.looper.exiter(system.io.ui.keyboardObserver(new system.io.ui.controlKeys.ctrl_break())); // allow ctrl-break to exit
    repeater.repeat(hello);
}

Kinda miss the good ol' days now, don't we?

Re:BASIC

[Anonymous Coward]

And here's the equivalent in an OOP language:
...
Kinda miss the good ol' days now, don't we?

Which illustrates how badly the concept of OOP has been bastardized. Just because you have objects to work with does NOT mean everything has to be an object! Actions, in particular, should never be modeled with objects.

Re:BASIC

[Anonymous Coward]

In academia you don't have users with obscure ideas, managers with deadlines and budgets and someone breathing down your neck when you are late...

In academia at least at the professor level, you are pretty much free to do what you want within the guidelines of the curriculum so they can afford their lofty ideals and language bigotry.

I am a professional software engineer and in 32 years I have seen and done a lot of things but I have never had a need to implement something in lisp. It's generally been the nuts and bolts toolbox of C, C++, C #, basic and very occasionally, assembly.

If you really want to be an effective teacher get some real world experience otherwise your students might just be thinking "how the hell does this apply to my world..."

Re:BASIC

[Anonymous Coward]

lisp isn't a functional language, it's a tool that allows you to build a language closest to the domain of your problem.

Can't get there from here

[icebike]

There is still the theory that once you teach someone basic it becomes impossible to teach them programming. /running and ducking...

Re:Can't get there from here

[YrWrstNtmr]

Theories are frequently wrong.

Re:Can't get there from here

[Anonymous Coward]

I remember learning to program with BASIC, and not doing a lot with it for a while. Then we were taught Pascal, which sped things up a little, and I found jumping over to C and derivatives fairly easy. I guess they're very similar structurally. BASIC tends to eschew structural stuff slightly, perhaps being more in favour of a kind of "do this, do that, then do that, goto 4" kinda approach. I'm not sure whether teaching kids' 'goto' as a feasible solution to things is really a good idea.

Re:Can't get there from here

[Anonymous Coward]

Not this one.

Re:Can't get there from here

[chispito]

There is still the theory that once you teach someone basic it becomes impossible to teach them programming. /running and ducking...

What, then, do you propose to teach kids?

Re:Can't get there from here

[Anonymous Coward]

This theory is easy to prove false with a counter-example. Me.

Re:Can't get there from here

[SilverAlicorn]

There is another theory that the first theory was concocted by a wily editor of the Hitch Hiker's Guide to C Programming to raise the level of general insecurity in the industry, and thus boost the sales of the book.

Re:Can't get there from here

[Anonymous Coward]

section .text
        global _start

_start:

        mov edx,len
        mov ecx,msg
        mov ebx,1
        mov eax,4
        int 0x80

        mov eax,1
        int 0x80

section .data

msg db 'Teach them in assembly, you insensitive clod!',0xa
len equ $ - msg

Re:Can't get there from here

[hcs_$reboot]

I started with the BASIC language as a child. And it was not easy.
If Basic didn't have lines numbered, a goto, a limited set of instructions (no while for instance), and no mysterious crash (no pointer for instance), maybe I'd have given up. After a while, when Basic concepts were understood, I wanted to get over the language limitations: speed and abilities. The next step was the assembly language, at the time.
Then learning C: coming from Assembly helped a lot to understand pointers and what happens under the hood.

Basic was simple enough to give me interest in programming, and its limitations made me want to learn more elaborated languages afterwards.

Re:Can't get there from here

[DeadlyFoez]

I partially agree. The part the I agree about is I used QBasic back in '95 and I have never learned another language since. I love basic programming and I have never stepped away from it because I have never had a need to. Trying to learn any C derivative while being an at home father is impossible. The part I disagree about, although I have no grounds to speak since I only know basic programming and I should just STFU, is that basic is a very good stepping stone. If I had more time or any money to goto school then I would already have a decent foot in the door with other languages because I understand how a program works and how logic is with computers. If I were to try and learn C (or any derivative from scratch) then I would be overwhelmed very easily. There is too much to learn with C (or it's derivatives) all at once. At least with basic I can learn and understand how subroutines work. I can understand program structure without having to worry about including libraries or .h files for what I desire to do. Basic is a very good stepping stone, but if you dont have motivation then someone may never get beyond it.

Re:Can't get there from here

[gstrickler]

My first language was BASIC, my second assembler. Since then, I've learned at least 6 more languages, but I still prefer a modern compiled BASIC for most projects. On the rare occasion that BASIC can't deliver sufficient performance, I'll link in some assembly or C routines. I've been quite successful doing that professionally for almost 26 years. That doesn't mean I always write in BASIC, I use the language that best fits the needs, the majority of the time, that has been BASIC.

Mind you, I hate old interpretive BASIC languages that require line numbers, don't have DO/LOOP, WHILE/WEND, Sub/Proc/Function calls, variable scope controls, and other necessities. I'm talking about modern compiled BASIC languages with most of the modern structures we all know and love. It's not a perfect language, but it allows me do code, debug, and modify far faster than any other language, and for most purposes, performance is close to any modern language.

Re:Can't get there from here

[Proudrooster]

That's called reductio ad absurdum or proof-by contradiction which is my favorite type of proof, since it's the only one I can actually do and understand :). Don't forget your QED the end of your proof :)

Re:Can't get there from here

[hedwards]

Just about anything else. No sanely designed programming language will ever require you to label each line of code and throw and require the lines to be renumbered whenever you want to put new code in the middle.

Basic is fine if you're just wanting to quickly introduce it, but anything beyond that is just going to convince them to go to arts college.

Re:Can't get there from here

[fean]

There is still the theory that once you teach someone basic it becomes impossible to teach them programming. /running and ducking...

Know the difference between Theory and Hypothesis...

http://lmgtfy.com/?q=theory&l=1

Re:Can't get there from here

[syousef]

This theory is easy to prove false with a counter-example. Me.

First of by saying this as AC, the irony is that you haven't even provided a firm counter-example.

Secondly just because YOU were re-trainable doesn't mean others will be. There will certainly be others that aren't re-trainable. Whether or not this is a significant percentage requires statistical studies.

Re:Can't get there from here

[Anonymous Coward]

I used basic growing up (ZX, GW, Q then Visual) and found it very difficult to make the step to c/c++, until someone pointed me to the classic K&R "The C Programming Language". It's pretty short, straight to the point and didn't labour over stuff I was familiar with.

Re:Can't get there from here

[syousef]

That's called reductio ad absurdum or proof-by contradiction which is my favorite type of proof, since it's the only one I can actually do and understand :). Don't forget your QED the end of your proof :)

Well you have to be very careful about exactly what you've proved. The statement that "No programmer who has learnt BASIC can be taught a modern object oriented language" could certainly be proven by a single counter example. However the statement that "Programmers who've learnt BASIC tend to be harder to retrain in a modern object oriented language" requires statistical study.

Re:Can't get there from here

[Lloyd_Bryant]

Just about anything else. No sanely designed programming language will ever require you to label each line of code and throw and require the lines to be renumbered whenever you want to put new code in the middle.

I take it you haven't used any BASIC variant in the last 20 years or so. Line numbers, as in GWBASIC, aren't required for any modern BASIC.

Re:Can't get there from here

[syousef]

Basic is fine if you're just wanting to quickly introduce it, but anything beyond that is just going to convince them to go to arts college.

10 REM ARTS COLLEGE
20 PRINT "HELLO WORLD"
30 GOTO 10

Re:Can't get there from here

[tibit]

Try Python. It's the only language I can think of that's similarly easy -- namely you can accomplish anything you want with zero fluff. If you want to, you can write in pure procedural style without creating a single class of your own. It'd be easy to transplant your QBasic knowledge into Python, and then learn more tricks (object orientation, functional programming features, iterators and generators, etc).

Re:Can't get there from here

[pizzach]

QBasic is the only programming language I failed. It was also my first. I couldn't figure out the damn QBasic for dummies Book. It made absolutely no sense to me what was going on. But it may have also been my age.

Re:Can't get there from here

[Anonymous Coward]

Secondly just because YOU were re-trainable doesn't mean others will be. There will certainly be others that aren't re-trainable. Whether or not this is a significant percentage requires statistical studies.

The question isn't one of specific percentages, but rather that no one who starts on BASIC would be "re-trainable". He was, and several others have as well. Is it common? No. Impossible? Hardly.

Re:Can't get there from here

[syousef]

I partially agree.

The part the I agree about is I used QBasic back in '95 and I have never learned another language since. I love basic programming and I have never stepped away from it because I have never had a need to. Trying to learn any C derivative while being an at home father is impossible.

The part I disagree about, although I have no grounds to speak since I only know basic programming and I should just STFU, is that basic is a very good stepping stone. If I had more time or any money to goto school then I would already have a decent foot in the door with other languages because I understand how a program works and how logic is with computers. If I were to try and learn C (or any derivative from scratch) then I would be overwhelmed very easily.

There is too much to learn with C (or it's derivatives) all at once. At least with basic I can learn and understand how subroutines work. I can understand program structure without having to worry about including libraries or .h files for what I desire to do.

Basic is a very good stepping stone, but if you dont have motivation then someone may never get beyond it.

First, you can learn any language you like as an at home father, albeit slowly. Wait till the kids are asleep. Dedicate 20 to 30 mins to it at at time regularly (at least 3 times a week). It wouldn't be easy, but it's far from impossible.

Second, in terms of the language, there is nothing that complex in C or any of it's derivatives. Certainly a bit of pointer arithmetic, and function call styles, which you must understand properly. But in terms of control flow and branching there's really not that much difference between BASIC and C. (There may be more ways to do it in C, but to write your own code you can certainly start with a subset and learn the rest as you encounter them, and they're very intuitive anyway). Beyond that the C library needs to be understood, but if you're doing anything serious in BASIC there are libraries to understand there too. At least C libraries are standard.

Re:Can't get there from here

[Proudrooster]

Or you could use the dreaded, "Research suggests that programmers who've learnt BASIC tend to be harder to retrain than ..... " :)

Re:Can't get there from here

[honkycat]

The one serious limitation of Python, particularly for beginners, is that it makes extremely liberal use of external (though standard) libraries. While the availability and easy of extending it like this makes it powerful, it doesn't make it a great beginner's language. You've either got to introduce the concepts of namespaces and hierarchies before you can do some of the good stuff or you need to drill in a lot more rote syntax.

I love Python, and it's much simpler than many of its alternatives, but I think BASIC is still a pretty solid language for a n00b. Many of the weaknesses people point out (line numbers, simple flow control) are actually strengths when you are training someone who really doesn't have the slightest background in how computers work. I thought the article's rationales were pretty sound.

If, as is the case for the OP, BASIC fulfills all your needs, there's no shame in using it. It may not be ideal for all purposes, but if you know it and it can do what you need, then sometimes it's better to use the tool you know than to learn a new one. All it has to be is good enough for the task at hand.

Re:Can't get there from here

[HeLLFiRe1151]

Pascal was the only programming language I failed, because twas the only one I took.

Re:Can't get there from here

[Anonymous Coward]

It will all depend on who the learner is: some learners get used to a way of programming and never ever leave it, others like me can use completely different ways in the same project without even blinking.

Re:Can't get there from here

[shutdown -p now]

You've either got to introduce the concepts of namespaces and hierarchies before you can do some of the good stuff or you need to drill in a lot more rote syntax.

I don't see how it's "a lot" more. One nasty thing about traditional BASIC is that it had very inconsistent syntax when it came to built-in operators - stuff like LINE(x1,y1)-(x2,y2),B to draw a rectangle. In comparison, when teaching Python, it's not at all hard to explain the need to prefix all function calls with "turtle.".

Re:Can't get there from here

[Anonymous Coward]

QBasic (and other "structured" BASICs released around the same time) was a major step forward for the BASIC programming language. Older versions of BASIC lacked useful control structures like IF...END IF (only single-line IF was available), DO...LOOP and SELECT CASE and thus heavily relied on GOTO (and IF...GOTO and ON...GOTO) for control flow. THAT was what Dijkstra was complaining about.

Re:Can't get there from here

[pikine]

Since you know BASIC, you may actually find it easier to learn assembly language next. Both of them are very similar actually. Then from the point of view of assembly language, try to familiar yourself with the C calling convention, which will help you understand what a C compiler does under the hood when it compiles a C program.

Another approach that is completely orthogonal to that is to start learning about how to define mathematical objects on paper. After you learn a few basic building blocks such as tuple and pattern matching, you can start defining data structure and write algorithms in math. Then you'd be delighted to find out that an algorithm written in mathematical notation can be easily transcribed to a functional language.

Re:Can't get there from here

[smash]

I managed it. I agree that there's a hell of a lot of brain damage in basic though. Luckily i moved on before i got too far beyond the simple stuff in basic.

Re:Can't get there from here

[Anonymous Coward]

Except for this from TFA:

Line numbers make control flow obvious

Apparently they think this is thought of as a good thing?

Re:Can't get there from here

[Anonymous Coward]

um.. python is not intuitive at all and quite hard to move to other languages from. i.e. whitespace should not be a programing constraint.

Re:Can't get there from here

[pizzach]

I do all sorts of more modern languages from C++,C,Java, Javascript, Python etc. But still looking at that old QBasic for Dummies book I have no idea what is going on. Basic I can understand. I just look at it as either the book or the language was poop.

Re:Can't get there from here

[nomadic]

They're frequently right. BASIC was fun to learn as a kid but probably derailed me from ever learning proper programming.

Re:Can't get there from here

[Requiem18th]

The way I've experienced this is that the most difficult thing to learn when programing is the startup overhead.

Learning to develop on C on Windows properly requires learning Visual Studio and project management with that. It is also useful if you can have code *written by yourself* running as soon as possible.

Understanding compiler messages from gcc is cruelly hard for a programming virgin without hand holding, and IDEs are complex, Trying to write graphical apps right away is counterproductive and C itself is incredibly opaque, the language is just a bit pusher, you can't even do basic IO without calling external libraries, which is excellent for a systems programming language but taxing on a newbie, who is already trying to remember about string buffers, pointer arithmetic and C data types.

No, my recommendation for a teaching programming language would be javascript. It is high level enough that real programmers use it, yet simple and dynamic for beginners to learn. It is broken and fragmented, but so are many languages so it won't hurt them to learn that different users will see different results.

It doesn't need anything but a browser and a simple text editor, yet I recommend KomodoEdit, it's free, has simple class browser features for javascript and also helps with the html and css that you will also have to teach. And talking about HTML and CSS will prepare them for SQL and XPATH wich are excellent examples of DSLs. if there was a Javascript based web server with integrated sqlite that was dead simple to install it would be the perfect teaching tool ever.

One of the greatest things about Javascript in my opinion is that it has integrated form controls in the DOM. It's the best setup I can think of.

Re:Can't get there from here

[camperdave]

Alternatively, any variant that does NOT use line numbers isn't really BASIC.

Re:Can't get there from here

[Haeleth]

No sanely designed programming language will ever require you to label each line of code and throw and require the lines to be renumbered whenever you want to put new code in the middle.

Line numbering is actually not a bad way of introducing programming. It models a program as an explicit list of instructions, which is a decent metaphor for very simple programs.

Contrast something like Python, where the student is forced to worry about things like indentation before he even knows what a loop is, or Java, where the student is forced to copy huge chunks of class definition boilerplate before she has even grasped the concept of a variable.

I will agree that BASIC of the classic line-numbered sort is not suitable for learning to write real-world programs. But as a way to learn the basic concepts, it is arguably superior to "better" languages, precisely because it does not force you to learn about the structure of real programs just to make your computer do something interesting.

(Someone is about to point out that "hello world" in Python is a one-liner. Don't bother. "Hello world" is not a useful learning experience in the way that "20 GOTO 10" is.)

Re:Can't get there from here

[plasticsquirrel]

Indeed, Edsger Dijkstra said this back in 1975: "It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration." He also said, "I think of the company advertising 'Thought Processors' or the college pretending that learning BASIC suffices or at least helps, whereas the teaching of BASIC should be rated as a criminal offence: it mutilates the mind beyond recovery."

I'm surprised that anyone still wants to teach BASIC when far superior "easy" languages such as Python and Ruby exist, or Squeak, which is a great approach. This is not even mentioning Scheme, which is probably the best way to start, and has been around for a long time now. There is all sorts of nice introductory material from the PLT Scheme people, with custom dialects of Scheme that have extensions specifically for easy graphics and other fun stuff that students would like.

Re:Can't get there from here

[msauve]

BASIC didn't support any graphics (unless you count ASCII "character graphics"), so there were no "LINE..." commands. What you're complaining about were non-standard extensions to the language, not much different that what MS did more recently with Java (where do you think they learned the commercial lock-in value of proprietary language extensions?).

Re:Can't get there from here

[narcc]

No sanely designed programming language will ever require you to label each line of code and throw and require the lines to be renumbered whenever you want to put new code in the middle.

BASIC existed long before the full-screen editor -- hell, it existed before the full-screen! Line numbers made a lot of sense back in 1964 (and for some time thereafter). If you can't figure out why this is so, just ask.

You should also note that most people designed their programs on paper *before* they entered it into the computer. They also had the good sense to leave gaps in the numbering (10 20 30 instead of 1 2 3) for possible later additions and used the hundreds or thousands place for marking off program sections.

Only a totally incompetent idiot would constantly be using renum.

Besides, line numbers haven't even been necessary since the advent of structured BASIC in the early 80's. In case you didn't notice, structured BASIC has dominated the language for the past 25 years. -- While it's true that you'll find any number of BASIC interpreters which support line numbers, you'll have a hard time finding one that requires their use.

But don't let your total ignorance of the subject keep you from forming strong opinions.

Re:Can't get there from here

[Anonymous Coward]

I disagree.

Coming from Fortran, it's pleasant to see a language that gives real functionality to the otherwise aesthetic enforced whitespace regimen.

Re:Can't get there from here

[bhcompy]

Better yet, find the text for a high school AP Computer Science class from the late 90s/early 00s. C++ tailored for teenagers. Uses a bit of custom libraries to make it easier, but delves in to most basic concepts you'll need at later levels(class creation, recursion, pointers, etc). Best part was that we used Borland Turbo 4.5 rather than Visual Studio. Didn't make for great Windows applications out of the gate, but it was a very simple and straightforward compiler that compiled applications that ran in the Windows environment(albeit they looked like a terminal emulator)

Re:Can't get there from here

[Bengie]

I started learning Basic when I was ~11. Got lost and gave up. Picked up C++ shortly after, was easy.

I still find multi-threading and C/C++ easier than Basic.

If you can write pseudo-code and understand how to work a calculator, programming is easy. Computer's just manipulate math, one problem at a time. Crazy easy.

Basic is anything but natural(for me). I've yet to see someone write pseudo-code similar to Basic, even from people who don't program. Most people use the syntax they learn from math class, and that's mostly "C" style.

My lonely opinion

Re:Can't get there from here

[shutdown -p now]

It's true that the very first version of the language, Dartmouth BASIC, didn't have any operators for graphics in it. But at that point in time, there was no language standard yet, so what "non-standard extensions" are is unclear. All implementations of BASIC were "non-standard" then.

By the time the language was standardized by ECMA in 1986 and then by ANSI in 1987, it already had graphics, and that was captured in the standard. Granted, the syntax in that document was different from the typical syntax used by DOS BASIC implementations (which is the one I shown earlier), but it was equally incoherent.

Re:Can't get there from here

[SanityInAnarchy]

It's spelled "QED, bitches!"

Re:Can't get there from here

[SanityInAnarchy]

Or Ruby, where you don't have to worry about indentation, and where Hello World is a one-liner.

And GOTO is bad enough that I do NOT want that to be people's introduction to programming. Try this instead:

loop { puts 'Hello' }

Same thing, less goto.

Re:Can't get there from here

[aliquis]

Basic on steroids (?): :D
http://en.wikipedia.org/wiki/AMOS_(programming_language)
http://en.wikipedia.org/wiki/Blitz_BASIC

Written in Blitz Basic:
http://www.youtube.com/watch?v=-lSihEAxvTs

Seems like the first Worms (Total wormage) was written in AMOS.

Best Amiga racing game:
http://www.youtube.com/watch?v=wZiRQ0bzGds

Re:Can't get there from here

[Osgeld]

lua

Re:Can't get there from here

[Confusador]

goto school

I see what you did, there.

Re:Can't get there from here

[EvanED]

Better yet, find the text for a high school AP Computer Science class from the late 90s/early 00s. C++ tailored for teenagers. Uses a bit of custom libraries to make it easier, but delves in to most basic concepts you'll need at later levels(class creation, recursion, pointers, etc).

The custom libraries it uses (apvector, apmatrix, apstring, ...) and the fact that it was developed before C++ was standardized and thus gets some things "wrong" makes me strongly disagree with this suggestion. Hell, I suspect you are likely to not even be able to write the "hello world" program in a typical C++ APCS book because it'll tell you to include . I know that would be true of the book we used in the class I took.

I'm sure you could find a book that would be way easier to learn from than going through an APCS book and trying to figure out how to use it with any compiler made in the last decade.

Re:Can't get there from here

[EvanED]

I suspect you are likely to not even be able to write the "hello world" program in a typical C++ APCS book because it'll tell you to include .

Let's try that again: "it'll tell you to include <iostream.h>".

Re:Can't get there from here

[Anonymous Coward]

I went straight from BASIC to assembly language. On multiple processors. Everything else was basically a variation on that theme. And I will post AC as often as I please, thank you.

Re:Can't get there from here

[Anonymous Coward]

"Hello world" is not a useful learning experience in the way that "20 GOTO 10" is.

Most insightful comment likely to be made in this thread.

Re:Can't get there from here

[Anonymous Coward]

Actually Basic was the stepping stone for me in programming and in a way i will say that BASIC does give you an understanding of how to write a simple program. Now i am programming C, C++, PHP, assembly and still learning others. So in conclusion i would say BASIC is a good start to get an understanding about what is programming.

Re:Can't get there from here

[c0lo]

I still find multi-threading and C/C++ easier than Basic.
...
Computer's just manipulate math, one problem at a time. Crazy easy.

I wonder what did you understand from multi-threading?

Re:Can't get there from here

[plopez]

Teach a man to program, and he will problem solve for life. Teach a man BASIC, and he will have a horrific career in IT management mandating that all projects must be in BASIC.

Re:Can't get there from here

[willoughby]

...If I had more time or any money to goto school...

Yep, he programs in BASIC allright...

Re:Can't get there from here

[noidentity]

Maybe it's just me, but I don't associate the original BASIC with the joy of programming. Line numbers were a major headache. (Amiga) BASIC with C-style block structuring was getting there, but it was still slow as hell. It wasn't until C that I could say I experienced joy of programming. With that, code ran about as fast as it could, and I could structure things very freely. This was in the late 1980s/early 1990s.

Re:Can't get there from here

[Anonymous Coward]

Let me guess: early-mid 80s? My route to "real" languages pretty much the same. Started out with basic, which as you describe was a wonderfully simple and forgiving, yet surprisingly powerful, sandbox (or seemed so to 10 y.o. me). Then once I had the basics down pat and wanted more speed out of my slow old computer (microbee 32k) I taught myself z80 assembly programming, which in those days was a wonderful way of diving "under the hood" of the machine to really get to know how things worked at the fundamental level. Then I moved to C, which was pretty easy after a few years of assembler, then C++, fortran (ugh, *that* is an ugly language), java...

Basic certainly didn't seem to hold me back.

Re:Can't get there from here

[cinderellamanson]

... and html + javascript is the winner!

Re:Can't get there from here

[Phoobarnvaz]

I started with the BASIC language as a child. And it was not easy.

Have to agree with you. It was BASIC on an HP 3000 mainframe which got me started with computers for a math class to graduate from college back in 1983. While I was one of those who didn't go past BASIC to do any type of programming...this class was just like finding the perfect person to spend your life with and never looking back. Except for a 3-4 month timeframe 20 years ago when I was homeless...have had some type of computer...all the way from a Timex Sinclair 1000 I bought used for $5 to my current quad-core AMD system with 8 GB of memory.

Funny thing about that Timex...had to goto Wal-Mart to get an Atari 2600 power adapter to be able to use it. Think I sold the whole bundle for $20 with a couple of books I bought to program some games by hand.

Re:Can't get there from here

[Pogue Mahone]

Nah - that's easy to debunk. Just ask for the citations. ;-)

Re:Can't get there from here

[Pogue Mahone]

That's called reductio ad absurdum

No it isn't. Reductio ad absurdum is where you assume the opposite (of what you want to prove) to be true and then after a series of logically correct inferences arrive at a "true" statement that is inconsistent with your assumption or the axioms.

Disproving a conjecture by finding a counter-example isn't a proof of anything except the falsehood of the conjecture. I suppose you could set up the falsehood of the conjecture as a theorem, but it doesn't really tell you anything.

Maybe you should try reductio ad nauseam. That's where you make a series of logically correct inferences until you arrive at the conclusion that everyone in your audience has dozed off. Then you suddenly announce "QED!" in a loud voice and move on to the next topic.

Re:Can't get there from here

[honkycat]

It's a diversion from the goal. Memorizing "type turtle dot before every command" is both not quite right (is it turtle.print or just print? why?) and doesn't add anything to the educational experience. It adds one more "just do this and we'll explain later" layer.

Also, don't discount the cost of distracting syntax. Sure, to you and me it's just "turtle." at the start of each line and is easy to ignore. But someone who doesn't yet recognize the patterns it's another word to read and think about. If you ignore the rectangle option, even with irregular syntax, it's really clear what LINE(x,y)-(x,y) does---there's nothing there that doesn't contribute to the meaning (to the human, not to the interpreter) of the statement.

Sure, things like this are not complete deal-breakers, but they do add difficulty for a newcomer without adding any benefit to the experience. BASIC may not be absolutely perfect as a first language, but it's pretty good in terms of presenting a simple model as an introduction to the concept and basics of programming.

Don't get me wrong, I am a huge Python fan and regular user, and do think it's a language that is worthy of introduction early in one's education. I just think it's less than ideal for teaching the very basics of programming.

Re:Can't get there from here

[narcc]

THAT was what Dijkstra was complaining about.

Try actually reading the Dijkstra letter in question.

Now do you see how totally wrong you are?

Re:Can't get there from here

[SharpFang]

And even then the common practice was to label lines in increments of 10, so if you wanted to put something between your 10 print "hello" and 20 goto 10, you could just write 15 print "world" and renum only if you needed to insert more than 10 lines (and couldn't use gosub for some weird-ass reason).

Re:Can't get there from here

[Anonymous Coward]

Basic was simple enough to give me interest in programming, and its limitations made me want to learn more elaborated languages afterwards.

This. One of the most important lessons I learnt from BASIC was why other languages have the features they do.

Re:Can't get there from here

[Hognoxious]

What you're complaining about were non-standard extensions to the language

I'm pretty sure that when I was tinkering with BASIC (early 80s) there was no such thing as a standard.

Re:Can't get there from here

[Joce640k]

What language is "C/C++", exactly?

Re:Can't get there from here

[tibit]

I don't see why introducing namespaces is bad. Turtle stuff is in the turtle namespace, thus the prefix. Easy to explain.

Re:Can't get there from here

[Hognoxious]

Back in 1975 were people also saying that Dijkstra was a pompous ass? I'm sure thinking it right now.

Re:Can't get there from here

[julesh]

I take it you haven't used any BASIC variant in the last 20 years or so. Line numbers, as in GWBASIC, aren't required for any modern BASIC.

The BASIC variant that TFA is about requires line numbers for all lines. The develoeprs suggest this is better, because it makes control flow explicit.

Re:Can't get there from here

[santax]

Well my msx with msbasic certainly had line, circle, point commands.

Re:Can't get there from here

[msauve]

First, Kemeny created BASIC, so you claim that Dartmouth BASIC wasn't "standard" is ludicrous. I suppose Kernigan's C or Wirth's Pascal weren't standard until ANSI got a hold of them, either.

So you're complaining that some language extensions for graphics, which appeared prior to "official" support for that capability were non-standard. Nice tautology, there.

Re:Can't get there from here

[digitig]

My first language was FOCAL, and BASIC came as a huge relief. Since then I've worked in Ada, C, C#, C++, Forth, FORTRAN, Modula2, Pascal, Python and VBA (not in that order). All except FORTRAN and VBA came as a huge relief from BASIC, but I can't help wondering whether that early BASIC experience is why I never got on with LISP, Haskell, Scheme, OCAML, Prolog etc, all of which I've dabbled in.

Re:Can't get there from here

[digitig]

"Theory" is a clothing store? That's what your link takes me to...

Re:Can't get there from here

[Anonymous Coward]

Presumably Bengie is sufficiently older than 11 now that they learned "C/C++" at a time where processors you'd typically find in a computer were not multi core. Given that assumption, they're right, and I have to wonder what you understand about multi-threading.

Re:Can't get there from here

[serviscope_minor]

I'm not too keen on labelling every line, but if only there was some kind of automatic machine which could maniuplate numbers really quickly and flawlessly track and update cross-references...

Some basic variants acquired automatic renumbering 30 years ago, complete with updating goto/gosubs if you still insisted on using them, when the language provided proper functions. See e.g. BBC basic, and the REN. command.

Re:Can't get there from here

[c0lo]

Presumably Bengie is sufficiently older than 11 now that they learned "C/C++" at a time where processors you'd typically find in a computer were not multi core. Given that assumption, they're right, and I have to wonder what you understand about multi-threading.

Given that assumption and also assuming Bengie (or they, whoever they are) stopped learning in the meant time .
BTW: have you noticed? They also invented GPU in the mean-time... lo-and-behold... GPU-es are already notorious for handling multiple math manipulations per every clock-cycle (letting aside the threading issue).

(as for my understanding of multi-threading... don't be fulled by my 7 digits ID; it's only when getting older that I got frustrated enough to post on /.)

Re:Can't get there from here

[BeanThere]

Or maybe, just maybe, you just weren't all that inherently interested in programming? I somehow find it very hard to believe that anyone truly interested in programming would 'give up' simply because they 'learned BASIC'.

I started on BASIC(first ZX Spectrum, later QBASIC) - for years - later learned Pascal, then C and C++, and now have programmed full-time C++ for 10 years. And from day one, every step of the way, I've been hooked - loved it, loved learning new things, loved being able to create things.

I could equally claim that I never got good at woodwork because we only had crappy tools at home (which was true). But the reality is I was just never that interested in it.

Re:Can't get there from here

[Fizzl]

Well, it's still like this. One problem at a time.

1. In co-operative multitasking, the computer oompaloompas work on the calculator one at a time and let their boss know when the calculator is free to use. The working oompaloompa can also decide to take a break, leave their work on the desk and let someone else do their work while they do not need the calculator.

2. In pre-emptive multitasking the boss tells an oompaloompa to start working. The oompaloompa is forced to work until their work is done or the boss decides to hit it with a stick and put some other oompaloompa to work. Poor oompaloompa does not know how much time he has and when he gets hit, he has to drop his work immediately.

3. In symmetric multiprocessing the oompaloompas have multipla calculators but only one table and a filing cabinet. The oompaloompas have to coordinate together how to organize their work, so they don't scribble on each others notes, while they take turns on the calculator. The boss is usually in charge of the desk space and the filing cabinet.

4. In distributed vector... I think I write something about hungry philosopher oompaloompas now! They are not good with forks. Or something... Anyway, what was I speaking of? Oh yeah, I'm thirsty. Mmmm... Sluuuuuurmmm...

Re:Can't get there from here

[Anonymous Coward]

>Most people use the syntax they learn from math class, and that's mostly "C" style.

Actually that's mostly "Pascal" style.
C messes up the comparison operator, the definition operator, gives wrong results when dividing, has strange non-mathematical notation for conversion, etcetc.

Re:Can't get there from here

[Anonymous Coward]

This theory is easy to prove false with a counter-example. Me.

The theory as quoted is probably exaggerated for the purposes of making a point- I suspect that in a number of cases (but not all), it'll be possible to overcome the bad habits promoted by learning old-school BASIC if the person is motivated, is willing to accept that these are bad habits, and receives good tuition.

But that doesn't change the underlying (correct) sentiment, that BASIC teaches some really bad (if not downright destructive) habits that can become ingrained and hard to overcome if it's someone's first language.

Many of the design limitations of BASIC may have been justifiable in the 1970s and 1980s when they had to fit the interpreter into an 8K ROM (or whatever) and you couldn't have had C-like syntax and extendibility on a typical small computer. But there's absolutely no excuse for it with today's computers- anyone suggesting that we teach it to kids nowadays should be shot.

(Speaking as someone who learned BASIC as a kid and *did* pick up lots of crap habits and get stuck in a rut for too long because of it).

(*) Modern Visual Basic and Visual Basic.Net really don't count. Yes, they have lots of modern language features. But their raison d'etre was that they let people who *already* knew old-school BASIC move on more easily than (e.g.) with C and C++. But VB is more complex than it used to be, and if you don't already know BASIC (which a kid nowadays won't), is no easier than say C# which has more standard C-style syntax, so it'd make more sense to learn the latter instead.

Re:Can't get there from here

[Gunstick]

I started with basic, namely GfA-Basic. Which has, surprise, no line numbers!
http://en.wikipedia.org/wiki/GFA_BASIC
And it was useable, powerful and fast.
The editor even did the auto-indentation.

Re:Can't get there from here

[c0lo]

Anyway, what was I speaking of? Oh yeah, I'm thirsty. Mmmm... Sluuuuuurmmm...

Hope that's a good brandy (substitute with your alcoholic beverage you like) that you drank... Are oomplaloopas tasks or threads?

If tasks, there can be multiple oompaloompas in progress at any given time (even if only some of them active). Also, the coordination for the table is not necessary, the boss takes care to allocate *dedicated* virtual table-space, moving physical table pages back and forth to accommodate (unlike in the real-world, the boss does something!). The access to the cabinet (HDD) is subject to queueing (and no, the boss have nothing to say about concurrent accesses to the same post-it note, the oompas need to take care by themselves, potentially involving IoC... errr... that's inter-oompaloompa-communication, not the inversion-of-control).

If oompas are threads, then yes, they'll need to coordinate between them... but only if they really need exclusive access to the same virtual table space or post-it notes. And the godly creator of the oompaloompas (i.e. the programmer) should be very careful to minimize the need of oomtexes...

Errr...? Where's that cold "James Squire" ale? What? Already finished? Time for another. Pffsssst.. gulp... ahhhh...

Re:Can't get there from here

[honkycat]

It's just that it's on a sidetrack for someone who's just learning what it means for a series of commands to be executed in sequence.

I'm not saying it's far, far beyond their grasp, but understanding what a namespace means beyond just "type this nonce" requires understanding of a few things you don't need just to see how a simple program is constructed. Plus, it can lead to bad habits along the lines of "from turtle import *".

Re:Can't get there from here

[Bengie]

sorry "Hardware Threads manipulate math, one problem at a time"

Re:Can't get there from here

[Bengie]

omg, I love Fizzl :-)

P.S. My best friend use to be scared of oompaloompas as a kid

+2 for incorporating my analogy with oompaloompas.

Re:Can't get there from here

[Anonymous Coward]

I think of the company advertising "Thought Processors" or the college pretending that learning BASIC suffices or at least helps, whereas the teaching of BASIC should be rated as a criminal offence: it mutilates the mind beyond recovery. - Edsgar W. Dijkstra

Re:Can't get there from here

[Bengie]

The language that has you delete your malloc and wonder what happens... or is it free your new?

Re:Can't get there from here

[tibit]

There is only so much you can do without thinking things through. The bad habit you allude to is easy to unlearn by necessity. Once your project is complex enough, clashing imports will be haunting you enough to force a change. IOW: all in due time.

Re:Can't get there from here

[Anonymous Coward]

IBASIC tends to eschew structural stuff slightly, perhaps being more in favour of a kind of "do this, do that, then do that, goto 4" kinda approach. I'm not sure whether teaching kids' 'goto' as a feasible solution to things is really a good idea.

As if most programmers today are capable of producing any better code just because they learned something other than BASIC? I began with BASIC and moved to 6502 assembly language and then to a myriad of other languages including FORTRAN, COBOL, Pascal, SmallTalk, Modula-2, WATFIV, Perl, BASH, Tcl, and iAPx86 assembly language.

I cannot tell you the amount of garbage code I have had the misfortune of encountering in my professional life and that required a complete redevelopment effort on my part for the simple reason the code was not maintainable.

Re:Can't get there from here

[msauve]

You don't know what a "non-standard extension to a language" is, do you?

Re:Can't get there from here

[miknix]

Where did you program BASIC? I'm 24 now and I started at 12 yo in a Philips VG 8010 (MSX Basic) that my uncle offered me.
I still have the programs I wrote at the time in tapes. There was one thing though that was too tough for me at the time, I never managed to make games with sprites.

After BASIC, I bought a real PC and learned Visual Basic to turn around CLI limitations. C programing only came when I wiped the windows partition with Linux for the first time.

Sometimes I wonder if it would change anything if I started by using a PC with Linux instead..

Re:Can't get there from here

[autocracy]

Multi-threading is still the same rule, and can be seen as a sequential series of singular threads that have stop / pause points. That's what happens on a single processor anyway.

Re:Can't get there from here

[Fizzl]

I didn't want to complicate my broken analogy by bringing fairies into this man!

Re:Can't get there from here

[DeadlyFoez]

Not that easy when you have 2 autistic children to care for 24/7. ;)

Re:Can't get there from here

[Anonymous Coward]

Secondly, I am sorry to say, both the computer industry and the education business contributed more than their fair share of misleading the public. I think of the company advertizing "Thought Processors" or the college pretending that learning BASIC suffices or at least helps, whereas the teaching of BASIC should be rated as a criminal offence: it mutilates the mind beyond recovery.

-Edsger W. Dijkstra

The threats to computing science
http://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD898.html

Re:Can't get there from here

[Profane MuthaFucka]

Nine out of ten dentists recommend that you brush your teeth after you eat a pussy.

Re:Can't get there from here

[mikael]

BASIC did support subroutines through GOSUB and RETURN. Though some versions didn't have an ELSE statement, so you had to use a GOTO to skip over exclusively mutual code segments. Some variants dispensed with line numbers and just had 'proc's' - procedures defined with 'defproc' and 'endproc' along with 'callproc'. Acorn Basic and Sinclair QL SuperBasic come to mind.

Most times, you could avoid the use of IF-THEN statements and associated GOTO's:

1010 IF (DX0 ) THEN X=X+1
1030 ...
and just have:

1010 X = X+(DX>0)-(DX0)

It works for GPU shader languages 30 years later ...

Re:Can't get there from here

[MBGMorden]

I did about the same, minus the give up step.

At about 9 years old I started with BASIC. First on a Commodore 64 (and a Tandy TRS-80 that my aunt had - I'd go to her house just to play on a different computer than the C64 I had at home), then later on QBASIC when my family got a DOS-based PC.

Eventually I started using various compiled BASICS's that I found on BBS's. I remember one
was called ASIC and another was called BasicBASIC.

One of the compiled versions in particular (I can't remember which one) actually was pretty neat in that it didn't require line numbers, and allowed you to use tags instead for blocks of code.

IE, I could do.

beginning:

PRINT "Enter input?"
[gather input]
GOTO handle_input

handle_input:
[process some stuff]
GOTO beginning

Ended up working a lil like a function call.

Overall, it helped a lot. Yes, I learned to do fairly bad practices, but those were quickly dropped, and the basic understanding of thinking about things in a very sequential and logical manner helped TREMENDOUSLY when I started my CompSci degree (where we learned on Java). A had several friends who were very much into computers but had started on PC's in the Windows era when programming at home wasn't quite as ingrained into computer usage, and they had a MUCH harder time picking things up.

Sure these days the mere thought of writing anything useful in BASIC turns my stomach, but as a good, solid entry into programming? It worked great for me.

Re:Can't get there from here

[nomadic]

I didn't "give up," just in subsequent attempts to learn programming (including college level classes), I found it extremely difficult to think in terms of subprocedures, classes, etc., and I think a lot of that was because of the linear nature of the BASIC programming I learned on the PC Junior.

Re:Can't get there from here

[Anonymous Coward]

Thinking about it just now, if it weren't for BASIC, I might have never succeeded to learn programming by myself.

See, I didn't have a computer as a kid, so I read some books including BASIC. When I got my hands on a computer with MS QBASIC at dad's work, I had a couple trivial programs prepared. I typed them in, chose RUN from the menu and a question mark was displayed. I was done for the day because I didn't know what that meant. A week later I figured out that I was expected to input a number at that point.

What I mean is if you already learned programming, you don't even stop to think about such things anymore. Most modern languages are compiled or somehow preprocessed (C, Java), so you have to learn to control the compiler first. With others like Python or Perl the magic is in the libraries, so you have to learn those concepts very soon. With BASIC, I had to type in code from a book, and press RUN. As a kid with nobody to hold my hand, all I needed was discoverability. Sure, I moved to Pascal a few months later but I don't regret starting with BASIC, even if today I can't remember what the control structures were called.

Re:Can't get there from here

[TheRaven64]

try to familiar yourself with the C calling convention

There is no such thing as 'the C calling convention'. C does not define a calling convention. The language more or less requires that parameters be pushed onto the stack right to left, in order for it to be possible to implement variadic functions, but that's about it. Each OS defines its own calling conventions for each architecture. Even FreeBSD and Linux have different calling conventions on x86 (the Linux ones are spectacularly braindead and will pass a word-sized union by putting it on the stack and then putting its address in a register).

Re:Can't get there from here

[TheRaven64]

Nice try, but that's not the relevant letter at all. That's the letter that defined structured programming (as part of the Algol process). Dijkstra's comment about BASIC was from one of his public lectures.

Re:Can't get there from here

[chthon]

You should first learn Lisp using 'How to Design Programs', 'Structure and Interpretation of Computer Programs'. Then you will see that object-oriented programming is just a special case of imperative programming. Proper structure can be achieved by architectural decomposition, for which you only need a packaging or namespace system. Functions are more important and powerful than datastructures. You can implement data structures using functions, but not the other way around.

Re:Can't get there from here

[clone52431]

I was the opposite. Learned BASIC quite well, picked up C, got disgusted with the shenanigans one had to put up with to handle strings, and gave up. Plus it had no built-in support for colours, sounds, graphics, and cursor control, which I had by that time already been using quite frequently in my BASIC programs. C was like going back to a teletype terminal. Stuff goes in, stuff comes out.

Re:Can't get there from here

[DavidTC]

I always thought a good language to start with would be PHP.

It has all the language conventions that BASIC skips, like var++, it has looping constructs that actually are used in the real world, not GOTO, it has variables marked (With a $) like in most modern languages, it doesn't require compiling, it doesn't require pointer knowledge.

And you can start off simple and go all the way to OOP.

Note I mean 'command line PHP', not web stuff.

Ruby would also be a reasonable alternative, as the other response said. (Although I think the do....while thing would be horribly confusing later.)

Older BASIC just teaches bad practices, and newer BASIC is all sorts of weird retrofitting of stuff onto a language that's not designed for. And don't even get me started on VB. No introductory programming course should be cluttered up with having to write programs that have a GUI.

Re:Can't get there from here

[shutdown -p now]

Also, don't discount the cost of distracting syntax. Sure, to you and me it's just "turtle." at the start of each line and is easy to ignore. But someone who doesn't yet recognize the patterns it's another word to read and think about.

Are you saying that someone who speaks English would be unable to comprehend "turtle.move(10)" or "turtle.pen_up()", seriously? Especially after you explain them why it's called turtle graphics in the first place?

The only question that may arise there is the meaning of the dot. And yeah this is a diversion that has to be memorized, but a very minor one. Compared to some of the idiosyncrasies of BASIC syntax, such as "IF..END IF" but "WHILE..WEND"; or, say, how boolean operators are actually all bitwise (and there is no boolean data type at all!) and non-short-circuiting, it's positively benign.

You can, of course, make an educational dialect of BASIC that intentionally avoids all the traps. But guess what - you can do the same with Python, and make sure that all the modules you want to be "just there" are auto-imported on startup.

Re:Can't get there from here

[narcc]

Do you mean this speech? or this letter? (Dijkstra's unsubstantiated list of aphorisms.)

Oh, yeah. Neither of them mention GOTO -- that's just in the one letter I linked to above.

Funny that it doesn't mention BASIC at all...

It looks to me like the GP is still wrong.

Re:Can't get there from here

[Machtyn]

While it is still probably ASCII graphics, I sure liked Gorilla.bas

Re:Can't get there from here

[drcheap]

They're frequently right. BASIC was fun to learn as a kid but probably derailed me from ever learning proper programming.

Still using GOTO statements everywhere, I presume.

Re:Can't get there from here

[drcheap]

What language is "C/C++", exactly?

Well, if C were an int, it's a Floating point exception.
If C were a float, then it's 1.000000 except for C=0, in which case it's nan.

At least according to code written in C.

Re:Can't get there from here

[drcheap]

"Hello world" is not a useful learning experience in the way that "20 GOTO 10" is.)

10 GOTO 10

Now that's a learning experience.

Re:Can't get there from here

[c0lo]

Multi-threading is still the same rule, and can be seen as a sequential series of singular threads that have stop / pause points.

Hmmmm... I sense a mathematician structured mind here

The validity of a conceptual description of the reality is limited and will limit what you can derived from the model.

That's what happens on a single processor anyway.

For example, do you care to explain within your limited model how a GPU works? Does your model helps here? If not, wouldn't one rather drop a simplistic model (easy to understand for an 11 years old) and advance your learning?

For the matter at hand: isn't this supposed to happen for the students on a programming or CS track? I.e. if C/C++ is allegedly better than Basic and should be preffered, why stop here and not add a "better understanding of multi-threading and parallel processing" down the track? Should one stagnate at the same level of understanding one had while at age of 11 years old?

Re:Can't get there from here

[pikine]

Anyone who bothers a cursory glance at Wikipedia would have found out about what you said, but that's really not the point of what I wanted to say.

After "the C calling convention" add "of the compiler and operating system of your choice" if that pleases you.

Re:Can't get there from here

[RockDoctor]

They're frequently right. BASIC was fun to learn as a kid but probably derailed me from ever learning proper programming.

Still using GOTO statements everywhere, I presume.

Considerably dangerously, I hope.

Re:Can't get there from here

[TheRaven64]

Even on a single OS, there are multiple calling conventions. For example, when returning a structure, it is common for the caller to allocate space and then pass a hidden first argument as a pointer to that. When calling a leaf function, lots of systems will use a different calling convention, and some will use a different one for tail calls. Some operating system functions (e.g. on classic MacOS and Win32) use a different calling convention where parameters are passed left to right.

If you look in a modern C compiler, you'll see a huge amount of logic for determining exactly which calling convention to use for any given function. Things get even more fun when you include unions.

Re:Can't get there from here

[aliquis]

May I add these two to since they support other platforms and the later one seem very current (and the former one cool for east-to-make demos? =P)

http://en.wikipedia.org/wiki/Dark_Basic
http://en.wikipedia.org/wiki/PureBasic

Re:Can't get there from here

[pikine]

Let me tell you a piece of history that you won't find on Wikipedia.

The reason why Mac OS (classic) use left to right parameter passing is because that's the Pascal calling convention, which was the dominant structural language at the time Apple first came out. In fact, Inside Macintosh uses Pascal to illustrate how to write code on Mac, so I wouldn't be surprised that most of the early Mac applications were written in Pascal.

I don't actually know why Win16 uses Pascal calling convention, but Win32 uses stdcall convention which passes arguments right to left, contrary to what you claimed.

Re:Can't get there from here

[Anonymous Coward]

No it isn't. It's trying to disprove an argument by taking it to an extreme, illogical conclusion.

Re:Can't get there from here

[Anonymous Coward]

pro tip: use "RENUMBER"

Yay!

[Anonymous Coward]

10 ? "First Post";
20 Goto 10

Python vs. BASIC

[Anonymous Coward]

I learned to program pretty much with Applesoft BASIC and a Franklin Ace 1000 manual

Now I'm teaching my mom (!) to program in Python using the Hello World book.

Honestly, I wish Python were around when I was learning. Trying to squeeze a new instruction between line 11 and line 12 kinda sucked sometimes. (Then again, I wish a lot of things were around...)

Re:Python vs. BASIC

[Yaos]

Python is a easy as BASIC, and you can teach good programming practices in it. Once they get to understand programming, they can move on to the harder things without leaving the language.

Re:Python vs. BASIC

[Anonymous Coward]

I found a nice cite for that: "Python's a drop-in replacement for BASIC in the sense that Optimus Prime is a drop-in replacement for a truck." - Cory Dodt

Re:Python vs. BASIC

[BagOBones]

Why do I suddenly imagine Optimus Prime holding his cargo trailer over his head and running..

Re:Python vs. BASIC

[Hatta]

Writing a program to renumber your programs is an excellent early programming exercise.

Re:Python vs. BASIC

[Anonymous Coward]

Python's IndentationError and NameError exceptions make it one of the worst languages to learn first. A program shouldn't treat block structure or typos as run-time errors. Even FORTRAN and C fail at compile-time to teach the rules clearly. BASIC is far more forgiving.

Re:Python vs. BASIC

[thethibs]

Python doesn't have turtle graphics; the language these folk created is Basic with turtle graphics.

ClubCompy isn't Programming 101, it's fun with computers.

My kids learned Logo and got pretty good with it but neither of them codes for a living.

Re:Python vs. BASIC

[fyngyrz]

A program shouldn't treat block structure or typos as run-time errors.

Wrong. A language that actually uses whitespace should. Which is what Python does. The fact that you can't wrap your head around it isn't in any way a condemnation of Python. It just says you're inflexible, and frankly, in forty years of programming experience, I've never found lack of flexibility to be a useful trait.

Whitespace utilization in Python uses the programmer's intuition to instantly perceive block structure. This beats the heck out of scanning lines for randomly embedded (speaking spatially, now) braces. Mind you, it is possible to write C (and I do), for instance, nominally a free form language WRT whitespace, with meaningful whitespace. Really helps, especially later on, when you haven't seen the code for years.

The fact that Python *requires* whitespace is simply a means to bring your intuition to the table by force, and frankly, I think it's a good idea. That some folks can't, or won't, get it... that's unfortunate. For them. :)

Re:Python vs. BASIC

[Anonymous Coward]

What the heck are you talking about?
IndentationError _is_ a compile time error in Python as are all syntax errors.
NameErrors are run time errors, as is the case for any interpreted language like most BASIC dialects.
I think you are terribly confused.

Re:Python vs. BASIC

[SharpFang]

You seem to have missed the essential phrase run-time.

I have no beef against Python using whitespaces. But I'd rather be warned I made a typo in an obscure procedure called once a year when I first start the program, not when it encounters that procedure after a year.

Re:Python vs. BASIC

[narcc]

A language that actually uses whitespace should.

Languages shouldn't use whitespace. I thought we had established this in the 70's

Whitespace utilization in Python uses the programmer's intuition to instantly perceive block structure.

This is the most inane defense of Python's use of whitespace I've seen to date. If I want a block, I'll delineate it myself. I don't want the interpreter 'intuiting' my intentions.

Oh, wait. It doesn't use my "intuition to instantly perceive block structure". I delineate blocks myself via indentation.

Tisk, tisk. You had me all wrapped up in your magical thinking.

This beats the heck out of scanning lines for randomly embedded (speaking spatially, now) braces.

Badly formatted code is badly formatted code. Run it through a pretty-printer -- we've had those for 30 years. Problem solved.

Mind you, it is possible to write C (and I do), for instance, nominally a free form language WRT whitespace, with meaningful whitespace. Really helps, especially later on, when you haven't seen the code for years.

Yeah, this is what virtually everyone does already. Except in that case the whitespace isn't meaningful to the compiler -- just to the programmer. This is the way it should be.

The fact that Python *requires* whitespace is simply a means to bring your intuition to the table by force, and frankly, I think it's a good idea.

It in no way brings "your intuition to the table" by force or any other means. It just makes you indent your code according to Guido's preferences.

That some folks can't, or won't, get it... that's unfortunate. For them. :)

There's nothing to get -- Whitespace is how you delineate blocks in Python. There is nothing mystical here. It does not magically "bring your intuition to the table".

It DOES, however, allow Python un-aware editors to introduce errors into your program. (Think: converting tabs to spaces and the like.) It also doesn't allow you to use whitespace to format for readability. (Yes, there are cases where not indenting according to structure will actually improve legibility. You can probably quite easily think of a few examples yourself.)

I get why people like Python. What I don't understand is why they feel the need to defend this particular aspect of the language.

Even if you think meaningful whitespace is great, it should be easy to understand why other people dislike it. You should also at least be willing to acknowledge that it can, and often does, cause problems (moving code between editors or sharing code on webpages or via email, just for starters).

Really, the only benefit I can see is that you'll never be forced to look at badly-indented Python code. Considering the problems it causes, I hardly think it's worth the trade.

Re:Python vs. BASIC

[Anonymous Coward]

A program shouldn't treat block structure or typos as run-time errors.

Wrong. A language that actually uses whitespace should. Which is what Python does. The fact that you can't wrap your head around it isn't in any way a condemnation of Python. It just says you're inflexible, and frankly, in forty years of programming experience, I've never found lack of flexibility to be a useful trait.

(I'm not the GP)

A program shouldn't treat block structure or typos as run-time errors.

Emphasis on run-time, that's how I understood GP's post: "Python does good, albeit too late", because later on he praises C and Fortran for failing typo-ridden programs at compile-time. However, Python is interpreted language, not a compiled one, and check-as-you-go is expected behavior for interpreters.

Re:Python vs. BASIC

[fyngyrz]

Languages shouldn't use whitespace.

This is an absolute you have no justification to be declaring.

  I thought we had established this in the 70's

Ah. Well then, we've learned where you made your mistake. Carry on.

Re:Python vs. BASIC

[fyngyrz]

But I'd rather be warned I made a typo in an obscure procedure called once a year when I first start the program, not when it encounters that procedure after a year.

You do understand the difference between interpreted and compiled code, do you not? Yes?

And you also understand that even an aggressively picky compiler won't save you when your typo is not syntactically invalid?

It is not the language's responsibility to ensure that you are a good programmer, or that your code is "right."

This is something every assembly language programmer learns right out of the gate; something that is almost as harshly taught by C; and something that even the most syntactically precise and picky language will eventually teach you when you depend upon it to ensure the rightness of your programming.

Python does what it does very well, within the limits of the type of tool it is. Which is not to say that you can't botch up your programs if you don't give them your best effort. To be blunt, carping about a language's error checking simply shines a light on your own lack of skills. Strive to write good code, and test your code. If you write something such that it is only run into once a year -- and you put that same code into production without testing it -- someone has you doing work you're not qualified to do. Even if that someone is only you.

Re:Python vs. BASIC

[Anonymous Coward]

Trying to squeeze a new instruction between line 11 and line 12 kinda sucked sometimes.

never used AUTO 10? RENUM?

I don't like the idea of unstructured programming but how many are there which are interpreted structured languages which educators would consider are in corporate use enough to be taught to students who are about to program for the first time?

Re:Python vs. BASIC

[narcc]

This is an absolute you have no justification to be declaring.

Yep. I did not justify my assertion. You are correct.

I assume that you completely agree with the rest of my post, as you didn't raise any objections to it.

Re:Python vs. BASIC

[digitig]

Languages shouldn't use whitespace. I thought we had established this in the 70's

You want to get your religion from ancient books, go ahead. Those of us who are more scientifically minded will look to the evidence.

Re:Python vs. BASIC

[digitig]

Python doesn't have turtle graphics

Really?

Re:Python vs. BASIC

[Anonymous Coward]

>Languages shouldn't use whitespace. I thought we had established this in the 70's

"We" did? Speak for yourself.

>This is the most inane defense of Python's use of whitespace I've seen to date. If I want a block, I'll delineate it myself. I don't want the interpreter 'intuiting' my intentions.
>Oh, wait. It doesn't use my "intuition to instantly perceive block structure". I delineate blocks myself via indentation.

That's exactly what you do and that's what happens and everything works.
Note that in Python you delineate blocks yourself via indentation and in C you delineate blocks yourself via both indentation and markup. I don't see how redundancy helps.

>Yeah, this is what virtually everyone does already. Except in that case the whitespace isn't meaningful to the compiler -- just to the programmer. This is the way it should be.

I disagree, I think it being meaningful to the compiler is the way it should be. Most modern programming languages seem to agree - and it's really common sense: if you communicate, it helps when the other side perceives the world at least somewhat like you do: that is, the programming language should at least have the rudimentary two-dimensional picture of the code that you have (Python isn't perfect, but at least it's a step in the right direction).

>There's nothing to get -- Whitespace is how you delineate blocks in Python. There is nothing mystical here. It does not magically "bring your intuition to the table".
>It DOES, however, allow Python un-aware editors to introduce errors into your program. (Think: converting tabs to spaces and the like.)

That's also a problem with Makefiles and Haskell and half the tools on the planet, so if the editor is crap, the editor is crap.

> (Yes, there are cases where not indenting according to structure will actually improve legibility. You can probably quite easily think of a few examples yourself.)

Or you use a language that allows you to abstract those repeating blocks instead of stuffing the entire block into one line somehow. Ah, I remember back in the day when I did weird stuff like that.

>I get why people like Python.
>What I don't understand is why they feel the need to defend this particular aspect of the language.

Because that particular part is good, it eliminates redundancy and useless clutter. I don't know how to say it well, but I'll try: in life, places where there is nothing are as important (if not more important) as places where there is something. Whitespace matters.

>Even if you think meaningful whitespace is great, it should be easy to understand why other people dislike it.
>You should also at least be willing to acknowledge that it can, and often does, cause problems (moving code between editors or sharing code on webpages or via email, just for starters).

As I said, then you also have problems writing Makefiles, Haskell code, and so on and so on. Editor bugs are no good reason. Editors aren't exactly rocket science.
That said, I didn't have any of these problems for a decade or so now (after all, would would I have written Makefiles?).

Really, it's weird pretending that Python is somehow special in it. Many languages use significant whitespace, that's nothing new.

>Really, the only benefit I can see is that you'll never be forced to look at badly-indented Python code.

Exactly. Or if you do see one, you'll know it's broken. That's one advantage right there.

>Considering the problems it causes, I hardly think it's worth the trade.

I think it is worth the trade.

Re:Python vs. BASIC

[pjt33]

Of course it's impossible for static checking to catch all bugs - this is a well-known result. And of course programmers should write tests. But a compile-time error (or static-check error, if you prefer) costs less programmer time to debug than a run-time error - IIRC estimates I've seen vary from a factor of 3 to 10. A mistyped function name is something which can easily be picked up by static checking and result in an error or, if eval is invoked somewhere, at least a warning.

Re:Python vs. BASIC

[SharpFang]

You are horribly wrong. You're so wrong it is mind-boggling.

Interpreted code can still be parsed a'priori for syntactic validity. This won't be 100% sure (for stuff like 'eval string') but WAY better than nothing.

An aggressively picky compiler will catch 90% errors leaving the programmer with 10% as much work debugging, and the resulting production code with 90% less remaining (unnoticed) bugs overall.

The absolute responsibility of a compiler/interpreter/VM is to minimize chances of human error. Ignoring machine-detectable errors "because the programmer shouldn't have made them in the first place" is a faulty, evil design. Errors happen, will happen, and the language, IDE, compiler, automated tests, QA procedures and about every tool at programmer's disposal is intended to make detecting them easier. The wishful thinking "be a good programmer and just don't make errors, and it's not the system's job to ensure you were correct" is at fault of some of major disasters. Including at least one NASA probe crash.

Of course you can't depend on the compiler to solve all your problems and find all your bugs. But every procedure can fail. Every test can miss out things. A test can be faulty too. You ought to receive any and every suggestion of error from every source possible. You will not catch all bugs, never. But by consciously suppressing warnings from some source, you just increase the number of bugs shipped.

Also, in this thing you might have heard of, known as The Real World, there's this odd concept called "deadlines". Meaning getting every possible subroutine and condition tested before shipping is often not plausible.

Re:Python vs. BASIC

[narcc]

You want to get your religion from ancient books, go ahead. Those of us who are more scientifically minded will look to the evidence.

Okay, make your case. If you have evidence, as you claim, present it. I'm willing to evaluate it objectively.

Re:Python vs. BASIC

[jordan_robot]

... in forty years of programming experience, I've never found lack of flexibility to be a useful trait.

Except where python's whitespace rules are concerned. You really didn't see the irony when you typed this out?

Re:Python vs. BASIC

[digitig]

The fact that Python users don't have the problems with whitespace that FORTRAN users did. What was established in the 70s is that FORTRAN used whitespace badly, not that whitespace shouldn't be used.

Re:Python vs. BASIC

[thethibs]

I stand corrected.

Re:Python vs. BASIC

[Anonymous Coward]

Writing a program to renumber your programs is an excellent early programming exercise.

And many of us put our assembly language skills to use by developing utilities to allow renumbering of BASIC statements. Kids today with GUIs and IDEs and frameworks have been too insulated from the computer hardware to understand efficient algorithm design and implementation.

Re:Python vs. BASIC

[dbrueck]

One of the things I love about Python is that whitespace is significant, and for the very reason that the other poster mentioned - even in languages where you do have block delimiters, it's pretty much universally accepted that "good" style dictates that you use indentation as well - indentation expresses block structure in C, Java, etc., etc. It just makes code more readable. In any open source project or any professional setting it's the same - if you write code that isn't well-formatted (with your blocks properly indented), the code is considered bad, ugly, unprofessional.

Given that this is the case - that indenting your code is expected and good form, what purpose do the curly braces in C actually serve? They may add to readability perhaps (though in terms of readability they are much less important than the indentation itself), but in reality they exist for the parser, for the tool, and not so much for the humans reading and writing the source code. To me, this is the first indication that something is less than ideal - you're required to do something all over the place in your source code but it's not primarily for your benefit, but for the benefit of the tool you're using. Maybe this doesn't bother you, but I hope you at least appreciate in principle why it would bother some people.

The second and related problem here is that there exists the potential for errors: when a human scanning the code visually, the whitespace is a stronger indicator of the structure of the program than the curly braces are, but for the parser, it's irrelevant, only the braces matter. That's why you can get errors like:

if (i < 5);
        i++;

or

if (i < 5)
        i++;
        j++;

These are silly examples, and yet they are ones I've encountered in real code (both mine and other's). I don't know how common they are, but they sure have driven me crazy, and they demonstrate the point I'm trying to make. What I find even more telling is how some companies with coding standards deal with it: they mandate that /all/ blocks have the curlies. It's not bad per se, but again it's just mandating that things be done a certain way, not for the benefit of the folks doing the coding, but for the benefit of the tool.

Anyway, that's why I like Python: there is never ever a disconnect between my intent and the actual block structure of the program - the human and the tool are /always/ on the same page.

Two anecdotes you are free to ignore:

- All the people I've ever encountered who have persisted in objecting to Python's use of whitespace have been people who haven't actually used Python very much. Similarly, all the people I've ever encountered who have used Python for any program of substantial size, including those who initially objected to it, pretty quickly stop considering it an issue, and nearly all of them eventually come to admit that they really like it. I'm not saying this is a universal experience - but it's been interesting to observe.

- The theoretical problems that can arise (mixing editors, copying and pasting code) don't seem to happen very much in practice. I've used Python for well over a decade and off the top of my head can't think of *any* cases where it's happened to me. I'm assuming it has happened at some point, just because it's unlikely for it to never have occurred, and yet I honestly can't think of any time it actually /has/ occurred. Maybe I'm just extraordinarily lucky, or maybe it's just not something that occurs that often in practice.

I do appreciate that some people object to the significant whitespace approach - some people have real concerns, others it just rubs them the wrong way. To them I'd say (1) don't knock it until you've really tried it and (2) at least recognize that the curly braces are you serving the tool, and not the tool serving you, since you undoubtedly also use indentation to express block structure of your program.

Re:Python vs. BASIC

[TheRaven64]

So, it's like BASIC, but may occasionally fold up and crush anyone driving it to death? Actually, that does sound like the Python code I've debugged (I've never been unfortunate enough to have to write Python, but I've often had to fix Python code, usually after it was given to me as 'working').

Re:Python vs. BASIC

[Anonymous Coward]

Languages shouldn't use whitespace. I thought we had established this in the 70's

Received wisdom of what should and should not be is almost always an overbroad generalization; most modern languages are sensitive to the use of whitespace in some degree (its very common for there to be cases where the presence of a newline has a different effect than a any other whitespace, for instance.)

The particular degree and manner in which Python is sensitive to whitespace may be undesirable because of its particular effects. Certainly, I think it is, because while I think that formatting conventions are good for code clarity and readability, there are almost always exceptional cases where clarity and readability is best by varying from conventions, and Pythons particular sensitivity to whitespace prevents that.

But I don't think its all that big of a deal; any of the other differences between Python and any other languages are likely to be more important in selecting which one to use than that.

Re:Python vs. BASIC

[narcc]

This is your evidence?

The fact that Python users don't have the problems with whitespace that FORTRAN users did.

No, they have a host of new and different problems caused by the use of meaningful whitespace.

Problems moving between editors, problems sharing code via webpages and email, even problems moving chunks of code around in the source file (even the best python-aware editor will often need to make guesses about indentation.)

Simply using the wrong editor can introduce error into the source file -- that can be especially frustrating when those errors can be completely invisible.

Re:Python vs. BASIC

[Draek]

I thought we had established that editors shouldn't fuck up with tabs and spaces in the '70s. Guess we didn't.

I do acknowledge that its whitespace-aware design may cause problem with some editors. What I don't acknowledge, however, is the idea that the blame for that problem lies on Python.

Re:Python vs. BASIC

[Anonymous Coward]

I think people say "significant whitespace is bad" just to excuse the fact that they've never bothered to learn python.

But at the same time, I think people say "significant whitespace is good" because they haven't used any modern IDEs.

Python was created when whitespace was still a constant source of friction among programmers. People still used a lot of lousy editors fifteen years ago, and it was a constant headache to deal with incorrectly formatted code with a visual layout that didn't match the semantic layout. But in every programming editor I've used in the last decade, the correct indentation is handled automatically.

Whitespace just doesn't matter anymore. It's not bad or good. It's a total non-issue.

Re:Python vs. BASIC

[narcc]

I thought we had established that editors shouldn't fuck up with tabs and spaces in the '70s. Guess we didn't.

You have quite the imagination.

I do acknowledge that its whitespace-aware design may cause problem with some editors. What I don't acknowledge, however, is the idea that the blame for that problem lies on Python.

What? If it's Pythons "whitespace-aware design" that "may cause problem" I'd say that the blame lies squarely with Python.

Re:Python vs. BASIC

[digitig]

No, they have a host of new and different problems caused by the use of meaningful whitespace.

Well, that contradicts your original claim then, doesn't it? And the funny thing is, Python users don't actually have the problems you think they should have.

Re:Python vs. BASIC

[rev0lt]

The seventies are long gone, and so are (most) languages with strict indentation rules. As a former cobol programmer, I can't stand it. As a basic/pascal/delphi/assembly/c#/php developer, I can't understand why a modern language would dabble with such archaic concept. That is the main reason I wouldn't touch python code with a ten foot pole.

Re:Python vs. BASIC

[amicusNYCL]

I have no beef against Python using whitespaces. But I'd rather be warned I made a typo in an obscure procedure called once a year when I first start the program, not when it encounters that procedure after a year.

You know, some basic unit testing would catch problems like that. You may want to look into testing a little more before deploying your once-a-year code.

Re:Python vs. BASIC

[narcc]

Well, that contradicts your original claim then, doesn't it?

No, it doesn't.

Meaningful whitespace is bad because it introduces errors (which are now invisible). We did learn this in the 70's. The fact that specific problems are different is irrelevant.

And the funny thing is, Python users don't actually have the problems you think they should have.

Ah, but they do! The honest ones just admit it. If you dig through various discussions on the subject, you'll find that even the most ardent Python advocates admit the problems that meaningful whitespace causes -- they just think that the one benefit it brings is worth the trade:

See, the only argument that is (and can be) made for the use of meaningful whitespace is that it forces developers to properly intent their code -- something every experienced programmer is likely doing anyway. (some benefit!)

It's silly, if you chance to encounter improperly intended code (a rare occurrence indeed), a quick run through a pretty-printer will take care of the problem in under a second. It'll also apply whatever formatting conventions you, not Guido, think are easiest to read.

Now, with that one "benefit" comes a host of problems, like the ones I mention above and others which you can read about yourself. Is the trade-off really worth it?

I say no.

Oh, I'm still waiting for your alleged "evidence".

Re:Python vs. BASIC

[digitig]

Meaningful whitespace is bad because it introduces errors

How does meaningful whitespace introduce errors? Typing the wrong thing introduces errors, not the whitespace.

(which are now invisible)

Python will tell you where they are. Actually, so will all of the editors I use.

We did learn this in the 70's.

I was using Hollerith cards into the 1980s, and whitespace is anything but invisible on Hollerith cards. I think you might be idealising the 70s a bit.

Ah, but they do! The honest ones just admit it. If you dig through various discussions on the subject, you'll find that even the most ardent Python advocates admit the problems that meaningful whitespace causes

But it really doesn't. Non-significant whitespace has all the same problems in different forms.

It's silly, if you chance to encounter improperly intended code (a rare occurrence indeed)

Significantly less rare than improperly indented Python!

It'll also apply whatever formatting conventions you, not Guido, think are easiest to read.

The thing is, once you get rid of block start and end notation, all arguments about matching braces v. one-true-brace go away. Python is very flexible in its indenting, and the only requirement is that blocks be indented. You can indent Python the way you think is best, not the way Guido wants.

Oh, I'm still waiting for your alleged "evidence".

The fact that people don't have the problems that you insist we learned were inevitable in the 70s. You put forward a falsifiable hypothesis, and a counterexample falsifies it.

Re:Python vs. BASIC

[narcc]

The fact that people don't have the problems that you insist we learned were inevitable in the 70s. You put forward a falsifiable hypothesis, and a counterexample falsifies it.

You must be new to this reasoning and evidence thing. See, in this case, a counter example in no way falsifies my hypothesis.

Also, if you were using hollerith cards in the 80s I feel sorry for you.

The developed world had VTDs and, yes, whitespace cause no end of headaches.

How does meaningful whitespace introduce errors?

Have you read any of my posts? This has already been explained.

But it really doesn't. Non-significant whitespace has all the same problems in different forms.

What? Okay, you're just being contrary for no reason now. Explain to me insignificant whitespace causes ANY of the problems I've listed.

Really, when you write things like this it makes me wonder if you're a complete idiot or a really good troll.

Re:Python vs. BASIC

[seekertom]

"Trying to squeeze a new instruction between line 11 and line 12 kinda sucked sometimes." I never wrote a basic program line-numbered by 1's, and you see the reason why. I used 10's and 100's, depending on the complexity. I found basic to be structured, like math. Learn a few simple rules and you can begin. Add more rules and go further. You didn't need to learn more rules than necessary for the job at hand. Basic's simplicity allowed me to focus on problem solving in a step by step approach, and in doing so, learned much about general problem solving.

Re:Python vs. BASIC

[Tastecicles]

There's always "RENUM"...

Re:Python vs. BASIC

[Anonymous Coward]

Apparently you didn't learn BASIC all that well.

renum 10

that renumbers the entire program with 10's instead of 1's, so you can squeeze instructions in wherever you need.

Re:Python vs. BASIC

[SharpFang]

I think you ought to discuss it with my boss. The deadlines rarely allow time for writing test units. Unfortunately much more customers value rapid delivery and active support afterwards than spending more time waiting for a more polished product, and as the case is, the company that has its product released first wins - and bugs can be fixed later.

Sure I'm not happy about it but that's the reality out there.

Re:Python vs. BASIC

[Draek]

You have quite the imagination.

Thanks, though the statement you quoted is hardly an example of it.

What? If it's Pythons "whitespace-aware design" that "may cause problem" I'd say that the blame lies squarely with Python.

No, the problem lies squarely within poorly-designed editors, that much ought to be obvious. Are you, by any chance, the developer behind one such project? if so, I'd say fixing your own software would be far more productive than trying to hinder the adoption of a language as good and popular as Python.

Re:Python vs. BASIC

[narcc]

No, the problem lies squarely within poorly-designed editors, that much ought to be obvious.

Sorry, if I need a special editor to write code in a language, that's the fault of the language.

I hear this all the time from people defending meaningful whitespace in Python like it's some kind of revolutionary idea. In reality, it causes many more problems than the one it unnecessarily solves. This has been very well established, though you seem to be having trouble seeing this through your zealotry.

Pretending that the problems don't exist or that the problems are caused by something external is irrational.

You're free that like meaningful whitespace -- you're entitled to your subjective opinion.

You should, however, acknowledge the drawbacks. As I said before, willfully ignoring their existence is completely irrational.

Are you, by any chance, the developer behind one such project? if so, I'd say fixing your own software would be far more productive than trying to hinder the adoption of a language as good and popular as Python.

I see that you think that because I disagree with you I must have some ulterior motive? I'm sorry to inform you that I do not.

My opinion is based on reason and evidence. The fact that you refuse to acknowledge that the problems I've listed exist despite the overwhelming evidence suggests that you've based your opinions on nothing but your subjective impression of the language.

To move this discussion back on topic, we're talking about teaching programming to children. The whitespace issue will likely lead to mistakes difficult to find as students enter examples and problems from print sources (textbooks, handouts, etc.) where correct indentation may be non-obvious especially if they're struggling with the concept of blocks. They are also likely to inadvertently mix tabs and spaces -- for programmers, the distinction is obvious, not so for beginners. Consequently, it becomes an easy rule for students to accidentally ignore, leading to unnecessary problems.

Aside from that, having end of blocks clearly marked can make instruction easier as children can think of an end of block mark as a kind of instruction. (e.g. "When the interpreter sees 'next i' it jumps back to the top of the loop")

But you don't care about that. It seems your devotion to python has blinded you to it's drawbacks. I suppose you think it's perfect for all applications, including as a pedagogical aid, with no deficiencies at all.

Re:Python vs. BASIC

[Draek]

Sorry, if I need a special editor to write code in a language, that's the fault of the language.

Sorry, if I can't code in my favorite language on a given editor, that's the fault of the editor.

I hear this all the time from people defending meaningful whitespace in Python like it's some kind of revolutionary idea.

It isn't, it's merely a stylistic choice of the language, like using curly brackets or 'begin ... end' keywords.

In reality, it causes many more problems than the one it unnecessarily solves. This has been very well established, though you seem to be having trouble seeing this through your zealotry.

Wrong, any perceived "problem" with the language occurs only when using poorly-designed editors, most of the world has no such problems which is why it's still such a popular language.

Pretending that the problems don't exist or that the problems are caused by something external is irrational.

That's what I've been telling you about your choice of editor.

My opinion is based on reason and evidence. The fact that you refuse to acknowledge that the problems I've listed exist despite the overwhelming evidence suggests that you've based your opinions on nothing but your subjective impression of the language.

It'd seem to me it's you who holds an irrational zeal against Python, apparently for bringing to light the shortcomings of your own tools.

To move this discussion back on topic, we're talking about teaching programming to children. The whitespace issue will likely lead to mistakes difficult to find as students enter examples and problems from print sources (textbooks, handouts, etc.) where correct indentation may be non-obvious especially if they're struggling with the concept of blocks. They are also likely to inadvertently mix tabs and spaces -- for programmers, the distinction is obvious, not so for beginners. Consequently, it becomes an easy rule for students to accidentally ignore, leading to unnecessary problems.

Learning how to properly indentate your code is as vital as learning how to properly comment it, as such it's a lesson best taught early.

Aside from that, having end of blocks clearly marked can make instruction easier as children can think of an end of block mark as a kind of instruction. (e.g. "When the interpreter sees 'next i' it jumps back to the top of the loop")

Python does have the end of blocks clearly marked, by one level less of indentation. That, in turn, helps easily differentiate where each instruction belongs. Though that's an advantage not inherent to Python but rather to proper indentation which, as I said before, should be mandatory regardless of language.

But you don't care about that. It seems your devotion to python has blinded you to it's drawbacks. I suppose you think it's perfect for all applications, including as a pedagogical aid, with no deficiencies at all.

No, it's just that fortunately, I'm not blinded by hatred against it and believe it to be harmful in any and all circumstances, and certainly not for a reason as petty as whitespace awareness.

As far as learning goes, the language I'd recommend varies depending on the context, with Software Engineers starting with Pascal then moving on to Ada, Computer Scientists learning Python followed by Haskell, and school-age children with either Python or Lua and then, if they're willing, C. Python is certainly not the "be all, end all" of programming languages, but neither is it the anti-christ as you treat it.

Re:Python vs. BASIC

[narcc]

any perceived "problem" with the language occurs only when using poorly-designed editors,

If by "poorly designed editors" you mean any good code editor designed before Python...

Sorry, I think you've lost sight of reality.

Besides, any Well Designed code editor will have features for converting tabs to spaces (and vice versa) and features to auto indent and otherwise format code to your preferences.

As these are common and well-liked features of code editors, I find it odd that you'd call a program which included them as 'poorly designed'.

Ignoring that for just a moment, there is one unique problem that python has regardless of how good the editor is -- that's moving large blocks of code within or between source files. The editor will (in some cases) be forced to 'guess' at the intended indentation after the copy or move. In a language with traditionally delimited blocks, this isn't an issue as the average editor can automatically correct the indentation. No so with Python.

As a Python user, you should already be aware that the lexical analyzer adds indent and dedent tokens to mark blocks. When an editor is forced to guess, and guesses incorrectly, the tokens it generates for that purpose will also be wrong and it will improperly indent the code.

Why bring this up? It's a very weak argument against the use of meaningful whitespace, but it IS a clear problem with any language which uses meaningful whitespace the way python does which will exist regardless of the quality of the editor used.

It'd seem to me it's you who holds an irrational zeal against Python, apparently for bringing to light the shortcomings of your own tools.

Now I see why you're so irrational -- you struggle so with reading comprehension.

I've not said one word about hating python -- I've only talked about the problems with pythons meaningful whitespace.

But because I dared to criticize one aspect your sacred cow, you imagined that I was some sort of anti-python infidel.

As far as learning goes, the language I'd recommend varies depending on the context, with Software Engineers starting with Pascal then moving on to Ada, Computer Scientists learning Python followed by Haskell, and school-age children with either Python or Lua and then, if they're willing, C. Python is certainly not the "be all, end all" of programming languages, but neither is it the anti-christ as you treat it.

Again, I've only criticized one aspect of Python. The opinion you think I have was created whole from your imagination.

Still, your list does tell me one thing: Your advise is completely worthless.

Look at what you've produced: You took three completely random groups and wrote down which languages you (inexplicably) decided they should learn.

Here's a clue -- learning about programing has NOTHING to do with the language. Absolutely nothing. The principles taught don't change with the language.

The instructors choice of language, however, can make learning about programming easier or more difficult. That's all the impact it can have, and why this Slashdot article exists in the first place.

This is why your "software engineers should learn two nearly-dead procedural languages" and "computer scientists should learn my favorite language and a functional language" so laughable.

First, there is no reason why the students intended future profession should have any bearing on the curriculum -- the principles are the same, no matter what the student chooses to do in the future. As stated earlier, the principles you teach are the same no matter WHAT the language!

As for "school-age children" you should know (if you're handing out advice) that that covers a broad range of ages. (Consequently, a good chunk of the cognitive development spectrum.)

You should also know, that there has been a good deal of actual research done on the subject of teaching children about programming. Research of which you're clearly unaware.

Re:Python vs. BASIC

[Anonymous Coward]

Sweet! This is now more incentive for me to look into Python. I've always been very careful with whitespace and structure when programming, and I've always thought that those attributes should/could meaningfully contribute to the structure and function of the program. Glad to see a programming language agree.

Re:Python vs. BASIC

[Anonymous Coward]

A program shouldn't treat block structure or typos as run-time errors.

Wrong. A language that actually uses whitespace should.

I agree, with the wrong part, but not the reason. The reason that syntax errors like this are run-time is simple: Python doesn't have a compile step. You type your code; you run your code.

I think this person is just uncomfy with interpreted languages in general. Better not show him Matlab either.

BASIC Programmers Never Die...

[Blackwulf]

...They GOSUB and don't RETURN.

Re:BASIC Programmers Never Die...

[RoverDaddy]

Hooray! My sig is finally on-topic.

Re:BASIC Programmers Never Die...

[Anonymous Coward]

Does that make you a zombie?

Re:BASIC Programmers Never Die...

[drmitch]

And then they get an error

Re:BASIC Programmers Never Die...

[SharpFang]

10 gosub 10

the first time I found out 64KB is NOT enough for everyone.

Re:BASIC Programmers Never Die...

[Yuioup]

You mean they GOTO

Re:BASIC Programmers Never Die...

[Blackwulf]

You mean they GOTO

Nope, you can't RETURN from a GOTO. The RETURN command only works with a GOSUB, where it stores the line you came from - so you can execute the same block of code at different areas.

Um...those are teaching languages?

[Anonymous Coward]

Logo is an educational language. With the addition of Turtle Graphics, it's a great way to show a student how to deconstruct a task into components and instruct the machine to perform that task. Wanna draw a hexagon? Pen down, move a bit, turn 60 degrees, rinse and repeat.

BASIC means Beginner's All-purpose Symbolic Instruction Code. It, too, was an educational language. Of course, since so many learned it early on, it turned out to be useful to evolve it into things like VB Script, VBA, and now VB.NET, so you can do everything from web page scripting to writing spreadsheet macros to building sophisticated desktop applications with some form of BASIC.

So why is it any surprise that languages created for teaching purposes are good for teaching programming?

Re:Um...those are teaching languages?

[Anonymous Coward]

I was introduced to Logo when I was kid, and I never saw point of it. Why would I (this is me as a 7-year old kid) want to make turtle go around? I rather draw pictures or make it prints stuff on the screen or any other number of things.

Re:Um...those are teaching languages?

[shutdown -p now]

The point of Logo (and turtle graphics in general) is to teach basic algorithms and composability. You're given the most basic primitives only - lines - but then taught how you can combine those into other things. As you go, you learn loops to draw polygons, and functions to reuse that drawing code. Then recursion to draw spirals, stars and snowflakes. And so on.

Re:Um...those are teaching languages?

[TheRaven64]

It was also used at my school to teach basic geometry. We had to write programs to make different polygons by advancing a fixed amount and turning the correct distance. We later had to write a program that would work out the angle of each corner of a regular polygon from the number of sides, so you give it the number of sides that you want and it drew the polygon. It wasn't used so much for teaching programming as for teaching you that computers were good at solving specific cases of problems once you had a general solution - a lesson that lots of people seem not to learn.

yeah but

[hguorbray]

despite their limitations and age, procedural languages are a better way to teach kids (or anyone)how to think logically about the steps required to make a computer do something they want it to do.

It worked for me in 1971 on a teletype at Cory School in SJ connected to a Stanford mainframe -which I had to feed my 'saved' paper tapes to

and it will work just as well today on whatever BASIC emulators (or even VB.NET god forbid) that are available today on PCs, pads or whatever.

Although Java is probably better for middle/high school, I do believe that Basic or Logo are better for those younger who have not yet learned how to deconstruct a desired outcome into a bunch of logical steps.

-I'm just sayin'

Re:yeah but

[forkfail]

Good initial assignment:

Have them write an algorithm for a peanut butter sandwich.

Then ask where the knife came from, how they got the peanut butter out without opening the lid, etc.

Re:yeah but

[bigtone78]

What your suggesting is like trying to teach someone how a car works by first showing them a horse drawn carriage and telling them you'll work up to the real thing. I say throw them in head first and from there it's sink or swim. There's already a dearth of moronic programmers no need to create a whole new generation of them.

Re:yeah but

[camperdave]

You aren't allowed to use peanut butter as an example in schools anymore. Too many kids are allergic.

Re:yeah but

[Anonymous Coward]

Java is a great language for learning mostly because it has great tools.

Strongly typed with syntax checking/realtime warnings and completion means that you can spend most of your time writing code rather than debugging why "1" != 1 or why (a!=1 && a=1) can be true.

Re:yeah but

[Anonymous Coward]

Java? Really?

Pascal is a much better learning language. After that they should learn machine/assembly language followed by C. After those some sort of functional language like Erlang, Haskell, or whatever (not Lisp though, it's not a real functional language). Then finally a scripting language like Bash, Perl, Lua, Python, Javascript.

At no point in a scholastic career should Java, C#, or whatever fad language of the day be taught. They can learn those later after they have a solid foundation.

Re:yeah but

[narcc]

I don't know that I'd ever use a language like Java to teach programming (as a first language) to a student regardless of age. It just has too much indecipherable cruft for the beginner. Take this, for example:

public class hello
{
  public static void main(String args[])
  {
    system.out.println("Hello, World!");
  }
}

Now, if you're trying to each basic concepts like input/output, direct sequencing, bounded and conditional iteration, and conditional branching you're going to want to ignore everything except what is in the inner block. It's totally unnecessary and is confusing for the student (who can only view those lines as magical incantations that let the program work -- and that the instructor will dutifully tell them to 'just ignore'.)

Hell, I've met lot's of Java programmers who don't know why main is declared static -- to them, it's still magical -- they learned the chant which would appease the complier, but never bothered to find out why it worked.

Languages like BASIC are excellent for learning as, if for no other reason, they don't have that sort of cruft. Just about every basic around is structured -- no line numbers required, subroutines, functions, everything you need. It makes introducing new concepts to students really easy.

That said, I'm a big supporter of using Logo to introduce programming to children under 10. Turtles are fun, and the immediate feedback you get after tying a command turns the whole process into a kind of game.

Re:yeah but

[The_mad_linguist]

Then ask where the knife came from, how they got the peanut butter out without opening the lid, etc.

Ask a librarian!

Re:yeah but

[Musc]

Dearth, i don't think that word means what you think it does.

Re:yeah but

[FrootLoops]

Maybe you're right (except that dearth means an insufficient number, and you used it in the opposite sense). Maybe not, though: at some point things are just too complex to take in all at once. To take an extreme example, I could give a 5-year-old a very rigorous explanation of what a vector space is in a few minutes, but they'd have no hope of comprehending it. Extending your analogy, you might not be able to teach someone how a spaceship works without working up to it.

Re:yeah but

[Nyder]

despite their limitations and age, procedural languages are a better way to teach kids (or anyone)how to think logically about the steps required to make a computer do something they want it to do.

It worked for me in 1971 on a teletype at Cory School in SJ connected to a Stanford mainframe -which I had to feed my 'saved' paper tapes to

and it will work just as well today on whatever BASIC emulators (or even VB.NET god forbid) that are available today on PCs, pads or whatever.

Although Java is probably better for middle/high school, I do believe that Basic or Logo are better for those younger who have not yet learned how to deconstruct a desired outcome into a bunch of logical steps.

-I'm just sayin'

It's funny, but I remember my math class teaching us flowcharting, and while most the peeps didn't do any computer programming (this was the early 80's), I realized it was a way to setup a program before getting dirty with the nitty gritty. Which I'm sure is what it was for, but most the class would always complain when we did them ( and story problems) but I rathered enjoyed them.

I'm not a math dude though, when I discovered I had the teachers edition in math (geometry) that was the end of me learning math. Soon I was so far behind the others, I had to cheat off the rocker in parachute pants next to me. Funny thing is, for him being so smart ('cept maybe for his taste in clothes), I used to see him panhandling for crack during the early 2000's.

Personally, I say teach the kids basic. It's not the best language, but it's a good starter language.

Re:yeah but

[TheRaven64]

If you want to teach children, give them Smalltalk. Everything is an object and everything is directly manipulatable. You can create an inspector for any object (windows, pixels, controllers, whatever), browse the properties of that instance or the code of the class. You can create new classes by inspecting an existing class and sending it a subclass: message. You can try methods by creating an instance in the transcript and sending it messages, and you can have those objects stick around and create new ones. You can inspect the code editor itself and see how it works, and you can inspect every single object in the system in the same way. The only problem is that you then see that 'modern' IDEs are laughably primitive in comparison with where Smalltalk was in 1980.

ClubColditz

[Anonymous Coward]

# We wanted a system easy to secure, such that there are no mechanisms to escape the security of the system to manipulate either the underlying machine or the experience of other users. In this case, a language with fewer features and fewer possibilities for abstraction and cleverness is easier to audit. This meant evaluating our implementation for potential mischief.

clubcompy sounds like a miserable creativity quashing experience.

Scheme not Basic

[amightywind]

I learned Basic on a Commodore VIC-20 in 1978. I think it is a terrible choice for learning to program. I suggest newbies learn Scheme, a very simple language that will lead you as far down the rabbit hole as you are willing to go. If you are more interested in electronics you should learn C, particularly on the nice small embedded development boards that are available.

Re:Scheme not Basic

[xigxag]

You left out the important part.

WHY do you think Basic is a terrible choice for learning to program, and WHY is Scheme better?

The good and the bad, let me add the ugly...

[Anonymous Coward]

Logo is indeed a excellent beginner's language that can instill all the good programming habits that lead to great code. And if the learner is young, add some graphic library like the old turtlegraphics and you will pique their interest to go in deeper.

Basic, on the other hand, is a half-assed POS that was excreted out of an abortion, one dark Friday the 13, when Bill Gates and Belzebub got together to play a cruel joke on the universe.

Oh, the ugly.... How about Assembly Language? >:D

work with what you've got

[sankyuu]

I personally started with Logo and assembly language, but only because it was what was available in school (Logo) and on my DOS 2.0 floppy (DEBUG).
Looking back, BASIC may have been the most available language available on ROM at that time, so that's what folks used (despite that it supposedly 'mutilates the mind beyond recovery' according to Dijkstra http://en.wikiquote.org/wiki/Edsger_Dijkstra ).
I think now, javascript would have that advantage since it comes with the browser (and firefox is particular has got good debugging support for javascript).

Re:work with what you've got

[anton_kg]

I'm with you. I've started with BASIC 20 years ago and it was cool to type 10 print "A" and see "A" on the screen. Today, the char "A" on the black screen is definitely *not* impressive. People do amazing things using Javascript, like a 1kbyte size AI chess master. Go and teach HTML5, Javascript; something what is more visual like jQuery. Whatever, but no BASIC.

Re:work with what you've got

[narcc]

I've yet to see any valid criticism of BASIC. It's been a modern procedural language for more than 25 years, yet claims of it 'mutilating the mind' or forever ruining programmers who learned it as a first language abound.

What's wrong with BASIC? More importantly, what's wrong with using BASIC as a teaching language? It's got everything you need and none of the "just ingore it for now" cruft you'll find in modern languages.

Is it too much exposure to bad VB code? I've seen very good VB code -- and some of the worst VB code ever written. It never once occurred to me to blame the language for the bad code, nor praise it for the good.

On your other suggestion, teaching JavaScript as a first language (by virtue of it's availability). I would strongly recommend against it.

See, I have actually used JavaScript to introduce computer programming. The results were ... discouraging.

See, if the students aren't already familiar with HTML and CSS you get to spend two weeks of precious class time giving them a crash-course (which will require periodic review) Then you introduce events and functions -- another day lost to NOT learning about programming. (Yes, functions are important, but not comprehensible at the level the students would be at.)

It's very frustrating for the students, who feel like they're cramming for a final exam. By the time you actually get to teach some basic concepts, they're mentally exhausted.

Add to this the quicks in the various implementations of HTML, CSS, and JS in the hands of complete beginners and you've set yourself up for the worst intro class in history.

Re:work with what you've got

[billyswong]

How about really spend some time on teaching HTML and CSS, put them as the main characters of the class and start on Javascript later, maybe next semester?

Re:work with what you've got

[narcc]

How about really spend some time on teaching HTML and CSS, put them as the main characters of the class and start on Javascript later, maybe next semester?

Because it's far easier to just use a different language for the course. No new courses need to be created and no additional prerequisites are added to the current course.

Re:work with what you've got

[mikael]

Dijkstra was complaining about the first versions of BASIC which had line numbers and didn't have any flow control like IF-THEN-ELSE or WHILE-ENDWHILE . Combine that with code-monkey practises of banging in code in without any design or layout, and you would end up with spaghetti-code-monsters of applications where GOTO's would be used to jump out to what would be a subroutine (no local variables), a conditional GOTO to return to whichever routine actually made that call.

Re:work with what you've got

[Anonymous Coward]

See, if the students aren't already familiar with HTML and CSS you get to spend two weeks of precious class time giving them a crash-course

If you spent 2 weeks teaching HTML and CSS, that just means you didn’t spend 2 hours writing up a template page or 2 days writing a simple Javascript IDE. I/O can be done with prompt() and alert(), or you could build something a little more elegant with minor effort. They don’t need to know about everything Javascript interacts with before they know basic control structures and syntax.

Re:work with what you've got

[narcc]

Dijkstra was complaining about the first versions of BASIC which had line numbers and didn't have any flow control like IF-THEN-ELSE or WHILE-ENDWHILE

Why would Dijkstra complain about a version of basic that never existed? The first version at Dartmouth had IF-THEN-ELSE, just not block IFs. (It would appear that you're somewhat misinformed. I recommend you read the Dijkstra letter and speech I link to elsewhere in the discussion.)

As for railing against GOTO -- It was Wirth, not Dijkstra, that titled that infamous letter "GOTO considered harmful". (Which greatly upset Dijkstra) Dijkstra only suggested that GOTO should be avoided in structured languages.

You'll note that Wirth went as far as to eliminate break statements from Modula-2 and Pascal for the same reasons Dijkstra used against goto in the aforementioned paper. It had nothing to do with "spaghetti" code.

Oh, and the best you can come up with is an argument from authority? How about a real reason?

Keep in mind that only bad programmers wrote "spaghetti" code. That's certainly not the fault of GOTO. You don't hear people complain about "spaghetti" assembly code, do you?

(Bad programmers today write even more indecipherable OO "spaghetti" code without giving GOTO a second thought.)

Web-based programming environment...

[windcask]

"Here, son, let's look at this Wordpress site that hasn't been updated in 18 months. Now, this is called 'SQL Injection' and 'Cross-site Scripting.'"

Nothing better than learning by example...

Re:Why I Use Basic

[Anonymous Coward]

I guess it's a good thing you don't teach Unix.

Not too big of a surprise

[TythosEternal]

While high-level abstractions like .NET and Java are splendid modern tools, nothing teaches you the fundamentals of how a computer thinks and works like a line-by-line BASIC program. Two reasons off-hand: a) The leap to assembly language is natural and easily understood. b) The leap in the reverse direction, to functional languages, is mostly a simple matter of wrapping blocks in headers and return statements. If you start in a language with these two attributes, you're already 1 - 2 years into a collegiate computer science degree.

Re:Not too big of a surprise

[hardburn]

b) The leap in the reverse direction, to functional languages, is mostly a simple matter of wrapping blocks in headers and return statements.

Nay, no, notta. Functional languages make you think completely differently about how the computer operates. Simply wrapping things up like that is how you get spaghetti code. The budding programmer will tend to keep writing this way for a long time. Some never grow out of it.

If you start in a language with these two attributes, you're already 1 - 2 years into a collegiate computer science degree.

That's the biggest indictment of CS curriculums I've ever read.

Re:Not too big of a surprise

[shutdown -p now]

I suspect that by "functional" GP really meant "procedural". You don't normally get statements of any kind in truly functional languages, much less "return statements".

Re:Not too big of a surprise

[hardburn]

Either way, really. Procedural languages turn into a spaghetti mess. Functional languages won't work at all.

Re:Not too big of a surprise

[Anonymous Coward]

b) The leap in the reverse direction, to functional languages, is mostly a simple matter of wrapping blocks in headers and return statements

I think by "functional language" you might be referring to languages that support code modularization by creating and calling functions or procedures (e.g. C, Pascal). Those are not functional languages, and functional programming is something completely different from the imperative or procedural programming that BASIC teaches.

Re:Not too big of a surprise

[El_Oscuro]

I went through this same leap. Unfortunately, I also brought the bad GOTO habit from BASIC. After awhile of mysterious stack overflows in my games, I figured out that using JMP from a subroutine instead of returning from it was a very bad idea. Later I got a C-64 but didn't have the money for the Macro Assembler cartridge. So in BASIC (no longer using GOTO), I wrote an assembler which supported the full 6502 instruction set and address labels. The C-64 didn't have any kind of text editor so I wrote an EDLIN style one, also in BASIC. Using my homegrown assembler, I was able to write a simple Q*Bert style game. Best $30 I never spent!

Re:Not too big of a surprise

[Rockoon]

Procedural languages turn into a spaghetti mess.

Then what of OOP? When you get right down to it, OOP is just procedural with a heavy amount of implicit data indirection.

The original BASIC's were spaghetti 1.0 while anything fully OOP is spaghetti 2.0

..and don't even get started on the more complex OOP stuff like polymorphism, because thats spaghetti 3.0.

Re:Not too big of a surprise

[c0lo]

Procedural languages turn into a spaghetti mess.

Then what of OOP? When you get right down to it, OOP is just procedural with a heavy amount of implicit data indirection. The original BASIC's were spaghetti 1.0 while anything fully OOP is spaghetti 2.0 ..and don't even get started on the more complex OOP stuff like polymorphism, because thats spaghetti 3.0.

Template and meta-programming? spaghetti Aleph-1.

Re:Not too big of a surprise

[narcc]

went through this same leap. Unfortunately, I also brought the bad GOTO habit from BASIC. After awhile of mysterious stack overflows in my games, I figured out that using JMP from a subroutine instead of returning from it was a very bad idea.

Wait, are you telling me that using GOTO in BASIC is what prevented you from understanding the stack when you switched over to 6502 assembly?

Sorry, I don't buy it.

Nor can I imagine why (or believe that) you'd put yourself through unnecessary pain by writing a macro assembler in unstructured BASIC without using of GOTO. (It's a pretty important, and useful, aspect of flow control in BASIC on that C64.)

Best $30 I never spent!

What did you spend $30 on? It couldn't have been the Macro Assembler cartridge (you didn't have the money) Was it the C64? Did you pick it up at a garage sale in 1996? If that's the case, how much did they want for the Macro Assembler cartridge? Why would they sell the two separately?

No, this doesn't add up at all.

Re:Not too big of a surprise

[Anonymous Coward]

b) I hope you are being sarcastic here.
That's like saying Optimus Prime is just a better version of a truck.
Or like saying what matters about Calculus is the differential symbol is now a d instead of a delta. Who cares about that difference?

Functional languages are nothing like that.
And functional languages don't have a return "statement". They don't even have any statements.

Maybe you meant procedural languages. The whole debacle with naming procedures "functions" certainly adds to the overall confusion of humanity.

Re:Not too big of a surprise

[clone52431]

I don’t get the problem with GOTO either. Was he using GOTO-GOTO instead of GOSUB-RETURN? then he used CALL-JMP instead of CALL-RET or JMP-JMP?

However, he said he never spent the $30.

Re:Not too big of a surprise

[narcc]

However, he said he never spent the $30.

Ah, you are correct.

Re:Not too big of a surprise

[El_Oscuro]

I guess I left out some details. The original CALL/JMP mistake was made on an 8080 Heathkit H-89 thirty years ago when I was a kid. I wanted to play games and the only way to play them without putting in quarters (which I didn't have) was to program them yourself. The BASIC that came with the H-89 was totally shitty in every way. So I was programming in assembly without knowing jack about programming principles, and only a few months after having touched a computer. A few years later, I worked my ass off to get a (then new) C-64 so I could actually program some games with nice graphics. However, I still didn't have the $30 that a new Macro Assembler cartridge cost, so I made one myself. As far as not using GOTOs, I might have had a few in my BASIC program but only to emulate IF/THEN/ELSE type logic. Everything else was handled by nice clean subroutines like we have in .net today. Since that lesson 30 years ago, I really haven't used GOTO in much of anything.

Re:Not too big of a surprise

[narcc]

I guess I left out some details

Yes, thank you. This definitely clarifies things.

I might have had a few in my BASIC program but only to emulate IF/THEN/ELSE type logic.

GOTO was also quite handy for doing conditional iteration.

Everything else was handled by nice clean subroutines like we have in .net today. Since that lesson 30 years ago, I really haven't used GOTO in much of anything.

See everyone, you can write structured code in BASIC -- even in those old unstructured 8k ROM versions of BASIC. It's the programmer, not the language, that produces good or bad code.

The main point, of course, is that GOTO isn't inherently evil. I know how the meme got started, I just don't know why it persists.

The two folks who inadvertently started the great GOTO war were Dijkstra and Wirth -- who weren't even railing against GOTO in general and certainly not for the popular (but unfounded) "spaghetti code" reason. (You can read the original letters yourself to get their true intent. Links to them are posted several places in these comments.)

It's interesting to note that Wirth kept Break out of Pascal and Modula-2 for the exact same reasons he was opposed to the use of GOTO in structured languages -- yet this bit never spread, and people use Break (and Return, to the same effect) without a second thought.

After all, what is Break if not an unconditional branch?

That's right folks, Break is GOTO

Just let that sink in.

Basic is the best

[Anonymous Coward]

BASIC helps to teach logical though process, critical in both programming, and in business analytics. I learned BASIC on an Apple IIE back in the 80s and a C64. That knowledge went dormant, until about 10 years ago when I began using Access, Crystal, SQL (and derivatives) and now SPSS.

Slashvertizement

[SoftwareArtist]

Wow, this "story" is a really blatant advertisement for a commercial website.

No, BASIC is not a good language for much of any purpose, including education. Especially not the archaic type of BASIC they're using. Computer science really has progressed in the last four decades. Personally, I'd recommend Python as a starting language - it's easy to learn enough to do simple things, it's a well designed language that teaches good habits, and it's a "real" language that you won't outgrow as soon as you start writing anything beyond toy programs. But if you want a language designed specifically as a learning tool, there are lots of those that are a lot more modern and let you do a lot more than this company's offering: Processing, Alice, etc.

Re:Slashvertizement

[outsider007]

I came for infotainment but was disappointed to find an edutizement

Re:Slashvertizement

[guruevi]

well designed language that teaches good habits

Except for teaching you line/statement endings and how to share your source code through channels that don't keep track of tabs and spaces.

Re:Slashvertizement

[Anonymous Coward]

Favoring a language with significant whitespace over a language which has Goto is like saying Santa isn't real but the Easter Bunny is.

Re:Slashvertizement

[RzUpAnmsCwrds]

It's not even the first one from this site:

A Real World HTML 5 Benchmark

That story references the exact same website.

Re:Slashvertizement

[swilver]

Python did not do itself any favors by using idents for blocks. It makes it hard to teach on a blackboard, or any other medium that has finite space.

Re:Slashvertizement

[Anonymous Coward]

Well in 1999 I was working in an environment in which only COBOL and DYL-280 were available on the mainframe computer and there were no development tools provided on the woekstations except BASIC, maybe it was QBASIC as I cannot remember for sure. Anyway, the task at hand was to determine the number of customers within each email domain (joe@hotmail.com, helen@aol.com, gwhite@hotmail.com, etc.); to produce a viable solution to determining these counts I created a BASIC programme to parse each email address into mailbox and domain components and adding a '.' (dot character) to the file named by domain (hotmail.com => .., aol.com => ., etc.). As the final part of the programme a syscall to the filesystem (MS-DOS) to report directory listing ordered by file size to allow determination of the top X domains or most popular domains. Sure this could have been accomplished in any number of languages but all I had available was BASIC and at the time my COBOL skills were rusty enough that BASIC was the faster-to-develop solution. Sometimes being able to think creatively is more important than being uber cool. Now get off my lawn!

Re:Slashvertizement

[anegg]

I have recently chosen to use BASIC to introduce my kids to computer programming. I think it is a relatively decent choice for many reasons. It only requires a simple interpreter that runs in a terminal window. It can be used to teach programming that relates the program to what is actually being done on the processor (a series of numbered step-by-step instructions). It uses very simple data typing (numeric variables and string variables). It has very simple control-flow structures (that ultimately are what all high-level languages are broken down into).

Is it the be-all end-all of programming? No. But it gets the ball rolling as a good, uncomplicated, first approximation of what programming is that relates directly to the fundamental actions of instructions on the CPU. There is lots of time, later, to add all of the complexities of more detailed data representations and control-flow structures, including OOP.

Those who think that the presence of the GOTO statement somehow damages people's brains don't seem to have much respect for the cognitive abilities of other individuals. Anyone who has used GOTO to program, who then doesn't immediately see the benefit of GOSUB/RETURN or a function call/RETURN, and understand that the GOTO should not be used to return the control flow outside of the code unit (as delineated by other control-flow structures), needs to be gently remonstrated by their instructor for unclear thinking. Its a teaching moment, not a cerebral hemorrhage.

Re:Slashvertizement

[Anonymous Coward]

Interesting, I was taught to program in basic. Compared to your 'newer' languages my style is probally arachic but I think the principles are sound.

All programs are made up of 3 components sequences, iterations and selections. by using the simple rules and and If then else structure you can build any flow logic you like. Gosub is only used when you have more than one line of code before and else or endif.

Ie if condition 1 then
              gosub logic 1;
        else
              let x = x+1 ;

in addition functions and subroutines only have One clearly defined return. I have certainly written some programs that arent 'toys' in my working life.

Re:Slashvertizement

[BigSes]

Is there a book that you would recommend to learn Python? I learned to program BASIC about 15 years ago back in high school, and always wanted to give something more modern a try. Python sounds like the way to go, especially if it is as similar in nature as it sounds to BASIC. I don't mean a classroom "teaching" type book, unless you think that is best, I mean more of a self-teaching manual?

Teach Python instead

[talcon]

I think Python is a better contemporary choice now (and I learned on structured BASIC - QuickBASIC)

Re:Teach Python instead

[Haeleth]

BASIC has one important advantage over Python.

BASIC is not a religion.

Sure, Python is a nicer language for writing modern programs in. But the cult-like fervor that many Python advocates tend to adopt, particularly whenever the subject of learning programming comes up, is frankly rather disturbing -- and certainly not something I would want any child of mine to be exposed to in an educational environment.

Re:Teach Python instead

[digitig]

BASIC is not a religion.

Oh, I think you'll find that it is. All programming languages are. But BASIC is one of those ancient religions that nobody takes seriously any more.

Programming should begin with OO - yes really!

[robbak]

There is noting inherently complex with OO, unless you already have a head full of linear or procedural programming that you need to get rid of.

A nice, stripped-down OO language - I'd sugest parts of java if it was a free language - would be a good start. Even a graphical interface, although they are undeniable useless for real programming, would be useful for starting off.

Re:Programming should begin with OO - yes really!

[aztracker1]

I would think that JavaScript would be appropriate, it's easy enough in terms of syntax, there's a lot of flexibility, and it's an event driven, functional language with prototype based inheritance. I know it gets a bad rap, but honestly it's a very good language, and very widely available.

Re:Programming should begin with OO - yes really!

[shutdown -p now]

There is noting inherently complex with OO

There isn't, but it's one level of abstraction higher than you need to get started. One has to learn conditionals and loops and the concept of code reuse via functions before you can meaningfully explain what classes and methods and polymorphism are for - and before you get to that point, that pesky "class" keyword only gets in the way and requires handwaving along the lines of "we shall study that later".

I mean, you can certainly explain what objects and classes are to people without any programming background. The problem is explaining why they're useful. To someone who already knows basic structured programming, you can take any task that nicely fits OO modelling - e.g. any simulation, or a simple roguelike game - and suggest that they first try to implement (or describe how they're going to implement) it using the techniques they know. And then show how much more neatly it can be done with OO.

Re:Programming should begin with OO - yes really!

[narcc]

Programming should NEVER begin with OO. If for no other reason than the cruft you need to add in OO languages before you can even begin to introducing basic concepts.

Objects are great when used appropriately. However, knowing how and when to use objects takes experience. Beginners by definition don't have experience.

"Pure" OO languages are even worse. When everything is an object, you don't have a choice about when to use them and, consequently, are much more likely to use them inappropriately. (Bad OO code makes you wish you were maintaining bad VB code!)

Sure, a good programmer can write great OO code, but such programmers are extremely rare -- You're not likely to find an introductory class full of competent and experienced OO programmers.

Having taught programming to many different age groups (from children to adults) I know from experience that OO is not the way to go. You can't just start off with structure -- it's totally inappropriate. They simply can't learn to structure their code until they're capable of writing some!

Teaching someone programming is a bit like teaching someone to think. A good teaching language should let you introduce all the basic concepts like direct sequencing, bounded and conditional iteration, conditional branching, variables and types, i/o, etc. without a bunch of indecipherable code cluttering up the program and confusing the student ("magic" just-ignore-this code does not aid in the learning process).

For that, the submitter is spot-on. Languages like BASIC and Logo are excellent introductory languages. All meat and no fat. I prefer Logo for children under 10, BASIC for everyone else. I've tried Java, JavaScript, C, Pascal, and even COBOL. Nothing stays out of your way like BASIC or gives you the instant satisfaction (crucial to younger children) like Logo.

Re:Programming should begin with OO - yes really!

[robbak]

I agree with the point about "magic-just-ignore-this code". But that comes from teaching non-OO programming in an OO language.

My point is the OO is as much - maybe more - of a basic concept as iteration and branching. A programmers first 'hello world' should be taught as giving a string object to the system object.

Teaching OO as a basic concept leads more quickly into displays and graphics, even simple games rendered in 3d.

Of course, choosing your language is critical. Many OO languages have a history of being procedural with OO extensions. You end up programming that way, especially if your history is the same: Learning procedural programming, and adding OO to it.

Re:Programming should begin with OO - yes really!

[julesh]

A nice, stripped-down OO language - I'd sugest parts of java if it was a free language - would be a good start.

Err... most of Java *is* a free language. There's only a few bits and pieces (e.g. the API for mobile phone applications) that aren't free. OpenJDK includes all of the core language, AIUI.

Re:Programming should begin with OO - yes really!

[LordNacho]

While I agree OO is useful, it seems you need to have an awful lot explained to you (classes, inheritance, polymorphism, etc...) before you can actually start doing anything. And if you don't have stuff explained, you'll wonder what the heck you're looking at when you run into a new keyword. However, it can be hard to grasp what the concepts mean without something concrete to look at. It's a bit of a Catch-22.

Re:Programming should begin with OO - yes really!

[narcc]

I agree with the point about "magic-just-ignore-this code". But that comes from teaching non-OO programming in an OO language.

I suppose with the right language and lots of instruction before you start writing code, you could avoid some magic code. I just don't see why you'd *want* to start with it. It seems foolish to me to teach OO design before the student has a solid grasp of the fundamentals of programming.

Try drawing up a few lesson plans and I think you see what I mean.

My point is the OO is as much - maybe more - of a basic concept as iteration and branching.

I don't we'll find much common ground here. I can't even conceive of how OO could in any way be as or more fundamental than iteration and branching. (I honestly don't understand how you could reach this conclusion. I'd be interested if you had a way to explain this to me.)

I view OO in terms of design. (You can write OO code in non-OO languages, from a design point of view.) In that sense, it can be quite useful when applied to specific types of problems -- but in no way is it essential. (certainly not as essential as iteration or branching) I'd go as far as to say that the OO way can even be a very poor way to design an application.

I'm reminded of a question posted on a discussion board about writing a chess program. The submitter was working on a way to represent the board. He was toying with a 'piece centric' approach. (See this page for a better understanding of the problem. Board representation involves more than just a data structure.)

One of the replies was from a "pure OO" advocate, who suggested that a piece class be created from which specific piece classes (pawn, biship, etc.) could be derived.

Now, in a chess program, potentially millions of boards will be created, evaluated, and discarded as the computer attempts to determine its next move. Using the OO approach, in this case, is quite obviously the wrong thing to do.

Now, you might rightly say that this is OO misapplied (and it is), but how is a programming novice able to identify this?

A programmers first 'hello world' should be taught as giving a string object to the system object.

Again, I would disagree. It just seems too far away from what's actually happening in the computer -- and completely useless outside of the OO approach. (Which, as illustrated above, is not always the most sensible way.)

One surprising advantage of unstructured BASIC as a teaching tool is that the approach you take to structuring your programs is reasonably close to the way you'd structure a program in assembly. So close, in fact, that even in this discussion you'll find that many micro users made the leap from BASIC to assembly without difficulty.

There is no direct connection from the OO way to the machines way -- not that I expect many people to work in assembly in this modern age -- but I can see how it could hamper a transition to an imperative language. (Granted, this would be a disadvantage for declarative and functional programming as well.)

giving a string object to the system object.

I was never comfortable with strings being objects, though being an aggregate structure I could at least understand it -- the idea that scalars should be objects is just insane!

When I see things like this, it makes me think that the "pure OO" movement has taken the 'everything should be an object' mantra just a bit too far.

Please understand that I'm not anti-OO in any way. OO design is excellent for simulation or any similar design case where you have otherwise discrete components which can be seen as communicating with one another. It's just not all that useful (and potentially detrimental, as in the chess example) in other design cases.

That said, OO design, being non-essential, should wait until after the student has a solid grasp of programming fundamentals -- an advantage which imperative programming languages hold as teaching aids over OO languages for reasons stated earlier.

Re:Programming should begin with OO - yes really!

[Anonymous Coward]

There is noting inherently complex with OO, unless you already have a head full of linear or procedural programming that you need to get rid of.

A nice, stripped-down OO language - I'd sugest parts of java if it was a free language - would be a good start.

Java? Are you serious? If you are going to introduce anyone, including children, to the "joys of computer programming", then SmallTalk within an IDE is probably the least painful while providing immediate feedback. Java would turn off most children due to its complexity.

While attending university and taking a third-year compiler design and implementation course, we had to use C to produce a compiler for a special language (basic language constructs). Since we had been taught SmallTalk over the previous two years in a variety of courses (introduction to programming I & II, data structures) and most students had been exposed to C in limited way as part of a hardware course I decided to demonstrate the suitabilty of SmallTalk for the compiler course though implemented an interpreter instead. This was in addition to completing my required compiler using C. In fact, with SmallTalk I was able to implement an interpreter for the full Pascal language in less time than it took to develop the compiler for the 'special language' in C.

Re:Programming should begin with OO - yes really!

[beelsebob]

Sir, you have it backwards. OOP is linear procedural programming, it's just got additional constructs on top of it that add inconsistency and corner cases.

Re:Programming should begin with OO - yes really!

[DragonWriter]

Programming should NEVER begin with OO. If for no other reason than the cruft you need to add in OO languages before you can even begin to introducing basic concepts.

That's not really true of OO languages generally, its mostly true of the those languages whose heritage or inspiration in a static procedural language like C or Pascal that then had an OO layer bolted on to it; the Pascal-derived branch of that tree is pretty much dead now, I think, but the C-derived branch, including C++, Java, and C# is still going strong.

OO languages like Smalltalk (for class-based OO) or Self (for prototype-based OO) and those inspired by them (like Ruby and JavaScript) that haven't, somewhere along the line, tried to wed OO structure with an existing static procedural language, don't really feature much boilerplate cruft that needs to be included in simple programs before beginning to introduce basic concepts.

Re:Programming should begin with OO - yes really!

[TheRaven64]

A pure OO language, like Self or Smalltalk, is very simple. You have objects, you send them messages. The only flow control that you need is the combination of closures and messages. Neither language has an equivalent of an if statement in the language. If you want a conditional, you send an #ifTrue: message to an object with a block (closure) as the argument. The receiver is typically either the True or False singleton, which implements its #ifTrue: method by either sending a #value message to the argument or ignoring it. You can build additional loop constructs on top of it.

The notion of an object is trivial to understand. An object is a simple (special purpose) computer. It receives messages, does some computation, and sends messages to other objects. If you understand what a computer is, you understand object orientation. It's just about decomposing your problem into smaller components, each of which is implemented as a (model of a) special-purpose computer.

Trying to teach OO as a special case of procedural programming is a recipe for disaster.

Re:Programming should begin with OO - yes really!

[narcc]

OO languages like Smalltalk (for class-based OO) or Self (for prototype-based OO) and those inspired by them (like Ruby and JavaScript) that haven't, somewhere along the line, tried to wed OO structure with an existing static procedural language, don't really feature much boilerplate cruft that needs to be included in simple programs before beginning to introduce basic concepts.

So... how much cruft do think is acceptable? I think any amount is too much, for the reasons stated above.

Re:Programming should begin with OO - yes really!

[omnichad]

I disagree - but that's because my first computer was slow. CPU's don't run OO code directly. It's compiled into linear or semi-linear code - and CPU's still run mostly linear code. I say start with the GOTO's, move on to GOSUB/functions, and then move on to "Computers are fast enough that we can usually forget about all that junk, and put things into containers that make more sense to humans."
 
Not knowing how computers work leads to poor algorithms. And linear processing is something that one can understand easier than having to keep track of the layers in OO.

Re:Programming should begin with OO - yes really!

[narcc]

If you want a conditional, you send an #ifTrue: message to an object with a block (closure) as the argument. The receiver is typically either the True or False singleton, which implements its #ifTrue: method by either sending a #value message to the argument or ignoring it. You can build additional loop constructs on top of it.

Great... so... how does this make programming easier? More importantly, how does this make Learning to program easier?

The notion of an object is trivial to understand.

Yeah, but that alone does not a programmer make.

An object is a simple (special purpose) computer. It receives messages, does some computation, and sends messages to other objects. If you understand what a computer is, you understand object orientation.

See, they don't understand "what a computer is" in the sense you mean here. That's a bit of a problem from an instructional standpoint.

It's just about decomposing your problem into smaller components,

This is good, but it's not an advantage that OO holds over procedural languages in either teaching or practice. (Quite the opposite, really.)

each of which is implemented as a (model of a) special-purpose computer.

Which is great -- for already competent programmers.

Trying to teach OO as a special case of procedural programming is a recipe for disaster.

That certainly would be. Who is advocating this?

I'd much rather OO be taught as a design technique -- not the "one true way" the purists advocate.

While I agree that OO has it's place, it's no panacea -- and is most definitely an unnecessary barrier to learning the fundamentals of programming.

Re:Programming should begin with OO - yes really!

[DragonWriter]

So... how much cruft do think is acceptable?

Define "cruft" concretely enough that it is possible to measure it quantitatively, and then we can discuss that question.

I think any amount is too much, for the reasons stated above.

I don't think most dynamic OO languages impose any "cruft" that must be included before you can begin addressing basic concepts. I think that (and this is true of most procedural and functional languages in general, as well as OO languages) that there are certain concepts (e.g., arbitrary flow control) that are harder to express in those languages, which makes them less suitable for an introduction to programming whose purpose is to teach a low-level understanding of how computers work (compared to BASIC, whose structure, despite the more accessible syntax, is more similar to assembly language.)

OTOH, I think that the ease of expressing structure in functional, OO, and procedural languages makes any of those models better than old-school BASIC for teaching introductory programming in a context where the intent is to focus on designing solutions to problems. (I think each model has different strengths here, but I think a decent curriculum in this regard could be based around a language supporting any of those models, or modern multi-paradigm dynamic languages like Ruby or Python. The best specific implementation I've seen of an introduction of this type is the book How to Design Programs, which uses a series of successively more involved versions of a Scheme-derived pedagogical language.)

Re:Programming should begin with OO - yes really!

[rovolo]

I've found that beginners have a ton of trouble with "public static void main()". The only self evident keyword is 'main', and it takes them weeks of classes to understand how objects work, and thus the flow of the program. OO is complex for beginners because it requires days to get a handle on, and if you don't think that's true then you haven't actually tried to teach OO to absolute beginners.

Re:Programming should begin with OO - yes really!

[narcc]

Define "cruft" concretely enough that it is possible to measure it quantitatively, and then we can discuss that question.

Why? You quite obviously know what I mean by 'cruft' (necessary code incomprehensible to the student within the context of the material presented) and you know that I think that 0 is the only appropriate amount. It's really up to you to pick a measure if you think that some cruft is acceptable -- go with lines or characters for all it matters.

OTOH, I think that the ease of expressing structure in functional, OO, and procedural languages makes any of those models better than old-school BASIC for teaching introductory programming in a context where the intent is to focus on designing solutions to problems

Remember that the discussion is about teaching programming concepts to children. Though even if we weren't, I find it unnecessary (and consequently less-effective) to introduce structure early in the learning process.

The best specific implementation I've seen of an introduction of this type is the book How to Design Programs, which uses a series of successively more involved versions of a Scheme-derived pedagogical language.)

I'm familiar with the book and while I think it's one of the best for introducing functional programming to already competent programmers, I wouldn't use it to teach programming to beginners. Given the content, I certainly wouldn't use it to teach children under the age of 15. (This is my intuition from years of experience teaching programming at various age levels. I'm not sure that I can properly explain why I believe this to be the case.)

Re:Programming should begin with OO - yes really!

[DragonWriter]

Why? You quite obviously know what I mean by 'cruft' (necessary code incomprehensible to the student within the context of the material presented)

In that case, I would say both "zero" and say that procedural, functional, and OO languages -- which permit single-line calls to externally-implemented code that can be explained as telling something else what to do are actually are better at minimizing cruft than old-style BASIC is with mystical routines accessed with GOSUBS and arcane DATA statements.

That being said, you probably want to avoid languages where library access is "in your face" for common I/O tasks (if you have to do an explicit import of an I/O library to read from and write to the console, its probably not the best choice; OTOH it may for some languages be possible to conceal this by not using the normal program running facilities and using a "bootstrapping" mechanism which adds these things in invisibly behind the scenes; if you are teaching concepts and not the particular language and library structure, this may make sense if the other features of the language make it good for the task.)

Remember that the discussion is about teaching programming concepts to children.

I am aware of that. And I remain convinced that the relative merits of structured languages vs. something like old-style BASIC in a language to ise for that vary based on what the purpose of teaching "programming concepts" is: whether its more about teaching programming-as-a-vehicle-to-understanding-computers or programming-as-a-vehicle-to-understand-problem-solving.

That doesn't really change with the age of the audience, though there may be some reason to choose particular languages within broad families based on the age of the audience.

I'm familiar with the book and while I think it's one of the best for introducing functional programming to already competent programmers, I wouldn't use it to teach programming to beginners.

I disagree, I think HtDP great for teaching programming to beginners (I think that's what it is best for, and indeed that's what it is designed for) -- again, if the focus is on problem solving rather than understanding how computers work at a low level, either of which is a valid focus for a first course involving programming. I wouldn't consider it a great book for teaching functional programming, as such, to competent programmers, though I think could be a good book to teach competent coders to be better at structured analysis and design of solutions.

Given the content, I certainly wouldn't use it to teach children under the age of 15.

I'd agree with that as far as the book as a text is concerned, I was citing it as an illustration of a basic approach. I'd use the basic approach (though not necessarily either the book or Scheme specifically as the language) at any age where I wanted to teach programming-as-problem-solving.

Programming-as-a-window-into-the-workings-of-a-computer I think old-style BASIC is still the most accessible language for novice programmers to use. I'm not sure the best approach for that, its not really something I've spent as much time thinking about.

And the -- different but somewhat related -- programming-to-get-over-the-idea-that-its-a-magic-box-that-someone-else-has-to-make-work-for-you can you any language that is readily accessible. Old-style BASIC's line-oriented structure might make it particularly strong here for younger learners, but I'm not sure that it is better than, e.g., Logo for this.

 

Re:Programming should begin with OO - yes really!

[narcc]

In that case, I would say both "zero" and say that procedural, functional, and OO languages -- which permit single-line calls to externally-implemented code that can be explained as telling something else what to do are actually are better at minimizing cruft than old-style BASIC is with mystical routines accessed with GOSUBS and arcane DATA statements.

This doesn't make sense to me. With old unstructured BASIC there is never a case when the student would need to encounter a DATA or GOSUB without first being introduced to it. (I don't know of any mystical routines accessed via GOSUB -- any routine you'd call is one that you've written. Could you explain this further?)

That's really what makes BASIC shine in the classroom: there is never any cruft.

Lisp and Scheme (and others, like forth) share this advantage, but have other barriers, like prefix notation, that make them less than ideal.

With most (all?) OO languages, some cruft is inevitable -- even most procedural languages offer their share (C and Pascal come immediately to mind here.)

The point, of course, is why choose some when you can choose none?

if you are teaching concepts and not the particular language and library structure

Any competent teacher will be teaching concepts -- no matter what language they use for the course.

I'm convinced that the reason many beginning students fail in the classroom is the instructor is trying to teach [language] and not programming.

I remain convinced that the relative merits of structured languages vs. something like old-style BASIC in a language to ise for that vary based on what the purpose of teaching "programming concepts" is:

Well, most structured BASIC interpreters have all the classroom advantages of unstructured BASIC plus the ability to introduce subroutines and functions (that they're distinguished is also nice) after they're already familiar with blocks.

Add to that, in many structured BASICs, line numbers are optional but still supported (they can be nice from a pedagogical perspective)

whether its more about teaching programming-as-a-vehicle-to-understanding-computers or programming-as-a-vehicle-to-understand-problem-solving.

I understand why you'd make the distinction, but you can't really teach one without teaching the other to some degree. While teaching programming, the emphasis is always on problem solving, the "understanding computers" aspect is not only unavoidable but naturally blends itself into the instruction with phrases like 'the computer will ...' and 'that tells the computer to ...'.

I'd agree with that as far as the book as a text is concerned, I was citing it as an illustration of a basic approach. I'd use the basic approach (though not necessarily either the book or Scheme specifically as the language) at any age where I wanted to teach programming-as-problem-solving.

I'd disagree, on the basis of my experience. The approach the book introduces concepts in an order I see as inappropriate for beginners -- All-in-all the book is a bit ham-fisted in it's approach. Topics don't build on (or flow into) one another and Related concepts aren't generally presented together.

This isn't really a problem if you want to learn Scheme and a bit about functional programming -- it actually works rather well -- but in the classroom, such a presentation quickly turns into a confusing mess.

Programming-as-a-window-into-the-workings-of-a-computer I think old-style BASIC is still the most accessible language for novice programmers to use. I'm not sure the best approach for that, its not really something I've spent as much time thinking about.

"The best" is nebulous. It's certainly the best I've found for children 10+ and adults. (Though I use a structured BASIC)

Old-style BASIC's line-oriented structure might make it particularly strong here for younger learners, but I'm not sure that it is better than, e.g., Logo for this.

I agree. Logo really is a great choice for children 10 and under.

Re:Programming should begin with OO - yes really!

[GlassHeart]

OTOH, I think that the ease of expressing structure in functional, OO, and procedural languages makes any of those models better than old-school BASIC for teaching introductory programming in a context where the intent is to focus on designing solutions to problems.

I disagree. I think the beginner does not want to design anything, much less a complex software system. I think the beginner wants to learn how to make the computer follow some instructions, like add some numbers, or move a square from one part of the screen to another.

The rest of CS is very important, but they are only important for big programs. Just as bubble sort is perfectly adequate for an array of 10 items, splitting a program into functions only really helps when you're in the hundreds of lines of code, and OO really only begins to make sense in the thousands of lines of code. IOW, I think there's something in letting beginners make the same mistakes that our pioneers did, just before teaching them methods to avoid those mistakes.

Re:Programming should begin with OO - yes really!

[Anonymous Coward]

Beginning with OO is utter madness. As a sibling post already said, you need to add a lot of boilerplate code to actually make your program run. (See "http://www.ariel.com.au/jokes/The_Evolution_of_a_Programmer.html .)

Since a lot of students don't like that, you use an IDE like Eclipse. Then they don't know how to compile their code on a terminal. They probably will have no idea whatsoever about actually building a project. For a seasoned developer who knows his shit, IDEs are 'mkay, but for students still learning the language? They'll be crippled forever, far worse than BASIC could cripple them.

Re:Programming should begin with OO - yes really!

[DragonWriter]

I disagree. I think the beginner does not want to design anything, much less a complex software system. I think the beginner wants to learn how to make the computer follow some instructions, like add some numbers, or move a square from one part of the screen to another.

I think you are misunderstanding what I wrote. I am not arguing that "the beginner" wants a design focus. In fact, people who are new to programming may want different things, and may not know what they want.

In the part of GP that you quote in your post, I refer to suitability of certain programming languages to a first course where the intent (of the course) is to focus on designing solutions to problems (inherently, this is not "complex software systems", although the skills learned in such a course are transferrable to more complex systems.)

In other parts of GP, I refer to the suitability of different programming langauges for first courses with a different focus.

To the extent that your post rests on the idea that "the beginner", universally, has a single preference and thus that there is only one true and correct focus for a first course, I disagree strongly, and to the extent that your post appears to be directed as a response to a perception that part of my post was arguing on the same premise but with ascribing a different singular preference to "the beginner" I feel obliged to point out that that is a misreading of what I wrote.

Re:Programming should begin with OO - yes really!

[DragonWriter]

This doesn't make sense to me. With old unstructured BASIC there is never a case when the student would need to encounter a DATA or GOSUB without first being introduced to it. (I don't know of any mystical routines accessed via GOSUB -- any routine you'd call is one that you've written. Could you explain this further?)

IME, its very common and useful for introductory courses, regardless of language, to want, fairly early on, to introduce simple concepts through compelling demonstration uses which rely on things whose implementation relies on techniques that have not been taught (and in some cases which are beyond the scope of the course.) In structured languages where this can be presented as a simple call out, this isn't distracting. Where you have to include the code directly, it is distracting.

Lisp and Scheme (and others, like forth) share this advantage, but have other barriers, like prefix notation, that make them less than ideal.

Prefix notation for procedure and function application is fairly directly analogous to verb-first word order in natural language, which is what, for instance, English uses for the imperative and for many questions. Since procedure and function application maps fairly directly to either imperative commands or questions, prefix notation should be fairly easy to teach to English speakers.

It probably makes things harder if you start trying to teach prefix notation focussing on mathematical operations using mathematic symbols rather than words for operators, since that does conflict with how people are used to seeing those things used.

The leap from the sentence "add 5 and 5" to "add 5 5" (in REBOL) or "(add 5 5)" (in a language using lispish notation) is fairly obvious.

The leap from "5 + 5" to "(+ 5 5)" is greater.

(Incidentally, that's one of the things I do think is a problem with HtDP.)

I'd disagree, on the basis of my experience. The approach the book introduces concepts in an order I see as inappropriate for beginners -- All-in-all the book is a bit ham-fisted in it's approach. Topics don't build on (or flow into) one another and Related concepts aren't generally presented together.

Its kind of hard to respond to subjective impressions with no specific cited basis, so I'll just say that I think that my subjective impression is that the topics in the book do build on each other quite well (the approach builds both breadth and depth as the course progresses, which I personally find is better than breadth-first -- e.g., covering all simple operations before starting either function definitions or control structures -- which is really the only alternative.)

This isn't really a problem if you want to learn Scheme and a bit about functional programming -- it actually works rather well -- but in the classroom, such a presentation quickly turns into a confusing mess.

Again, I don't think that's really the strength of HtBP. What its really good for is learning general approaches to problem analysis and solution design with programming as a vehicle; it teaches less about computers as technology and more about analysis than most introductory approaches. Given its stated intent, that's unsurprising.

Re:Programming should begin with OO - yes really!

[narcc]

Prefix notation for procedure and function application is fairly directly analogous to verb-first word order in natural language, which is what, for instance, English uses for the imperative and for many questions. Since procedure and function application maps fairly directly to either imperative commands or questions, prefix notation should be fairly easy to teach to English speakers.

Yes, it can be taught fairly easily and quickly. However, it is a distraction and complete waste of class time. You will be teaching prefix notation and not computer programming -- likely wasting a whole day. It also adds another stumbling block -- while I doubt they'd struggle converting 2 + 2 to + 2 2, converting 2 + 2 - 3 or anything more complicated will be a struggle without an acquired fluency. (Which they won't have after that wasted day of instruction.)

As we're talking about teaching children, you may need more than one day -- days that are wasted doing math and not programming. It's an excellent way to kill their interest!

IME, its very common and useful for introductory courses, regardless of language, to want, fairly early on, to introduce simple concepts through compelling demonstration uses which rely on things whose implementation relies on techniques that have not been taught (and in some cases which are beyond the scope of the course.) In structured languages where this can be presented as a simple call out, this isn't distracting. Where you have to include the code directly, it is distracting.

In that case, it's at the discretion of the instructor -- not forced upon him. Though in the classes I've taught, I've never found the need to use, in an example, anything that the student has not been exposed to. (with cruft-free languages anyhow) Of course, I take great care when preparing the course to ensure this. (This has the additional benefit of forcing me to present the material in such a way that concepts build directly atop one another. I've found this to be very effective.)

the approach builds both breadth and depth as the course progresses, which I personally find is better than breadth-first -- e.g., covering all simple operations before starting either function definitions or control structures -- which is really the only alternative.

It's not an either-or scenario. When you're starting from nothing, "breadth" is unavoidable -- but you needn't spend the whole course that way. If you are, you've likely stopped teaching concepts and started teaching [insert language].

While I generally don't cover functions until later, some control structures (like conditional branching) do get attention early.

I wait on functions because they're simply not important that early, and can be distracting.

Of course, we're still only talking about the first 3 weeks of a course (4, if you've got a slow class ;) ) Most of the "depth" enters in afterward as they explore common algorithms and data structures.

I'm curious, do you have much experience teaching?

Kids these days

[Anonymous Coward]

Back in the day, when I programmed a Harvard Mark III computer, you had to check out the entire computer six weeks in advance and then enter your program from the console, under tremendous time pressure, using switches for 1's and 0's. There were no compilers and no operating systems. If you made a single mistake, either during preparation or program entry you were hosed. If any vacuum tube blew or relay malfunctioned during your run you were hosed. If the CO showed up during your shift and commandeered the computer for some emergency purpose, you were out of luck. If the Germans attacked the base during your run - and sometimes they did - you were out of luck.

Is it 1994 again?

[mmaniaci]

BASIC? Really? In 2010 someone is making products with BASIC?!?!?! This has to be for legacy supp... wait you say it isn't? WHAT THE FUCK!!!

Please do your students a favor and use Python.

Re:Is it 1994 again?

[syousef]

BASIC? Really? In 2010 someone is making products with BASIC?!?!?! This has to be for legacy supp... wait you say it isn't? WHAT THE FUCK!!!

Please do your students a favor and use Python.

Yeah 1994 comes around every 500 lines or so. It's a bug in the code. That's what you get for using a language that depends on line numbers.

Re:Is it 1994 again?

[Anonymous Coward]

Damn, I hate that I agree with you on particularly the first line. I hate it, because as a programming consultant, I've been given a very large project that must be written entirely in WinWrap Basic--a dialect of Basic meant to feel exactly like VBA. Due to the program that this project plugs into, along with the constraints of how this will be used in conjunction with that program, this shitty excuse of a language is all that I have at my disposal.

Now, excuse me while I go sit in a dark corner and cry.

Re:Is it 1994 again?

[ziggyzaggy]

I'd rather my students not think of white space as significant. that's so gay

Re:Is it 1994 again?

[Anonymous Coward]

Do try not to be such a twat. BASIC is still hands-down the best way to teach young kids programming. Anything else is simply too complicated.

Re:Is it 1994 again?

[narcc]

What's wrong with BASIC?

You recommend Python as a teaching language instead, which I find confusing. Nothing suggests "my students will be confused" more than meaningful white space.

Remember that students aren't programmers -- blocks mean nothing to them. Try teaching iteration in a language where blocks end because the indentation level changes. (In BASIC, you have wend and next statements -- it gives the student an anchor for understanding the "jump back" part and clearly delineates the end of the block.) That bit of Python starts to look a bit magical from the students perspective -- and we DON'T want students to start accepting "magic" with the promise that they'll more fully understand later.

I do like the immediate mode interpreter, but the language itself just isn't well suited as a learning language.

For that purpose, BASIC and Logo have it beat.

Re:Is it 1994 again?

[SharpFang]

Interestingly, if you're looking for a job at a big business corporation (not IT-focused, just utilizing IT for its miscellaneous other goals) you'll find knowing BASIC (VB.net) does you much more good than knowing Python.

Re:Is it 1994 again?

[LordNacho]

Does VBA count as a form of Basic? From experience, a frightening amount of the world's financial institutions use it to trade huge sums of money. Go around a trading desk at your average firm, and you find everyone has a load of spaghetti code that they copied/modified themselves.

Microcomputers grew up with us.

[ZorinLynx]

Those of us who were kids in the 80s and grew up playing on microcomputers with BASIC have a very distinct property:

We grew up together with computers.

When we were kids, computers were simple, single-tasking, small memories, and it was easy for a youngster to understand the entire system. As we got older, systems got more complicated, and so did our ability to understand them.

Today's kids start with computers that are already large systems with complex operating systems, millions of times more memory than we have *disk* when we started, that are difficult to understand at a low level. I think this puts them at a loss. Every child should be able to play with and learn on an Apple II, C64, or similar small system. Of course realistically that won't happen. So emulated "systems" with simple programming languages may indeed be a good idea for today's kids.

Re:Microcomputers grew up with us.

[Nimey]

Or, you know, there's actual emulators such as AppleWin for the ][ series and VICE for the C=64 and its brethren. Also RetroForth.

Re:Microcomputers grew up with us.

[Anonymous Coward]

Why do my fellow old guys think that the old ways are the way to teach something. Go to the Photo.net site and the old guys and their hipster enablers their say that the only way to truly learn and understand photography is to shoot film.

The logic, algorithms and thought processes can be learnt perfectly well on modern "complicated" machines.

Alright, I'm getting off your lawn - stay out of my rose garden!

Re:Microcomputers grew up with us.

[underqualified]

also, we were the ones who were different: we were those kids who were fascinated by this new thing. that fascination eventually turned into passion. for kids these days, a computer is as commonplace as a door. the fascination is still there, but no longer as strong. there's no strong desire to find out how it works.

back when i was still a CS student, i could easily divide the class into two: those who had this passion for programming(self-taught during HS for the most part) and those who were there because they were told that programmers get paid well. guess who shifted after two sems?

Re:Microcomputers grew up with us.

[JoeMerchant]

I "grew up" through the TRS-80 / Apple II era, and I think that the "magic" of BASIC is still accessible on today's machines - sure you can't (easily) program super slick applications in it, but then you never could, even in the old days.

For me, BASIC was great because it was interpreted, very fast to try something and see what happens. It also had enough "power" in its relatively simple syntax (60 to 70 commands) to do a lot of things without resorting to insanely huge bloated libraries (stdlib/Boost/Qt - I'm thinking about you now...).

I don't agree with Dijkstra's comment that programmers are "ruined" by BASIC, I think programmers are ruined by too much / too little pressure to deliver working systems in too short / too long a time frame. Teach someone basic and put them in the typical high pressure to deliver quickly scenario and yes, they will fix things quickly with GOTOs - more a result of the schedule than the language. Even worse than fixing things quickly under pressure using a GOTO or two is spending 8 years teaching someone theory, then giving them so much luxury of time to architect and plan and scaffold and framework that they construct elaborate extensible polymorphic frameworks that are universally reusable for practically nothing. I've seen a lot of very ambitious code over the years that can be effectively replaced by something 1/50th the size.

Procedures are procedures, regardless of the language.

Re:Microcomputers grew up with us.

[digitalhermit]

Today's kids start with computers that are already large systems with complex operating systems, millions of times more memory than we have *disk* when we started, that are difficult to understand at a low level.

That's a good point, and largely agree that todays systems are more complicated... But there's more to it, I think. Back then, when we played with our Commodore 64s and Atari 800XLs (and Ti 99/4A and CoCos and whatnot), it was easy to fix a problem.. You just rebooted. If you screwed up something by POKEing some reserved area, you just rebooted (well, unless you had a PET and could destroy the machine with an errant POKE).

It's coming around to that point again. With older systems, and cheaper systems, it's easy to experiment again. I love Linux for this reason.. It does let me poke around in the internals of the OS and break things and fix things... Whether it's mucking around with init scripts or actually rebuilding the kernel, it does bring back that "see what this does" attitude.

Re:Microcomputers grew up with us.

[MobileTatsu-NJG]

Today's kids start with computers that are already large systems with complex operating systems, millions of times more memory than we have *disk* when we started, that are difficult to understand at a low level. I think this puts them at a loss...

I don't agree. Today's kids are making flash games, putting up websites, making short movies, and a whole slew of stuff they wouldn't have been able to do (or share) when the C64 was king. Now the entry level for doing what it is you specifically want to do with computers which means it's a LOT more accessible to today's youth. That spark of interest is worth a lot more than an understanding of what a pointer is.

Re:Microcomputers grew up with us.

[Anonymous Coward]

As we got older, systems got more complicated, and so did our ability to understand them.

As we got older, we also realize how inefficient everything is constructed.

Re:Microcomputers grew up with us.

[ziggyzaggy]

funny, I programmed in Pascal on my microcomputer in the early 80s. BASIC was the shit sandwich choice.

Re:Microcomputers grew up with us.

[Billly Gates]

Which is why Javascript and html are perfect.

Microcomputers are old and bulky compared to the sweet Ipad and cell phones that are cool. HTML 5 and AJAX will gradually replace legacy programming languages expect on the bulky old pcs used at offices that use Java and .NET. They are the new mainframe and mainframe terminals of old. Your point helped me come to that conclusion.

Seriously Basic is so 1985. It is not cool and elite to own a pc anymore and just because you thought it was cool does not mean a child thinks the same today.

No one writes pc apps anymore.

People want cool multimedia, sounds, and utilities that utilize the internet on portable devices. Google's api's is what I think about. Getting a child excited about old 8 bit color Apple IIs is like getting us excited about typewritters or steam powered trains. They are old and frighteningly laughable and obsolete.

Re:Microcomputers grew up with us.

[ZorinLynx]

I did too, but I bet your first lines of code were in BASIC. Or LOGO perhaps, depending on how early you started.

I quickly progressed, first to 6502 assembly, then to compiled languages. But my first introduction to a program was

10 PRINT "JOHN IS AWESOME"
20 GOTO 10

I bet a lot of ours was.

Re:Microcomputers grew up with us.

[aliquis]

I think not. Why should they begin with something which isn't current any longer?

You can still give simple replies or draw/put up whatever simple graphics, even if you do it through some API which uses windows and what not. For basic system understanding does it really help much if you know how to put out graphics in assembler on an Amiga when you will most likely do it through DirectX or something such nowadays?

Maybe I'm wrong. Also 4 GB / one million = 4 kB. Did the C64 put everything in RAM and then executed it? Leaving some RAM for data / overwriting things which would later be unnecessary? I had a SVI-728 but i didn't knew much about it and I don't know how much data a few laps of a cassette tape can hold =P. Compared to the 880kB DD disks of the Amiga one million feels like an exaggeration :)

99% of the RAM is wasted on unimportant stuff anyway ;)

Re:Microcomputers grew up with us.

[ziggyzaggy]

My first lines of code were in ForTran (yup, another shit sandwich) in the 70s, but of course that not on any machine I owned. Yes, played with BASIC a little but didn't care for it, though I did type in some BASIC electronics hobbyist programs from magazines (open source before Bruce and Eric, heh)

Re:Microcomputers grew up with us.

[sourcerror]

They can still program (RISC) microcontrollers in C/assembly. It's much nicer than x86. You can get one for $25 (AVR Butterfly).

Re:Microcomputers grew up with us.

[c0lo]

Or, you know, there's actual emulators such as AppleWin for the ][ series and VICE for the C=64 and its brethren. Also RetroForth.

Not as an IPhone app, though. And that's the tool I heard the new generation is using.

Re:Microcomputers grew up with us.

[mister_dave]

I rather like The Elements of Computing Systms as an educational tool, you build a computer in an emulator.

Re:Microcomputers grew up with us.

[Nyder]

Those of us who were kids in the 80s and grew up playing on microcomputers with BASIC have a very distinct property:

We grew up together with computers.

When we were kids, computers were simple, single-tasking, small memories, and it was easy for a youngster to understand the entire system. As we got older, systems got more complicated, and so did our ability to understand them.

Today's kids start with computers that are already large systems with complex operating systems, millions of times more memory than we have *disk* when we started, that are difficult to understand at a low level. I think this puts them at a loss. Every child should be able to play with and learn on an Apple II, C64, or similar small system. Of course realistically that won't happen. So emulated "systems" with simple programming languages may indeed be a good idea for today's kids.

word.

While I know some assembly, I've wanted to learn it better. So I have been on my Apple IIe. Some peeps I know think i'm crazy, and I should learn in on an x86 system. But I don't know. I'm not learning it to program modern stuff, and you don't hit the metal on PC's today like you did in the 80's. Not to mention Apple II's have a built in monitor (assembly monitor, not crt type monitor), and as the above pointed out, it has little ram and single tasking. Plus I did most my programming in basic on C64's & TRS-80's, so I find it a treat to program stuff on the Apple II.

Re:Microcomputers grew up with us.

[Anonymous Coward]

"When we were kids, computers were simple, single-tasking, small memories, and it was easy for a youngster to understand the entire system. As we got older, systems got more complicated, and so did our ability to understand them."

Agree completely. I started with a C64 and migrated to a PC with a whopping 640K of RAM and 20M hard disk. I learned Basic, Pascal, C, C++. Then I went on to bigger and better. But that was the beginning of a career in IT.

Re:Microcomputers grew up with us.

[Anonymous Coward]

Making movies, flash games, and websites really doesn't have much to do with programming. In any event, most kids aren't doing that. Instead, they are posting Facebook updates and playing X-Box.

Re:Microcomputers grew up with us.

[MobileTatsu-NJG]

Making movies, flash games, and websites really doesn't have much to do with programming.

You should look at what goes into making websites and flash games.

In any event, most kids aren't doing that. Instead, they are posting Facebook updates and playing X-Box.

Who cares what the majority is doing? It doesn't matter. What does matter is a lot more are doing it now than they were before. Blimey, I see why you posted anonymously.

Re:Microcomputers grew up with us.

[Anonymous Coward]

"Every child should be able to play with and learn on an Apple II, C64, or similar small system."

I read this and I instantly thought of programmable calculators. They sometimes use versions of BASIC, and it's easy to experiment with them and learn the language.

Re:Microcomputers grew up with us.

[omnichad]

Forget emulated - for about the price of a non-grahping calculator, we can manufacture simple tablet machines like that. Put in two or three AA batteries and it will run for 10 hours at 10MHz. Where are they, and can I have one?

Teaching Kids Programming Considered Harmful

[the eric conspiracy]

Teach them math and language skills. These are the fundamentals of programming and it is a waste of time to teach programming until these foundations are in place.

Re:Teaching Kids Programming Considered Harmful

[Proudrooster]

This works well for geeks who are interested in programming, but for the general population, it is best to get them immersed and interested first before teaching syntax, grammar, and object oriented programming principles.

Re:Teaching Kids Programming Considered Harmful

[Anonymous Coward]

That's nearly backwards. Algebra is far easier to learn if you have a reason to use it, which programming an provide in a real world way. If I had been taught programming before math, I would have had a better reason to pay attention and retain it, rather than finally understanding why those things were actually important. Same thing with complex numbers and electronics.

Re:Teaching Kids Programming Considered Harmful

[Proudrooster]

I never said it was easier. The logical path does not always work best with humans. Generally speaking, humans are emotional beings and need to connect with something before they invest or connect with it.

Even the Head First books get you up and running in Chapter 1/Day 1. If Chapter 1 were a quick review of Algebra, followed by Chapter 2 a quick review of Discrete Mathematics, followed by Chapter 3 a quick review of Logic, followed by Chapter 4 Proper Object Oriented Design, followed by Chapter 5 Design Patterns most kids would drop the course somewhere between Chapter 1 and Chapter 2.

If programming were a high school graduation requirement or tested on the ACT it could be structured differently like Physics or Chemistry. Unfortunately the USA does not seem to care about computer programming and the course is generally treated as an elective and if you are lucky, really lucky, the computer teacher will inspire you and teach you programming. Hopefully, they will start with Alice move to Java and then onto LeJos on a Lego NXT brick. Then in semester #2 move on to html, php, databases, and operating system basics.

Re:Teaching Kids Programming Considered Harmful

[syousef]

This works well for geeks who are interested in programming, but for the general population, it is best to get them immersed and interested first before teaching syntax, grammar, and object oriented programming principles.

If you aren't interested in programming, and you don't have a burning need to program, you're not going to learn it. EVER. Getting someone interested only works if they're open to being interested.

Re:Teaching Kids Programming Considered Harmful

[crazycheetah]

I can agree with you, but I learned those fundamentals of programming (more so the math) through programming. Then it all came up in school, and I was left looking around at my classmates wondering how the hell they were struggling so much with it--it was second nature to me by that time.

I'm not particularly normal, but I think it varies by person. A lot of people will do better by learning those fundamentals first, but some people can learn those fundamentals better by just being thrown into it. The day that those are both catered to outside of the likes of me just getting curious and teaching ourselves is a day that I dream of...

Re:Teaching Kids Programming Considered Harmful

[Abstrackt]

Yikes, that just sounds depressing.... What's wrong with letting kids figure it out on their own? You know what got me into programming? Logo. You feed commands to a turtle and stuff happens. After a while, I developed an interest in queuing those commands up which eventually led to learning to write code. If a kid is motivated enough they'll pick up what they need to.

Re:Teaching Kids Programming Considered Harmful

[MobileTatsu-NJG]

Teach them math and language skills. These are the fundamentals of programming and it is a waste of time to teach programming until these foundations are in place.

This is not a one-size-fits-all solution. Some, like me, may find that programming can cause an interest in developing math or language skills. What's the big question whining youngsters have about math in high school? "How am I going to use this in the real world?"

Re:Teaching Kids Programming Considered Harmful

[Bengie]

You don't "wow" kids to get good programmers. Good programmers instinctively flock to computers.

Anyone who likes to solve problems, can break a problem down step-by-step, and has a basic(no pun) grasp of Algebra will make a decent programmer.

When I went to college, there were two types of programmers: 1) Those that spent 4 days on a project to get an A, because they thought programming was cool or was easy money; 2) and those that spent 2 hours on a project to get an A-, because they love to solve problems.

Re:Teaching Kids Programming Considered Harmful

[SharpFang]

Actually, programming for fun can vastly improve your ability to learn maths, and the unforgiving syntax teaches diligence in correct spelling.

Many years before I learned the circle equation and trigonometry at school, I was already drawing sines, circles and Lissajous shapes on Atari.

sys 64738, peek, & poke won't work but GOTO wo

[Proudrooster]

Pretty cool little Commodore 64 emulator but the peek, poke, and sys commands have yet to be implemented. Luckily the GOTO command was implemented. The Java and OOP Nazis have been trying to kill GOTO for years and I am glad to see that it is still alive and well for future generations of programmers to enjoy.

If you are new to basic try this little program...

10 ? 'HELLO WORLD'
20 GOTO 10

Re:Why I Use Basic

[Haffner]

Dear FBI, please stop by sometime later this week. As you can see, I am at home at 7:12pm CST. Thanks!

FTFY

Re:sys 64738, peek, & poke won't work but GOTO

[robbak]

loop while( true )
          screen.print( "Hello World" );

Why Not Python?

[chromatic]

Personally, I'd recommend Python as a starting language...

I might, if there were a simple, cross-platform, one-click-install download bundle for all of the major operating systems which included pygame and a decent IDE, and even then I'd target motivated 13 year olds as the youngest users.

If I were trying to teach motivated ten year olds in person, I might choose Python/pygame as well.

That's not our goal, though. We're trying to help motivated eight year olds discover the joy of programming as a means of using computers as creative tools, not to produce millions of practical programmers.

Re:Why Not Python?

[shutdown -p now]

I might, if there were a simple, cross-platform, one-click-install download bundle for all of the major operating systems which included pygame and a decent IDE, and even then I'd target motivated 13 year olds as the youngest users.

Well, why not create just that?

Re:Why Not Python?

[chromatic]

That's a lot more development work for little (or no) benefit. We don't want to bundle Python. We want to teach kids to create things with computers.

Re:Why Not Python?

[SoftwareArtist]

The younger the target audience, the more important it is to have a simple, well designed language. If you're claiming that line numbers make a language easier for kids to learn, you clearly have something you're trying to sell me. Which, curiously enough, you do.

Re:Why Not Python?

[chromatic]

Try it yourself. Find a smart eight year old, then ask her to make a list of instructions for a task with obvious multi-step loops.

Re:Why Not Python?

[digitig]

Then show them how to implement what they've written as a DSL in Boo...

I'll get my coat.

Re:Why Not Python?

[JustSomeProgrammer]

I taught myself BASIC at 6 years old. I was looking for simple step 1 step 2 step 3 concepts. BASIC actually helped me learn at a really young age with the line numbers because it gave me a very concrete "Do this, then this, then this" type logic structure. I didn't use all the features of BASIC for those first few programs like no subroutines or anything like that. It was just a straight up step 1 2 3 goto step 2 type program. It really got me interested and as I learned more I wanted to do more. Eventually the line numbers became a hindrance, but in the beginning at a very young age to start programming it was exactly what I needed to get my foot in the door with 0 help or instruction beyond a guide for syntax.

I agree that line numbers aren't needed for anyone learning with instruction or looking to do something useful, but for a hit the floor running figure this out... I don't know that they are a bad thing.

"How can we teach kids how to program?"

[underqualified]

the correct question would be...

how do we get our kids interested in learning how to program?

and the answer to that would be...

tell them they're not allowed to do it.

Re:Why I Use Basic

[Snarf You]

Sounds to me like he should only be allowed to teach eunuchs.

Re:sys 64738, peek, & poke won't work but GOTO

[Proudrooster]

Error: While is a word reserved for future use.

Looks like that is on the to be implemented list as well, but GOTO works :)

I completely agree with Edsger W.Dijkstra

[McNihil]

"It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration."
- Edsger W.Dijkstra

There might be hope for subjects that started using "gosub" without ever using "goto" but I have never seen anyone having done that.

But then again IMHO today's html/javascript is one form of modern spaghetti code too so maybe BASIC should be taught because of that.

Re:I completely agree with Edsger W.Dijkstra

[Anonymous Coward]

He was insanely WRONG in that comment.

Re:I completely agree with Edsger W.Dijkstra

[volkerdi]

Famous quote, but nonsense. In many ways, trying to build large BASIC programs and ending up with unmaintainable spaghetti code is one of the most valuable lessons a programmer can learn.

Re:I completely agree with Edsger W.Dijkstra

[catbutt]

If your teaching style is to frustrate your students, rather than get them doing something fun and satisfying as quickly as possible.

Re:I completely agree with Edsger W.Dijkstra

[kenh]

Your right, programmers should always work in confined, carefully-constructed environment where there is no possibility of a program getting too large or too confusing - that will certainly prepare them for their first programming job - maintaining legacy spaghetti code, likely written in a "dead" language running on "archaic" hardware...

Re:I completely agree with Edsger W.Dijkstra

[mypalmike]

Many of the best programmers I have worked with over the years started with old-school BASIC at a young age. The simplicity of having every variable being global and having control flow explicit with line numbers makes it easy to become quickly confident and competent at some of the basic tools every good programmer needs. After that, it's a bit of a leap to get to procedural programming, but I've known many who have done it without much fuss. On the other hand, I've seen many college students utterly fail to make the much larger leap from knowing nothing about programming to being taught a language like C, where you can't write reasonable code without understanding the call stack, memory allocation, etc.

Re:I completely agree with Edsger W.Dijkstra

[c0lo]

If your teaching style is to frustrate your students, rather than get them doing something fun and satisfying as quickly as possible.

Since when programming and software engineering is supposed to be fun and satisfying as quick as possible? If that's the goal of your students, why don't they teach marketing, sales and advertisement (like... have fun deceiving your potential customers. If it doesn't work with some of them, move quickly along, you are bound to find others. Better still... pays more than anything related with engineering or science).

Re:I completely agree with Edsger W.Dijkstra

[mevets]

Agreed! BASIC becomes so cumbersome, when you step up to the next level, the reasons for better organization don't need to be explained.

FORTRAN (my first), for example, sucked for all that incomprehensible gibberish you had to add, just to do nothing; never mind the JCL wrapper.

PL/I (my second) was worse - although you could understand the silliness 'sin(x) = y;' its endless desire to please grew quickly tiresome.

After being whipped by a Swiss dominatrix pretending to be a Pascal compiler; C was like a godsend.

C remains a godsend, despite its bastard offspring (c++, java, or the insane gcc-extentions).

Simple, clean and expressive goes a long way.
But without suffering through BASIC, FORTRAN, PL/I and Pascal; I never would have appreciated it.

Re:I completely agree with Edsger W.Dijkstra

[narcc]

Dijkstra was dead wrong on that (as is evident by the millions of programmers who learned BASIC on their micros in the 80's) -- He was just hating on BASIC without reason. (Really, he never gave a reason for his anti-basic screed in that speech.)

Now, you seem to be under the impression that he was railing against GOTO (he wasn't) -- you're thinking of Niklaus Wirth (who made up the "GOTO considered harmful" title to a Dijkstra letter --which Dijkstra took exception to! Read the original letter it's more about misuse of goto in structured languages than anything else.)

I challenge anyone spreading the "BASIC is the suck" or "BASIC will destroy your brain" meme to offer a legitimate reason for their beliefs. (None of this "it teaches you bad habits" rhetorical nonsense. If that's your reason, you've got to list those "bad habits" and explain how BASIC forces or encourages you to adopt them.)

So far, no one has tried. It seems that no one has ever bothered to justify their irrational belief.

Re:I completely agree with Edsger W.Dijkstra

[Anonymous Coward]

Yes it's a good lesson. What is this primitive version of BASIC the bashers seem to be talking about? Nobody's asking them to write a multitasking windows manager on a Commodore64 for Christ's sake.
They need to take a look at a version of basic that has advanced in the last 20 years.
Try "PowerBasic" or even freaking "AutoIT".. Something that actually compiles.
even better if you want cross platform compiling look at "BlitzMax".

Re:I completely agree with Edsger W.Dijkstra

[Viol8]

Agreed. The Anti BASIC argument is nothing more than unsubstantiated group-think that allows arrogrant language snobs to have a good laugh together.

Re:I completely agree with Edsger W.Dijkstra

[Anonymous Coward]

BASIC is an ideal language for a grade school kid to start hacking in, with minimal or indifferent instruction. I remember Bill Gates once said something to the effect that he got hooked on programming after he learned about the power of FOR-NEXT loops, which could iterate thousands of times, even forever.

The compiler/linker/memory model and software engineering stuff can be learned later.

Re:I completely agree with Edsger W.Dijkstra

[avandesande]

The lesson that knowledge of a language can be discarded and replaced by better things is a good one too.

Better BASIC

[Anonymous Coward]

Try a real one. http://members.cox.net/javacoco/

"computer programming" is not "logic"

[rbrander]

You can teach people logic statements and procedures and about objects, even - with ENGLISH.

In my grade 8 class, there were no computers except the ones at the University I was by then programming with punch cards using stolen student accounts. But the math teacher asked us to write out our procedure for tying our shoes - in precise, motion-by-motion detail so another student could do it exactly the same way as we did, without help. Most people required over a page, and it was a revelation how excruciating it was. Later, in CompSci 501, I learned about logic statements and predicates and the wonderful Lewis Carrol problems ( 1: All my turtles that are not green are old....) All English.

"Computer Programming" on the other hand, is about making computers do things for you. By hook or by crook, by object or procedure, just get 'er done. I completely agree with the language snobs and detest BASIC. And I do most of my programming in it because you can make Excel about 10X more useful with just a little VBA here and there.

Learning Python or Java is just great if you plan to be a professional programmer one day, those languages can solve very large problems without the codebase becoming unmanageable. If your problem is getting a bunch of kids excited about what computers can do, you have no choice but to use whichever language will produce results with the greatest WOW factor with the shortest learning time.

That cuts out ALL verbose languages, languages that demand typing. The "Hello world" program should be one statement long.

Notice that doesn't chop out Perl or Python. But also notice that at kid-levels, those languages can only take screen input and produce text output. That was cool for me in the 1970's but I think today you'll get better results with something that can go graphical right away. (This also just cut out your original BASIC).

So, if your school has MS-Office on every machine, well, as a FLOSS fan I hate you, but you're crazy if you don't leverage the presence of VBA. You can show them what cool stuff a computer can do with Excel alone, show them some formulas in action and all that. (This, by the way, keeps them from thinking of "computer programming" as necessarily procedural right there - clearly, you are instructing the computer, but you are NOT using a procedure, just setting up conditions for behaviour of the cell objects!)

Then show them procedural programming by modifying the spreadsheet with VBA. This can lead quickly to manipulating the Excel data structure, which is a huge collection of objects with properties and methods. Many can manipulate charts in pretty ways, or turn Excel into "graph paper" with coloured cells in funny shapes, like ASCII art. You can take it all the way to them inventing their own objects in VBA.

AND: It will be useful in a job, even if they only learn to write 10-liners. Bonus.

Re:"computer programming" is not "logic"

[tepples]

You can teach people logic statements and procedures and about objects, even - with ENGLISH.

I didn't know Pick OS was still around.

I think today you'll get better results with something that can go graphical right away. (This also just cut out your original BASIC).

Then the answer might be to make some sort of dumbed-down sprite graphics library on top of Pygame.

Re:"computer programming" is not "logic"

[chichilalescu]

Python (and I assume Perl) can go graphical right away if you set them up to use gnuplot properly.
I have to make a lot of figures for my work, and I wrote myself a subroutine that calls gnuplot to create an eps directly from Python; for a generic problem, it's trivial to set it up that you compile a full LaTeX document, describing some problem and a resulting graph. And you can just show kids the details if they want them, but they wouldn't need all of them.

As far as algorithms go... I would just have a class on Rubik's cube (the 2^3 version). That's enough for the base concepts, and kids should be able to understand it before they're 10.

Re:"computer programming" is not "logic"

[Anonymous Coward]

You can teach people logic statements and procedures and about objects, even - with ENGLISH.

So, you're advocating the use of COBOL as a teaching language? ;)

Re:"computer programming" is not "logic"

[datSilencer]

No offense man, but really, I would be more inclined to get kids started with something like Python (as suggested somewhere above). The reason being that, in some jobs I've been, I've seen unlucky co workers inheriting VBA code base abominations which were born inside Excel. Code base abominations of course, can manifest in every language, but I've seen them more frequently in the VBA + Excel combination. My point is that they should also learn that with great power comes... you know :P... great responsibility. Cheers.

Re:"computer programming" is not "logic"

[Anonymous Coward]

Notice that doesn't chop out Perl or Python. But also notice that at kid-levels, those languages can only take screen input and produce text output. That was cool for me in the 1970's but I think today you'll get better results with something that can go graphical right away. (This also just cut out your original BASIC).

I've recently started learning Python and the fact it has a built-in GUI toolkit was a big WOW factor for me. Then again, I'm a nerd and a professional programmer so I'm not sure newbies would be so WOW'ed by it. Either way, it gets you creating visual stuff in real time with an interpreted language which is pretty cool.

http://wiki.python.org/moin/TkInter

Yes, Python :)

[kripkenstein]

Personally, I'd recommend Python as a starting language...

I might, if there were a simple, cross-platform, one-click-install download bundle for all of the major operating systems which included pygame and a decent IDE, and even then I'd target motivated 13 year olds as the youngest users.

You can run Python directly in the browser - no need for installs at all. In fact one of the motivations for getting CPython working in JavaScript was for things like this. (Note: It doesn't work perfectly yet, but all the hard work is already done.)

For a basic IDE, that demo includes Skywriter. Integrating some additional features like load/save etc. would make it very usable I think.

Regarding pygame: It would be possible to get something like that working in the browser, targeting an HTML canvas element. See this demo for C++ code written against SDL, compiled into JavaScript and an SDL implementation that targets a canvas.

Re:Yes, Python :)

[chromatic]

I agree that it's possible, but we decided that rather than producing a stripped-down version of Python or Scheme or Smalltalk which runs client-side in the browser and includes graphics primitives, we'd enhance a simpler language designed for teaching. Remember, we're not trying to produce professional programmers. We're trying to produce people who see computers as tools which they can use to create, not just consume.

Re:Yes, Python :)

[SoftwareArtist]

Processing is also available in a version that runs directly in the browser: http://processingjs.org/

Re:Yes, Python :)

[Anonymous Coward]

Very cool :-)

Simple things seem to work.

Unfortunately, the first higher-order thing I tried doesn't work:

f = lambda item: (item * 2)
print(f(2))

Traceback (most recent call last):

File "", line 4, in

File "", line 3, in

UnboundLocalError
:
local variable 'item' referenced before assignment

That said, I like the idea :-)

Re:Yes, Python :)

[TheRaven64]

The VPRI guys already have a version of Smalltalk that runs in a browser. Some guys at Sun already ported the Squeak Morphic UI (originally from Self) to JavaScript.

Re:Yes, Python :)

[chromatic]

Thanks, I'll take a look at the VPRI project. That's very tempting.

Java For the Loss!

[Anonymous Coward]

Could always teach them java.

First they would have to install the java interpreter, and then some class libraries.

Then, they would have to figure out what to import to run "hello world".

Then, they could share their java program with other people, as long as they have the same version of the interpreter, and the same class libraries.

Then, when something doesn't work, they can sift through a huge stack trace and figure out they missed a semi colon.

Or, we can use basic, not have to worry about libraries, versions, etc, and concentrate on algorithms, etc.

Java is great for those who want to learn how to type.

BASIC is great for those who want to learn how to program.

Re:Java For the Loss!

[Anonymous Coward]

First they would have to install the java interpreter, and then some class libraries.

The essential class libraries come with the interpreter; you never get one without the other. And it's not like BASIC is bundled with computers any more.

Then, they would have to figure out what to import to run "hello world".

Answer: absolutely nothing.

Then, they could share their java program with other people, as long as they have the same version of the interpreter, and the same class libraries.

Um, what? You make it sound like Java breaks source-code compatibility with every point release, which is totally untrue; most Java code written in the last 5 years will work with any current version of Java.

And I really don't have a clue what the fuck you think you're talking about with all this "class libraries" bullshit. Java has a single standard library that contains 99% of the functionality required by any program, and it is the same everywhere.

Then, when something doesn't work, they can sift through a huge stack trace and figure out they missed a semi colon.

If you miss a semicolon, the compiler tells you. Just like in BASIC. Except it happens at compile time, not just whenever the interpreter happens to reach the erroneous line.

Or, we can use basic, not have to worry about libraries, versions, etc

Yes! Unlike nasty Java, with its single well-defined standard, BASIC is so simple, because there is no standard and every single implementation does everything differently! So you don't need to worry about libraries and versions, because there are no libraries, and every version is completely incompatible with every other version!

Er, wait, no, you've kind of got every single thing wrong there.

It is true that BASIC is a better starting point than Java, but that is because BASIC presents programs as a simple list of instructions, whereas Java hides all that behind a mess of objects and classes. Nothing to do with interpreters, class libraries, or stack traces.

How to teach programming

[QuoteMstr]

When teaching students how to program (which is entirely different from teaching them computer science), you should begin with the most fundamental concepts: talk about raw memory and opcodes. Discuss briefly how these instructions are actually interpreted and implemented (how a half-adder works is fascinating, even if most people never have to build one in real life).

Once your students understand how to make computers do basic things with raw instructions, teach them jumps, conditionals, loops, and even subroutines. After that, introduce higher-level languages and compilers, and demonstrate that the compiler merely automates what your students have already been doing. From there, teach progressively higher-level constructs, including second-order function references, data structures, and so on. Object-orientation falls out naturally once you get to structures and function pointers.

If you follow this approach, your students will have an understanding of the entire abstraction hierarchy, which is not only of immensely practical value, but also underscores the principle that nothing in this field is "magical". You can always pierce an abstraction, and even more importantly, erect new abstractions where appropriate. The most common flaw I find in programmers is the inability or unwillingness to build new abstractions. The only way we make progress in this field is by the old reductionist approach of breaking a hard problem into smaller parts and attacking each individually. When you teach your students how to do that by demonstrating the power of abstraction, you make them better programmers.

Programmers shown UML, Java class graphs, and so on right away become too familiar with that level of abstraction. They think of lower levels as some kind of magic and don't realize they can and should build their own levels on top of what they're given. The result is often incoherent, rambling, brittle, and ugly code. Don't let that happen.

Re:How to teach programming

[EvanED]

I have given this a lot of thought over the years (I'm not in a position to actually test the hypotheses, so I don't have empirical evidence to support my position) and I understand where you are coming from. (There was a /. post a long time ago about this book and I think it's a really interesting approach.)

That said, I think in general it would fail miserably. There are a bunch of drawbacks. First, if you write in assembly you are basically completely tied to a particular platform. If you use a higher-level language -- even just bumping it up to C -- then the students have the freedom to use "whatever" they want. Your lab computers have Linux and they have Windows? No good if you teach assembly. Your lab has Windows and they have OS X? No good. Your lab has recent Apples and they have an old G5? No good. Want to allow them to work on their choice of platform? Have fun grading. Logistically, this is very difficult. (C isn't perfect in this regard -- but it is pretty darn close compared to assembly if you stay away from C99-specific features.)

The second problem is more pedagogical. If the students aren't actually interested in learning, they aren't going to learn. And I think it'd be much easier to get most of them interested if they can actually program something that is useful and/or cool. You can spout off all you want about how "why we're doing all this will make sense in a year or two" and it won't help. Programs that are one of those two things are usually at least mildly complex, and thus the low-levelness of asm would be a true hindrance in achieving that goal.

Personally, I think you'd have far more success (in terms of both students continuing through the curriculum and in terms of understanding of the material) if you approached the material you suggest in the opposite order: start out with a language that is actually reasonable to use for creating neat stuff, show them how to create neat stuff, then gradually unroll the layers.

Re:How to teach programming

[FrootLoops]

In one of my CS classes, the instructors made their own cut-down version of assembly and gave us an interpreter written in Java, for cross-platform compatibility I assume.

I think the parent and grandparent posts are targeting different audiences. The parent is trying to interest people in CS, while the grandparent is dealing with people who are already interested. People who are already interested, realistically, will mostly have computer experience--sometimes very significant experience. Because of that the ground up approach might get a bit pedantic for that audience.

My CS program followed the sequence (in order) of "let's learn Python!", "let's dabble in Java, Scheme, and basic algorithms!", "now let's get serious and do some C++ with lots of data structures", "go learn about the low-level hardware you've been using", "zoom wayyy out and learn about basic hardcore theoretical cs", "*elective time!*". I'd say it was actually pretty effective. It stimulated interest early for a long trek through more tedious low level material later. Then again, it also showed me how much I don't want programming to be my life's work, and how happy I am to also have a math degree.

Re:How to teach programming

[DerekLyons]

If you follow this approach, your students will have an understanding of the entire abstraction hierarchy, which is not only of immensely practical value, but also underscores the principle that nothing in this field is "magical".

Those students who don't run screaming into the night or aren't bored into a zombie state, sure. But that won't be many.
 

The only way we make progress in this field is by the old reductionist approach of breaking a hard problem into smaller parts and attacking each individually. When you teach your students how to do that by demonstrating the power of abstraction, you make them better programmers.

You won't teach them how to do that with the method you propose - which does the exact opposite, it takes smaller parts and incomprehensibly links them into bigger parts then discards the bigger parts for a new set of smaller parts and repeats the process.

Re:How to teach programming

[LordNacho]

While computers have a traceable abstraction hierarchy from transistors and up, is that really the best way to teach stuff? The point of each abstraction is (partly) to hide the underlying layer. Aren't we better off starting at the top, and diving down as we become more curious? While you're right that building your own abstraction is necessary for programming, wouldn't you say the students ought to have a look at how others have built the underlying layers in the first place?

Re:How to teach programming

[jeffliott]

Lets face it - not every future programmer is cut out for that level of understanding. Those who need it, will learn it. Those who don't can safely ignore it. Teaching as you say would waste a great deal of time for the bulk of future programmers who will probably end up working in higher level languages for their entire careers.

Re:How to teach programming

[Anonymous Coward]

Teaching young students programming by first introducing them to electronic circuit diagrams, binary truth tables, and the inner workings of the CPU is the surest way to make 90% of them (of those initially interested) lose interest. Young students want to do something cool with programming: make games, make websites, whatever. Once they understand higher-level concepts like variables, expressions, assignment, statements, conditions, etc., they might have enough interest to take a brief detour into assembly language to better understand the nitty-gritty.

Re:How to teach programming

[Anonymous Coward]

When teaching students how to program (which is entirely different from teaching them computer science), you should begin with the most fundamental concepts: talk about raw memory and opcodes.

Memory and opcodes? Are you sure you want to start out at such a high level?

In my day, elementary school programmers started out with experiments to derive Maxwell's equations. And then used that knowledge to build the transistors that make up the memory and opcodes. And we liked it that way.

Memory and opcodes.... you kids don't know how easy you have it.

Re:How to teach programming

[Veretax]

This is pretty similar to what I went through.

Early on I learned TI Basic, then C64 Basic, then IBM Basic, they were all similar but were different contexts and quirks at times. Then when I got into Engineering, we learned C (In Borland Environment), and MATLAB. MATLAB was cool for being able to do a certain set of problems, but beyond our signals and processing class I have never used it since. Then we started taking CS classes where they taught you Ada, then later Data Structures with Ada, then another class on C on a *ix system learning about multi processing etc. I didn't really get into true C++ until I got my first professional job, and Java I picked up a book to learn a bit about it, but hardly use it. Now I dabble in C#, VB, VBA, PHP, etc. So I disagree that Basic kills you, but I do think given environments today, a safer environment to learn, might be best especially for young coders.

Breaking news

[Anonymous Coward]

Languages designed for teaching coding to kids are useful for teaching coding to kids.

Also, water is wet, pope is catholic.

Worthy Cause

[Anonymous Coward]

This looks like a great place to donate a few bucks, especially in light of the article last week about how most schools don't have anything approaching Computer Science classes these days (if they ever did). Anecdotally, there are plenty of graduates with a BS in CS who couldn't traverse a binary tree if their lives depended on it, and I think a lot of that is due to students who have no actual background in programming before entering college or university. I dropped $10 in the jar, and I'd encourage anyone who's concerned about the future of CS talent to do the same. I don't know if it will help, but it seems like something worth trying.

Full disclosure: I've been looking for a way to show my kids about programming for a while now. There are standalone BASIC and LOGO IDEs, but I think the social/online aspect of this project is something that will appeal to a lot of kids, especially since they can't just hang out at a friend's house making games that rival the latest commercial titles anymore. Almost nothing of the culture that drew me to computers in the 80s exists today.

Posting AC since I already moderated in this discussion..

Get them going first

[Goboxer]

Perhaps the reason we start at a higher level than BASIC is because we want the kids to get in there and start going first. A hello world program is pretty exciting. But if it takes you a shit ton of time to make it happen you aren't going to capture the attentions. A simple program should be simple. I know I found the underlying structure and commands a hell of a lot more interesting once I saw what their higher level counter-parts could do.

Abstraction == Good

[Anonymous Coward]

Today's kids start with computers that are already large systems with complex operating systems, millions of times more memory than we have *disk* when we started, that are difficult to understand at a low level.

Actually, there's another side to this.
We now have much greater abstraction between the developer and the underlying hardware -- so you don't need to fully understand how to position a hard-drive head, or write assembly or even proper memory management[*].

Today's kids will have the "next big ideas", do we really want to scare them away by forcing them to worry about all the things we lost hair over?
The closer we can get them to turning ideas into working software the better.

[*] Blasphemy, I know... but leaving it up to Java or .Net can make things much easier to learn.

Re:Abstraction == Good

[ZorinLynx]

I think there's a lot of benefit gained from learning how the underlying guts of things work.

For one, understanding the underlying guts can help a lot in understanding why something is failing in a mysterious way.

For two, it would be a serious problem if the art of implementing the lower-level guts of a system stopped improving. The attitude of "It's already done, why mess with it?" means that we'll end up systems which don't reach their full potential because nobody is trying to improve the bare-metal.

Re:Abstraction == Good

[Anonymous Coward]

I think there's a lot of benefit gained from learning how the underlying guts of things work.

Understood, but I don't need to know how an internal combustion engine works in order to drive.
And for the vast majority of drivers, that's the case.

For two, it would be a serious problem if the art of implementing the lower-level guts of a system stopped improving.

Someone will always be working at that level (someone always has).
It's like saying "we have planes now so no one will ever travel by boat or car again".

I guess we're talking about the difference between "Computer Science" and "Programming".
Both paths are necessary, but one is not necessarily a prerequisite for the other.

Hell, get kids going on HTML.
Then add Javascript.
Then add a PHP (or JSP, ASP) back-end.
Throw in a database.

Get them thinking about the importance of things like "syntax" first; get the foundation of an engineer's brain.

You can follow that up with all the ASM you want, but just like "Jurassic Park" got kids interested in dinosaurs, and "Buck Rogers" for space, there needs to be a decent "hook" to get them started.

And saying "learn this to build the next FriendFace" is more appealing than "learn these dozen esoteric technologies before you can see any results"

Re:Abstraction == Good

[anegg]

My kid is interested in learning how to build and program robots. He *needs* to understand how to perform low-level tasks on a computer-driven machine. I don't think he will be "scared away" by the complexity. I see him being fascinated that he knows what is going on at the lowest level. Oh - he also has an electronics set so that he knows what AND, OR, NAND, and NOR circuits look like. I also plan on showing him exactly *how* a machine-language instruction set is implemented in silicon. He can always think at an abstract higher level even though he knows the lowest levels. However, I suspect that solving a problem at a high-level caused by a low-level aberration without understanding the fundamental low-level representation of the higher-level processes would be quite difficult.

Depends on which version of BASIC

[pedantic bore]

The answer to "Why teach programming with BASIC?" depends on which language called BASIC you mean, and the answers vary from "You don't know better" to "You want to teach them how to write quick one-off VBA macros, not to program" to "You passionately hate your students."

Assuming that you want to teach them to program, use a language that incorporates some modern language features and gives them room to grow, but has enough in terms of training wheels that they aren't distracted or frustrated by unnecessary trivia. Python, Ruby, maybe C#.

Learning BASIC led me to a CS degree

[t'mbert]

I learned to program in BASIC, on an Apple ][+, back in the early 80's when I was 10 or 11. I loved it, but I started wondering how programs like word processors could access a large document in RAM, and work with files bigger than available memory, and other mysteries...which led me to learn C (with a classic Borland C compiler) at 15, and eventually to a CS degree.

In my case, BASIC (and I did LOGO too) didn't ruin me, it made me more curious and moved me into the more complex languages. When I got to college, data structures class was a piece of cake, as I'd already done linked lists and other structures while learning C, and I could easily deal with pointers and pointer arithmetic, multiple indirection, function pointers, and more. I feel a debt of gratitude to the humble BASIC language.

Just a couple weeks ago, I started teaching my son Apple BASIC from a web-based Apple BASIC emulator, hoping that he'll be as excited about programming as I was.

Beginners All-purpose Symbolic Instruction Code

[meerling]

Gee, you might think that name stood for something... I heard about it many many years ago. Some programmer wrote it to be easy for newbs to learn to program with... Now what was it...

Oh yes, I remember now! Basic!

Sarcasm aside, Basic is an acronym for Beginners All-purpose Symbolic Instruction Code, and yes, it was written to be used in teaching newcomers how to program, so it's absolutely no surprise that some people have found it useful for that purpose. (It's about as surprising as finding out that snakes slither...)

Scratch

[gmuslera]

When i first saw Scratch, included with the XO, got stunned on how powerful it was, and how visual and intuitivel could be for the children. Not sure if there is a web based implementation, but is open, available for all platforms, and maybe more important, already included in a computer meant for children (not sure how much it count in the rest of the world, but in my country almost all school chidren have it).

Re:Scratch

[cacba]

The android app inventor is web based version of scratch for android.

Not written from chrome.

Re:Scratch

[DrugCheese]

Yeah me and my son spent countless hours playing around and laughing over the crazy things we were able to do with scratch. Fun to learn programming and foster creativity.

Re:Scratch

[Anonymous Coward]

There IS a web based implementation caled appinventor for android. It is really, really cool.

Link: http://appinventor.googlelabs.com

Cheers,

Re:Scratch

[Anonymous Coward]

Second this. Scratch IS for the current generation what basic was to us. It is simple enough for a four-year-old to understand (and actually make functional games with), and yet deep enough to do real time ray tracing (for sufficient relaxed definitions of real time). Anyone who has not tried scratch needs to do so. RIGHT NOW. No there is not a web based application, but it does run on LINUX, and features the ability to convert your creation to java and upload them to the scratch website.

Why not?

[drolli]

Kids are Kids. They should play. The more they play the better. They can learn basic first, then the others.

While i personally always would use an opamp at work to build a precision measurement amplifier, if i had a kid i would start to teach them electronics by building a simple amplifier using one transistor or two.

pascal

[smash]

I've got a big soft spot for pascal. I started wtih basic, and then LOGO (home computer had basic, then logo in school as a kid), but Pascal was the first useful language that actually taught me about data types, functions, and later, object oriented programming (TPv6).

Its easy to read, not prone to bugs like using = when you mean == (in C), and fast enough to get useful stuff done.

Problem with programming these days is that to get anything useful done you're buried under a hundred layers of toolkits and abstraction from what is actually going on.

Give kids an old PC with a copy of DOS, turbo pascal and some basic instructions on VGA mode 0x13 and you can write fun stuff pretty quickly.

Re:pascal

[A Friendly Troll]

Give kids an old PC with a copy of DOS, turbo pascal and some basic instructions on VGA mode 0x13 and you can write fun stuff pretty quickly.

One of the great things about Pascal 15-20 years ago was that it ran like lightning. Those were still the days of old 286-386 machines with slow hard drives, and when you compared Turbo/Borland Pascal/C++, the difference in getting your program to run was just HUGE.

In TP/BP, you'd press Ctrl+F9, and your program would be running in a second.

In TC/BC, you'd press Ctrl+F9, and wait for half a minute until the compiler and the linker did their job.

Now, when you're a kid, and when you make tons of programming errors, the speed difference is very, very important. In the classroom as well.

I actually learned C first and then switched to Pascal because I had a shit PC. Never really regretted it. Later on, in Windows, we got Delphi, which was a truly incredible development environment. Ah, the memories...

These days I'm doing VB.NET development (though I'm proficient in C#), as I've grown accustomed to language verbosity and words instead of symbols. It just reads better in my mind.

VB.NET

[tepples]

However the statement that "Programmers who've learnt BASIC tend to be harder to retrain in a modern object oriented language" requires statistical study.

Is C# "a modern object oriented language"? If so, then there's a dialect of BASIC that requires little or no retraining because it's functionally equivalent to C#, just with different syntax. It's called Visual Basic, and it's part of Microsoft Visual Studio Express.

Re:VB.NET

[Anonymous Coward]

It's called Visual Basic

Are you trying to prove that basic is harmful or not?

Re:VB.NET

[FrootLoops]

VB.NET is a dialect of BASIC in much the same way English is a dialect of Old English--that is, the names are similar.

Re:VB.NET

[syousef]

VB.NOT is not traditional basic. VB6 was much closer, but even that was a huge departure.

Re:VB.NET

[Joce640k]

Go read the daily WTF for a while...

Some people think that programming OUGHT to have high barriers to entry.

Re:VB.NET

[Anonymous Coward]

Visual Basic may be "a modern object oriented language", but I assure you it is not BASIC.

Re:VB.NET

[DJRumpy]

The basic foundation of the language is the same, although of course VB is decades newer and therefore uses more complex methods and properties. I just don't understand this concept that someone who was taught basic (ala 1980's basic) can't learn OOP. It assumes that the programming language is somehow burned into your thought processes to such an extent that you can no longer think 'outside the box', which is patently ridiculous.

Every language I work with has core concepts based in old Basic to some extent. That doesn't mean I can't take the leap from line numbers to object models.

Re:VB.NET

[FrootLoops]

I'd say the "basic foundation" of VB.NET is OOP and interaction with a GUI. I guess both '80's BASIC and VB.NET are imperative languages instead of a functional language like Lisp or weirder languages like Prolog, but still, I don't see how they're similar in any other meaningful way....

But I agree, BASIC hate is kinda like MS hate in that it's socially convenient for nerds to do so, above and beyond whatever reasoning there might be to back up that hate.

Classic 8-bit micros' ROMs are copyrighted

[tepples]

Or, you know, there's actual emulators such as AppleWin for the ][ series

How did the author of AppleWin get the right to redistribute the Apple IIe's copyrighted ROM?

Re:Classic 8-bit micros' ROMs are copyrighted

[0123456]

I believe the Sinclair ROMs have officially been released for emulator use. No idea about Apple but I'd be surprised if they had done the same.

Re:Classic 8-bit micros' ROMs are copyrighted

[Nimey]

Beats me. Maybe Apple released them gratis like they did some of their older software, like System 6 for the //gs and Mac System 7.

Re:Classic 8-bit micros' ROMs are copyrighted

[Rockoon]

How did the author of AppleWin get the right to redistribute the Apple IIe's copyrighted ROM?

I don't think that Microsoft protects this copyright.

(What... you didn't know?)

Re:Classic 8-bit micros' ROMs are copyrighted

[tepples]

How did the author of AppleWin get the right to redistribute the Apple IIe's copyrighted ROM?

I don't think that Microsoft protects this copyright.

Only 83 percent of the Apple II Plus ROM ("Applesoft BASIC", $D000-$F7FF) is Microsoft's work. The rest ("Monitor", $F800-$FFFF) is Apple's. There are a few more pieces of Apple's work (such as "Mini-Assembler") in the enhanced Apple IIe ROM.

Re:Classic 8-bit micros' ROMs are copyrighted

[Nyder]

Or, you know, there's actual emulators such as AppleWin for the ][ series

How did the author of AppleWin get the right to redistribute the Apple IIe's copyrighted ROM?

Who cares?

Modern Apple can screw itself over how they treated the Apple II's.

And those that mod me as a troll don't know the history of Apple.

Re:Classic 8-bit micros' ROMs are copyrighted

[tepples]

How did the author of AppleWin get the right to redistribute the Apple IIe's copyrighted ROM?

Who cares?

A school system that wants to distribute copies of AppleWin to its students and doesn't want to get sued cares.

Re:Classic 8-bit micros' ROMs are copyrighted

[Nimey]

It's distributed under the GPL and there are no ROM files, as such, included with it.

Back in the day, Apple was really open about their design; they'd even post ROM listings. With all that information, perhaps the project reverse-engineered the ROMs, or Apple was cool with them including 30-year-old software that they had no hope of making a single dollar on ever again.

I very much doubt your putative school district would have anything to worry about. Further, I doubt they'd go to the trouble of using an emulator; more likely they'd teach the kids Visual Basic or AppleScript or Python.

Let's not kid ourselves: old line-number BASIC without any sort of proper text editor is a nasty and frustrating way to learn programming. I was there.

simple rules of first programming languages

[RichMan]

1) no type declarations
      - it gets in the way of learning how to do stuff
2) interactive command line
      - you need to be able to see the variables and change them
      - edit run debug is part of the learning process we don't want them separated yet
3) persistent environment
      - being able to interact with the variable and program set is part of the learning process

Suitable base types: basic, logo, lisp, matlab/octave

I would really suggest Matlab/Octave for high school math.

For those that hate basic because of the lack of structure, use COMAL. Similar substitutions may be made for the other languages.

(smash (1351))
>> Problem with programming these days is that to get anything useful done you're buried under a hundred layers of toolkits and abstraction from what is actually going on.

Anyone looked at BASIC since line numbers went?

[Invisible Now]

Line numbers and gosub/goto s haven't been used since the mid80s.

Ever program with a VBA object model, using Intellisense prompting? Name a better, more complete, and useful IDE environment...

Count curly brackets all you want. Regard semicolons as essential. But you can't craft code that reads like simple English in any other language. Well named objects only make BASIC better.

BASIC is like the O'Reilly cover that was chosen for it: A big friendly St. Bernard or a language.

If you haven't built dozens of useful, maintainable, systems quickly, with small teams, maybe you should keep an open mind...?

Re:Anyone looked at BASIC since line numbers went?

[thethibs]

It's not a St.Bernard, It's a Newfie.

Re:Anyone looked at BASIC since line numbers went?

[Anonymous Coward]

Ever program with a VBA object model, using Intellisense prompting? Name a better, more complete, and useful IDE environment...

Squeak

Count curly brackets all you want. Regard semicolons as essential. But you can't craft code that reads like simple English in any other language.

Smalltalk

Re:Anyone looked at BASIC since line numbers went?

[backwardMechanic]

I have to script in VBA for a large commercial package I use. It's like a bad trip back to the 80s. I knew things were going to be fun when I discovered that the square root function is called sqr().

My favourite part is the 'object oriented' bit. It's like a bad parody of OO misunderstood. There is no object orientation - as far as I can tell, a VBA object would barely pass for a C struct.

Add to that a rather 'special' vendor interpretation of OO (no doubt guided by the VBA way), and I find myself building CAD models where the transform (rotation, translation, etc) is the object, to which I pass the ...um... shape (even in plain English I struggle not to call it an object!) by its name as a string. The code is virtually unreadable, even by me, and I wrote it.

The faster VBA dies, the better. I'm not sure it really counts as BASIC. Go and try Python - it's actually fun to write.

Re:Anyone looked at BASIC since line numbers went?

[pjt33]

Ever program with a VBA object model, using Intellisense prompting? Name a better, more complete, and useful IDE environment...

Is the search facility as useless as in VS2008? If so, Eclipse.

Re:Anyone looked at BASIC since line numbers went?

[Anonymous Coward]

But you can't craft code that reads like simple English in any other language.

COBOL would like to have a word with you.

Re:Anyone looked at BASIC since line numbers went?

[lbates_35476]

>>But you can't craft code that reads like simple English in any other language.

O but I disagree. Python "real" code is as close to "pseudo code" as you can get. It is amazing how little you actually have to do to pseudo code to translate it into Python working code. Python also works as a procedural and an OO language. I came from a background of Basic, Fortran, Pascal, Cobol, etc. (35+ years at this point) and moving into Python was VERY easy. I just kept writing procedural code and it worked fine. When I discovered OO in Python, I was really impressed.

I taught in the Computer Honors program at my local University for several years and would have loved to have taught my students Python instead of BASIC and Fortran (but that was a long time ago). It has the power of being interpreted (which is really important for learning), but the power of an industrial strength OO language to build non-trivial real world applications.

Other reasons to teach Python is that it is EVERYWHERE and free. You can get a consistent Python runtime on virtually all platforms, but not a consistent BASIC or for that matter a consistent version of virtually any other language except maybe C (which would be a TERRIBLE teaching language). Using Python I can write to a web framework (Django, Zope) in the morning, write a Windows Service or COM object in the afternoon, and write a Linux/Macintosh GUI app or daemon in the evening. I dare you to do that in any other language. You can't begin to do that with BASIC, Java, or C#.

Re:sys 64738, peek, & poke won't work but GOTO

[shutdown -p now]

The Java and OOP Nazis have been trying to kill GOTO for years

It depends on what kind of Nazis. C# still has it, for one, even though it came long after Java (and is otherwise similar).

Voc-Ed or Navel Gazing?

[gafisher]

The perennial question ought to be "Why should we teach kids to program?" Was it the essence of the industrial revolution to teach every child to operate a spinning jenny or a steam engine? Society's goal ought not to be to make each student a master of the newest tool, but to teach them how to live in a society which that new tool has changed. Some will naturally gravitate toward the technological side, and may become invaluable for the abilities they develop, but the world does not need a population of composers, designers, writers, builders, leaders and more who are first of all amateur programmers.

Certainly those of us who write code needed this vocational education, but it is shortsighted or arrogant to think everyone else does.

Re:Voc-Ed or Navel Gazing?

[John Hasler]

Society's goal ought not to be to make each student a master of the newest tool, but to teach them how to live in a society which that new tool has changed.

But they already know how to send text messages with their thumbs.

Octave - the math tool

[RichMan]

Granted most will not think of it as a programming environment. But it has all that is needed.

http://www.gnu.org/software/octave/

If then, else for ....

It has all the fundamentals.
It allows you to plot all those high school math functions.
It has a persistent environment/cut-and-paste commands for debugging and looking at your state space.

And it is free to all, so great for the education system.

Re:Octave - the math tool

[RichMan]

Here is your introductory sort lesson, complete with graphs

octave-3.2.3:18> x=rand(100,1)*100;
octave-3.2.3:19> size(x)
ans =

      100 1

octave-3.2.3:20> plot(x); % see we have 100 values, all from 0 to 100 in a random order
octave-3.2.3:21> for j=1:99; for i=j+1:100; if x(i) plot(x); % see we now have 100 values in a nondecreasing order
octave-3.2.3:23>

BASIC rocks

[Pugwash69]

I worked for 11 years writing payroll applications in a version of basic. It powered a significant number of payroll systems in the UK and probably accounts for most people's wage slips even today. Now I write web sites in ASP, running VBScript. BASIC lives and will always have a place.

I like turtles!

[Requiem18th]

But snakes are better. Kidding aside. Python is based on ABC which was an educational language just the same.

Ack AWK!

[Billy the Mountain]

I bet awk would be a good first language. You can do interesting things almost immediately with it and when you delve deeper you start getting the rudiments of C syntax which leads to a good many of other languages. Plus it gets you thinking about regular expressions. Then you can go on to C++, Java or ruby for OOP.

Re:Why I Use Basic

[Anonymous Coward]

What makes you fools think I'm not a chick? Plenty of ladies like 'em hot and young.

Perl

[motorhead]

Just saying...

MOD Parent Up

[walterbyrd]

Seems that every time BASIC gets mentioned on slashdot, everybody jumps to the conclusion that nothing has changed since GW-BASIC.

I was programming, professionally, with BASIC, in the early eighties. Never used a GOTO, or a line number, once.

Might also be worth mentioning that BASIC commands are also used in spreadsheets, and other applications.

Re:MOD Parent Up

[plopez]

I feel the same way about Fortran. The latest versions support OOP very well, are much safer and more consistent than C++, much safer than C, as fast as C (faster than any interpreted language, no matter how good the VM is), and supports parallel processing from the ground up. If you need a GUI, use Java or C# to write a web app and link in the library. It is the 60 year old "language of the future".

Re:MOD PARENT UP

[EvanED]

Saying that the smartest programmers you know "are the ones who know their low-level stuff" is not a very supportive reason for that sequence of teaching. All it says is that, when all is said and done, they had learned those things at some point. Did they start there? Did they end there? Who knows? Did they know those things because they actually had the interest to learn them for the same reasons that they are the best programmers you know? Is there, in fact, not really a causal relation at all?

As an old timer...

[MrWin2kMan]

who learned AppleBASIC, and COBOL, and FORTRAN, I feel the best 'beginner' language is still TurboPASCAL. It's basic enough for teaching concepts, and powerful enough to do advanced techniques before graduating to C++ or Java. If you want a language that's actually used professionally, there's always VisualBASIC, which again can teach you the basic concepts which you can then build upon.

Re:As an old timer...

[smash]

Seconded. It was my third language (Basic and LOGO being prior), but the first one actually useful for much.

You can get away with a hello world being about 5 lines of code, comes with a nice IDE that doesn't get in the way (v6 or 7 even have syntax highlighting which helps) and you can actually write some pretty cool stuff with it. I even wrote a couple of small PC games with it with full 256 colour graphics and sound - you could use inline assembly to help speed things up too.

Re:sys 64738, peek, & poke won't work but GOTO

[MobileTatsu-NJG]

loop while( true )

          screen.print( "Hello World" );

GRrr!! I typed Screen.print and it just gave me a stupid error! I hate this language!!!1!

I would tend toward C

[Tjp($)pjT]

Why C? Because it allows the easy introduction of the mechanisms for expressions, evaluation of expressions, and looping constructs. Then when appropriate theory is taught, objects can be introduced using two of the most common metaphors by branching to Objective-C and C++.

Remember that C is dead simple as a language. Most of the perceived complexity is in the use of the optional libraries. When in a post introduction phase you need say, regular expression evaluation, or something like sparse arrays to match the theory you teach alongside the practical course (catch a theme here?) you have several well designed libraries to invoke. Want an advanced course in generative algorithms? Well, C++ templates can be a very powerful tool. The "C" family of languages covers basic applications level programming to constructs that allow code very close to the hardware.

Post learning C you have the tools to learn other languages without much headache. I love APL, but as a first language its a nightmare (unless you are an engineering, physics or math major and won't program regularly in the real world, then it's a perfect language! Unless you're in the US Financial industry where IBM sold APL and it still is going strong.)... And Dartmouth Basic is the basic to avoid, similarly RPG, and FORTRAN are right out along with COBOL. Each has a place (somewhere far away I hope) in the real world, and except for RPG I've made money on contracts for all of them. But as a beginning language they establish bad patterns of behavior and expectations. Where "C" falls down is that it takes a competent instructor. But I can write a bad program in any language.

Modern "Basic" languages are not "BASIC" as it was from Dartmouth and don't have a lot of the failings or foibles. Real Software has RealBasic which is an awesome cross platform tool, so write once execute a real self contained program on Linux, Mac OS X or Windows xxx. It has Classes and inheritance and mechanisms for interfaces. It has properties for the classes. It is not remotely related to Dartmouth Basic except in the use of Basic as part of the name. I'd recommend it if they'd actually fix bugs posted _for years_ by multiple people to the support forums. It is a nice product for user interfaces, and I still use it when cross platform UI is an issue. But write the backends in C++ sometimes as custom plug-ins. But it is not my first choice for teaching the intro comp sci folks. It is overly complex for a newbie. It requires an instructor that could separate issues from teaching.

Again C to start, object models in Objective-C and/or C++ then complex subjects from there as needed.

Teach BASIC on 8-bit machines

[hessian]

Get the kids Apple ][s so they can learn good programming:

* Use RAM and disk sparingly
* Integrate BASIC with assembly
* Write simple drivers and disk routines
* Learn telecommunications from the bit level
* Learn how spaghetti code sucks the life out of you

Logo, BASIC and assembly provide all the fun a kid needs. Well, maybe not all... but a good start to learning CS from the ground up.

2 years of Logo during elementary school. FU, CC!

[Anonymous Coward]

BASIC leaves you brain-damaged, Logo leaves you bitter and scarred inside. Perfect combo. 93.5% of kids benefit more from watching adult content more than being trained in this abomination.

Nice slashvertisement, what about Microsoft Kudo?

[Anonymous Coward]

Not to burst ClubCompy's bubble, but this has already been done, and VERY well, with the microsoft Kudo project (http://research.microsoft.com/en-us/projects/kodu/).

Yes, the technology involved in Compy has kind of a cool factor being all javascript, but the demos on the website run at a sluggish pace on my Core2 Duo. I agree quite a bit with the intention, but question its execution (disclaimer - I work in research dealing with serious games for education, particularly teaching programming). Just from what I see, this is far behind existing products already available, if not advertised very well. I'm just generally underwhelmed.

It also smells a bit of slashvertisement trying to meet the Kickstarter deadline.

My first language was BASIC, second Logo

[jrincayc]

I originally learned to programming on a Commodore 64 using BASIC. My second language was Logo on the C64. I have since programmed in over a dozen languages, and I don't think starting with BASIC harmed me. It's just a matter of learning that there are alternatives in the newer languages.

I do think that Logo is a better starting language than BASIC, since it has things like user defined functions and better list handling.

Re:sys 64738, peek, & poke won't work but GOTO

[Anonymous Coward]

Yeah, I was disappointed that there's no PEEK or POKE or other more powerful commands to be discovered. Seems kind of limited to me.

So

[ledow]

So the *BEGINNER'S* All-purpose Symbolic Instruction Code, and a language created exclusively for educational use are great languages for demonstrating and teaching kids how to program? What a shocker. You "surprised" yourselves how/why? By having ridiculous notions that "any idiot" knows how to teach kids better than the experts who set out in the 60's and 70's to EXPRESSLY do just that ?

You've been suckered by language-purists, people who spend so long arguing about WHICH programming language to write something in that I could have written something in ten languages before they come to any conclusions whatsoever. BASIC is *wonderful* for teaching programming. I know, I've done it, from class-mates back in the 80's to modern-day kids nearly 30 years later. And yet my ENTIRE intake year for university sat through a whole year of Java lectures from a qualified professional and still didn't understand what half the statements they were using actually DID, while I didn't attend a single lecture and passed the course just by emailing in the assignments from home 30 mins before they were due. That's not to make me a genius, I was just taught properly, encouraged to learn, and started with simple tools - I wasn't forced to learn, by rote, a complex tool that requires deep understanding to know what it's actually doing. I started on something I *could* understand and progressed in steps. BASIC didn't corrupt me, it was a stepping stone that I outgrew.

When you teach a child to write, you don't teach a 2-year-old quill-calligraphy, or demand their first piece in iambic pentameter. You give them a crayon. If it hits the paper 3 times out of 10 you congratulate them. Then you progress to more advanced things as the need requires. But guess what? If you think that's the last time you'll ever write anything with a crayon, you're wrong. If you're still submitting your CV (resume) in orange crayon aged 30, you have a problem (the same as someone routinely programming important code in BASIC at the same level of experience). But neither should you go and hunt down a quill and parchment to scribble the note that says you're out of toilet roll.

Some people can't understand that BASIC is *excellent* for teaching. It was *designed* that way, and beats 99% of mainstream languages for that. But if your company is still running exclusively off it in 2010, it's a bit like sending out invoices in crayon. However, even in a modern office, sometimes you just need a tool for a small, simple job and sometimes BASIC works fine there (in the same way that scribbling "pay the caterers" in crayon on a post-it is perfectly acceptable as an aide-memoire). There are schools that, without a bit of BASIC, or shell-script, or DOS batch file, etc. wouldn't be filing their accounts, or importing the new student-intake data each year, I know that. When the job is once-a-year, with changing requirements, with specific needs, with various "mental hacks" that have to be applied anyway (i.e. "we need to drop column X this year if column Y is less than 20 because that old law no longer applies"), and needs to be done quickly it can happen in any language you like.

I have taught BASIC only a year or so ago, to a top-class prep-school student, in a single one-to-one session, in a single afternoon. That was from *zero* programming knowledge (but a keen mind), exclusively on paper and the next day they were writing (working) games and hadn't required a single extra tool, library, download, reference or command-lookup - we ran them through QBASIC to see them in action but they worked perfectly. I have also spent several HOURS trying to clean up a single function written by a top-class MSc CS-student that had only ever been exposed to Java in order to find out WHICH of the several dozen syntax errors, scoping errors, operator-precedence errors, etc. was actually the main cause of their function returning junk. I could have taught them a whole programming language AND done the same job quicker than I could teach them to d

Re:So

[javabandit]

I wish I had mod points. GREAT post. The analogy of teaching a child to write is spot on. Excellent post.

Re:So

[MROD]

Here, here!

Re:So

[narcc]

Brilliant post -- well done.

Re:So

[Anonymous Coward]

Turing

Re:So

[fotoguzzi]

I have taught BASIC only a year or so ago, to a top-class prep-school student, in a single one-to-one session, in a single afternoon. That was from *zero* programming knowledge (but a keen mind), exclusively on paper and the next day they [They were? Don't you mean, he was?] writing (working) games and hadn't required a single extra tool, library, download, reference or command-lookup...

Re:So

[Bozdune]

Great post, except you are feeding the Basic-haters too vociferously. So let me undo a bit of the negativity.

VB6/VB.Net and VBA are not just "educational" languages, they are languages that serve an important purpose, and they are NOT replaced by other technologies. Show me how to build a great-looking GUI in 2 minutes, and one that I can change around in another 2 minutes if I don't like it. Why should I spend hours screwing around with C# or Python or Swing and end up with stuff that's hard to maintain?

That's what VB (and its competitors like PowerBuilder) brought to the table. They made it possible for a non-programmer to create a nice-looking GUI, in no time at all. And that makes "real programmers" look bad. Well, tough. Use the technology, don't bad-mouth it. Move the "real" code to C# or C and leave the GUI in VB. You'll save tons of development time, and time-to-market is what counts, not "purity of soul".

Re:So

[ledow]

Though I sort-of agree, VB forms designer isn't really "programming". It *is* fabulous and quick and easy, but it's basically a pretty UI on a set of classes / function prototypes (depending on how far back you go - VB was pretty great just for UI work even for databases as far back as VB 3.0). That's not "the language", that's just a pretty damn well designed UI as a frontend. I have seen similar setups with some decent Java tools, for instance, that basically do the same thing in the same way. VB predates them by up to a decade in some cases but it's not really the "language", it's just a forms designer linked with a prototype of each function that each object generates when clicked etc.

Don't get me wrong, nothing does more for nice, quick visual programming than those VB interfaces but it's not really the language, they just happen to autogenerate a bit of code that uses sufficiently similar object references and is clever enough to link that with a forms designer in both directions. That interface could (patents aside) work wonders if it was tightly integrated into *any* language, as many expensive emulations of the same thing for Eclipse will show you. Though I agree it's fabulous, genuinely useful and very desirable if you ever do any UI work, there's nothing in the compiler specific to that - it's just calling functions from the Windows system files to do the magic from a predefined windowing API but doing it during *debug*/*design* stages too. There's nothing stopping you having something just that good on a PASCAL compiler in DOS, for example.

Though personally, I've found everything since VB v5 a bit of an abomination but as a younger lad I splashed out a whole year's present money on a copy of VB 3.0. It was worth every penny just for the functionality you describe. There's *nothing* stopping someone doing that using X-Windows, or SDL, or framebuffers, or anything else with any other windowing toolkit you care to mention (e.g. an SDL-based development environment that comes with QT libraries that let you design forms while programming them too and then generating code that displays the forms whenever a certain initialisation function is called. It's a development *tool* part of VB, not the actual language.

Re:So

[Bozdune]

I think it IS "programming." Is it "programming" when somebody painfully builds the same thing by hand in MFC? OK, so I'd argue it's "programming" here, also.

As you point out, it shouldn't be that hard to produce this kind of IDE/framework for a different/better language. But nobody's really done it (OK, there are some Web tools that are getting there, but we're talking desktop). There was an abortive open-source effort around Python whose name I can't recall, but that fizzled. I suspect it's actually a lot tougher than one might think to make the whole thing work together reasonably well.

With regard to VB5 being the last reasonable version of VB, I've converted a VB6 code base to VB.Net and although the conversion process was extremely painful (no excuse, Microsoft, for screwing VB users this badly), the code is up and working OK, and VB.Net provides a similar level of flexibility and speed as the "old" VB did, with the advantage that you can inherit from classes trivially (and therefore change the behavior and appearance of things) without the enormous pain that was required to do that sort of thing in "old" VB.

Of course, there are new and exciting pain points, largely relating to the task of integrating managed with unmanaged code. There are also (many) bugs and idiosyncratic behaviors in Visual Studio, but once you learn how to avoid them (by trial-and-error), the behavior is tolerable.

Re:So

[Marxist Hacker 42]

I agree- so I'm going to give you a counter-example: VBA.

No forms designer at all, or worse yet, one crammed into an OLE box on an application not designed to be that flexible. But when it comes to quickly massaging data in the background of an office document, I am unaware (I'm not saying it's not there, but it's not as obvious to me) of a similar, powerful scripting language in Open Office (somebody, please respond and enlighten me, it has to be there, and I'd love another reason to dump Microsoft's monopoly).

Once again though, it regulates VB to being a one-trick pony, and worse yet, one that has been abused by script kiddies to the point that Office 2007 and above actually requires the user to verify *every load* that they want to turn on VBA macro scripting, even in Access which is the competing data UI front end to VB.

Re:So

[Nethead]

As someone that learned programming in high school on Xerox BASIC via a DecWriter and a 300 baud acoustical modem I have to agree with you. When the Apples and Commodores came out I was ready and making money putting them to work for people. I even ran several radio stations on QBasic DOS machines that controlled the on-air programming. I put a payphone in production that used BASIC at its core.

I now use perl and C for most quick tasks, but still love the quick simplicity of BASIC.

Re:So

[CyberTech]

I do believe this may be the best post I've ever read here.

Re:So

[Titoxd]

Awesome post. Let me add one thing, though: If you like BASIC, you will love FORTRAN. It is procedural, so it is similar in concepts to BASIC; and it is extensible, so you can start with a Hello World program in Fortran with a PRINT *, "Hello World", similar to BASIC's PRINT "Hello World".

You can then gradually introduce concepts, such as loops and conditionals in the same way with BASIC; then, you can take on more complex ideas, such as variable typing and allocation (IMPLICIT NONE ftw!), pointers, modules/classes, and you can go all the way to object oriented fluff with the latest standards.

Moreover, FORTRAN is still being used in industry, and not just as a legacy language. There is extensive development of parallel code in Fortran, and the language still reigns king in High-Performance Computing. Thus, the language can grow and be anything from a crayon to a calligraphy quill as desired.

Re:So

[cavebison]

> BASIC is useful for quick, simple tasks and can be simpler than more complex tools.
> BASIC isn't ideal for complex tasks.

First line true, second line is false. For *past* versions of BASIC, you'd be right. Why does every mention of basic bring up memories over a decade old? Thanks to a small revolution, MS's VB.NET can (semantic differences aside) do anything C# can and is completely OO. Whether you choose VB, C# or Java, you can all code using similar, industry-standard paradigms now. Where exactly is VB.NET inferior to C#?

Microsoft did good, both with C# and VB. I distinctly remember people bitching blue in the face when C# came out, vowing never to use it. You could say C grew up a bit. BASIC grew up a hell of a lot. Now it's good for your kids *and* for you.

People who pick on basic now are living in the past. Be honest and just say you prefer your chosen language simply because it's *familiar*, not because it's better.

Re:So

[ledow]

My degree is in mathematics. I certainly have heard of and used FORTRAN, especially having an older brother who did a maths degree too a few years before me. The problem with FORTRAN (leaving aside my personal prejudices against such things as the horrible pre-F90 DOS compiler / IDE we used to use which had any number of annoying quirks regarding code layout and naming) is mainly that it is not a good language to *teach*. Apart from having lots of inherent mathematical statements (built in complex variables!), it also suffers from heavy use of non-alphabetical characters to achieve its syntax (colons, brackets, etc.). You'll notice that BASIC, on the whole doesn't. It's certainly not a bad second step, though, and as you say quite a good transition to further things but in itself it's composed of so many standards and little foibles that it's not a good one to start with.

It's array manipulation is truly fabulous, though. You can tell it's written for mathematicians.

Re:So

[ledow]

That depends only on your definition of "complex tasks" and "ideal". You wouldn't want to be writing an OS in BASIC (of any variant) - it would not be ideal. You wouldn't want to be writing a life-support-system in it, it would not be ideal. You would not want to be writing Google's codebase in it, it would not be ideal. There's lot of things that *any* variant of BASIC would not be ideal for. Doesn't mean you *can't* use them or that it's instantly a bad project *because* you used them (hell, you could write a space shuttle that ran on BASIC and, with the right people and checks, it would be as safe as any other - it's just that the people who *do* write those systems would not consider it as "ideal").

VB.NET is fine for the average desktop-wide program, in fact it's damn near ideal. Technically, if you added up all my programming time, I've probably done as much, if not more, BASIC than C in my lifetime. Certainly not very much Java (personal experiments plus the compulsory uni courses in it). The fact is that most of the stuff I churn out daily is *not* in BASIC of any kind. Hell, I've probably written more lines of shell script (bash) and DOS batch file than almost anything else, but there's no way I'd recommend that as the "ideal" language.

The simple fact, for me, is that VB.NET and C# are too new for me. They can't do anything that I can't do in an "old" language. They require heavy runtimes that are so large that most of my programming projects would instantly go up in size by an order of magnitude, would instantly be locked to an operating system (I've never used Mono and don't really intend to), and performance compared to the code I would write without them suffers. VB.NET and C# are *not* ideal for writing cross-platform, embedded, time-dependent or other classes of programs. However, some of the "old" languages *can* fit that criteria absolutely perfectly (C excels in all departments there, for example).

I use and manage any amount of programs that were written in VB.NET and C# - it's my job. But when it comes to *writing* them, I've been put off before I've even started most of the time (I've forced myself through several entire projects with them and just can't find anything that leaps out as a killer feature that I *must* tolerate them for). If MS produced a "VB7" that didn't use all that .NET crap, compiled to native code and even allowed you to plug in foreign compilers (so I could get a cross-platform version) I'd probably be using it now.

The fact is that lots of those people who vowed to never touch anything .NET based actually did just that. Desktop application developers love it, because it still has VB's rapid development, but everyone else tends to steer clear. To be honest, in my job, putting ".NET" on the end of your application name (which is surprisingly common nowadays with large school management programs, e.g. SIMS.NET etc.) is a good way to suddenly lose upgrades and custom. There are reasons for that that extend beyond programming language snobbery.

Re:So

[Joey Vegetables]

BASIC today is much more than VBA or VBScript. Even these have their uses. I've done VB 4/5/6 and VB.NET for a living, and yes, the language has its frustrations, but it is possible to write clean, maintainable code in any of these if you know what you're doing and are willing to be confined to the Windows platform (or Mono).

Having said this, I would usually choose Python over BASIC anytime I could. I realize a lot of people are turned off by the whitespace-as-syntax, but just some of the things you get in return more than compensate for that in my opinion; things like "batteries included," the multi-paradigm nature, human-readable pseudocode, and the fact that while it is an incredibly powerful language, you don't have to learn the whole thing to get useful work done, or even to read and maintain another moderately experienced programmer's code. For real-world applications you do also need other skills (HTML, SQL, COM, data and object modeling, etc.) but for teaching I think Python is sufficiently self-contained and self-documenting that most of the elementary-age kids I know could learn a large and useful subset of their own with minimal guidance.

Re:So

[Anonymous Coward]

Like PHP, VB's reputation at least partially comes from the sort of people who tend to use it. A disproportionately large number of them tend to be incompetents and write garbage.

Right tool for the job

[Weaselmancer]

No, it's a worthwhile comment. He could have phrased it more diplomatically but it is a useful thing to know.

C, C++, C#, Java, Ruby, Python, assembly... - these languages and all others are tools. They go in the toolbox and are brought out as needed. Each does something better than the others.

Were I to write a VM I would use C as well. A good way to think of C is "user friendly assembly". This is an excellent language to use for an interpreter. For a VM you want SPEED. So you need something with as little baggage as possible. It must be fast, and C has that going for it. After primary compilation it creates asm files. So why not go straight to assembly? A VM is complex. For something huge and complex ASM is a little too fine grained. You want C. So C was used. Best tool for the job.

Writing a gigantic user space application? C may not be your best bet. A lot of those types of programs spend a lot of time just sitting there waiting for input. You may not need anything that optimized. A big fat high level object oriented language can be a better pick. That's where Java/C# shine. You can do a lot with the fat libraries that go along for the ride. The UI creation is simple. Lots of bang for the buck.

Match tool to task and you'll make better software.

Re:Right tool for the job

[Hognoxious]

No, it's a worthwhile comment.

It's technically true, but that doesn't mean it's worthwhile or relevant to the discussion at hand.

Programming using tools written in language X is not the same as programming in language X. Ultimately, it's ones and zeroes that run. And if Java, C0807 or whatever is the best way of converting an idea in your head into the correct sequence of ones and zeroes, the converter in the middle (and the language it was written in) is largely irrelevant.

Still, gave you a chance for a bit of dick waving, didn't it?

Re:Right tool for the job

[Anonymous Coward]

Unless you are writing for small memory devices, JAVA can be optimized to have speed within an order of magnitude of c for many applications and be faster than c for some.

Re:Right tool for the job

[jambox]

Java does not shine, it's blows. My god; the amount of hoop jumping we do in java that post-java languages like python would obviate. The trick is hooking it up to a cross-platform runtime...

Re:Right tool for the job

[vlm]

A good way to think of C is "user friendly assembly".

Its also a "universal assembly". Very handy that I can run the same software on a PIC, AVR, MSP, or pretty much any other microcontroller, and only have to worry about the relatively tiny I/O and timing functions.

Forth is almost as good, but not nearly as widespread.

Re:Right tool for the job

[T.E.D.]

Actually, that's a bit of a myth with C. The truth is that its pseudo-low level nature, and particualy all the aliasing it supports (and encourages!) makes the optimizer's job way harder. With the same amount of effort, an Ada or Fortran compiler can do a much better job optimizing code.

Of course "the same amount of effort" is where the rub is. What really matters for speed is how much effort the compiler writers put into optimizations, not what language the compiler is for.

The main advantage C always had was that the language is so simple that it was fairly easy to write a compiler. That made it the first (and often only) compiler written for a new platform. C was generally "the right tool for the job" only because it is the only tool available for the job.

Re:Right tool for the job

[T.E.D.]

...and in those cases you should probably be using Ada instead of C. The only time to use C is when there is no other compiler available.

Re:Right tool for the job

[Viol8]

"JAVA can be optimized to have speed within an order of magnitude of c for many applications "

Total bullshit. It might be slightly faster on the odd occasion when the JIT compiler spots a runtime optimisation that a standard optimising C compiler wouldn't spot at compile time but generally thats not the case. As for 10 times faster? Puhleease.

Re:Right tool for the job

[Viol8]

The aliasing is no different to what you'd do in an equivalent assembler program. Thats why C allows it.

Re:Right tool for the job

[Wolfger]

Match tool to task and your employer will get upset with you for coding in an unacceptable language.

Re:Right tool for the job

[T.E.D.]

That's not the point. The aliasing prevents the compiler from being able to safely hoist your variables up into registers without doing an expensive analysis of the entire program (all source files in extreme cases) to make sure its safe. Even then it might not be able to figure it out.

A theoreticaly really smart assembly programmer would know his inteded data flows, and if it is safe or not. A compiler has to figure it out mechanically (and often can't).

The problem is that C is a portable assembly language for 1970. Modern assembly has to worry about things like pipelines, predictive branching, multi-level caches of various sizes, etc. Only the most godlike of humans could hope to keep track of that in their heads. Languages that try to tell the compiler precisely what circa-1970 assembly instructions to generate have become an active menace. Its like an 8 year-old sitting the the back seat trying to tell you how to drive (because he as a tricycle and knows all about it).

Re:Right tool for the job

[cforciea]

Really, there aren't very many good reasons anymore to use C or Assembly over C++. Aside from a few situations that you can avoid if you code smart, C++ gets as good or better performance than C using fewer lines of code, and very rarely are you actually going to beat the C++ compiler at generating efficient assembly. There are maybe a few niche cases where you'd still gain something, but the smart move would probably be to use C++ for writing your VM.

Re:Right tool for the job

[CptPicard]

"Under 10x the speed of C" sounds like a reasonable bound to me...

Re:Right tool for the job

[Viol8]

Sorry , I think you're overegging it a bit. Casting makes up a very small part of any program and I'm not convinced it makes a huge amount of difference to optimisation analysis these days anyway.

Re:Right tool for the job

[Khashishi]

You'd better work on your reading comprehension. Within an order of magnitude could mean anywhere from 10 times slower to 10 times faster.

Re:Right tool for the job

[T.E.D.]

I never said anything about casting. Aliasing is when one variable is actually an "alias" for another. So what is at issue here is C's over-relaince on pointers for everyday tasks like array element manipulation and parameter passing.

I know its an article of dogma among many that C is somehow inherently fast. That makes any inconvenient facts pointing otherwise kind of hard to swallow. Sorry. The dogma is wrong.

Clubcompy is sort of cute...

[kuzb]

...but I question the merits of a language that doesn't implement FOR or WHILE. Loops are a pretty important part of a language, and having to implement them using GOTO is stupid.

Re:Clubcompy is sort of cute...

[kthreadd]

Modern versions of Basic have those. You know, Basic has also evolved just like many other programming languages.

Re:Clubcompy is sort of cute...

[omnichad]

Even GW-BASIC had while loops. That's not exactly a recent development in the language. Dartmouth BASIC had FOR/NEXT. Just how far back are you going?

Just like parenting..

[mustPushCart]

everyone wants to raise their kids the way they were raised. The way they were raised was the best way simply because its the only way they know and as far as they are concerned, they were raised just fine.

Although in this case it should be easier to rate which one is better, i'd go for whatever language is easy for the childs age, they will eventually learn to detach the logic from the code after a few languages unless you are worried that learning another language will cause them to lose interest so hook them up on any language/system with a lot of visuals.

Instant gratification

[Just Brew It!]

I think it really helps to use an interpreted language with an "immediate" mode (just type a statement and it is executed on the spot) if you're trying to get non-programmers interested in programming. The first two languages I learned (back in 1976 or thereabouts) were BASIC and FORTRAN. Of the two, BASIC was easier to pick up and (quite frankly) more fun, precisely because it was more interactive.

These days most of my "real work" is done in C/C++ and Python. I would argue that today, Python is a reasonable first language. It is simple enough that someone can easily learn the fundamentals and make it "do something"; yet it is also powerful and expressive enough to build complex real-world production systems with.

The end of accessible programming?

[QJimbo]

First programming language I ever learned was BBC Basic on an Acorn Archimedes computer. A fantastic language which was easy to pick up and start working with.

I feel very, very fortunate that I caught the tail end of the time where easy programming environments were bundled with computers, since learning those concepts at an early age is what has allowed me to learn the other languages I do now.

Surely it must be harder for this generation to really start programming, at least on the desktop, without such accessible environments?

Logo is more powerful than BASIC

[OrangeTide]

I don't think people realize there is more to Logo than turtle graphics. It is essentially a dialect of LISP and has very powerful list processing and array features. And using property lists you can build data structures from it.
People have built binary trees and small personal database apps from Logo. While the data structure support isn't as powerful and flexible as what you find in C, Java or JavaScript, it is sufficient for a teaching language.

I think a Logo and/or BASIC for iOS and Android might be just the ticket to getting kids involved in programming. Fiddling around with turtle graphics on a mobile device in quiet boredom seems like something today's kids might actually do. (how long can you play Angry Birds before you need a break)

Interactivity is key

[White Flame]

With classic screen-editor BASIC, you can just type in PRINT "1+1=";1+1 and immediately see the results. Once you've entered in a program, you can interactively do things like A=3:GOSUB1000 and try out a sub-portion of their code.

This sort of interactivity is completely lost in programming languages that have an edit/compile/run cycle, to the detriment of stark newbies getting to play around with the language and just "try stuff".

Lisp is my main development language. It and some of the other dynamic languages of today do keep that interactive prompt for the user, letting newbies play and letting seasoned developers test/debug very quickly. When it comes to being beginner-friendly, I think this interactivity with the language environment is the most important aspect, and it doesn't have to be tied to just "simple" beginner languages.

Re:Interactivity is key

[Just Brew It!]

I agree completely (and made a similar point a few posts up). I think interactivity was one of the reasons I immediately liked Python when I first tried it a few years back - it reminded me of those exciting days long ago when I was first learning how to program in BASIC!

Re:Interactivity is key

[plopez]

Meh.... you can do the same thing with Python, Ruby, R, Perl, or a host of other interpreted scripting languages. Nothing special about it.

Re:Interactivity is key

[Just Brew It!]

Teaching a newbie how to program using Perl? Surely you jest...

Re:Interactivity is key

[clone52431]

With classic screen-editor BASIC, you can just type in PRINT "1+1=";1+1 and immediately see the results. Once you've entered in a program, you can interactively do things like A=3:GOSUB1000 and try out a sub-portion of their code.

Agreed. Back when I was learning BASIC, I probably did a test-run for every two lines of code (maybe every single line). It probably sucked for my productivity, but I wasn’t programming for productivity’s sake back then.

Re:Interactivity is key

[plopez]

The parent post's thesis is that the interactivity of BASIC was required and made it superior. My point was that there are many other interactive programming languages you could use. Besides, Perl programs don't have to look like "line noise". If they do, you're doing it wrong.

Re:Why I Use Basic

[Anonymous Coward]

I know what you mean, I worked with boys at the CC level. HOT!

Nothing wrong with either one

[Nitewing98]

I started with BASIC, like a lot of hackers from my generation. Learned LOGO as well, then on to 6502 ASM, Pascal, 8086 ASM, all on my Apple //e! BASIC gives immediate feedback, and so it good for the beginner. I think starting someone on OOP or other advanced concepts from the beginning is a mistake, since students need a rudimentary understanding of basic programming concepts first, which BASIC and LOGO do very well. I guess I'm saying you can't understand the real power of modern OOP languages without doing it "the hard way" first.

No!

[rastoboy29]

I was one of those poor ruined youths deluded by BASIC.

Better to go with Python or Perl, imo.  Not PHP...no need for that.

Web site not trustable

[SpaceLifeForm]

Massive javascript attack. Also https by default.

Because...

[sitarlo]

In my 20+ year career as a software engineer I made the most money writing Visual Basic code. Of course it was more professionally rewarding to do C, C++, ObjC, Java, etc... But, I definately got paid the most for VB applications in the financial sector. Funny, because I probably spent a lot more time mastering the other languages and their development tools than I did learning BASIC and VB.

8-bits are the best

[RonMcMahon]

I hunted down a pile of Commodore and Atari 8-bit systems in order to teach LOGO and BASIC programming to my two sons. The languages are immediate and responsive with a direct response to user input in a way far long lost in 'modern' development environments like Visual Studio 2010. The clear syntax of these two languages gives a child an easy path to comprehension that one command like: LEFT 34 makes something happen on the screen that you can immediately view.

The old "Hello World" sample application can be completed in 2 or less lines long in these languages. C++, C#, F#, VB.NET, etc... all fail to deliver such an accessible learning path, and that is why they fail to surpass 25+ year-old systems.

I believe that this approach has been a success. This year my eldest asked for the Flash development environment for Christmas...

Because it is as old as epSos.de

[Anonymous Coward]

The question should be: "Why not to teach Kids Programing with Basic". .....
JavaScript is more practical and useful.

RPN

[fyngyrz]

I found a free HP48GX thang for the iPad recently -- made my day. Now I have two hardware versions, a 48 and a 48GX, a 48 emulation on my Mac desktop, and a 48GX in my iPad. I feel... "covered." :)

I keep HP 12Cs around in about the same places, too. That thing does an awesome job with loans and the like.

Nope. Basic has outlived it's usefulness.

[dbc]

I have been teaching my daughter to program over the past couple of years. Logo and turtle graphics were certainly good to start with. But there is *nothing* in BASIC that is easier/better/clearer/friendlier than Python with Idle. Ditch BASIC. Start your kids on Python. Go get the "Hello, World!" book by Sande and Sande.

Yes, I did my first programs in BASIC -- on an ASR33 with an acoustic coupler modem. This was *hot* stuff at the time. (The MITS 8800 and the ability to solder together your own computer was still three years down the road.) Stored my programs on punched paper tape. I loved it at the time, but sheesh already, let's move on.

Don't equate BASIC and Logo

[laird]

I'd agree that interpreted languages (with BASIC and Logo being examples) are great for programming. The edit/compile/run cycle causes too much friction, discouraging kids from experimenting.

But having taught hundreds of kids programming, there's a huge difference between BASIC and Logo. Logo is a simple but powerful language that teaches kids how to express what they want to a computer. BASIC is a complicated but limited language that mainly confuses kids and teaches them loads of incorrect beliefs that make it hard for them to eventually learn to express themselves clearly. Certainly starting with BASIC can be recovered from (Dykstra was being overly dramatic) but I would advocate doing that to anyone on purpose.

Of the introductory languages that I've taught, I think that Logo was the best introduction, because it's the simplest, most natural syntax, with the ability to easily generate graphics that engage students. And while most people don't notice, Logo is a fully expressive programming language.

For comparable, but more modern languages that are good for introducing kids to programming, there is Scratch (http://scratch.mit.edu/), which is friendly and interpreted and visual. Also free and open source.

Reading the ClubCompy web site, they built something that is intended to be simple for kids to experiment, with no install, and thus is a "computer" interpreted in JavaScript. This seems like a nice idea. No real connection to BASIC or Logo, other than they want to achieve the simplicity and openness to experimentation that those languages represent. After giving it a look over, I like the fact that their language based on LOGO, but am not thrilled that they added LINE NUMBERS. I can't believe that it's a good idea to make kids learn about line numbers, with all of the associated complexity, rather than to use a simple text editor. The only reason that line numbers ever made sense is that back in the era when BASIC was invented, you couldn't assume a text editor, or even the ability to move a cursor on the screen (remember working on printing terminals?). But I think that limitation no longer applies. So while I like their goal quite a bit, I have a feeling that they would have been better off sticking with an existing simple language, such as python, lua, or even Logo.

Re:Don't equate BASIC and Logo

[chromatic]

I can't believe that it's a good idea to make kids learn about line numbers, with all of the associated complexity, rather than to use a simple text editor.

I've gone back and forth on that myself, but ultimately we're sticking with line numbers in the dialect we have there now for simplicity sake. You hit on this when you mention a simple text editor: either we implement that text editor to keep our zero-installation cross-browser footprint, or we allow people to use their own text editors and take the hit of setup and configuration.

Further, then we have to find another mechanism to distinguish between immediate commands and commands to store to create a program or else explain the REPL concept early. We'll also have to explain using named labels or even user-defined functions.

Remember, we're talking about teaching motivated eight year olds.

Re:Don't equate BASIC and Logo

[yomammamia]

The days of the Z80 based Home PCs were the best for BASIC. Persuading or motivating a child to learn a written language by copying from the board can be difficult. However, teaching a child programming the same way was once easy. Typing in a basic program from a book was just another way to load a game.

I started out like this from the age of around 7. You would be amazed how much you pick up just from copying like that and the line numbers do help with understanding. In fact I would argue that for someone very young and with no initial understanding of programming that GOTO and line numbers are far better as they are more explicit than functions. I totally agree, its horrible to have to write a program like that. But when I was 7 and read GOTO 50 the intention was immediately clear and the program's flow could easily be deduced. It's also worth noting that GOTO and line numbers more closely resemble what goes on under the hood. If I had to do the same for a more modern procedural language I wouldn't have found it so obvious. It would not be so clear that systemproc() and definedproc() are separate or change the flow of a program.

I never had any intention of learning basic and never did in any big way. However, when I got something a little more substantial than a Z80 machine, thanks to the passive learning I received from loading programs from book into a Spectrum or an Amstrad CPC I was able to master any programming language I needed to use extremely quickly.

This isn't really presenting the teaching merits of BASIC according to the teaching method you have in mind but I think it's a nice way to teach. Sadly this is no longer such a viable teaching scenario. Why would someone type in a tiny program that does very little when it takes less than a minute for their Nintendo DS to boot up a massive ROM cartridge?

Re:Don't equate BASIC and Logo

[walterbyrd]

I can't believe that it's a good idea to make kids learn about line numbers, with all of the associated complexity, rather than to use a simple text editor.

FYI: BASIC does not need line numbers, and hasn't for the last 30 years, or more. Unfortunately you are trashing a language that you actually know very little about.

Re:Don't equate BASIC and Logo

[dkf]

Further, then we have to find another mechanism to distinguish between immediate commands and commands to store to create a program or else explain the REPL concept early.

I don't know that you have to explain it. What is important is giving them something which will do what they tell it to immediately, i.e., a REPL or equivalent. A few obvious pitfalls that they'll have to navigate their way around aren't a bad thing either, so long as there's no lasting damage from getting it wrong. It's also good to minimize the gap between what they type immediately and what they do in a saved program.

Give kids something they WANT to learn

[Opportunist]

What do kids want? That's the first question, because you cannot teach children something they do not want to learn. For reference, see schools. If you want your child to WANT to learn, give him something he likes.

Now what do kids like? In general, at least in my experience, this can be summed up in a few key parameters:

1. They like things that affect their world. They like to see that what they do has some impact on the world around them. Ever been in a train where some child keeps pressing that "stop at next station" button at every single damn station because he loves to see how the train reacts to it? How it makes the train stop (even though it's more an indirect result of them pressing it)? Kids like to see that their world acknowledges their existance.

2. Kids like to show off. When they do something, they want to show that they've done it. That's one of the reasons kids like to draw, they can take that sheet of paper and show it around to everyone who wants (or doesn't want) to take a look. Later they might build something out of Lego or other things we give them to "build stuff" and we'll get to see what they built. So think twice before you buy your kid that Lego box, you'll have to admire the result!

3. Kids like the idea that they've done something by themselves. If you ever gave your kids some model kits, you know what I mean. They want that sense of accomplishment, that they have completed something and that they have done some "good work".

What I would hence suggest is not to "bore" your kids with programming languages that do not produce anything that affects their environment, anything they can carry around and show to unsuspecting relatives or anything you couldn't have done better. Especially when you're a programmer, your child will have a hard time stepping out of your shadow.

My suggestion, as radical as it may sound, to introduce kids to programming and computers in general, is microcontrollers. They are the perfect combination of everything above and has a few additional goodies: They give them something that will affect their world, provided they learn enough about them to, say, create some blinking leds or control servos with them, it gives them something they can carry around and it offers them manageable projects that scale well when their skill increases.

And besides programming, you teach your kids something about electronics, and once they learned the basics they can even start to create their own projects that actually have a goal they set themselves (important for kids, they are very hard to motivate for some abstract "learning goal"), and even small projects give them a great sense of accomplishment.

You can even program most of those Cs in C these days, though I would actually suggest (radical that I am) that they start with assembler. Odd as it may sound, I think kids would have an easier start with it, since they're not set in procedural and OOP thinking as we are, and in general C assembler is easy enough and straightforward enough without the baggage that weighs down i386 assemblers (there's rather little to take into consideration with Cs, they have very small capabilities). That way kids also learn automatically the foundation of programming, why there is a stack and what it does.

Yes, that will take them much longer to become OOP programmers. But kids have something we grown ups usually do not have in such extreme quantities: Time. When you start your child at age 10 with Cs, they have a decade before they have to be "productive". That's plenty of time for them to switch over to OOP and "higher level" languages later, and they will have a fairly easy transition, considering that Cs and assembler will have taught them a very important skill: Being observant to detail.

MOD PARENT UP

[Pherlin]

The smartest programmers I've met are the ones who know their low-level stuff. Until you understand the nuts and bolts you're just a part-swapping-monkey.

I suggest teaching C

[Anonymous Coward]

I began programming in basic in 1980 on an HP45 at Sperry Univac. A few years later Pascal was being heavily used, and then around 1986 I started programming in C exclusively (as did large parts of the industry). I would have to say that it was a "steep learning" curve going from BASIC and Pascal to C. I am not putting forth an argument against you, but would like to suggest to start out with C for the main reason it would be so easy to teach programming with it. You don't have to teach pointers, etc. Just teach in C what you would teach in BASIC. For example:

main() {
  printf("hello world\n");
}

In BASIC instead of 3 lines it would be one:

10 PRINT "HELLO WORLD"

Frankly I don't think it would be much harder to explain the C version than the BASIC version. Here is another example:

main() {
int a;
int b;
int c;

  a=5;
  b=7;
  c=a+b;
  printf("5+7=%d\n", c);
}

The above code fragment seems so simple to explain, I am not sure you gain much by teaching BASIC. Also it must be mentioned that the above C code is dirty on many levels, main returns void, no , etc. But, hey, it will compile and run fine the way it is (snicker).

A very good reason to start out with C is that if one desired to learn Java or C# as a progression the learning curve isn't as steep as the transition from BASIC to Java or C#.

Also I am not saying you are wrong in any way, I had a thought I think is interesting. Please keep up the good work !

Re:I suggest teaching C

[ledow]

Just going by your simplest programs, and I know you mentioned this:

Your main function is declared incorrectly (two points - no return value and no parameters).
You didn't include stdio.h

Almost all C compilers will thereby reject even that three-line C source program with at least one and maybe 3 errors (maybe 1 or 2 warnings instead). All those warnings/errors will say different things and point out different lines with different parts of them being the problems (smart ones might know the include is missing, other might just call it an undeclared function, insufficient prototype etc.). You've just scared off any teacher and any kid wanting to learn it. However, the BASIC is syntax-perfect and will execute on any conforming BASIC interpreter. You don't even need the line number. THAT'S why BASIC wins when teaching kids (especially a roomful of kids).

It depends who you're aiming at but this is EXACTLY why C isn't a good language to start with. In BASIC you don't *need* unexplained mysterious boilerplate. You can explain every damn character and every keyword of the language in an afternoon to a bunch of 11-year-olds (or younger). Even they will typo when copying that C down (colons instead of semi-colons, etc.) - hell, they'll typo the BASIC to death too, but to a less degree - and if you are expecting them to copy/paste, that's a bit pointless (it's like saying "You can write French!" by copying/pasting French words into a document).

BASIC can be learned by a 7-year-old. BASIC can be *self-taught* by a 7-year-old under their own attention span, from a book, with no adult help, and no previous experience. I know. I did it. C cannot (I work in schools, trust me). You have to have a bright kid, who knows what they want to do, and is dedicated enough to do it and see it through no matter what, and quite an extensive C reference / referee.

C is also an absolute PIG to get a working IDE / compile environment that the kids can take home to carry on with and it's all just "black-boxing" things that you think are too complex in order to make things simple (think about it - start with simple and get complex, or start with complex and have to force it into a simplification? How do you prefer your computer AI, for example? Starts easy and progressively gets cleverer, or is insanely perfect but deliberately makes huge mistakes - like standing still 99.9% of the time at the beginning of the game?). You don't need to black-box the complex stuff, it's only there for those people who NEED to use it anyway (even the semi-colons in C are pretty unnecessary, really). If you're not going to write programs long enough to include files yet, you don't *need* the inclusion commands, for example, and using them means explaining them or teaching "magic". Every kid in that class will be include'ing stdio.h in every program for the rest of their lives and have no idea why because you *won't* have time to explain every one of the little foibles of tiny programs like that. With that C program, suddenly you're saying "Don't worry about this bit" rather than "This is a complete, valid, perfect, program that will work anywhere."

BASIC was designed to be taught to children. Most people who started programming in my generation did so on BASIC as children. A lot of them taught themselves. There's nothing *wrong* with BASIC for kids. Sure, when they're older, teach what you like - you *can* teach a young adult any language you like and they'll pick it up if they have the vaguest interest. But for *kids*, BASIC wins hands-down every time, still after 40 years. Just don't learn ONLY BASIC. That's the mistake people should berate you for, it's like using a crayon-only for the rest of your life instead of learning to write with a biro - sometimes a crayon will do to jot down a note even today but you shouldn't be writing your CV (resume) with it.

Personally, I did BASIC -> Z80 assembler -> (moved into secondary school) FORTRAN -> PASCAL -> x86 assembler -> lots of others

You may be right...

[Invisible Now]

I don't have my dog eared copy with me...

(but Newfies are big, smart, friendly, and loyal dogs!)

Enterprise Java Beans

[cowboy76Spain]

I mean, after having them spend a couple of months:

• Explaining the theory
• Configuring IDEs (and plugins)
• Installing and configuring the server/container
• Trying to compile / package
• Find the JNDI name of it

only the most brave, geeky, girlfriend-less boys will be ready to join us....

I disagree about the notion that once you learn

[Archeleus]

BASIC, you are fucked. It's not like that since I was interested in BASIC as a kid and did pretty well at it too. Then I moved on to C/C++/Java/Python/Perl and all that and I can code well. I think that it has even helped me to understand some languages like assembly more.

GOTO in teaching. Re:Use C#

[Anonymous Coward]

There is actually (at least) one use of GOTO in teaching. To wit: undoing the mess in someone's head some other teacher made teaching structured programming WRONG.

It goes a bit like this:

You will need: a dialect of basic that supports both GOTO *and* structured programming (I used BBC BASIC).

We can control program flow using IF and GOTO. We'll try some examples.

Now notice how you shouldn't cross your GOTO's, because that would be bad, and makes your code over-complicated. (That's what structured programming actually is!).

Now as it turns out, there's only really so many ways to do this, and we've given each way a name. So we can start by showing how GOSUB works, and PROC and FN:

GOTO {subroutine}:
REM return here

REM ...

REM subroutine starts here

REM ...

GOTO {line with return here}

Further we can show loops (REPEAT UNTIL, WHILE...ENDWHILE.).

REM Start loop ( "while")
IF NOT ({condition}) THEN GOTO {end of loop}

REM...

REM end of loop

Finally there is a common loop construct that shows up so often we have a separate shorthand for it:

I=0
WHILE I {some number}
I=I+1
REM do something
ENDWHILE

which can be shortened to:

FOR I = 0 TO {some number}
REM do something
NEXT

in really modern langauges like python, we can go a step further, for instance looping over an iterator.

arraylength=100 : REM some constant
DIM elements(arraylength)
FOR i=0 TO arraylength-1 :REM don't forget your fenceposts!
elementToWorkOn=elements(i)
REM do something with elementToWorkOn
NEXT

which has been shortened (in eg. python) to:

elements=[]
# Fill elements here

REM ...

for elementToWorkOn in elements:
            #do something with elementToWorkOn

(ps. sorry about the curlies. TIL slashdot treats BNF like HTML; also it messes with code formatting )

Learning the joy of programming in less than 1hr

[inf0stud]

I've taught five groups of 8 to 15 "work experience" kids from local high schools, year 10 to year 12 (15 to 18yo), using http://squeakland.org/ Etoys. Most of them hate computing classes they do in school: learn how to use Office. I tell them the visual language isn't designed for them but kids 6yo and up. Then I teach them the simple car (turtle-like), the car with a connected steering wheel (functional programming), and then the car staying on track by sensing fences in about 40 minutes. Zero programming experience (in most cases) to environment sensing (I call it AI) programming in less than an hour.
One bright kid figured out how to spawn cars and managed to create a race.

Basic evolved too.

[Anne Honime]

Pick a good look at something modern like Gambas. All Basic goodies, in a GUI-friendly package.

Learn Basic...and ur Fucked?

[tonywestonuk]

Totally disagree. Iearnt basic back in the 80s - Im a Java programmer now, I dont think its hindered me at all.. Infact, i built a framework based around what I learnt back then, which I use in all my projects, and I challange any java programmer to write things as quick as I can nock up using it:

import static basic.Basic.*;
public class HelloWorld {

        static{
                Object[] pgm = new Object[1000000];

                pgm[10]= print("Hello World");
                pgm[20]= Goto(10);

                run(pgm);

        }
}

Sorry but it's not proper BASIC

[Anonymous Coward]

Out of nostalgia I was going to do a

10 print "hello world"
20 goto 10

But guess what?

10 print "hello world"

Error: Use single quotes (') for string literals.

Since when is the apostrophe used as string indicator in BASIC? When they started writing that error message, they should have stopped and thought "wait, we're going against every BASIC dialect in the world here, let's use ASCII 34 as string indicator instead".

Re:Sorry but it's not proper BASIC

[dingen]

' is not an apostrophe. ` is.

Re:Sorry but it's not proper BASIC

[clone52431]

Actually, no. That is a backward apostrophe used as an opening single-quote mark in typefaces where the ' looks slanted.

E.g. http://ompldr.org/vNnJ2bQ/untitled.png (Apostrophe is the 8th char in; the ` is directly before the lowercase alphabet.)

Haskell

[Vahokif]

At my uni, they assume we know no programming to start with and go from high-level to low-level languages. We start with Haskell, then Java, then C++ (and other languages). Couldn't this work for kids? There's nothing intrinsically hard about Haskell, assuming you have no imperative biases, and you learn all the good habits before you get to use a messy language where you can make stupid mistakes.

Reminds me of my color computer 2 days...

[CFBMoo1]

> 10 INPUT "Pick a noun: ",A$
> 20 INPUT "Pick a verb: ",B$
> 30 CLS
> 40 PRINT "In Soviet Russia, "; A$ ;" "; B$ ;"'s you!"
> LIST
10 INPUT "Pick a noun: ",A$
20 INPUT "Pick a verb: ",B$
30 CLS
40 PRINT "In Soviet Russia, "; A$ ;" "; B$ ;"'s you!"
> RUN
Pick a noun: basic
Pick a verb: program
*Post clears screen*
In Soviet Russia, basic program's you!
> 5 REM Not exactly my old light cycle program after watching Tron back then but still fun!
> LIST
5 REM Not exactly my old light cycle program after watching Tron back then but still fun!
10 INPUT "Pick a noun: ",A$
20 INPUT "Pick a verb: ",B$
30 CLS
40 PRINT "In Soviet Russia, "; A$ ;" "; B$ ;"'s you!"
> _ *blinking*

There's also OOREXX

[Anonymous Coward]

A very good language to start programing is Open Object REXX.
http://www.oorexx.org/

Easy to learn
Cross platform
Based on common English language
Great start for object-oriented programming

BASIC is not the problem

[Noah69]

Like for so many others, BASIC was what got me into programming when I was young. It was easy to open up a game I just played, change a line and - whoah - it actually showed the change right the next time I started the program, even if it was just replacing a word or a variable to give me two extra lives.
The sheer ease of creating something myself without spending hours reading a wiki or creating a dozen "Hello World" applications was what fascinated me.

Does BASIC teach you things that are no longer used in modern programming? Absolutely. But any reasonably smart person should have no problem adapting and understanding that when moving on to another language, it does not corrupt your ability to work in other environments.

Organiser II

[cheros]

I started with the Psion Organiser II, more or less the world's first PDA. Amazingly, some of the stuff I wrote is still out there :-).

Personally, I think a device like that would be the best for teaching kids how to code, for a number of reasons:

1 - it is portable. You can play with it wherever you are, and playing is what is needed.
2 - it is always on. Resume wherever you left off (this is better nowadays - the Org II was singletasking, so you had to save code before you could do something else)
3 - it is a simple programming environment. OPL (Organiser Programming Language) evolved to add graphics, but at its most basic (pardon the pun) it was a sort of BASIC with touches of Pascal (procedures, subroutines, typed variable declaration) which made a distinction between source code and "translated" code to run.
4 - you could access the built-in flat file databases. It had a simple database mechanism that you could also reach with your programs, so you could mess around with the built-in database function. As a matter of fact, I miss this simple database mechanism in "modern" operating systems and PDAs, TapForms on iPhone is about the closest I got to it..
5 - it had growth stages. Once you got familiar with the device, you could progress to machine code, bit by bit. You could call certain functions, mess around with buffers - lots of stuff to play with once you knew the first principles. And crash recovery was a matter of removing the battery (which also taught you the importance of saving your work on the memory packs).
6 - it had expansion devices. I learned about barcodes because you could plug in a reader to the Organiser. There was a printer, a mag swipe reader - all this stuff taught me about the technologies we still use.

I agree that "modern" computers are too complex for beginners. I built an Apple II, sorry, ][ :-). I got my first PC because I was given one that was broken (so I learned about MFM drives), but I really got into programming (for a while) with the Organiser because I could change the way it worked to suit me, and it was always around. No need to boot, no great battery dependence (one 9V battery lasted for weeks), and it forced me to memorise structures because a 2 line 16 character display is a rather small window (the later 4 line 20 character display was luxury :-).

If there was a way to bring OPL to a platform like Android or the iPhone I think it would do a great deal to get kids going.

By the way, keeping structures in my head turned out to be a good exercise: it made the film "Inception" easy to follow :-).

List handling

[pjt33]

The list handling is great if someone teaches you what it's for. I taught myself BASIC and Logo from the Amstrad CPC6128 manual, and later used that manual as a language reference to implement a Logo interpreter in Blitz BASIC on the Amiga - but I didn't bother with the list handling functions, because I couldn't see the point of them. It was only when I was taught SML at university that I realised how powerful they were.

why teach kids programming...?

[braindrainbahrain]

...at all, in any language? Is this the modern equivalent of a previous century's idea of a good education, something like all kids should learn Latin and Greek?

Re:How *not* to teach programming

[backwardMechanic]

I find an automobile analogy is called for: If someone wants to learn to drive, do you start by explaining the operation of internal combustion engine? Compression ratios maybe? Many of the problems programmers of a 'certain age' have come from trying to outguess the compiler/interpreter. A programming language should be designed to express the problem you want to solve, not how the particular processor will actually do it. Logo, for example, is a very long way from assembly code, but a useful teaching language.

Think about why you would want to use any language

[Targon]

The only real advantage to BASIC is that it allows for some very quick and dirty code to do some VERY VERY basic things. From that perspective, BASIC is better for showing simple concepts such as a "for" loop, or the use of variables. From there, Pascal is a good language to teach programming structure, since it is a bit more obvious about where the beginning and end of each block of code is for loops(begin/ends that are more obvious than {}). C of course has a similar structure to Pascal, but is a bit less verbose, meaning it can be harder to read, and you can miss a } and have problems with tracking down why something is not working properly.

The big issue is in the introduction to programming, and what is the best way to introduce CONCEPTS. Learning how to program when you are 12 or older would be a lot different than learning when you are younger. So, BASIC to teach some simple stuff early on, but then QUICKLY move to either Pascal or C to teach structured programming.

my favorite program

[billmarrs]

10 PRINT "BILL RULES "
20 GOTO 10

I typed some slight variant of this program into many a TRS-80 on display at Radio Shack as a youngling.

Basic == Bad Habits That Last A Lifetime

[assertation]

Almost every time I have found endless columns of code, even written in OO languages, it has always been the case that the programmer responsible learned programming with Basic.

In today's programming world it just teaches people bad habits that they carry across a career.

If you want a kid to learn programming on their own, outside of a class, send them to python.org where they even have materials for teaching programming. I don't know if the results will be better beyond starting them off with a modern language still in use, but the results can't be any worse as far as the bad habits of people weaned on Basic tend to go.

Re:Basic == Bad Habits That Last A Lifetime

[walterbyrd]

Specifically, what bad habits? I know BASIC, and Python, and I can tell you that Python has as many oddities as any other commonly used language.

Learn Python and you learn that whitespace is always significant, right?

In Python, variables can be changed in the background, without you explicitly changing them.

Python does not have records, or arrays, and "variables" in python are used in such an odd manner, that they hardly deserve to be called variables.

Should you really learn that "everything is an object?" Might not be a good mindset to have if you want to learn C later on.

Re:Basic == Bad Habits That Last A Lifetime

[assertation]

Walter;

Being snarky is the general currency on slashdot, so I want you to know I mean no disrespect.

Isn't writing solid walls of code that go on for pages in a single function bad enough?
There aren't too many languages left with a goto statement or something similar, but the programmers I've met who weened on Basic also tend to overuse that feature.

I understand and agree with your point about the use of white space in Python, but I also think it is a good thing. If a young programmer goes on to never use Python again at least they will have a respect for how their code is formatted which will make their code easier to maintain and if it is one thing I have learned is to never think of screwing the maintenance programmer over because there is a good chance it may just be you :).

Why demonstrate Joy of Programming

[Anonymous Coward]

When the reality of bondage and domination of Java awaits all hapless initiates who go further into computer science? /sarc

Try Python.

Tabs vs. spaces

[gumpish]

In practice, though, it's not a big deal - everyone sane just uses spaces anyway

Really? Why? After all, tab is THE indentation character.

Is this about people who are too lazy to change their tab stops complaining?

Well fuck them.

Re:Tabs vs. spaces

[shutdown -p now]

Really? Why? After all, tab is THE indentation character

No, it's not, actually. The original purpose of tab stop is to neatly align columns of numbers of varying length.

Is this about people who are too lazy to change their tab stops complaining?

The reason why using tabs for indentation is bad is because it doesn't really buy you anything, since a particular tab size is forced regardless if you write any comments on the same line of code, and try to align those. Or align variable declarations. Or many other things. The only difference with spaces at that point is that it's possible to open a file with tabs with a wrong setting and get messed up layout, but a file with spaces will always open the same.

Re:Nice slashvertisement, what about Microsoft Kud

[Marxist Hacker 42]

Kodu isn't Code.

It's visual programming. It teaches something utterly different. The real brilliance of ClubCompy is the magazine- I fondly remember coding games from magazines, it's how I learned programming.

And they missed the Kickstarter deadline. Which is sad, because they offered something unique.

Language doesn't matter API and IDE do

[grumbel]

I'd argue that when you want to teach kids programming, the language is actually rather unimportant. It is the API and the IDE that matter. Have something that allows the kids to use graphics easy without a ton of initialization, have an IDE that automatically jumps them to errors in there code and all the little things like that. QBASIC was pretty good in that regard, it even auto-corrected the upper/lower-case when you mixed it in your variable names.

These days I would probably go with Python/Pygame or Processing as they make it easy to get interesting stuff happening. Python has also the advantage that you can do real stuff with it, when you are bored of toying around.

Re:Long Live Peek!

[TaoPhoenix]

Actually, do you know how to do something like a Peek on a webpage?
"If character #427 on _____.com page is a 1 , then CanaryTest = True"
It would be a form of notification of sites being redacted to snip out the Bad Things.

nobody heard of smalltalk?

[Anonymous Coward]

Squeak smalltalk seems to be perfect for this, Made by Alan kay!

Learn something useful

[Anonymous Coward]

I learned on C++ at 12 years old. I'd played with filemaker databases at age 10. I have looked at Basic but it never appealed to me. I think, having learned C++ at the time, it was far easier for me to learn any other language. 12 year old brains should really be able to think through logical steps towards a desired outcome. We need to stop coddling students!

Encourage kids learn a language that will be useful throughout their life. I don't work as a programmer, but I do use programming to solve problems on a daily basis, and I would hate to have to use basic.

-Jess

Re:Graphics

[TaoPhoenix]

Aha!
Commodore 128. End Of Line

You could both draw lines and use built-in Sprites. (What other machine had native Sprites? I still don't know.)
I burnt out because at 12 I was writing racecar games, shoot-em's, and HuntWumpus-LORD crossovers.
I can still write little exercises to diagram problems I am pondering.

Then the minute I looked at C & Java the lights went off and I lost interest in being a pro dev. Today my interests are all about exploring existing apps.

Worked for me

[mattcoz]

Got started with QBASIC when I was a youngin, wrote a rudimentary wireframe 3D renderer that worked at about 1 frame per second, and I've been hooked ever since. I always had problems with these early classes that I would go far beyond the assignment and get marked down for not following the instructions. Like in this Visual Basic class, we had to do this simple matching game, and I made Wheel of Fortune with Simpsons graphics and sound effects. DOH!

Re:Nice slashvertisement, what about Microsoft Kud

[Anonymous Coward]

Exactly. Kodu teaches by indirect learning methods, allowing it to teach programming concepts without much programming syntax. By doing this, it can target a broader audience of children, possibly pulling in many who wouldn’t have been interested in programming to begin with. From interest sparked by Kodu, they can then begin to explore more detailed examples utilizing actual code through Scratch, Alice, or any other of a handful of tools that already provide a reasonable product and could use more funding.

Compy teaches with experiential learning methods, which generally isolate particular groups of individuals that already show a degree of direct interest, and can make it difficult to pull in others. Additionally, as noted above, it’s trying to step into a market that’s already starting to fragment, with a product that (from their website) appears to be very sub-par in comparison.

I completely agree with what they’re trying to do. I think it’s a good idea, in general. I don't think they offer something unique, just a slightly different way of doing something thats already being done. My opinion is that they need more research behind their approach to target the gaps that the other products are missing, rather than just taking a blind shot in the dark of “hey, I liked this when I was a kid”.

Tail call elimination

[Estanislao Mart�nez]

Goto provides for the natural expression of a state-machine. The most common example of that is in lexical analysis. [...] Some of the more dogmatic try to get around it by using a case statement in a loop (with an enumeration or something controlling the current state). But really the internal structure of the code flow there has nothing whatsoever to do with that loop, and artificially imposing that on it just obscures the state machine underneath.

And now you've just made a case for tail-call elimination, which turns each state into a function, and each state transition into a (syntactic) function call.

Re:Tail call elimination

[T.E.D.]

That really only works if the "goto" always happens at the end of the state (rather than conditionally somewhere in the middle). The state machines I've written tended to have quite a few states with that property.

A very interesting idea though. It hadn't occurred to me to try to implement a state machine using a mutually-recursive web of routines.

Re:Tail call elimination

[SanityInAnarchy]

I'd have to imagine that if your state transition is effectively the end of that function, tail-call optimizations could still be done. For instance:

some
code
if (time for a new state) {
  switch_to_another_state();
  return;
}
more
code

Effectively a goto, but semantically a function call. Why wouldn't that be caught as a tail call?

Re:Tail call elimination

[Estanislao Mart�nez]

That really only works if the "goto" always happens at the end of the state (rather than conditionally somewhere in the middle). The state machines I've written tended to have quite a few states with that property.

I don't understand whether you mean the trivial statement that tail call elimination can only be done for tail calls, the confusing, seemingly contradictory idea that a finite state machine would need to keep a state "alive" beyond the point of the transition (you were talking about finite state machines, right?), or some third thing that I'm totally missing.

Also, I can't quite tell exactly what you mean by "end of the state" vs. "conditionally somewhere in the middle." You might not be making the mistake I'm about to point out, but just to make sure: you can tail call conditionally from the middle of a routine. Tail call just means that all that the caller does with the return value of the call is immediately return it to its own caller; that can happen in the middle of a routine (e.g., in if cond then return f(x) else whatever, the call to f is a tail call).

A very interesting idea though. It hadn't occurred to me to try to implement a state machine using a mutually-recursive web of routines.

It's standard practice in Scheme and other languages that insist on tail call optimization. As long as the people reading the code understand what a finite state machine is, the code tends to be extremely readable.

Re:Tail call elimination

[T.E.D.]

Ahh. I see what you are saying. Yes, any goto pretty much by definition isn't coming back. To change to a web of routine calls, you'd still have to rearrange the way the state is coded (since again semanticly routines *do* come back), but I guess at worst that just means you put a "return" after every routine call.

Re:Tail call elimination

[T.E.D.]

...still, where all your actual control flows are going doesn't seem to me to be nearly as clear when coded this way as if you just went ahead and used gotos.

It would be interesting to do as an experiement (I might even try it sometime), but for actual code that has to be debugged and some poor schlub has to maintain, I'd rather see gotos used.

40oz.

[Anonymous Coward]

Malt liquor comes in different dialects?

Not for me, anyway...

[NitroWolf]

I didn't find any joy in programming until I got to use real languages. Granted this was decades ago, but when I started with BASIC, Logo and Pascal, I found very little interest and certainly very little joy in it. It was clear they were toy languages and served no real purpose... and I was in the third grade or so. It wasn't until I was introduced to ACOS, then C that I found programming to be fun... because you could actually do something useful with it.

One could argue that you can do something useful with BASIC, but it was a chore if you wanted to do anything beyond crappy little programs that printed something on the screen. Paradoxially, perhaps, but batch files are also something that was fun to program.

If someone had wanted to introduce me to programming and get me interested in it BASIC would have been a total put off... it just happens that I was self-motivated and saw the possibilities in it, so found something on my own that would allow me to realize those possibilities. If it was externally directed, you can forget about it.

I would start a kid on PHP or something that's both simple AND useful.

Re:Not for me, anyway...

[InFire]

In case anyone is interested, there is a little known language that is simpler than BASIC and yet allows one to write complex applications or just simple scripts. It can be interpreted or compiled to Java byte code and perhaps to native machine code although I have not yet found any compelling reason to do so. It can be used to write procedural code or OO code. (Sorry - no "GOTO" statements.) "Hello World" is about as simple as you can get:

say "Hello World"

But you can write a functional web browser in a single line not much more complex than that.

There is even a simple IDE available that allows you to write some code in a window and click a start button to interpret the program and see the output in a window.

I personally use this language to write Android applications for the Dalvik VM.

I say "little known" because no one has mentioned it here. The language is called NetRexx and IBM is currently in the process of releasing it as open source code so the language community can maintain and enhance it as needed. I don't think there is a simpler way to learn programming with a language that can produce practical applications at this time. Info: http://kermitkiser.com/NetRexx

TSA Error!

[TaoPhoenix]

You aren't allowed to use the knife anymore either. Too many kids are Terrorists!

Re:Dearth

[TaoPhoenix]

Don't help him, he wants to bet allowed to sink.

Re:Cruft

[TaoPhoenix]

I dunno. Newcomers can be good at being told to ignore stuff in class.

I had grand fun with basic and then the first time I looked at Java the indecipherable cruft whacked me in the head and killed any interest I previously had.

Re:ClubCompy

[TaoPhoenix]

Yeah, for $1000 you can either get a new gaming rig or a credits mention.

Basic Brain Damage as Pedagogy

[Baldrson]

Teaching the Basic programming language as an introduction to programming is a step in the right direction but you really have to understand the point of the education system:

Produce a stream of young adults who are effectively brain damaged and in hock up to their eyeballs.

Now, I will freely admit that Basic accomplishes the brain damage goal of pedagogy, but let us not forget our obligation to saddle the zombies with debt that cannot be discharged by bankruptcy. Unless you charge thousands of dollars to turn young people into brain damaged zombies, how can you honestly call it "education"?

Re:Linux & Breaking

[TaoPhoenix]

Why poke around to break Ubuntu when an approved upgrade will do it for you?

When teaching kids...

[belleb]

The most important thing is a GOOD teacher. I don't mean a diploma and memebership in a union. From gradeschool on up to MS, I've had about six good teachers. I've had many instructors that were decent and tech savy. A good teacher will overcome any shortcomings of the books and tools.

GAMBAS : free (GPL) Visual Basic-like for Linux

[odyssey72]

It is very similar to Visual Basic with a nice IDE, but it is free (as in beer and as in freedom, under the GPL license), and works with Linux (it is included in major distributions). http://gambas.sourceforge.net/en/main.html You can easily make GUI applications (GTK, Qt) with the visual form designer (so it is motivating) while learning basic programming constructs (if then, while and for loops, ...) Later, you can use to teach more elaborate stuff like connections to databases (MySQL, PostgreSQL).

clone's EPIC FAIL? Oh, yes... lmao!

[Anonymous Coward]

clone gets embarassingly "shot down in flames"?

http://it.slashdot.org/comments.pl?sid=1927208&cid=34689212

Hmmmm? Did Your big mouth and skimming get you into a jam again?? Absolutely. You tried taking on your betters, and your skimming and your stupidity did you in, promptly. How embarassing for you clone. It was totally hilarious watching you run away!

LMAO - Ah, now it's just going back to listening to "Lovely Rita, Meter Maid..." -> http://www.youtube.com/watch?v=l87Vvb7JcDU

Lisp failed?

[DragonWriter]

Lisp failed [...]

I'm not convinced that that is the case. Various Lisps (Common Lisp, Scheme, specialized dialects used in particular applications, and other varieties) continue in a number of important uses in production environments, continue to be actively developed, and Lisp features continue to be one of major influences on the evolution of many popular languages as areas that have long been noted as Lisp strengths become recognized as important in modern application development.

How, precisely, is that Lisp is supposed to have "failed"?

Re:Lisp failed?

[camperdave]

I'm not convinced that that is the case. Various Lisps (Common Lisp, Scheme, specialized dialects used in particular applications, and other varieties) continue in a number of important uses in production environments, continue to be actively developed, and Lisp features continue to be one of major influences on the evolution of many popular languages as areas that have long been noted as Lisp strengths become recognized as important in modern application development.

How, precisely, is that Lisp is supposed to have "failed"?

You could say that of any of the dead languages, like Fortran and Cobol, for example. They may have their uses in certain highly specialized arenas, but you ain't gonna code up a pvr gui or a spreadsheet or a motor control app in them.

clone gets embarassingly "shot down in flames"?

[Anonymous Coward]

http://it.slashdot.org/comments.pl?sid=1927208&cid=34689212

Hmmmm? Did Your big mouth and skimming get you into a jam again?? Absolutely. You tried taking on your betters, and your skimming and your stupidity did you in, promptly. How embarassing for you clone. It was totally hilarious watching you run away! There will be NO burying this clone, for your trolling others here repeatedly. Time to put the shoe on the other foot now. You like?? LOL!

clone52431's EPIC FAIL

[Anonymous Coward]

clone gets embarassingly "shot down in flames"?

http://it.slashdot.org/comments.pl?sid=1927208&cid=34689212

Hmmmm? Did Your big mouth and skimming get you into a jam again?? Absolutely. You tried taking on your betters, and your skimming and your stupidity did you in, promptly. How embarassing for you clone. It was totally hilarious watching you run away! There will be NO burying this clone, for your trolling others here repeatedly. Time to put the shoe on the other foot now. You like?? LOL!

clone gets embarassingly "shot down in flames"?

[Anonymous Coward]

http://it.slashdot.org/comments.pl?sid=1927208&cid=34689212

Did Your big mouth and skimming get you into a jam again?? Absolutely. You tried taking on your betters, and your skimming and your stupidity did you in, promptly. How embarassing for you clone. It was totally hilarious watching you run away! There will be NO burying this clone, for your trolling others here repeatedly. Time to put the shoe on the other foot now. You like?? LOL!

Basic vs. Scheme

[DragonWriter]

I learned Basic on a Commodore VIC-20 in 1978. I think it is a terrible choice for learning to program. I suggest newbies learn Scheme, a very simple language that will lead you as far down the rabbit hole as you are willing to go.

I learned BASIC, approximately in parallel, on the VIC-20, the TI-99/4A, and a Timex-Sinclair 1000 in elementary school in the early 1980s.

I think its a fine language for learning to program as part of learning how computers work; its high-level enough to be accessible, especially to young students, but structured similarly to assembly languages and provides a good vehicle for teaching about how computers work at a basic level.

I think Scheme is a much better language for teaching how to design programs to solve problems, but the features that make it good for this purpose are precisely the features that obscure the low level process.

Netlogo

[oraclejon]

Since no one else seems to have mentioned it, I'd like to add a vote for the Netlogo agent-based simulation system as an excellent tool for teaching kids programming. It's not open source, but is free and available for most platforms, has excellent graphics, an easy UI builder, and can be extended with Java code if more advanced functionality is required. I use it off and on to prototype simulations for work, and have found it excellent for many purposes. Last summer, my son expressed an interest in learning programming, so I pointed him to the Netlogo site. Soon he was happily working through the hundreds of examples included with the package, and has since developed some pretty fancy simulations for his school science classes. Netlogo encourages such experimentation, and unlike more powerful languages, allows kids to quickly build useful programs that include fancy stuff like graphical displays, charts and graphs, and complex GUIs without having to do a lot of low-level programming. Take a look....this is NOT the simple logo we all remember from decades ago.

clone gets embarassingly "shot down in flames"?

[Anonymous Coward]

http://it.slashdot.org/comments.pl?sid=1927208&cid=34689212

Hmmmm? Did Your big mouth and skimming get you into a jam again?? Absolutely. You tried taking on your betters, and your skimming and your stupidity did you in, promptly. How embarassing for you clone. It was totally hilarious watching you run away! There will be NO burying this clone, for your trolling others here repeatedly. Time to put the shoe on the other foot now. You like?? LMAO...

clone gets embarassingly "shot down in flames"?

[Anonymous Coward]

http://it.slashdot.org/comments.pl?sid=1927208&cid=34689212

Hmmmm? Did Your big mouth and skimming get you into a jam again?? Absolutely. You tried taking on your betters, and your skimming and your stupidity did you in, promptly. How embarassing for you clone. It was totally hilarious watching you run away! There will be NO burying this clone, for your trolling others here repeatedly. Time to put the shoe on the other foot now. You like?? LOL!

PHP has my vote

[PhilFrisbie]

I second that: PHP (from the command line) would be a great language to learn. Uses simple text files, no compiling, reasonable error messages, and it is enough like C/C++/JavaScript/Java that a person could transfer most of their experience into any of those languages.

Why?

[SphericalCrusher]

The same reason we teach kids math. Teaches them to think for themselves and to understand exactly what their graphics based editors are doing for them. Or at least get their mind to a point where they can think openly and creatively.

Karel The Robot

[exoduss]

http://karel.sourceforge.net/ Technically my first exposure to programming was a loop in BASIC that printed hello world, however, I was fond of Karel as my second encounter with programming. It has a very small instruction set (prevents kids from being overwhelmed and forces them build more tools with procedures) and can keep their interest because it is a game/puzzle.

Re:Use C# - GOTO is essential

[kjhambrick]

> I actually did think for myself when I rejected GOTO. I actually went back and read the "GOTO considered harmful" essay.
>
> Can you provide an example of when goto is appropriate -- in particular, when it's appropriate to use a goto rather than actually structured
> programming, or even a safer option like break, return, or throw?

When you're telling the CPU what you want it to do ?

Show me an object orientated CPU

Show me a CPU without a jump instruction

-- kjh

Re:Use C# - GOTO is essential

[SanityInAnarchy]

When you're telling the CPU what you want it to do ?

In what sense?

I'm telling the CPU what to do when I type here, but I'm certainly not giving it a jump instruction, or any other instruction, manually. I'd have to be insane to do so just to type up a Slashdot post.

Now, if I needed assembly for some reason, yes, a jump instruction becomes relevant. I can't remember ever needing assembly for anything.

I'll look into Python..

[Invisible Now]

Your assertion that Python travels well is a strong point.

Visual Basic and VBA have very accessible OO environments, but mostly over MS Windows. Which is a serious limitation.

Reviewing this thread, I think that the capability of writing lucid code was the key feature I was trying to advance. If you can name wisely and have the basic syntax of the language, even if purposely verbose, read like pseudo code then I think we're on the same page.

BBC BASIC

[Richard Russell]

BASIC isn't standardised in the same way as many programming languages, so you can't lump all BASICs together and criticise them generically. For example if you are in the 'GOTO considered harmful' camp (which I am) you may disapprove of those BASICs in which GOTO is unavoidable, or at least encouraged. However other BASICs positively discourage the use of GOTO, notably BBC BASIC. In nearly 30 years of programming in BBC BASIC I've never used a GOTO (except in programs designed to test that GOTO works!).

BBC BASIC was designed quite specifically to teach programming, as a key part of the BBC's Computer Literacy Project of the early 1980s. Advice was sought from academics of the day on the features the chosen language needed to have, and being sufficiently well-structured that GOTO can be entirely avoided was a central requirement.

As recently as 2006 BBC BASIC was chosen by Portsmouth University as the language to teach in the Introductory Programming Unit of their Engineering Foundation course.

Just of couple of comments...

[stonewolf]

Just tried your system out. Found a few bugs.

I coded an infinite loop. Then I typed "run" and then I realized that there doesn't seem to be anyway to halt a program once it is running. There must be a big red octagonal button on the screen with the letters "STOP" in it that actually stops the program.

I tried to code an IF statement. I had to look up the syntax because "if i 0 then goto 2" got a syntax error. I can almost forgive using the C like "if()" for the if statement but using FORTRAN like "LT" for "" is pretty nasty if you ask me.... But, you didn't :-)

You have a "declare record" statement when just "record" would do. Using "declare" make sense if you are planning to add more things to declare, otherwise it is just a waste. And, seriously, no "for .. next" statement, no "if ... then ... else..." statement, no while statement, no multi-line statements at all. I see that you have reserved some keywords for those so it looks like you are planning to add them in the future. Please, these are critical parts of any language. I know for a fact, having done it, that it is f(&#$@#*$&^King easy to implement those compared to some of the things you have already added.

I tested what would happen if I typed "run" for a program that has a syntax error. It went away forever. No error messages, no output at all. It just stopped reacting to the keyboard. This is a serious bug.

The documentation is really really really poor. Very few examples. No real introduction. You use things like "boolean-expr" but do not define that anywhere it the document.

"turn" is great, but you need left and right also. Kids understand left and right. Positive and negative angles are a bit harder for them.

Palettes? Really? It is very hard to find a computing device that can run a modern browser that is not using RGB pixels. Why put this ancient cruft in the way of kids? Color values are RGB in the range 0 to 1. There are no palettes anymore.

Sprite maps? Nostalgia is an addictive drug, but like all drugs it is damaging when used to excess. Why not just have a place on the screen to browse and drop graphics that can then be used in your program?

I've written an ANSI standard BASIC compiler, I've written a Logo interpreter (or 2 or 3 :-), and I've taught courses in which the final project was a Lisp interpreter. In fact, I've written many compilers, interpreters, and even a linker once. I've also used both basic and logo to teach kids aged 5 to 12 to program. And, I have to say that while you have a good idea your implementation is far from ready for use by kids if I can break it in 5 minutes doing exactly the kind of things kids do.

It looks to me like you have focused on the "cool" parts, the graphics and the math library, but have skipped, or at least skimped on the critical part. The critical part is creating a system that works, followed by the documentation needed to use it.

BTW, WTF is "proof" for? It is left over from back in the day (your nostalgia is showing...) when you actually had to type in code that was published in magazines. OMFG!!!!! We live in a world where magazines have websites (in reality a few websites still have magazines) and flash drives are nearly cheap enough to show up in cracker jack boxes (yeah... I'm old, I learned Basic and Logo on an Univac 1108a :-). We do not do that anymore!

You have a good idea. But, shake off the nostalgia and make something that acknowledges the 21st century.

Yes, I know I have been harsh on you. If I didn't really like the idea of what you are doing I wouldn't bother to find the flaws, let alone spend the time to point them out.

Stonewolf

P.S.

I've recently managed to eliminated the use of paper in all the classes I teach. Doing that has really pissed off the English teachers who still insist on paper and give tests using blue books.
 

"we surprised ourselves"

[Anonymous Coward]

You're spending too much time on /.

Even more retro-BASIC programming for kids

[wad4ever]

How funny! I just did the same thing!