You could probably easily buy a computer with Linux on it today from Ebay for around $100. Installing Linux means you have a wealth of ways to instantly write code (gcc, g++, ruby, python, php, perl, and a browser where you can write Javascript) and there are plenty of places to go when it's capabilities run out.
I think it's even easier to buy all of this today.
Or, have I totally misunderstood what you've said?
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
Type run, and blammo, drawing pictures on a screen.
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.
That's sort of the idea behind a project I've been tinkering with for a while called Mako[1]. It's an extremely simple VM that is essentially an idealized game console. I initially designed the system as a convenient way to play with compiler design (currently compilers for Forth, BASIC, FORTRAN and a BCPL-like language are available, in varying degrees of robustness), but having some limitations to work within has proven quite fun from a game development standpoint as well.
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]
Thanks! As far as F# is concerned, it's the latter. I really wish Github provided a way to override syntax highlighting based on file extensions. The reference implementation of MakoVM is written in Java, and a few other people have been working on implementations in C and Factor. As you can see, though, the VM implementation is much smaller than the libraries and examples for the platform.
> 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.
Oh that is pretty cool. I like that it can do graphics too, that is pretty important when grabbing a kid's attention.
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
}
}
All with the added advantage that you can watch the drawing happen as you type in the code instead of waiting until the end to enter "run". Note, I have assumed your "DRAW" statements draw rectangles because they have four coordinates. The canvas widget supports many more shapes than just basic rectangles, substitute as desired.
This is the real beauty of the RasberryPi. I heavily doubt that it will in it's default state convince anyone to start controlling their computer. (I explicitly avoid the phrase "Become a programmer" here because it has all sorts of baggage that shouldn't be there but is. "Programming" is really about controlling computers. To say anything else is misleading.) But the range of environments that it allows hacker-types to build and experiment with will be what spawns the renewed interest in deeper interaction with computing systems. At least I hope so.
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.
This is exactly how I learned on an Atari 800 XE. I clearly remember the moments where I understood variables, iteration, arrays, multidimensional arrays, subroutines, etc. The fact that I could teach it to myself while I was a child is a big deal. With a modern context, I'm not sure where I would even start. I'm proficient with a bunch of programming languages, none of them seem as accessible as the BASIC code above.
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?
> With a modern context, I'm not sure where I would even start. I'm proficient with a bunch of programming languages, none of them seem as accessible as the BASIC code above.
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.
Superficially, HTML Canvas drawing is very similar. (Also, many people taught themselves programming because they wanted to make Flash animations. )
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.
Installing Linux means you have a wealth of ways to instantly write code (gcc, g++, ruby, python, php, perl, and a browser where you can write Javascript) and there are plenty of places to go when it's capabilities run out.
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.
I think it's even easier to buy all of this today.
Or, have I totally misunderstood what you've said?