Author: grant

Programming in Education: OLPC Case Studies

Ben blogged here about some stories about OLPC case studies. They are all worth checking out.
Listen to the following NPR articles (both found here):

And read this article One Laptop Per New York City Student a Success and report.
The company WavePlace, mentioned in the story, can be found here. Be sure to have a look around the site!

Analogies are a bridge

Analogies are often used to introduce folks to new ideas, introducing them not directly, but through comparison and inference. This seems to work well in all areas, including technical. The risk in using them in technical matters, though, is that person will never move past the analogy and into the realm of accurately understanding the subject matter.
For a long time, I very much disliked analogies. Perhaps this was due to bad personal experiences in my study path with them, or alternately, hearing other folks go on and on about how “such and such is just like such and such” when that is simply not the case. In the past year, though, three interesting things have happened.
The first is that I’ve chatted with someone, who is very level headed and takes the time to talk through his point of view, who is a proponent of analogies.
The second is that I’ve taken a much closer look at how people teach, and, they certainly don’t do it by throwing their students into the deep end.
The third is that I visited a foreign country where it was clear to me that it wasn’t just the language, but just about everything, that I didn’t understand. On the trip I had the experience of analogies about “how things work” in the country just keep popping into my head. It was the strangest thing, but it was interesting, too, because I finally realized the role of analogies:
Analogies are a helpful bridge, that you must cross. If you stay there, you will never get to where you really want to be.

On Lisp

During my vacation, I skimmed Paul Graham’s book On Lisp. There were many interesting bits in there:

  • He really tries to “sell the wonder of Lisp”. I’m not sure is possible, though.
  • “Users prefer double edged swords to blunt ones”
  • I think that he loves Scheme, but uses CL for practical reasons.
  • He digs deep into code, heavily visiting macros and even implementing continuations, non-determinism, and an object system
  • He is probably a world-class hacker who will never be recognized for his talent, but instead his success
  • This is probably not a good “first Common Lisp book” as it is very deep stuff

Joel Bartlett’s Famous Scheme->C System

Joel Bartlett’s original Scheme->C system has been in stealth mode for some years now, but with a recent re-license under F/OSS terms by HP, the allocation of a web site http://scheme2c.alioth.debian.org/, the integration of all known useful patches including LINUX/i386 and LINUX/amd64 ports, and uploading into the Debian incoming queue, this zippy R4RS Scheme is on the move again!

(via comp.lang.scheme)

An alternate syntax for let

In this post I wondered how one might implement an alternate syntax for let (described in this C.L.L. post), which looks like this:

(let (x 0 y 1 z 2) (+ x y z))

As it turns out my solution was actually let*, and therefore wrong.
Nonetheless, here is wonderful macro provided by Jos that both implements the alternate syntax for let and also demonstrates a technique for how to use the equivalent of “temporary variables” inside of a macro:

(define-syntax my-let
  (syntax-rules ( )
    ((_ my-bindings body-expr0 body-expr ...)
     (my-let-aux my-bindings ( ) body-expr0 body-expr ...))))
(define-syntax my-let-aux
  (syntax-rules ( )
    ((_ ( ) (binding ...) body-expr0 body-expr ...)
     (let (binding ...) body-expr0 body-expr ...))
    ((_ (var value-expr . rest) (binding ...) body-expr0 body-expr ...)
     (my-let-aux rest (binding ... (var value-expr)) body-expr0 body-expr ...))))
(my-let (x 1 y 2 z 3)
        (+ x y z))