Why Johnny can't code

'BASIC used to be on every computer a child touched -- but today there's no easy way for kids to get hooked on programming.'

I have to say that, much as I love more modern higher-level languages (why else would I be here), BASIC was what I grew up on, and really was ideal for picking up a first understanding of what programming is all about. With its global variables, GOTOs and all. It gets the computer obeying your command and following your logic with the absolute minimum learning curve. You don't have to learn any more abstractions than are absolutely necessary in order to feel that power (wow, it actually does what I tell it to, step by step!) and get yourself hooked.

Comment viewing options

Early programming languages like BASIC were line-oriented because the user's interface to them was a teletype. Back then, there were also line-oriented text editors, where you'd type a bunch of lines, and then edit by saying "on line 3, replace 'teh' by 'the'".

Logo's fine and imho much better. I had a painful time growing up on BASIC, I soon realized that I needed to be saved. I taught myself some logo, played with turtles for a while and then felt much better after making recursive drawings.

I think for kids today, making pictures using programs is a very rich way to teach programming.

I remember enjoying LOGO a lot too. It was never really taught (to me at least) as a programming language, though, more just as a drawing tool for kids to play with the fun robot turtle, and a way to help kids understand angles and geometry. Figuring out how to plot fractal trees with it was interesting, but it has a bit of a higher-level feel to it, and the control flow wasn't quite as blindingly obvious as BASIC's line-numbers and GOTOs. For me at least, as a kid.

Logo might be suitable for younger children...as a teenager, I remember that having the option to use Logo or Basic on the Amstrad 6128, I chose Basic, because it felt a more 'mature' tool, and everything else was coded in Basic too.

I think though that the Basic model (i.e. a program is a list of commands) is a very simple model that sits well with the young minds...other models like object orientated or functional programming are more complex and therefore maybe unsuitable for first teachings.

On the other hand, starting with a pure functional language maybe is better in the long run, because the programmer's mind is not 'littered' with the imperative model. I think it is easier to go to imperative from functional than the other way around.

I think that one of the reasons that 'Johny can't code' is because programming languages are not as accessible as they were. Today's languages include huge and scary IDEs, projects and solutions, huge APIs and a level of knowledge that is scary for beginners. Even the available Basic languages are not that simple. For example, in order to draw something on the screen, the programmer has to open a window, create a class, get a device context etc. And the plethora of choices does not help either.

On the other hand, starting with a pure functional language maybe is better in the long run, because the programmer's mind is not 'littered' with the imperative model. I think it is easier to go to imperative from functional than the other way around.

For lots of beginner-type programming problems (e.g., converting a string to an integer), yes, I agree that pure functional programming would be better. But there's definitely something to be said for incrementally updating data structures and interactively inspecting them.

but I can't help but notice that I'm reading it using a web browser, a tool shipping on every computer and including a full-featured but pretty accessible programming environment (JavaScript). I'm not sure how it could be said to be any worse than Basic for teaching young coders.

Growing up I had regular access to an Apple //e and a TI-99/4A. Both these computers presented a command prompt where I could play with BASIC commands (including graphical ones), write programs, and dissect and edit other programs. Web browsers provide no such environment - at best, Firefox's JavaScript console provides a limited REPL, but it's hard to get any good interaction going without a knowledge of HTML and the browser's DOM.

Of all languages, Python reminds me most of my years learning BASIC. It provides a REPL, and other programs (including the standard library) can be dissected and learned from. What's more, it provides online help and a "turtle" graphics interface. The "RUR-PLE" environment grant mentioned below is a beautiful example of how Python can be used as a teaching tool.

I thought the python-based environment RUR-PLE looked promising. It's an update (in spirit only) of the older 'Karel the Robot'. Of course it's hard now to tell what makes sense to kids who know nothing about programming.

There's also Guido van Robot which is rather similar but actually creates its own (extremely pythonic) simple language to do things. Stuff like this seems ideal for kids - it's problem solving and games, but involves programming to do it.

teaching to program at the hands of a full fletched programming language seems like teaching to read at the example of a joyce novel.

modern educational tools like kara avoid this problem and allow entry level education at very young age. kara is a graphical interface for building finite state machines. it teaches the underlying concept of program evaluation (in obviously non-functional context) without the complexity of programming languages.

the bottom line is:

learning a programming language is simple. in the end, in comparison to natural languages, it is nothing else but a syntactically and semantically nearly trivial foreign language.

learning the abstraction of (stateful) programming is the intractable task. there is no former knowledge to built upon for this for pupils.

What's important is having an easy to use graphics API. I don't mean easy like GLUT or SDL, say. I mean easy. On my BBC Micro years ago I could type a command to go into a 'high-res' graphics mode and then start interactively typing in graphics commands. Within 5 seconds of switching it on I could have graphics of my own creation on the screen. In a modern OS I have to write a few hundred lines of code just to grab a window reliably, and when I've done that, I can't experiment interactively. Kids need instant feedback. Even the kids of my generation, before ADD had been invented, needed instant feedback.

I found a canvas tutorial. The canvas is non-interactive (in the sense that you can't type commands into it on at a time and have them executed). You need to fire up a web browser at the same time as a text editor. Obviously you need to understand the concept of a file and a filesystem to actually get the data in the text editor to be the same data read by the web browser. And the simplest example involved several lines of HTML just to get a blank window. I'm happy with this stuff, but I have been programming computers for 30 years. I don't think it's what a young kid is looking for. On the other hand, I was impressed with the relative simplicity of this demo. That took my right back to the good old days! So maybe the canvas element would make an excellent second stage after a simpler introduction.

It is simple to add a nicer interface on top of canvas and a javascript REPL in a single self-contained page. With the appropriate permissions, you can even save the program as a webpage, which I guess you could then upload to myspace, etc. Sounds like a nice weekend hack :)

Graphics on the BBC were very easy. Here is one of my first programs. Note that the exclamation marks are not optional:

PRINT "[shift+f1][shift+f8]EDWARD RULEZ!!!!!!!!!!!!![shift+f0]"

This printed a message about me in flashing red text. An addition of another [ctrl+f?] allows the text to be mixed with coarse graphics. This is particularly appealing, since it requires next to no knowledge, which is why it was one of my first programs. The next program propably proceeded that line with the SOUND command.

My point is that the barrier to entry was so low that it was hard to get discouraged and give up.

Thanks for the link! I searched in vain for something like this several times. A wiki like environment for interactively sharing source code is part of the e-learning vision I articulated recently. Domain specific languages for learning specific subjects should support such a wiki infrastructure (called "wiki-source" in my slides, if you came across them - basically a wikipedia style repository, based on sharing the DSL code, and rendering it automatically).

The slides are here. Alas, I don't think they are very helpful if you weren't there. My presentation mainly includes carious videos (not included in the slide deck), and the slides contain very little information in themselves. There's a bad transcript of the talk available - if you read Hebrew...

Well, at least on OS X and Linux (haven't run windows in ages, I don't know if there's a free easy X11 setup for it), you get something fairly similar to that with tho OCaml graphics module. Fire up your REPL, enter a #load "graphics.cma";; then open Graphics;; and you're good to go. Granted, OCaml might be a bit tricky for a young kid (especially when they get to the int/float mismatch -- that makes grown men cranky), but I'd like to think a programming savvy parent could guide one along nicely.

I think it is worth noting that the ultimate goal of Logo wasn't to teach programming but rather to teach or develop mathematical thinking in kids via programming. I think that the notion of learning via programming can (and should) be extended to other domains. This was the subject of my talk I briefly mentioned here. The approach I envision relies heavily on DSLs, tailored to learning and interacting with specific subjects.

I was reading over the comments to this story when it hit slashdot a few days ago. Someone there (sorry, don't remember who) had made an excellent point as to, perhaps, the real nature of the problem the author was writing about: simply knowing that's it's even possible.

In a modern setting, you buy your new machine, take it home, and it boots up to Windows and you've got everything there in front of you to just click on stuff and make things happen. In the good old days, you turned on the machine and were dropped at a prompt where you had to type commands just to load your favorite games. That would naturally lead the curious into wondering what else they can type there. Next thing you know, they're reading BASIC books and making cool little games or whatever.

I think the author is really lamenting the fact that things aren't like that anymore and while he has the experience required to help his kid(s) get into the technical side of computers, I kind of took away from his article that a part of him is worried about the future as a whole. What about all the kids who don't have technical parents or influences? How will those kids even know they can have power over their machines in the first place? That sort of thing.

Is there a solution to that? I don't know. It's hard to say if it even needs an explicit solution because those who are driven will figure it out somehow. I think there's enough information out there that simple google searches will lead down a path to programming enlightenment eventually. It just might not be as obvious or easy as it was way back when. Or perhaps it just isn't as obvious to those of us who grew up without GUIs.

The culture of programming in which BASIC was once a key element is just over. Instead deprived languages such as JavaScript are advocated here and elsewhere, not because they let people "feel the machine" - on the contrary: all modern programming languages are dedicated not to feel it but living in increasingly abstract phantasies instead - but they share some superficial similarities ( simplicity / being widespreaded ). "Controlling the machine" by a single individual is the ideal of another generation which lead not-surprisingly also the political discourse of emancipation. Today software is just another industrial product that requires division of labour for avoiding to be sub-standard. Even the creation of computer games will be guided by scientific theories. This way BASIC turns back as some kind of ghost and as a medieval romanticism: a crufty, spaghetti producing, dark age computing language that lead people less alienated and deprived after all.

As I understand it, this niche is being neatly filled by Lego Mindstorms and other robotics toys. Evidently there's more of this going on than I thought, with junior-high robotics clubs and competitions becoming more common. Robotics has a lot to recommend it over graphics for introductory programming: more interactive, less abstract, absurdly simple programming models, and problems ramping from the trivial to the mind-expanding.

This seems like a good time to provide a link to the Transterpreter, a runtime that can be used to run programs written in occam on Mindstorms. Apparently they're looking at adding other language support too.

Also, while it is not quite the same problem as Brin is talking about (I wouldn't hand the URL below to a bright 10-year-old and expect him to bootstrap himself on programming or robotics), modern integrated microcontrollers let you get up and running, talking directly to LEDs and such, with a remarkably small amount of solder. And it seems to be a strongly related problem: I wouldn't give this to any 10-year-old I've met, but some 14-year-olds might be OK...

I did assembly language programming as a teenager starting with a Heathkit 6800 microcontroller trainer kit. I came back to it two decades later cooking from scratch with substantially the same recipe as the one below (wiring up the bare chip directly to the parallel port and all). I find it very impressive how simple such modern recipes are.

Although today's computers come with web browsers, which in turn come with Javascript, (and moreover most OSes come with gcc), they still omit one thing curiously, and it is also curiously missing in the foregoing discussion: introductory programming tutorials.

Some of my first computers were BASIC-capable calculators, specifically Casio FX-702P and Sharp PC-1500. Their manuals taught very introductory programming, and some ideas taught were not language-specific. For example, the 702P manual taught flow charts; the 1500 manual advised you to "group only those statements which are conceptually related" (on writing like 40 stmt1 : stmt2 : stmt3); both introduced GOSUB as a factoring construct. Each came with a second book full of programs, and one could have a lot to read. Each of course also suggested further, more serious programming books.

Yes of course similar books are available at bookstores, in libraries, and on the Internet. But from the perspective of a child receiving the gift of a computer package for the first time: what is exposed visibly out of the box is influential to how you think you are expected to play with this new toy. If the manual does not showcase programming, if the desktop icons refer to just surfing and games, you will not be aware of its programmability for a long, long time.

The solution is easy though. Give the gift of a programming book too (or a URL).

_why, a famous ruby hacker (and, perhaps incidentally, the author of the blog post The Little Coder's Predicament) created an interactive tutorial that resides inside a REPL which resides inside your web browser. The only prerequisite is that you must have a modern web browser.

The default tutorial starts you creating and outputting simple strings ("hello world!") and takes you through to creating a fake 'blog'. It was purposelly built to enable the embedding of new tutorials in the REPL so I suppose one could create a tutorial specifically tailored to children.

Other kid-oriented structure editors I've seen are Carnegie Mellon's Alice and Berkley's Boxer. I do believe assisted realtime manipulation of the AST is the way forward here, providing a level of transparency and safety at input time that you just don't get with the dumb character buffer and separate parse-compile stage of older-style environments. For average computer users it'll be like the difference between DOS and Windows.

Incidentally, I wonder if Apple might go this route if/when they eventually get around to replacing AppleScript, given that they're already dabbling in this general area with Automator and Quartz Composer. The major OS vendors are in the ideal position for getting these technologies from the research labs onto every user's desktop, after all. I guess the big question will be whether or not they've any motivation to do so.

One of the more interesting attempts to introduce older programming concepts to young people was the 1982 text, "Elementary Pascal As Chronicled by John H. Watson" by Henry F. Ledgard, which employs the literary conceit of a series of Sherlock Holmes mysteries solved with an analytical engine whose programs were coded in Pascal.

It would be a most interesting project to update the text to employ a modern language like Scheme if the appropriate copyright permissions could be secured.

This is a timely topic for me, since we just had our first child, and I would like her to eventually have the benefit of some of the wonderful experiences I had as a kid. I'm not a serious programmer, I am a designer who does a little coding (I've written a couple of medium sized Flash applications in actionscript). Even if programming were no longer a part of my life, I'd still feel greatly indebted to the logic and problem solving skills I learned from programming. Not only that, but learning to program at an early age provided me with a strong sense of being able to effect change in my environment. I credit my being self-employed and my entrepreneurial spirit to those early days of knocking out simple programs in BASIC.

I first encountered the joy of programming in the 4th grade, and learned the basics of creating a simple "choose your own path" story (a rudimentary adventure game adapted from kids books that were popular at the time) in an afternoon from a friend who had just introduced me to the school's brand-spanking-new Tandy Color Computer. I quickly moved on to David Ahl's enjoyable BASIC GAMES books, and they opened up a whole new world to me.

Programming teaches systematic, rigorous thinking that equips one to engage life much more effectively. Being conversant with code is also the new literacy. People who can't at least understand "how machines think" are at a distinct disadvantage. Plus, I want my kids to see computers as tools, not as consumer electronics. The distinction is an important one, since I want to train them up to be producers, not just consumers.

Being interested in the golden age of Xerox PARC, I looked up Squeak. However, doing a little reading on this site has made me think twice. Where are people going these days to get the contemporary "BASIC Games" experience? That world won me over as a kid because it was not at all intimidating, and provided fast results that I was quickly able to learn from and adapt.

I guess I could always eBay an old CoCo and some David Ahl books, but surely there's something better?

I learned BASIC on an 8-bit computer specifically to write games. I think a lot of people still have the same motivation. I'd recommend looking at Game Maker (http://gamemaker.nl/) and Blitz Basic (http://www.blitzbasic.com).

I'm not a big fan of Blitz, but it does let you get stuff up on the screen quickly. Game Maker hides programming completely for a while, but it encourages logical thinking from the get-go. Then you can start moving toward writing real programs behind the scenes.

Flash's ActionScript is another possibility. There was a great book out a few years ago about doing algorithmic graphics with Flash. I found it inspirational to flip through, with some of that old-timey spark to it.

To a large extent I think the huge variety of options is a hindrance. I learned BASIC on an Atari 800 because (a) my parents bought an Atari 800, and (b) it came with BASIC. Things are not so simple now.

There's a whole OOP programming language behind the icons (and I agree, the icons are annoying for anything except simple actions, but kids seem fine with them). You can ignore the icons completely and work directly in the scripting language. See the manual for details.

Flash's ActionScript is another possibility. There was a great book out a few years ago about doing algorithmic graphics with Flash. I found it inspirational to flip through, with some of that old-timey spark to it.

Could the book in question be Flash Math Creativity from the Friends of Ed? I flipped through it, too, but never ended up getting a copy. (There is also a second edition out.)

Extra relevance to LtU: gosh, the stylized "ED" in the Friends of Ed logo looks an awful lot like a lambda; anyone know if that's on purpose? (More specifically, on purpose and referring to our favorite lambda :) ?)

Inform has already been talked about here at LtU. It's a system for creating "interactive fiction", or text-adventure, games. You do it by crafting your game in a english-like, OO-featureful programming language.

Povray is a long running quality freeware raytracer for rendering 3D graphics. It comes with a very powerful and expressive Scene Description Language, which is a full-fledged programming language in itself, though macro-based. Although you'll not create large 3D polygonal meshes by hand in said language, like most raytracers it thrives in simple mathematical Finite Solid primitives, syntatically simple to define, and constructive solid geometry operations to cleanly create nicely hand-made 3D graphics in few lines of code.

The reason i'm bringing this up is that i feel both are far more engaging and technically interesting examples of how to reach users who would not be interested in programming activities at all than something like Logo. Having fun by actually crafting a virtual world, either by words or by light, is reason enough to give it a try.

Besides, povray also boosts your mathematical and geometrical skills. And Inform should make wonders for your taste of good literature. :)

there, my little girl will be introduced to programming with these, when the time comes. hmm, or perhaps a subset of Scheme, and these when she gets acquainted to literature and math... :)

I did not get mathmatically introduced to real numbers until the 7th grade. It wasn't until 9th grade (Freshman in High School) that I had algebra. It was in the second semester of algebra that our instructor introduced us to computing by way of a tour to the school's computer class/room. The OS was GCOS 3, with BASIC, accessed via a teletype at 110 baud.

I was really introduced to programming by a physical science classmate (also my freshman year) who was taking the computer class. I wrote little programs solved equations by computing the value that was inputed as zero (eg A=r^2*pi, if the A was inputted at zero, it would compute it from the radius...). He entered a number of these for me, and looking back nearly thirty years, I likely did some of this homework. :-)

I spent nearly an hour after school every day after the computer lab tour observing those programming on the teletype and (mostly) playing games. I got a printout of several games and played computer with them at home. With paper and pencil, following the flow of control and the update of the variable. My most significant one was a biorythms program. I actually did a complete run of this program by hand. The things I did because I did not have access to a compter. :-)

So I wonder how much of a mathematics basis is required to start programming. Can real programming be done without algebra, either previously learned or picked up through the actual programming?

I learned to program in BBC BASIC before I started school. I learned 6502 assembler when I was 10, ARM when I was 11 and wrote my first real-time, animated, 3D demo at that age. When I was 15 I wrote a sphereflake ray tracer in BBC BASIC. I learned C++ and OpenGL when I was about 20, Mathematica at 24, OCaml at 27 and just started F# and Direct X at 29.

Had I known more maths at an earlier age, it would doubtless have made programming easier. Writing a sphereflake ray tracer before you've learned about vectors is quite challenging!

I didn't really do much real maths until I got to university (studying physics) but I think a more formal approach to mathematics really helped me to understand type theory and gain an appreciation for statically typed languages.

Overall, I think I'd say the opposite: children should be taught to program before they are taught algebra and algorithmic problem solving. I would have found it much easier to pick up maths if it had been described algorithmically, rather than by example.

As the subject says, those who started programming at the beginning of the pc revolution or thereabouts had tools that they could relatively easy extend the functionality of by programming, modern pcs cannot relatively easily be extended in functionality because they are so powerful already. The limited functionality of computers made extending them easier.

Furthermore someone starts to program and continues to do so in the way outlined here because they can achieve things they consider interesting. What do kids nowadays want to do with their computing devices and we can say what a programming language should make easy for them to do.

One thing is communication. I think a programming language to be 'easy' for a kid to learn nowadays should give them the instant response not so often of graphics moving back and forth because that is primitive and uninteresting in comparison to their video games, instead it should give them the possibility to automate messaging relatively easily.

I think in that respect Rebol is a relatively nice language for someone to learn to program in. But as it is mainly computer bound and not available on the tool most likely to be of wild interest for a kid and teenager to extend, the mobile phone, it is not the language likely to teach with.

I suppose python on the mobile is the most likely language to teach a teen to program in. maybe also a kid down to 9 years of age.

The 3APL language that I posted once before might be interesting to a "teen" becuse it is something that their parents and teachers know nothing about. It is different but I think a motivated teen could learn it. Also the GUI was created to teach the language. There is even a mobile version.

3APL is a programming language for implementing cognitive agents. It provides programming constructs for implementing agents' beliefs, goals, basic capabilities (such as belief updates, external actions, or communication actions) and a set of practical reasoning rules through which agents' goals can be updated or revised. The 3APL programs are executed on the 3APL platform. Each 3APL program is executed by means of an interpreter that deliberates on the cognitive attitudes of that agent. The EBNF specification of 3APL and the deliberation cycle are available through the following links...

Basically someone without an already established programming background is not going to be interested in that. To get someone to program show them how the language will allow them to do something they are interested in doing, show them how it can fix their computers problems or allow them to use the computer to fix problems they have.

If we are talking kids, teens and so forth the more important computing platforms they have access to are portable devices.

A programming language that you could put on an ipod would be a big hit with the assumed target audience of 'kids'.

Your statement that it might be interesting to have a language that " parents and teachers know nothing about." is interesting, although I'm not sure how far generational rebellion can be harnessed in driving teenagers learning programming. Perhaps some kid somewhere has taken up LISP to annoy his C++, Java programming dad. It would be nice to hear about if so.

Did you try it with the examples. The examples are simple and educational stuff like blocks world and goal orientated thinking. Also the GUI "shows you" how the problem is being solved. There is no need to go past this level, no need to teach AI. Let the language and the tool do its job.

From SourceForge.net:
"KidBASIC is an easy to use version of BASIC designed to teach young children the basics of computer programming. It has a built-in graphics mode which lets them draw pictures on screen in minutes, and a set of detailed, easy-to-follow tutorials that introduce programming concepts through fun exercises.

Version 0.3 eliminates the line-numbering syntax of previous versions, replacing it with labels. Performance has also been increased slightly. Linux source tarballs are now available.

I first looked at Rebol because it could be picked up so naturally by beginners - in my experience even more naturally than those old Basics - but it's much deeper and much more practical/useful for real work. None of the typically suggested language environments are small or simple enough to solve the problem of immediate use. Rebol's trivially small to download (100k-600k on most operating systems) and can be used immediately, without installing. Rebol runs identically on over 40 operating systems, and can be used to build serious applications with modern graphics, CGI interfaces, network functionality, database connectivity, etc... But it's absolutely the simplest language to begin using immediately, in a manner similar to those old Basic interpreters. I've never seen another package that's so quickly usable in so many ways, especially by beginners. There is not an easier way to build GUI's than with Rebol/View - simple interfaces can take as few as one line of code. It's a shame so few people even know it exists. Take a look at:

You must know the arity of each function in order to parse expressions with their calls. This makes code hard to read: you can't even know what is an argument of what unless you know the meaning of each word.

Rebol's built-in "help" function can be used to instantly determine the arity of any function (built-in or user-defined), and that potential problem is typically eliminated by adhering to even the simplest style guidelines ... obfuscated code can be created in any language by using unclear coding style. Rebol is no different in that regard.

In my experience, with beginners especially (not those indoctrinated and ingrained in modern coding practices), as this article is focused, Rebol seems to simply be more natural than other languages. The inclusion of so many useful native data types, native use of common Internet protocols, the single ubiquitous block data structure, super-simple GUI creation (with one line of code), and the way those elements all interact naturally without requiring any external modules or toolkits, and the way they can be simplified and extended at a higher level by the inherent dialecting ability of the Rebol language structure - those are features that are salient to this article's topic.

Professionals will continue to use the tools with which they've become accustomed. For others, Rebol is an amazing and powerful tool that's actually useful without months/years of experience. Like the author, it's my opinion that too many professionals in the industry miss the value of this point. Installing a modern C compiler and becoming familiar with the IDE interface is harder than learning to write and implement productive code in Rebol. The overhead that's required to understand, implement, and integrate object-oriented C++ libraries to accomplish any given programming task is significant for a beginner. And then to do web site programming with tools such as PHP, beginners need to learn a totally different development paradigm and language structure, and then they're confronted with databases and SQL, etc... beginners just don't know where to start. I think the main point that the author tried to make in this article is that there's too much overhead required to learn how to use typical modern computing tools, and that using them doesn't necessarily require or improve old-fashioned productive _algorithmic_ thought. Instead, modern programming has become about learning to implement the contrived and complex mechanics of multiple bloated environments. The idea is, wouldn't it be great if there was a single simple language/interpreter/compiler/environment that everyone learned to accomplish fundamental computing tasks, in a manner that's similar to the way those old BASIC interpreters were implemented - with a focus on algorithmic thought. Rebol seems to comes closer to that goal, in a realistic, simple, approachable, and useful way, than anything else I've seen.

Beside the language syntax, Rebol's interpreter file size is also dramatically smaller and easier to download/install (and available on more platforms) than that of any other powerful modern language. For that reason, and for all the others mentioned above, it just seems like a natural solution for the problem addressed in this article. It has been in my experience :) People can just pick it up and use it to do computing of all kinds. It's easier and simpler to use than any other language or development environment, especially when it comes to accomplishing practical, modern computing tasks (it's not limited to learning and completing simple tasks in the way most BASICs are).

We all have our reasons for using other favorite tools, and our preferences for coding syntax, environment, etc. I don't expect that to change, but for the topic of this article, Rebol seems perfectly suited. (... and I like Rebol syntax because it doesn't require so many unnecessary characters. Determining he arity of functions has never been a problem in my experience :).

My guess is there a lot more kids programming today, and a lot more young programmers than 20 years ago. And of course way more computer competence in general. In 'our' day the barrier to entry for computers was way higher, so naturally it was our ilk that was interested at all. In fact if you weren't interested in programming, there wasn't much to do other than watch the blinking cursor.

I agree it could be better, they could teach it more, etc... but my guess is 10 year olds 'like us' have no problem finding an outlet for the way they are bent. Certainly there are a lot more tools and tutorials at their fingertips than we had, and I bet ending up in the game industry sounds better to kids than ending up sorting customer records in cobol. That was as good as it looked where I was.