Saturday, March 31, 2012

devant les enfants

almost everything we have done over the last two decades in the area of ICT education in British schools has been misguided and largely futile. Instead of educating children about the most revolutionary technology of their young lifetimes, we have focused on training them to use obsolescent software products. And we did this because we fell into what the philosopher Gilbert Ryle would have called a "category mistake" – an error in which things of one kind are presented as if they belonged to another. We made the mistake of thinking that learning about computing is like learning to drive a car, and since a knowledge of internal combustion technology is not essential for becoming a proficient driver, it followed that an understanding of how computers work was not important for our children. 

John Naughton in the Guardian

Naughton goes on to take issue with the claim that code is the new Latin, because Latin is a dead language.  This is somewhat misguided: the Latin (and, for that matter, Greek) literature I learned to read 40 years ago is no more obsolete than Beethoven's Ninth.  If I had started programming the year I started Latin (1971) I would not now be able to use the programming language I learned then with the same benefits it offered when I first studied it. (I am not saying it is not a good thing to learn to code, or that I don't wish I had done so earlier, only that it's rare to learn something in school that retains its value close to half a century later.)

Naughton also argues that the reason to teach programming in schools is not economic, but moral. What he means by this is that we owe it to children not to leave them in the power of computer-savvy elites. I would have thought the moral obligation was in fact much stronger than this: programming forces one to think logically.  (Some may remember the complaint of the Professor in The Lion, the Witch and the Wardrobe: What do they TEACH them in school?  Don't they teach them logic?)  It also forces one to face up many, many times to one's fallibility. (Douglas Crockford's JSLint carries the warning: Your feelings will be hurt.)  Many of the problems I have faced with the publishing industry over the last 16 years could easily have been avoided if people who were "passionate about books" had the kind of logical training, the attention to detail, the awareness of possible errors, that programming provides. 

Anyway, very glad to see this new initiative.  (As a number of journalists have commented, IT in British schools has dwindled to getting schoolchildren up to speed on Word. Jesus wept.)

2 comments:

Chris said...

"If I had started programming the year I started Latin (1971) I would not now be able to use the programming language I learned then with the same benefits it offered when I first studied it."

I agree with your basic point (I'm very fond of Classical Greek myself, even if I'm not very good at it) but I can't resist pointing out that the ideas at the core of Lisp were first set down in the late 50s and that contemporary dialects of Lisp continue to offer abstractions more powerful than the ones on offer in most modern programming languages. Scheme, a dialect of Lisp, first appeared in 1975. It's current incarnation remains a way to get real work done.

I'm in the middle of reading both "The Last Samurai" (which I'm enjoying, thank you) and rereading "The Little Schemer," and so just the other day found myself wondering if you had read the latter. If you haven't, you really should.

Cheers.

leoboiko said...

I agree with both of you. Learning Scheme isn't exactly the most direct way of having a résumé that will earn you jobs quickly; it’s quite hard to get comitees and grant people to fund this kind of education. But yes, there’s something behind the surface of syntax and vocabulary, below the outward look-and-feel that so entrances novice programmers; and the more you program, the more you operate at this “deep” level, so that you can get work done in any language (at least in my experience).

The minimalism of “academic” languages like Scheme bypasses the plumbing and lets you concentrate on these structural, perennially useful, math-like problems. For example, The Little Schemer is not a book on Scheme as much as a book on recursion; if you can finish it, you’ll know recursion, really know recursion, for the rest of your life, for any language that uses recursion and any problem that needs recursion.

In a way, what I like about Scheme is everything that’s not Scheme; it’s polite enough to get out of the way. And exercising on the actual problems makes you a better programmer overall, just like learning to draw from life improves the art of a cartoonist even when they’re drawing cartoons.