Slashdot Mirror
Teaching Primary School Students Programming?
NotesSensei asks: "Recently I was teasing the teacher who runs the computer club in my sons' primary school: 'You teach the kids only how to use software but not how to make software.' Today I got an email: 'OK, you're in: teach them programming.' Now I wonder what language should I pick? My first lesson will be the board game c-jump, but after that? The contestants are: Kids programming language KPL (ab VB.net derivate; Java using BlueJ; Greenfoot (and the BlueJ); and HTML. Does it sound like I'm on the right track or should I try something completely different? We are looking at primary 3-5 (that's 10-13 in this part of the world). Where can I find inspiration for the curriculum?"
Some may argue (and probably will) but I have always found Scheme to be an interesting language to lets kids play with because of the "instant gratification" of an interpreted language's "read-eval-print" paradigm. Plus, with "The Little Schemer", which presents things in a very logical, pedogogical way, which is well suited to clever children.
The Little Schemer
Just a thought...
Have the kids make the turtle move around the screen.
I inherited my aunt's old Mac SE when I was six (she was moving to the US and couldn't take it with her), and several years later, (maybe I was about 10 or so?), while rooting through a load of the 800kb floppies that came with it, I came across HyperCard. It had no manuals, but it came with several example programs ("stacks") - and these were enough for me to pick up the language pretty much in full.
I booted the machine again the other week and it amazes me how much of it I picked up without any instruction at all.
Anyway, unless you can get hold of a load of classic Macs from eBay and load HC onto them, I suggest a modern language that's similar - Lingo. It comes with Macromedia's Director (or at least it did two years ago - haven't used it since I switched to Linux). Like HyperCard, it has a near-English syntax that's a cinch to pick up. I think you can also get an education version, presumably at a lower price.
Alternatively, have a look at Lego's Mindstorms kits. Fully programmable, using a visual (flow-chart bassed) lanuage.
I've tried both, and loved them.
Nobody else has this sig.
The freshmen level OOP class that I took taught us by using BlueJ and Karel. I loved it, thought it was fun and easy to use, and really helped teach solid OO concepts. I recommend it highly.
My first programming language was BASIC. There's just something simple about PRINT, GOTO, END that made sense as a child.
Visual Basic might not be a bad idea either, least it's a language they can build on and easily use in Windows if they decide to pursue programming in the future.
my karma will be here long after I'm gone
My almost reflexive reaction is to suggest Python. This is because it is a proper, well-designed programming language that is also compact. It is free and widely used, but more importantly it is easy to make it do stuff. The Python interpreter usually runs programs from files, but you can start it in a terminal mode in which you can enter programs and simple expressions. Demonstrate programming to your class live, by entering fragments of code, explaining how they work and showing what they do. There is no extra stuff to explain, no compiler, no headers, no IDE, no mysterious commands. So you can concentrate on the code.
Unless they're vaccinated, don't give them MUMPS; if you do find a nice Doctor (Like Dr. Pascal), 'cuz Pascal was fun for me in College.
If they like noises, Squeak is good, but the cogently verbiaged might prefer SmallTalk in a group. For those speech impaired, knowing there's other people who Lisp would be good.
The mean ones will abuse Snobol in Winter
The A.D.D. kids will probably like the feeling of Euphoria they get from their first
Of course, you could teach them a very nice language with a horrible name, Brainfuck.
Or, you could just look Here for a comparison of popular programming languages.
Unitarian Church: Freethinkers Congregate!
I know my little cousins in that age group would love to make their own "pretty" web-pages. They could each make their own page linked from a page about the class.
Insanity is nothing more than a difference in perspective.
Have you considered python? It has an interactive shell, which will let the basic concepts of programming come through. Also, you could take the first parts of How to Think Like a Computer Scientist (freely available and modifiable) and adapt them to the age level. The first few lessons should be fine, although they might need expanded somewhat.
Alternately, perhaps something more graphic-oriented would be desirable. If it were still around and supported, I would suggest Apple's Hypercard program. It appears there are some clones out there also, although I have no idea how good they are. (The first alternative listed says it is popular with educators.)
Good luck.
http://www.ceebot.com/ceebot/index-e.php I downloaded the demo a while back, and found it amusing and actually pretty usable. If I remember correctly, even the demo supported simple classes and structs and I think the classes even allowed overloading operators. The basic concept is to allow students to write simple programs that make a little robot do stuff. Take a look at it, it may be too pricey for the school but their links section has some other resources that might also be useful, like CodeRally http://www.alphaworks.ibm.com/tech/coderally.
At my school we have Visual Studio and all manner of modern, high tech tools at our disposal, but we still use turbo Pascal to teach programming, and I love it. It truly is a marvelous language, and while easy, can do anything a more complicated laguage can and shows all the steps of real edit-compile-etc programming. Perhaps a modern version of pascal would be a good choice, I would pick Pascal along with a good instructional book. The best part is that pascal is structured so as long as they follow the rules it is difficult for them to write crappy code. w00t Pascal!
I am Spartacus
While it's not specifically a 'programming' environment, it's programming mechanisms illustrate the general programming concepts and it's also coupled with a great engineering robots 'toy' as well. The easy click together programming blocks allow children to approach computing from the general concepts. Each clickable block also provides 'fine tune' controls. This approach is directly analogous to oo programming. There are also methods to use java programs with the RCX bricks so that as your students advance, they will be able to increase their knowledge using the same fun toy tools.
if I claimed I was emperor just because some watery tart lobbed a scimitar at me they'd put me away!
The year, 1981.
The place, suburbs of Minneapolis, MN.
I had a TI99/4A given to me by my parents for Christmas. I was 9 and in 3rd grade. I got a subscription to HCM (Home Computer Magazine) and initially had to get my mom to type in the code at the back since she could type so much faster.
I would modify the programs, save them to tape, etc.
In school, we had an Apple2 lab with Logo. People played Oregon Trail, had Math drills and such, but Logo was the shit.
By the time my friends and I hit Junior high, Quick BASIC was no big deal. In high school, we did Pascal, C and such.
Given that all of what I'm talking about above can be done on one of those $100 laptops, I don't see why people wouldn't do it.
OK, you might not have the machines to pull this one off (though you can get them for next to nothing if you know where to look, or perhaps try an emulator). One nice thing about this idiom is the ease with which the low-res graphics can be manipulated; the kids can draw some crude pictures.
I'm serious, by the way. It's really easy to learn a few fundamental commands in Applesoft. I remember doing this in a class in probably fifth grade, and everyone seemed to like it. (I already knew how to program in the language, so I didn't necessarily learn much.) No compiler; just type RUN and you're good to go.
Interactive shells are really helpful for teaching, because you get instant results. There is no complexity to confuse the matter, as there is no IDE or compiler. You can demonstrate a 1-1 relationship between every piece of code and its effects.
I think you will probably stuggle to teach children of that age programming. Abstract and executive thought does not develop (on average) until age 12-13 (if at all). Of course there will be exceptions to this, but will not be the norm.
Your efforts are probably better directed at 13-14 year olds. You will probably get more satisfying results. After this high level thinking has developed and they have a grasp of algebra as a basis of programming.
Sweet, simple and beautiful.
Are you teaching a regular stream of students or the "gifted" stream? Also, which grade level are you teaching? The answers differ depending on what you want to do.
While you did mention the answer in the posting, it's still a bit vague. 10-13 years is a large age group - 10 year olds may minimally grasp the concept, while 13 year olds may need something a bit more complex.
You can do something much cheaper - draw a flowchart. The computer thinks just like that - it mechanically goes to one instruction and executes it, and goes along based on what comes next.
While C-Jump may make the learning portion fun, you might want to consider LOGO instead - the users can provide commands, and get an instant result on screen (where the turtle draws a line.)
FYI, HTML is a typesetting language - not a programming language. No matter how hard you try, you cannot parse an HTML document using HTML. (If you come up with a webpage that does that, then you are embedding a program that is Javascript or some other document embeded programming language.) In addition, if you don't teach HTML properly, you'll have pages that use tons of as opposed to tables to align text (or the now-preferred alignment method.)
I won't comment on the three languages, but make sure you review the languages beforehand to see how well you can learn them. There is no better way to determine which programming language is the most suitable.
You might want to look into Squeak. It has the full power of an object oriented programming language, but has a morphic graphical programming language on top of it, so kids learning it can jump right in without learning the syntax, but will be exposed to it as they work with the language.
Languages like Scheme, Forth, SML are interesting and cool but the ways of thinking they teach are, for better or for worse, not part of the mainstream. Better to teach good OO methodology and design.
Am I part of the core demographic for Swedish Fish?
"Teaching Primary School Students Programming?"
Here's a related question for slashdot. Why do the majority of "Ask Slashdot"s that mention "School" also mention "Programming"? Don't they teach anything else in school?
Squeak, which I believe is a Scheme derivative, is geared towards children or at least people with minimal coding facility. I would also incorporate this with HTML. Being able to grok HTML is very handy even if all you're gonna do is put a blog up on MySpace....
'He who has to break a thing to find out what it is, has left the path of wisdom.' -- Gandalf to Saruman
I would recommend that you take a look at http://www.alice.org/ The site pretty much speaks for it self. The development takes place inside a 3D graphic enviorment. I think kids will find this very interesting and they can instantly see their results. There is also a text book that may be purchused, however, I'm not sure about the price.
Teach them the basics of python then turn them loose in Blender 3D. They can do game scripting, it is a real language, and they can use the logic buttons for things that they don't need or want to program.
Also there is predone games of a wide variety of types that they can play with, take apart, and rebuild into their own.
LetterRip
I find that Java seems to be one of the easier programming langauges to learn. Not only is it very simple, but also very well documented (ala the amazingly well documented api). Also, I would definately recommened Bluej for an IDE since it is very simple to use and understand. Anything more will just confuse the kids. For the explanation part, you could describe each object kinda like a box and tell the kids that there are bits of code inside the box, and show them how they are just like any other variable.
Klingon Software is not released, it escapes, inflicting terrible damage onto the enemy as it does
IMO, you're asking the wrong question. Almost any programming language will work, what you need to find is an appropriate curriculum and supporting materials. What's needed is a series of fun programming projects that start out very simple, but progress appropriately and catch and keep the kids' interest. The curriculum needs to be constructed around a specific language, so it can introduce specific language elements as needed to support the programming projects, but the language used is nearly irrelevant. Obviously, interpreted languages have advantages, "forgiving" languages may help, and it's really important to have a toolset that provides good, simple error messages so kids can understand what's wrong when they screw up the syntax, but all of that is far less important than a good, well-designed series of projects.
If you find such a curriculum, or if someone else knows of something like this, I'd really like to hear about it. A couple of my kids are mildly interested in programming, and I'd like to get them started, but I have neither the time nor, honestly, the imagination to put together a good curriculum.
Note to ACs: I usually delete AC replies without reading them. If you want to talk to me, log in.
I've had success with Lego. It was some years ago before Lego Mindstorms. Lego had a large computer controlled kit. There was a really good manual with lots of projects. There was enough stuff to make a robot arm with a grasper that could pick things off a conveyer and put them ... (hmm, can't remember that part).
There was enough challenge to keep the kids interested but not so much that they couldn't succeed.
Lego is expensive but the good news is that their patent has run out. There is now some price competition. You can also build your own sensors and motors by epoxying stuff (switches, dc motors, steppers) onto Lego blocks. The kids can start with something from the manual and extend it with home made parts. Because they are building on something that works, they never have to stray too far from their comfort zone.
The Lego project worked for all students, not just the ones who were already interested in programming. For students already interested in programming, it seems like a pretty safe bet.
Mainly because its free. Schools have a strict budget and I doubt they have a few licenses for VS for VB. Java is free but I would not recommend it. I tried java without knowledge of c/c++ and had to drop the course in my freshmen year of school. After taking C++ I recieved an A for my java programming course in object oriented programming. Even a hello world program is complicated if knowledge of public and private and strange syntaxes without meaning (if your new to programming) are used.
The link is here and the help menu has homework assignments and tutorials for begineers. You can do windows based gui's and even graphics with sprites and primptives. Since its free you also can legally make cd's for your students to bring home which is cool too.
http://saveie6.com/
If it is to teach "introduction to instructing a computer" then one idea I used (grades 7-8) is macro programming in spreadsheets. It wasn't "programming" per se, but it did get across the concept of a "variable", some simple calculations, conditional logic and for the more advanced kids looping and subroutines/functions. I was teaching to a very mixed class, but the "gifted" kids and the "general" kids all ended up having a successful experience. I had them program simple games such as having the spreadsheet "guess a number between 1 and 10 (for the advanced, between the values of A1 and B1)", or have the spreadsheet keep track of scores in a two person number guessing game, or hangman, etc...
If "introduction to programming" (i.e. you really want to teach them to "code"), then you really ought to think about what it is you are going to have them program, then choose a suitable language. If you want them to simply print their name to the screen 10 times, then just about any language will do. But if you want them to do something interesting (and to any kid born with a PC already in the house, printing their names to the screen will bore them to tears), that "interesting" thing may dictate which language (support libraries, IDE, ...) you want to go with.
It's a simple matter of complex programming.
I teach computers at an international school in Tokyo Japan. My students vary in age from grade 6 to grade 9. As you can imagine, they also vary in English language ability. Here is my curriculum:
Grade 6: Drape - A drag and drop programming language (No longer free but you can downloa it from my homepage).
Grade 7: Game Maker - A more complex drag and drop programming language created by the same person who created Drape.
Grade 8: Kids Programming Language - A BASIC-like programming language with easy to use graphics (sprite) capabilities and built in functions such as collision detection. Note that an updated version with 3D graphics capablities will soon be released (around Sept. 2006).
Grade 9: JavaScript - I use a program called Max's HTML Beauty++ for editing JavaScript and NVU for web design.
I have also used Small Basic and my own JavaScript Interactive Fiction engine.
You can find downloads of most of these programs and some lesson plans at my homepage.
Feel free to contact me if you have any further questions.
An invasion of armies can be resisted, but not an idea whose time has come. - Victor Hugo
Like most geeks of a certain age, I cut my coding teeth on BASIC, which in its traditional implementations (TRS-80, Apple ][, C64) was nicely interactive, but probably too boringly textual for Kids These Days.® Don't know how the "modern" versions of it compare.
Logo became available to me after I was "too advanced" for it, but certainly deserves a look as the "other" classical language for introductory programming.
I've heard some good things about Toon Talk.
Or there's always BrainFuck.
http://alternatives.rzero.com/
If you actually want them to be interested in what you are teaching I'd either focus on or at least start with html and css. This is relevent to 95% of the students. They already use, or soon will use Myspace, LiveJournal, XANGA, etc., so they will appreciate it from the get go.
-Michael, AKA Frankie.
They will be interested and it might help them to stay focussed, but it's NOT A PROGRAMMING LANGUAGE! (Sorry if it sounds pedantic, I'm just sick and tired of the "I can program in HTML" types). It's just markup. Various tags and some styling stuff. It doesn't teach anything programming related (javascript aside). And about CSS? Good luck trying to get them to understand the box model (we're talking about 10-13yo kids here). To get the results most people want, they'd have to learn a lot more than what you'll be able to teach in so little time, so it might be quite deceiving to them too (markup - including forms, css & box model, at least one server side tech, javascript basics, etc - if not flash too)
Instead of teaching them basic loops, variables, constants, conditionnal statements, basic string/math ops, subroutines and such, you want to teach them tags for making their text bold and such? (and then try to explain doctypes/DTDs and such)
Learning to program helps to understand how computers work. I think it's very useful. Whereas HTML... Most of 'em will likely end up using a wysiwyg editor anyways if they ever have to write some markup later on (dreamweaver et al) - unless they become web devs... Anyone can pickup simple markup in no time at all regardless.
http://www.phrogram.com./ It's actually the second version of Kid's Programming Language, will release next month, and is available as a release candidate download now. It's supposed to be as easy to use as KPL, but it adds some new stuff: compiling to EXEs, class-based programming, 3D programming with DirectX models, file I/O, and interactive debugging.
Programming, as we all know, is establishing a standard process, while allowing for certain deviations, in a directly or indirectly machine readable code. There are several layers of abstraction involve, the most obvious is the abstracting of they physical process, but one must also abstract concepts like repeatability. The student must also respect cause and effect and not, for example, attend Titanic 20 times hoping that both major characters die and in the process create a world in which the movie no longer exists, or perhaps exists with a reasonable director and competent actors. But I digress
But I digress. While this age group has the ability to recognize concrete structures, the ability to abstract those structures probably does not exist. To put this more plainly, a student might be able to understand that both sides of an equation must balance, but may not be able to do single variable algebra. Therefore the concepts of programming must be build concretely.
The game is good, but the kids have to learn process and algorithm. This is not necessarily done on the computer. Have them right how to do certain things, then see what could change and still result in a successful operation. How to we sharpen a pencil. How do we brush our teeth? Given them a map and have them find how to get from their city to another of their choosing. Their teacher probably has exact procedures. Have them write them out and discuss the rational. Any metacognitive activity for this age group will be good.
Another concern is the understanding of variable. For even high school kids the concept of a variable is problematic. Even for college kids the need for idiom t=x, x=y, y=t, is far from obvious. These problems can be surmounted, but they must be addressed.
In terms of the language, anything that minimizes the mental power needed to interface the machine will be good. At age 11 I learned to program on teletype using basic, though it was 3 more years until I understood what was actually going on. It might be fun if the language produced some nifty graphics, and the child could directly visualize the changes in code with the changes in graphic output. For instance, if a loop would produce more squares, and some parameter would change size and spacing. New language elements could be introduced to create more complex graphics. I would avoid complex APIs, and try to stick to stick with things that are native in the language. These requirements tend to point to an interpretive language. Also syntax should be short and forgiving to allow for the limitation of the children.
One last point is I do not think that worrying about a specific standard language is important. It is the concept building that is the likely objective. I mean memorizing and categorizing hundred of Dinosaurs may seem useless, but the concepts learned stay with the child long after every name is forgotten. So if the kids learns about process, and the basic elements of assignment, looppimg, and conditionals, that would be a great job done.
After this long aside, let me suggest a product. Though I am not the biggest fan of the company, The geometer's sketchpad is an interesting piece of software, and seems to have some script capability. I can't seem to find an online manual, which is one reason I do not like the company, but I believe the software does have at least some of the programming elements, and therefore can be used to teach some concepts. The school may already have it.
"She's a scientist and a lesbian. She's not going to let it slide." Orphan Black
Ruby is readable and pretty easy to grasp. There's even a free text, Learn to Program by Chris Pine, which takes the reader through the baby steps of learning to program.
[ check out my ruby book @ http://ww
In the best case, everything they type will have meaning and value to them. Instant feedback is also a plus. That means your best bet is a dynamically typed languages with a REPL. Many other posters have suggested languages/environments with convenient access to graphics; from my own experience, I would say graphics are nice but far from essential. That's your call, though, since you know the kids better than any of us do.
Here's a suggestion that may be a bit... out there. Teaching Haskell to kids might be risky, but it's guaranteed to be easier than teaching it to adults, especially experienced programmers.
That'll weed out those who have no commitment. It'll also make the handful of math-oriented people in the class more aware of the connections between mathematics and computer science. It's not like people these days are encouraged to get rid of the bad habits they picked up with J. Random Wanker Language or anything. Also, interactive programming with hugs. Who doesn't like hugs?
Hell, maybe it'll teach kids better habits (like focusing on the algorithm and on getting a working program first) than some heavy mittens language like Python or Javur. The error messages could probably be a little much for 10-year olds though. Maybe Helium, a Haskell variant geared for education and without some of the more esoteric features, would suit that better?
When I was in first and second grade, we were taught Logo-Writer at my public school. It's a lightweight programming language where the commands control a "turtle" onscreen who follows the sequence of commands for drawing, moving...lots of various tasks. Unfortunately, that has since been removed from the curriculum and Logo instruction was not taught much beyond fourth grade. (The program switched to using Word and the Internet and such...which is a shame, really.)
The Little Schemer was mentioned above - that might also make a good choice.
I've actually created a website at http://www.programmingbasics.org/ for teaching simple programming to young kids using JavaScript. It targets a level below that of KPL but above that of c-jump. It's designed to be completely self-contained, so the website provides an IDE, an extensive set of illustrated lessons, and various programming activites. Many of the other educational programming systems that have been mentioned here are quite nice and powerful, but they often come with only very brief tutorials. If kids "get" the tutorial, then you're fine, but if not, then a more detailed set of lessons like those provided by my Programming Basics site might be useful.
It sucks trying to do it for a living, when everybody is doing more with less, budget cuts, long hours due to PHB shortcomings, etc. Yes, I'm in the middle of a four-month long crunch mode due to management shortsightednsess; does it show?
DT
Is this thing on? Hello?
Although probably unintentional, those old Infocom games gave non-programmers a great educational CS experience. As you hunt treasure and outsmart the thief, or gather clues and question witnesses, you also learn to think abstractly, create and step through algorithms and carry around a lot of information in your head -- all while working at a genuine command line.
e =3&mode=htmle =4&mode=htmle =5&mode=html
Most of these Infocom games (link below) you can get from somewhere online if you look, and play them with an interpreter such as frotz or jzip.
http://www.infocom-if.org/games/games.html
Only the Zorks are technically legal though, because they were released by Activision. You can also try them out online right here:
http://www.ifiction.org/games/play.phpz?cat=2&gam
http://www.ifiction.org/games/play.phpz?cat=2&gam
http://www.ifiction.org/games/play.phpz?cat=2&gam
I credit years of tinkering with Deadline and the Zorks with giving me a better early foundation beginning around age 11 than I would have had just noodling with the C-64 "Ready" prompt. (Or worse, noodling around in a modern GUI.)
C-jump seems painfully uninspiring to me. I think the problem with games like that and the programming languages "designed for kids" is that they're insincere: Your students will know immediately that they're not doing something real.
As humans brains develop, they go through many developmental phases along the way. Piaget came up with a developmental stage theory. The most important thing to remember is that primary kids are in the "Concrete Operational Stage" and can do well with concrete ideas like numbers, colors, linear procedures, and facts. However, kids at this age (especially boys, who typically develop slower than girls) can not handle abstract concepts. An abstract concept would be something like the equation 'X + Y = 4' or 'if x+5 > y+10 then'. As long as your programming languages don't get too abstract the kids should be able to process it fine. I find that HTML doesn't really process in kids minds until 7th or 8th grade.
Also, you have to apply the 80/20 rule. We are all different and our brains develop differently. But Piaget's theory applies to 80% of kids. I like to use the Lego Mindstorms Robots. The robotics invention system supports big blocks e.g "Turn Left" or small blocks e.g. "Turn on Motor A, Turn off Motor B, Wait 5 Secs, Turn on Motor B". The Legos give kids the change to try to work with abstract problems, but they can drop back to the concrete stage very easily by using the cause and effect process.
I believe that someone mentioned Logo. That is a great 'cause and effect' type of programming language in which kids can create a small abstract program and then see concrete results. Allowing the young brains to move back and forth easily between concrete and abstract is the key to teaching programming at this age.
Hope that helped.
I agree. Logo is a great language for young programmers.
Please, for the good of Humanity, vote Obama.
Maybe I'm just weird, but I find BASIC very, very confusing. I look at BASIC code and it's like I can't even grok it. I can't see the program's layout or flow or anything...
I think it's the relative lack of parens/brackets/etc. I don't like the whole "similar to English" thing when it comes to programming.
We don't teach elementary school kids history because we want them to grow up to be historians; we teach it to them to give them a more rounded education, an appreciation of history, a new way of looking at the world, and exposure to a subject which, even if it doesn't become their profession, might at least become a source of fun and an output for creativity.
Teach programming for the same reasons. Computers are everywhere; if people knew how to program they might have a better appreciation of how software works, and they might even enjoy programming for fun, as a hobby. (I know I do.) If they use open-source software, they may be tempted to make changes to improve it: voila! a whole new generation of contributors to the open-source movement. If they get into the habit of it, they will learn to value the ability to see and change the source, which may lead them to spurn closed-source alternatives. (No, I don't mean everyone, but a growing number over time.)
I started learning BASIC at age 8 on my Vic-20, and while I'm not a professional programmer or computer scientist, I AM a theoretical physicist, and the ability to program has been vital to my career. No doubt, the same is true for many other fields as well.
With all that said, I first started off by entering in hex data from an Apple magazine (Byte?), later progressing to writing my own programs in AppleSoft Basic before I ever heard of Logo. I've dabbled with Pascal, Fortran, C, and Java. Of course, now most of my "programming" is shell and perl scripts with an occasional DOS batch script.
For learning how to program (the logic and though, not the syntax), I like Logo best for the reasons above. I also like Pascal for the strict structuring (good to learn even though a pain in the rear).
Edward Burr
Having a smoking section in a restaurant is like having a peeing section in a swimming pool.
Logo. Good, old fashioned Logo was designed to teach programming to elementary age kids. We home school, so I work with Logo with my 7yo daughter. She loves it. And logo is built on a lisp engine, so there is significant power underneath. We use Terrapin Logo, FWIW, and like it. There are other choices. Terrapin has an interface to the Lego RIS robotics system, and also the FischerTechnic stuff, if you get that far. Also Terrapin has some useful lesson and teacher guide books to give you some hints on how to go about teaching with Logo. All emaphisize learning by experimentation.
Side note: my daughter is a "kinesthetic learner", specifically, large motor kinesthetic. To plan out her turtle code, she will march around the room "being the turtle" and then go try it on the computer. I think that is a great way to learn about modelling execution in your head instead of the code-like-mad-and-crash development model. Brings a new meaning to the phrase "code walk through".
Be that as it may, I think that teaching HTML could be a good way to introduce primary school youngsters to programming. I agree that it lacks all of the charm and complexity of a real programming language, but that makes it simpler for the kids to grok and it also gives them an almost immediate graphic feedback which makes it easier to find bugs.
The biggest problem I see with teaching them HTML is that modern browsers will go a good job at displaying really messed up HTML. But this could be turned into an advantage by turning it into a game and having the kids see how far they can mess up the HTML and still get the pages to display correctly.
We don't see the world as it is, we see it as we are.
-- Anais Nin
Have you ever even worked with children? Tried to teach them anything? Have you ever watched (and listened to them) playing?
Kids hop between the abstract and the concrete, the real and the imaginary, with a dexterity that leaves most grown ups in the dust. They learn new languages, new rule sets, new abstract systems, at a rate that we can only envy. And when they learn them they retain the flexibility to think outside them when it suits them.
Your post is condescending and factually inaccurate in so many places I could waste an hour pointing them all out. Instead, I'll pick just one representative example:
Here's a bet for you. Pick some eight year old with an IQ twenty points below yours. Both of you move to Hungary and attempt to learn Hungarian. At the end of a year, who do you think will be better?
--MarkusQ
- Kids don't always remember details. This can be difficult, because most computer langauges are not forgiving in their syntax. Kids are good at picking up on details, but don't expect them to memorize things like StupidConfusingClassname isn't the same as stupid_confusing_classname.
- Kids like feedback. Thus, the read-eval-print-loop style is important toward keeping their interest.
- Related to that, the intrinsic graphical nature of logo is very engaging.
- This really just a general teaching comment (which I was totally new to when this project was given to me) - especially with totally new topics, kids will have all kinds of levels of ability and interest in the topic. It's important to have something that all of them can do, but also to have something to challenge the kids having an easier time of it. I would ususally introduce a simple topic and have everyone try it out, and then I would have a "master" level problem for the wiz kids to try.
- Robustness and responsiveness is good; kids aren't very patient, as a rule, and if the programming environment crashes, or performs slowly (and Starlogo, being a Java app, did run poorly on those iBooks), the kids will lose interest in it while they wait for the app.
I should also mention that StarLogo wasn't really being maintained when I was doing this (or it was being minimally maintained), but now it looks like someone has revamped the project with StarLogo, the next generation. Finally, whatever you end up choosing, don't teach them HTML and then tell them that it's programming. Few things irk me more than people talking about "programming in html". If you want to teach them HTML, fine, but don't let them think they're programming. By they way, youung children might have trouble with html for the first reason I gave above. The syntax is very clumsy and exacting, and worst of all, you don't get error messages from the browser when you screw it up! Anyway, have fun! njordI suggest you use MathCad or MatLab or Maple since then at least they'll learn something useful (mathematics).
How about PHP? It's an interpreted language, so no mess of compiling, and it runs (usually) on a Web server, so kids can make programs and upload them to the school server, letting them easily show other kids. The typing is pretty loose, so you don't have to worry about messy variable details. You can start the kids out with simple programs that take GET vars and process them, and introduce them to objects later. And the syntax is like C/C++, getting them nice and used to those more powerful languages if they want to learn them.
The only problem is they have to know something about HTML first, but HTML is pretty simple; I learned it in 3rd grade.
The language itself doesn't matter, although I would focus on more procedural stuff, since it's simpler than something like Scheme to write usable programs off the bat. I do love Scheme, but it's better to foist on college freshmen (or experienced high school students) than preteens with short attention spans. Teach them the absolute basics (print, read, if, do-while), and have them write games (simple, like a quiz show).
The programs will be really bad, and most of your students will hate it. But a few will love the ability to create what they want and will pursue it further. And, really, that's the best you can hope for in your situation.
Other possibilities that might appeal to the 10-13 age-group are:
- flash - in a similar sense to hypercard, this is great because it lets you create graphics that you can interact with. Some simple actionscript might be a way (albeit not an optimal way, but...) to teach some programming, while still being something kids can get excited about. dunno if the learning curve woudl be too much though.
- Javascript or PHP - two different ways to both introduce programming languages and things they can interact with on the computer. only problem with these two are that you'd probably have to teach some HTML first, which, while fun, may not be the "programming" that you're aiming for
I'm sure that there are a lot of other languages that would work really well, but based on my experience *learning* to program as a kid (in the not-too-distant past), I think that some sort of graphical/interactive element is really important for that age group. When you're ten years old, just seeing text output of a program isn't really all that exciting or attention-grabbing.i would reccomend one of the following languages BASIC C PASCAL those are all great starting languages VB is a horrible language for learning, it will cause bad programming practices
Several other people here have mentioned Logo - an excellent choice, in my view. I recommend taking a look at the three volumes of Brian Harvey's Computer Science Logo Style .
The Logo tree has spawned several other languages - two worth looking at are NetLogo and StarLogo TNG - both of these languages are particularly well-suited to modeling projects, the first with a traditional text-oriented perspective, the second with a graphical programming interface.
Another programming language specially designed for education is Alice - the language is designed so students can graduate rather quickly to more complex object-oriented languages. Python, Ruby, and Java would all be good follow-up languages to Alice.
Finally, let me gently suggest that you not follow through with at least one portion of your original plan: the game c-jump is a very poor choice for introducing students to programming. Not only is the game completely inappropriate for any child over the age of 3-4 (it is just a very boring version of snakes and ladders), it is also extremely poor from a pedagogical viewpoint, with no creative activity on the part of the students, reinforcing notions of code as arbitrary sets of commands. The first couple of tutorials in Alice will be far more enjoyable for your students, and actually get them involved in some real thinking about programming.
I learned all of this languages. However learning programming languages comes with lower increments over time. E.g. I knew Java and VB, to get VB.NET took a few hours (excluding of course understanding the .NET framework). Of course if you jump paradigm (e.g. Basic to Lisp) you have to unlearn which is more difficult than learning.
Your'e right HTML is a content rendering (I wouldn't say typesetting) / markup language. Since it's easy and can be extended with JavaScript and CSS it makes a good intro. However it lacks (until you hit JS) programming per se. The need of learning 3 languages (html, css, js) is an advantage if you want to focus on diversity.
I play C-Jump with my 6 year olds. It took them 30sec to understand that X is a placeholder for the number they throw with the dice. So it seems to me variables might not be too difficult. Of course the "full appreciation" might take a little longer. Nevertheless we all use internal combustion engines without appreciating their full complexity.
But then you'd be wrong.
It should be visual, and it should have a real-time interpreter. You want to make the process as simple as possible, and get them thinking about logic before you burden them overly with syntax.
Actually, here's a suggestion: Try games first. Not to program with, but as an example. "How do you think this would work?" "What makes this glitch work? How could we fix it?" And all along the way, you can discover and correct their misconceptions about what a computer can and cannot do.
Don't thank God, thank a doctor!
I have worked in schools and have often seen kids (11-16) working on open source games projects such as Open Tibia during there break times. There has been no programming lessons within the actual lessons themselves, the kids tell me that they are bored with the lessons as they only learn how to type letters and create spreadsheets, many of the kids had learnt this before starting at the school.
Also, try to introduce the concept of Open Source and encourage them to share there work, explain about licenses.
Good luck
The opening of the original gives the clue to the biggest issue here. You have to pick something that the teachers can pick up and carry on in the rest of the lesson planning. That's why I gave up on Logo when I was a school governor - we found a turtle in the back of cupboard - but nobody knew how to use it. That's why Lego mindstorms is good for the this age range. At this level all we really need to teach is that computers do exactly what you tell them - and that intelligent looking behaviour can be got from simple programs. Youd don't need a cool language for that. To make it really easy for the schools we used our industry/school links and had a group of industry folks go in to the schools and do a Lego robot racing event having had our training and education people work up lessons plans the school could use staight out-of-the-box. We've done events in the US and UK so it can be tailored to a different curriculum. Another good thing that it can be taken further into the First Lego League.
Both are excellent suggestions, and the good news is that you can have the best of both worlds!
Simply download Python and xturtle.py (the module is a single .py file, no need for complicated installation and no dependencies beyond the standard Python library).
The xturtle site has extensive documentation, interesting examples and, of course, screenshots (because everyone love screenshots!).
There's a hidden treasure in Python 3.x: __prepare__()
Like BASIC, Python can be very easy to learn. The one line print "Hello World" is right to the point. However, Python is also an extremely powerful language, allowing those students who excel and go "beyond the basics" to do more. My first year teaching programming was with a version of BASIC, and while young kids could learn it, it was limiting to those wanted to do more.
After tackling the basics with print, we move on to graphics, which kids find much more exciting. Pygame is wonderful for this, because it makes drawing simple geometric shapes like circles and lines and rectangles very easy. Like Python, Pygame (an SDL wrapper for Python) can be simple but it offers tremendous power to those who have an aptitude for the subject. Ability to work with bitmaps, sprites, and various devices gives advanced students a good challenge. While technically Pygame is Object Oriented, you can use it very "procedurally", which is a good idea for young kids.
We offer a Programming II class for our High School where students pick up where they left off in JH. This course is an elective, so only those with an interest (usually those with aptitude) take the course. Instead of learning a new language from scratch (believe me, these students would have gotten bored with Logo the first week), we start looking at more advanced applications with Python, including OO programming, GUIs, libraries (modules in Python), etc.
Back when I started this class, I looked high and low for a good, simple, yet powerful-when-needed programming language. The "experts" then recommended Python. I've used it for 3+ years and have no regrets! Of course, JH is a bit different than first grade. However, I seem to remember something about Python having a Logo module? I myself have been looking to introduce Programming to grade 2 or 3, nothing heavy, just a whistle-wetter, and for that Logo was of interest. Other priorities have kept me from pursuing the lower grades this year, unfortunately.
Anywho, let me know if you have any questions!
-Mike
Computer Science teacher
There are more things in heaven and earth, Horatio, Than are dreamt of in your philosophy.
A quick scan of the comments didn't mention this, so I thought I would. Clickteam make a set of 2d games and application creation programs, called "The Games Factory 2" and "Multimedia Fusion 2" specifically designed to be easy to use. They're trying hard to push their products to the education market, so you might want to take a look.
A friend's 10 year old got the hang of it and two years later he is teaching himself Perl out of a book. Well not all by himself, his father writes a lot of Perl code.
The family visited this year and I showed him how to write directly to the sound card to make funny noises. This might be the modern equivalent of buying a child a drum :-)
I know that this response will get buried in the others, but I'm gonna try anyway...
Some folks have said LOGO is the way to go. This is indeed a cute language, great for elementary school kids, and easy to understand. If all you want to teach is "programming is fun and easy", then that will do the trick just fine. If you really want to spice things up, I imagine that there are interpreters available that will turn LOGO commands into controls for MindStorms robots. Keep in mind that LOGO isn't going to accomplish much else other than getting kids comfortable with "programming". It teaches about as much in the way of CS concepts as a four-function calculator. The main limitation of traditional LOGO is the complete lack of conditionals/branching.
If you want to teach older kids a little more, Karel the Robot is the answer. This was used for the first month of my first High School CS class. In this little language, you use a simple, limited, syntax to control a little "robot" that runs around trying to find a "beeper" and avoid getting stuck against walls or go out of control. It teaches branching, conditional looping, proceedures, and the original textbook also taught good programming habits. (Thinking of "corner cases", indenting, etc.) While I haven't looked, I imagine there are also MindStorms implementations also available. That would be pretty cool.
At the time, we thought it was kind of silly (I was 15 at the time), but for kids a couple of years younger, it might do ok. This is available all over the web. It was originally based on Pascal, but has been adapted in many other languages.
I think parameter passing, OO, return values, etc. present in a more advanced language might be a bit much for the younger kids, but perhaps the more focused older kids could handle it ok. The issue with teaching those concepts is not that they are hard to understand, but rather you start getting into tricky syntax issues that quickly start making all this look like actual work. If this isn't something they are being graded on (I get the impression from your post that this is a "supplemental" type thing), most will lose interest quickly.
Some posters have suggested HTML/CSS. Those posters are idiots. That is just word processing made harder. If you want kids comfortable with computers overall, and not run screaming at the sight of a text editor, fine, but it isn't in any way, shape, or form, "programming". It is a formatting language, NOT a programming language.
SirWired
First, don't allow them to touch a computer at all.
Give them a problem, a real problem - not "print 'Hello World' on the screen" but something they actually have to think about, that has steps. Nothing abstract, something to the point - fuck, give them a math problem if you have to (ooh... this could be evil, but you could throw a semi-simple algebra problem at them! "How would you figure out what number x would be in the problem 17 + 2x = 42?") - and make them figure it out. Make them work out all the steps that would have to be done to solve the problem (sure, it's not too many, but make them break it down). Give them hints, of course, but let them all try to figure out how it works.
NEXT pick a language - I think BASIC is probably a good place to start, for simplicitie's sake. If you think they're really bright and want to give them a nice challenge, throw Perl, Python or Java at them. Give them a good overview of the language's functions and operators, show them a few sample programs, and let them tweak them around to get a feel for things. Then tell them to write a program that will allow them to solve your math problem, but that they have to do it all in variables.
Something along the lines of:
a = 17
b = 2
c = 42
c - a = d
d / b = e
print e
would be expected. Now have them turn the variables into numbers they can input. Now that they have an idea about breaking things down, give them other problems (math or otherwise). As much like a 'good idea' (because they'd be so interested, of course) you'd think that having them design and implement a game is - I don't think it's a good idea. For just starting out, that's a lot of work, and totally unexpected problems can and will arise. Some simple games may be okay (think Hangman, but counting down chances instead of showing a figure - unless your students are exceptionally bright).
If you've got a good deal of time with them - change it up. Make them start a new language. The meat is all the same, the way you go about it is just a little different. Every language has its own positive aspects, things it should be used for, and things it's probably a better idea not to. Procedural languages would be harder to do something like Hangman in (at least, after you've got a good grip on OO-programming techniques), but for just adding a few numbers and spitting out a result, procedural programming will save you a lot of time.
After a little bit of work, start introducing things like arrays and hashes (if your language of choice supports them), queues and stacks and such. Above all, show them reasons to use them, don't just say "this is a stack" and expect them to start coming up with useful things to do with it. It's a little abstract, and an example or 10 will go a long way.
Have fun!
Ever tried a Lisp editor that uses colored parentheses? Parentheses at level 1 are red, level 2 yellow, level 3 green, and level 4 blue. Then level 5 repeats the cycle. But I'd imagine in general that Lisp style languages might go over better in places where the national language puts the verb first.
Programming languages change and get better or new ones come along, etc..
But all of them are subjective to Abstraction Physics.
Though "Abstraction Physics" might sound way to advanced its basics is not. In fact its really more a matter of training self awareness as the human language they are using is also subjective to Abstraction Physics.
http://wiki.ffii.org/IstTamaiEn
http://threeseas.net/abstraction_physics.html
Once they understand how they are already using abstraction physics then they will be better able to grasp the subject matter of abstraction so widely used in programming.
If you are interested in more my email address can be found at the bottom of:
http://threeseas.net/vic/html/
but be sure to make the subject line something I will not skip over as that address has gotten on spam lists and I'm not going to give you another email address in public , but will privately.
I see squeak has been mentioned several times. It was developed by Alan Kay and his team. I can vouch that its EToys implementation, which comes with Squeak (i'm using an older 3.0 version) has been great for my son. He and I have created our own widgets (cars, planes, whatever) then using scripts right in the graphical environment, made them move around and interact. The great thing is that it gets the kids starting to think about what it means to make something move or interact programmatically.
There's been a lot of research done about how children learn, and squeak uses those ideas to its fullest. Check out squeakland.org for more details
When I was nine, I was introduced to programming with Apple BASIC. I almost didn't recover.
http://www.ni.com/academic/
So this is a fairly sophisticated package, but play around with some of the basic functions. Everything looks like a circuit diagram... just put your basic operators ( + - * / etc.) and pump in different inputs (start with constant numbers, then replace them with dials and stuff), and watch what happens to the output display (start with numbers, move up to gauges and graphs).
Eventually with enough money for extra hardware you'll have them building Lego robots.
They made us use this in college engineering projects and labs, and there were bits of it that were frustrating. But introduce the components a piece at a time, and the kids will be tinkering with all of the other functionality and figuring out the loopholes in no time.
As others have said, this is ridiculous. Many people start programming when they're quite young. I was proficient in BASIC (not that it's something to brag about :-) ) when I was 7, and Java before I was 12.
Secondly, abstract is not required to understand at least some programming languages. If somebody suggested teaching them the Lambda Calculus, I'd be a bit worried, but something like C/BASIC/etc. is sufficiently procedural to make things easy. Don't confuse procedural languages with algebra just because both involve variables, because the concepts are actually very different in different languages. (I'm unsure whether Lisp/Scheme would be "too abstract" for people. I don't think functional programming would be the problem; if anything, it'd be the syntax (not the parenthesis.))
Thirdly, you divide people into "12-13" year-olds and "13-14" year olds. Leaving aside that people 13 years old fall into both classes, one year of age difference is very little basis on which to delay teaching people programming.
Finally, and most importantly, you mention that those ages are where abstract thought develops "on average". Other people in this thread who have supported you have again cited average cases. NotesSensei is not going to be teaching a school-wide programming class. NotesSensei is going to be teaching programming to people who have joined a computer club. There's a big difference there.
As for precisely what to each them, I wouldn't recommend VBScript or, therefore, KPL. I also would not recommend Java; while I think Java is a nice programming language and has many decent uses, I don't think it'd be a language that kids would like to learn as there first language. There's way too much figurative red tape to wade through to get anything done. The same probably applies to greenfoot. I would probably recommend Python.
Once they get a handle on why a computer works the way it does, i.e. all it understands is one's and zero's, then you can turn to higher level languages of some flavor. Then as a final six to eight week segment you can give a preview of how OOP works. I lost track of how many people I've had to take back to ground zero and start over teaching them how the computer actually does what it does. If the students do not have a solid grounding on the hardware and basics of it's low-level software, they will build an internal (mind) model which bears little to no resemblence to the reality of the machine.
"[I]t is a wise man who admits the limits of his knowledge or skill, and that pretending either causes harm." --Terry Go
I cut my teeth on GWBasic. It's been awhile since I used a learning language, but I would stick with something that doesn't require a lot of boilerplate. Specifically, in languages like GWBasic, (and its successor, QBasic,) the programmer didn't have to worry about references, compiling, "include" and "using" statements, ect, ect.
A friend of mine wrote, (and taught with) ZLogo. What's important is that the kids don't have to do a lot of prep work that we take for granted. Every piece that they put into the program causes a change on-screen.
No, I will not work for your startup
We actually just finished running a kids' summer program at the YMCA Gambia, and we used edubuntu to teach the kids, among other things, an introduction to programming class, using kturtle. kturtle is a LOGO interpreter, with a very good help manual, and it is so graphical (runs in KDE) so the kids get immediate feedback. Plus it can run off CD along with the rest of edubuntu, if you don't want to install anything.
The kids themselves - we're talking between 5 and 18 here - had a lot of fun and at the end of the program we burnt edubuntu Live CDs for them to take home and continue using on their home PCs.
First off, you didn't really answer the question (I'm assuming here that this AC post was written by fermion, since it contains the same types of odd grammatical errors as the grand parent post). Have you ever actually worked with kids?
I have, and my experience is much more in accord with the standard view of childhood as a period of intense learning and rapid acquisition of new abstractions than it is with your picture of children locked in a world of simple and concrete structures. If you want to teach languages, math, music, computer science, or any other "structure rich" subject, childhood is the time to do it. The only things I would suggest holding off on are things like history, music appreciation, and literary criticism which require the acquisition of a large body of concrete but unstructured information before the underlying abstract structures can be perceived.
Addressing a few of your specific points:
This is the sort of thing that makes me think you don't have much experience with real children. You have described the stereotype of childhood play, which is but a faint shadow of the reality. For example:
This was a horrible lesson, for exactly the reasons you list. It taught the kids nothing of lasting value (most of what they memorized will no longer apply by the time they have a chance to apply it) and it focused on rote memorization, which is hard work, instead of developing an understanding which is much easier.
It depends on the source of the complexity. J.S. Bach and Scott Joplin are both complex and accessible without a great deal of prior knowledge, and kids tend to love them (go listen to the tunes of baby toys). On the other hand, if by "complex" you mean music that draws on a body of conventions and idioms that the kids won't know, you are right that they won't enjoy it as much as they would music which uses conventions they are familiar with. This is because it depends on concrete information which they lack, and not due to any deficit in appreciating abstractions.
--MarkusQ
My candidate languages were C++, which matches my own programming experience best; Java, which is used on the CompSci AP exam; and Python, which was recommended by an acquaintance.
Python won out, for the following reasons:
Here is my primary text, and here and here are my supplemental texts.
Human being (n.): A genetically human, genetically distinct, functioning organism.
HTML - teaching the importance of syntax ;)
CSS - rudimentary abstraction
Javascript - programming(loops etc), objects
Java - standalone programs, higher level abstraction
C - what not to do
My suggestion is to d/l edubuntu Live CD (x86, PPC, AMD64 versions available). I did this just this weekend and began showing my 6 year old around the system. There are a number of excellent applications for education (most above the level of the average elementary student, no doubt) and educational games. One is the LOGO programming language/environment, which is designed to teach programming to children. Also, in the GCompris educational packages is a "boat race" game that is a programming teaching aid (forward x, left degrees). Recommended.
-- @rjamestaylor on Ello
There are a lot of great posts here, and I am not competent to comment on the selection of programming languages, so won't even try. (For the record: yes, I do a little myself, but because I understand the fundamentals I can at least follow most languages.) I am looking to address this same questions on a smaller scale for my niece who is homeschooled. My main focus, then, is curriculum rather than language. Does it really matter what language they use? I would think that basic programming concepts would be an excellent place to start. To that end, and after a lot of research,I found KidWare Software (http://www.kidwaresoftware.com/vbkids.htm) that makes a text-book style manual for teaching those basic skills. Yes, it's VB... but so what. I have ordered the book but not received it yet, so I'm only going on the online samples, but if you are going to teach a large class of kids getting some pre-built material might be a lifesaver. Jim
Don't feel obligated to teach them anything like what people use in the "real world." At that level you should help them to construct virtual machines and use them to solve trivial problems. By virtual machine, i mean simply the conceptual machinery that is required to understand all programming languages. Understanding the type/token distinction is essential to understanding all programming languages. I would suggest avoiding functional languages like Lisp-derivatives because they assume that the programmer already understands the difference between code and data. At the primary level procedural languages are best. BASIC is always good because of its easy to read syntax and simple virtual machine. I've always thought that a quick intro to the sentential calculus would have been a boon for my computer programming education if anyone had taught it to me at that time in my life. It is perhaps the simplest virtual machine wherein the type/token distinction becomes apparent.
Oh shit! I forgot to click "Post Anonymously"...
The choices are very slim. They are, in decreasing order of desireability, Tcl, Python, Component Pascal, Oberon/2, or Smalltalk. C, Java, C# (properly pronounced "D-flat" as any music major could tell you), and Fortran (no matter what freakin' year) are child abuse.
here are 3 more you should look at:
http://www.alice.org/
http://www.opencroquet.org/
http://www.runrev.com/
The first 2 are free, the 3rd is commercial - sometimes
free versions show up on the DVDs from british computer
mags.
I looked at several 3D programming enviroments a few
years ago, and these stood out as being accessible
to beginning programmers. I can't give much detail
beyond that, all three have pretty good documentation
and active communities. They are also notable for making
fairly complex graphics easily accessible.
That isn't much to go on, but it will be very worth your
while to look at these environments.
I'd suggest looking at Alice, which was specifically designed for education. It helps new programmers avoid getting stuck on syntax, and provides a 3D environment that is both fun and teaches OO principles. (And Electronic Arts has agreed to let them use some Sims artwork.)
Scheme greatly impaired my ability to program--it's logic is counterintuitive to what kids that age are learning. OOP is dang near impossible, and it's rather an advanced task to make anything graphically interesting.
May I suggest Game Maker? It's interpreted, free, and graphically very powerful. Kids can drop pictures into the software and use the drag and drop programming interface to create full-fledged games. You can make a simple game in as little as 5 minutes, yet Game Maker has enough complexity to grow into whatever you wish to teach (even 3D in the $20 registered version). It has a built-in language--GML script--as well, in case you wish to teach more traditional coding. If you want a software package that allows kids access to the entire range of programming logic, yet allows them almost instantaneous feedback (eg, import a picture, set it as an object's sprite, drop it in a "room," and you have a working program), Game Maker is the best I can possibly suggest. There's even a book--The Gamemaker's Apprentice, that was just recently released by the software's author. And there really is no better way to teach concepts like OOP and inheritance. As you can almost certainly deduce, I've been an enthusiastic user of the software for several years now, and I often prefer it to many of the packages I learned in college!
http://www.gamemaker.nl/
Javascript would be a great language for teaching, it shares a lot of syntax with other popular languages (c, java, c++), but avoids the low-level details that would intimidate a beginning student. The big disadvantage to using javascript is that people only think of it in relationship to a web browser. Most javascript tutorials are about how to acheive some lame text-blinking effect, and aren't really about the language itself. A noteable exception is Douglas Crocford's Javascript page: http://www.crockford.com/javascript/, but that is really advanced stuff that would make a beginner's head spin.
Can you type "man date" without laughing?
The small town I grew up in started us in 1st grade (1979) with Turtle and Pseudo-code. Although Turtle may be a little too basic, I think the Pseudo-code was an invaluable lesson. There are also games out there that allow the students programs to directly compete against each other (maze-finding, fighting, whatever)... The key for a young age is to ensure that they get immediate feedback whether their code is working... I've never tried it, but maybe ActionScript ( http://www.actionscript.org/tutorials.shtml ) would be a good option, since that would give them immediate feedback and still be something you could post on a class website for them...
Just a few thoughts.
http://www.google.com/profiles/malachid
I've not taught primary students but secondary students have taken quite nicely to Ruby. Get to do something quickly, some framework (ROR), OO, scripting. Fun. Would use BlueJ and Java when introducing OO, then back to Ruby.
Because nothing says fun like optimizing low-level code to corrupt your opponent's program :-P
Take a look at http://en.wikipedia.org/wiki/Redcode
Much Madness is divinest Sense --
To a discerning Eye --
Much Sense -- the starkest Madness
Seriously....mod this parent up.
You're teaching grade school kids how to program. Not how to make websites, or how to beat Flash into submission, or how to deal with cookies. You need to teach them about programming, and how these words make a computer do what you intend. They have decades ahead of them to argue the intricacies of VI vs. Emacs, or Perl vs Python vs PHP, or C+ vs C vs Pascal. When they get into later Computer classes, they'll be exposed to Basic, or Java, or .NET, or C. But the best thing to do at this age is teach them how to program - the steps required to go from "I want my computer to do this" to "X requires steps A, B, and C" to "A means tell the computer (foo(bar));".
Most of us on here are so far past the point of where we first picked up the keyboard, and wrote, "10 PRINT 'Hello world'; 20 GOTO 10;" that we miss the important fact that people do not think like a computer program We infer, we use outside sources of information, we have a lifetime of learning to filter our decisions on. Training the mind to see a problem as discrete steps which can be represented by even more discrete commands to a computer is not natural.
My advisor in college was an AI fanatic who did a whole pile of research into computer education and learning. Scheme is not super-powerful, all-encompasing, and world-ending. It will not be the next-generation solution to world peace. But it simply and elegantly introduces people using it to most, if not all, of the cores of good programming and computer programming concepts - stacks and queues, functions, recursion, all the core "how to program" type of stuff.
Scheme (and LISP as a superset), as a language for getting things done (the Mancala program I wrote in my AI class notwithstanding), is not a first choice for much of anything most people want to do. However, as a programming fundamentals teaching language, it's a well documented basic teaching language.
This space for rent. Call 1-800-STEAK4U
I have taught programming as low as 5th grade. I always started with HTML. It can be written on any computer that has a text editor. I can be tested on any computer that has a browser. Although it is not really "programming," it does introduce all the basics.
/ index.htm
I started with a lecture on giving computers "special codes" to start and stop doing something, and then introduced the basic tags html, head, title, body, h1, and p. On the first day, they were able to type in something incredibly simple, and get instantaneous feedback. So, they were learning the Edit, Save, [Upload], Review cycle.
They got a lecture on documents (files), programs (executables), folders, and shortcuts, and then they were introduced to a and img. This also introduced them to attributes, and I mentioned that in other languages attributes were called properties.
They also got a lecture on nesting, whitespace and indenting, which would help them later on with control structures. After, that it was on to Javascript, and non-linear concepts. Some of my lesson plans are still at:
http://www.irolo.net/school/archive/saintmary/6th
Good luck!
Long live the Speaker Bracelet
Rolo D. Monkey
Start out with simple card sorting exercises where you represent a basic adder, etc... This is what we've done at home with our kids, and once they had a grasp of writing programs from a microcode level we have moved them up to Logo, giving them procedural tasks, such as "write a set of functions that creates your name on the screen", etc... Or for the youngest "fill the screen with replicating equidistant geometric shapes".
It's been a lot of fun. Our oldest is now taking his first steps into Second Life scripting (a *very* basic scripting language) in the games Teen grid to add actions to his creations.
Colored parentheses? Colored parentheses?
They are African-American parentheses! Racist.
When I was 10 I was obsessed with this book on the BASIC programming language, and i would enter all the sample programs from it to see what they would do. I also made a few simple programs on my own... too bad I didn't keep up with the habit.
I would higly recommend the Lego Mindstorms systems (there's now a new version) They are loads of fun and teach programming at many different levels. There are organized competitions where you try to program your robot to accomplish various challenges. The programming starts easy, but can be quite involved. And it's the old, "I'm having fun and don't realize I'm learning". The hard part for us adults is making sure we don't hog them and actually let the kids play with them. Link: http://www.legoeducation.com/store/SearchResult.as px?pl=7
I cut my teeth in a summer class programming PIC microcontrollers. It would take some work getting kids up to speed on assembly syntax but they can see hands-on results fairly quickly (like programming LEDs to flash in sequence). Besides that, the limited language can be less daunting. The more adept students can dive into their own projects, like building digital weather stations that output readouts to LCD displays, or making their own joysticks. I like that it's a very hands-on, real-world way to delve into programming.
the mods may say you posted flamebait, but to me it's a flame that warms my heart. rock on, brother! --chebucto
I was one of those kids that could do that kind of thing; by the time I was 9 I was reading at the college level, doing algebra, chemistry, having all kinds of fun. This was in an open classroom where the teacher saw my potential and took the time to provide me with materials that let me advance at my own pace.
Then the school system in my small town failed to have anything to offer a child that age with that level of learning, and I didn't see algebra again until 8th grade (that was early there!), and nothing like the reading material I'd conquered until late high school. My parents thought skipping grades would be bad, and there was no sufficiently advanced curriculum from 5th grade onward. I ended up frustrated and loathing school, and the resulting anger and poor study habits (really, what 5th grader is going to do lessons they learned years earlier?) nearly ruined my college career.
My point, I guess, is that you better bloody well be sure that whatever abstract concepts you teach will be reinforced and able to be expanded upon in the following grades. Teaching a child beyond the curriculum and the parents can cause unintentional problems.
There's not much more maddening than being 5 standard deviations from the norm IQ-wise, astonishingly well self-taught, and unable to do anything with it.