Teaching programming concepts to kids

Levi Pearson levi at cold.org
Sun Nov 12 00:40:00 MST 2006

On Nov 11, 2006, at 10:00 AM, Michael Torrie wrote:

> Recent discussion on Java's merits got me thinking.  I recently  
> read an
> article, entitled "Why Johnny Can't Code[1]," which I thought was
> interesting, but I'm not sure if his points really are valid.

I don't think his points are particularly valid either, though I  
appreciate the underlying question of how to introduce programming.   
I was thinking about this question a couple of years ago and it  
reminded me how exciting programming was.  It re-kindled my desire to  
learn computer science, and got me to start studying programming  
languages again.  Now you all have to listen to me talking about  
Smalltalk and Lisp and stuff!  Watch out, this kind of thinking can  
be dangerous. ;)

Anyway, I started in early elementary school when my dad got an Apple  
II clone to do word processing.  I was having trouble memorizing my  
multiplication tables, so he picked up a BASIC book and wrote a  
little flash card program.  That fascinated me, so he taught me how  
it worked, and I was hooked.

Back in those days, even some commercial programs were written in  
BASIC with simple menu-driven interfaces.  Creating those was within  
the reach of a hobbyist programmer, and more importantly, it /felt/  
like it was within reach.  Often you could buy a disk full of simple  
games, and they would be written in BASIC so you could look at the  
code.  You could buy books with source code for interesting things,  
and they were simple enough to fit in a few pages but still did what  
they were supposed to.  The fruits of my programming efforts, meager  
as they were, felt like they were only a little bit removed from what  
the 'professionals' made.

Now, programs are probably an order of magnitude more complex, and  
the applications a new programmer can write generally look like toys  
in comparison.  Instead of having a programming environment as the  
command prompt, most users get a graphical shell with no way to write  
programs in sight.  The FOSS movement has alleviated this to some  
degree, but UNIX is still far, far more complex than the simple BASIC  
prompt of my youth.

Anyway, my pondering of this problem led me to Squeak, which someone  
else has mentioned.  To me, it has very much the same feel as the old  
BASIC systems, except with graphics and a saner (but still very  
simple) language.  This is probably because Alan Kay always had kids  
in mind when he developed his ideas.  He's passionate about teaching  
kids, and he's developed a bunch of tools in Squeak to help teach  
programming and other topics such as physics through simulation.  You  
can 'inspect' any object on the screen, peek at the source code, and  
change it on the fly.  It would be a goldmine for a kid interested in  
computers and making them do stuff, since it's got a built-in  
development environment that is at the same time trivially simple and  
extremely powerful.

Anyway, it's worth looking into, at least to see what kinds of kids- 
related stuff is in it.  The LogoWiki mentioned earlier is run by a  
Squeak server, for example.  Lots of people interested in making  
stuff for kids get drawn to Squeak, so even if you don't want to use  
Squeak itself, perhaps you might want to use something built with it.

>   And I do think it is important to first teach
> procedural programming first.  OOP and event-driven are great, but as
> the computer itself is procedural, if we want to teach budding  
> computer
> scientists how computers actually work inside, we need to start on
> procedural programming (and polling), then probably event-driven (help
> them understand interrupt-driven stuff), and then introduce them to
> other artificial abstractions that they will eventually use  
> exclusively.

I don't think this order is necessarily the right one.  Budding  
computer scientists will want to find out how the computer works  
inside anyway, and those who don't care ought to be able to write  
stuff for fun in a high level language anyway and not care what  
happens underneath.  My dad certainly didn't care about what happened  
any lower than the BASIC level, yet he was able to write simple,  
useful programs that made a huge difference in my life.

I think you could start with any paradigm initially, so long as you  
had an environment to support it that brings the feel of the old  
BASIC prompt to the user.  I think Squeak (or maybe Python) for OO,  
DrScheme for functional, or... well, I haven't thought much about  
procedural languages for kids, so you can tell I really do disagree  
about starting them on one. :)


More information about the PLUG mailing list