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. :)
--Levi
/*
PLUG: http://plug.org, #utah on irc.freenode.net
Unsubscribe: http://plug.org/mailman/options/plug
Don't fear the penguin.
*/
