D in the ix magazine about "programming today"

[Nick Sabalausky]

"bearophile" <bearophileHUGS at lycos.com> wrote in message 
news:hh76ur$1thp$1 at digitalmars.com...
> Georg Wrede:
>>   - It has to be compiled to genuine executable code.
>
> This is a very interesting topic, but I don't agree with some of your 
> ideas.
>
> I think that today there are no languages really fit as first language. 
> Every language has downsides if you use for that purpose. And the sad 
> thing is, if you design a language for teaching, it probably comes out as 
> a toy language that no one wants to use anyway.
>
> Said that, a teacher has to choose a language anyway. In my opinion the 
> best languages for such purpose are Python, D1 and Java. Other 
> alternatives are StarLogo (And its variants, like NetLogo), Processing, 
> the Logo that can be used to control Lego, and few others.
>

Java can be ok *only* if you start from an imperative standpoint and not an 
OO standpoint. Years ago, I spent some time as a CS 101 tutor, and the 
school (a Java school) had two CS 101 instructors: one (teacher "A") started 
with imperative programming and taught flow-of-execution and flow control 
and then functions, etc, (and glossed-over the "class MyApp{ static final 
void Main() {} }" boilerplate) and only moved on to OO once the students had 
a good grasp of the imperative stuff. The other teacher ("B") started 
straight into OO, and only moved on to flow-of-execution late in the 
semester.

I got a number of students from both teachers, but noticed an interesting 
pattern: Every single one of the students I got from "A" already had a solid 
grasp of the material. Their work was already completed and they had only 
come to me to have it double-checked. I don't remember any of their work 
ever being wrong. There were a few cases where I'd gave an extra little tip, 
but they clearly knew what they were doing.

By contrast, every single student I got from class B was completely 
bewildered, couldn't make head or tails of any of it, and essentially needed 
to be completely taught again from the beginning. A number of them I had to 
refer back to their teacher because they were so confused about it that the 
only way I could have helped would be to develop a full CS 101 lesson plan 
of my own, and #1, I felt that would be overstepping my bounds, and #2, at 
minimum wage, that wasn't my f*ing job (actually, my real job there was 
"computer lab monitor", but the CS dept noticed that I knew what I was doing 
with code, so they asked me to help tutor while I was there. Of course, why 
a private non-party college with high entrance standards felt that they 
needed a hired babysitter was, and still is, completely beyond me, but hey, 
I was more than happy to take their money while I did homework, after all, 
they sure as hell were taking a fuckload of my money, and providing jack-all 
in return.).

But, I'm not convinced that professional languages (not that I consider Java 
professional in any way) should be used as a day-1 starting point. They 
absolutely should be taught relatively early, and any advanced programming 
concepts should be taught using them (or with psudo-code and implemented 
directly in a real language). But for most beginners, those languages are 
way too dry (and I don't mean "don't repeat yourself" DRY, I just 
mean....dry.).

For most people, programming is like math, it's a bunch of boring abstract 
formalities. To prevent people from being turned away right at the 
beginning, I think it's best to start with something that has a very high 
degree of immediate *and interesting* feedback, and with minimal effort and 
trip-ups. In other words, something like BlitzBASIC or DarkBASIC, that do 
very easy pictures, sounds, and games (But not flash, because #1, 
ActionScript and the Flash IDE are absolute fucking messes in any version 
and that's only going to serve to confuse them, plus, since Flash is, 
unfortunately, used frequently for real-world-work, it's unlikely they'll 
ever come to understand why Flash and ActionScript are pure shit). The other 
nice thing about that sort of language is that there's a lot they're not 
suited for, so it'll be easier to ween them off when the time comes to move 
to a professional language (which should be done *while* explaining in 
simple terms why certain things are harder or more work than what they'd 
been doing before, and what that's ok, or even desirable). You don't start 
cooking with blowtorches, gas burners, and double-boilers, you start with a 
toaster and a microwave, *then* learn the how's and the why's of the 
trickier-but-better tools.

A lot of people would probably disagree with much of the above because "You 
can't unlearn something", but I've always felt that's a complete load of 
bullshit. Of course you can, and painlessly too. I've done it plenty of 
times. In kindergarten, I spelled "of" U-V. Obviously I unlearned that, 
along with the bullshit claim about what sounds the letters O and F "always" 
make in the english language. Anytime you've ever been corrected on 
something, or corrected yourself on something - guess what? You've 
unlearned!

Example:
First grade teacher: "You can't subtract a bigger number from a smaller one, 
2-5 can't be done."
Student's internal knowledge: "Bigger numbers can't be subtracted from 
smaller ones, 2-5 can't be done."
Fifth grade teacher: "Your first grade teacher was a liar: There are 
negative numbers: 2-5 = -3"

Pop quiz, assuming there's no retardation involved (and I mean that word in 
the clinical sense...which reminds me: "PC" police can kiss my ass) what's 
the student's internal knowledge now?

A: "Bigger numbers can't be subtracted from smaller ones, 2-5 can't be done. 
My teacher keeps saying 'blah blah blah blah blah' and his words are 
nonsensical gibberish."

or

B: "I was mistaken, I *can* do subtraction like 2-5, the result is just 
negative."

So to any programmer, engineer or scientist who's ever been taught in grade 
school that subtraction of a greater number from a lesser one is impossible 
(see, there's another thing successfully unlearned - values are "greater" 
and "lesser", not "bigger" and "smaller"), don't ever try to tell me that 
unlearning is difficult or impossible.