I think it's even easier to buy all of this today.
Or, have I totally misunderstood what you've said?
Sort of. Do your experiment (build a linux box) and put it in front of a kid with no exposure to computers (other than as appliances) try this with kids from 6 to 16.
As you get toward 16 you will start getting better engagement, most will figure its too confusing and stop.
I've run the experiment with Arduinio, even with its pretty straight forward GUI there is still some serious complexities around the notion of compiling, downloading, driver compatibility, etc etc.
One of the things I will do with a RasberryPi is look at building an embedded BASIC box. Hook a keyboard to it, plug it into a TV's HDMI port and turn it on. Blammo, BASIC prompt. (If I can swing it it would be a Python prompt but I digress). Type in the code (using BASIC syntax sorry)
100 CLEAR
110 DRAW(100, 100, 200, 100, "WHITE")
120 DRAW(200, 100, 200, 200, "WHITE")
130 DRAW(100, 200, 200, 200, "WHITE")
140 DRAW(100, 100, 100, 200, "WHITE")
150 FOR I = 100 TO 200 STEP 10
160 FOR K = 200 TO 100 STEP -10
170 DRAW(I, K, K, I, "BLUE")
180 DRAW(K, I, I, K, "GREEN")
190 NEXT K
200 NEXT I
210 END
Why pictures? Being able to draw graphics is a compelling thing for folks, they like to do it, it touches their inner finger painting. It compels them to think about 'steps' and 'math' and stuff.
Doing graphics in Linux is a PITA. The notion of a system which throws away everything except a way to explore through programming, and has access to all of the capabilities of that system, is key. The programming needs to be accessible. I could be K&R C as easily as BASIC but it would need a very simple build environment (code for NOT gcc).
Something that with a manual of no more than a couple of hundred pages, can engage a student to explore it with programming. They don't know what programming is so complaining about types (for example) just demotivates them.
A few of my friends and I intend to roll a linux distro for the RaspberryPi which makes it into a physical "Mako game console", and in addition to playing games[2][3][4](etc) you'll be able to play with an interactive Forth prompt.[5]
[1]https://github.com/JohnEarnest/Mako
[2]http://i.imgur.com/IVNdt.png
[3]http://i.imgur.com/mJ1ZD.png
[4]http://i.imgur.com/XumXi.png
[5]http://i.imgur.com/gLknX.png(http://geoffg.net/maximite.html)
> The Maximite is a small and versatile computer running a full featured BASIC interpreter with 128K of working memory.
> It will work with a standard VGA monitor and PC compatible keyboard and because the Maximite has its own built in SD memory card and BASIC language you need nothing more to start writing and running BASIC programs.
> The Maximite also has 20 input/output lines which can be independently configured as analog inputs, digital inputs or digital outputs. You can measure voltage, frequencies, detect switch closure, etc and respond by turning on lights, closing relays, etc - all under control of your BASIC program.
One of the items in my list of ideas for this project is that the image save format is GIF or JPEG and that the files are stored on a USB stick (rather than an SD Card) since I'll use USB for the keyboard anyway, and with files on such a device you can carry them over to a laptop or desktop and play with them there too.
But thank you for this link! This is definitely the kind place I've been headed.
How so? Almost every Linux distro comes with Tcl/Tk (if not installed by default, installable by checking a box in a package manager). Using the Tk canvas widget your basic code above becomes:
$ wish <- start a live Tcl/Tk REPL
canvas .c
pack .c -expand true -fill both
.c create rectangle 100 100 200 100 -fill white
.c create rectangle 200 100 200 200 -fill white
.c create rectangle 100 200 200 200 -fill white
.c create rectangle 100 100 100 200 -fill white
for {set i 100} {$i <= 200} {incr i 10} {
for {set k 200} {$k <= 100} {incr k -10} {
.c create rectangle $i $k $k $i -fill blue
.c create rectangle $k $i $i $k -fill green
}
}
It's a cheap, more powerful, streamlined Arduino without a lot of the messy bits that make that product and it's kin what they are. (And make no mistake, those bits are what make the product desirable for it's target market.) The ability to fashion something as simple as a BASIC environment without having to sacrifice an expensive computer to do it is key.
But then, you're a part of that sort of hacker phenotype. How would a person who doesn't have that experience know how to do that for their kid? How would they even know that they should do it in the first place?
Once we can answer those questions in a satisfactory manner the world will be a better place.
I've often thought about how to replicate a similar experience for my kids, short of getting a collectible 8-bit home computer and removing their access to modern hardware. Anyone have success with this?
Core Tcl (i.e., that portion which a child would be exploring in his/her first introductions to programming) is very close to BASIC in accessibility. Core Tcl has very little syntax overall. Compare the Tcl/Tk code above to draw on a Tk canvas to the BASIC code for the same. There is nearly a 1:1 correspondence. And Tcl/Tk also gives the added advantage that when the children gain a bit of proficiency, then can also easily create GUI's for their code snippets and apps. The GUI's they create may not be beautiful GUI's, but they would be "their GUI's" that they created with their own efforts.
Back in the 8-bit micro days, the commercial games and other software were largely single person efforts. The beauty was that you could teach yourself some BASIC and very easily create something which was at least sorta close to the state-of-the-art.
I think to really hook kids on the idea, you need to have some platform which seems current (e.g. web or mobile) versus an 1980s-style box.
It's easy to "instantly write code" on Linux just like it's easy to "instantly change the brakes" on my car. (I say this as a long-time Linux user and developer.)
Squeak is the only "operating system" I've seen or used that is setup to instantly write code. Actually, I take that back. IIRC they jerry-rigged the OLPC to behave similarly with Python.