My professor at the time was a young dude who had the idea that the best way to learn about programming language design & construction was by learning five languages in one semester. Some were simple to wrap our C++-and-Java-bred minds around, like C, and some were painful to paradigm-shift into, like Prolog. But the first language, and the one that truly gave me insight into what makes a programming language a useful tool, was Scheme.

Scheme, the simple dialect of Lisp, the parenthesis-heavy language with terms like "car" and "cdr". Where tail-recursion is the paradigm of choice and the iterative, C-style "do-this-then-that" habits had to be broken before we could truly begin to program elegantly. I spent hours and hours writing tic-tac-toe in Scheme; I think the most important thing I learned was to avoid assuming that a particular convention works well in all environments.

To give you an idea, here's a lovely Fibonacci sequence generator in Scheme: (for the non-CS/math grads, the Fibonacci sequence is a pattern of numbers: 0 1 1 2 3 5 8 13 21 34 ... or, each number equals the sum of the two previous numbers ... which makes for a great little sample program )

(define fib
  (lambda (n)
    (cond ((= n 0) 0)
          ((= n 1) 1)
          (else (+ (fib (- n 1))
                   (fib (- n 2)))))))

Lately, as a mental exercise (read: to procrastinate on some of the less-interesting paperwork I was supposed to be doing ), I started to play around with Haskell. I'm having a ball, mostly because Haskell is so much more strict about eliminating side effects, which means that the language directly supports designs which are compositions of pure functions. Why does that matter? Well, if you can't mess around with memory or resources outside of your function, then you can't break things outside of your function either .

Fibonacci in Haskell:

fib x =
    if x == 0
        then 0
        else if x == 1
            then 1
            else fib (x -1) + fib (x-2)

Why do I like this better? Well, aside from the fact that there's no stack notation ( operator, operand, operand...), so I can let my brain think in a more human way, it does away with all those blasted parens.

Of course, since this is about hour two with Haskell, I can't quite comment on whether I like it as a whole, but I can certainly see how programs developed with it are more easily proven correct; an entire class of possible problems is eliminated by eliminating side effects.

Anyhow, if anyone else is interested in learning Haskell too, and wants to put some code together on a side project ( purely for the fun of it ), let me know.

Now THIS was something cool: the game opens with the computer giving you the introdiction to a story. Then, you just tell the computer what to do in more-or-less plain English, and it'd go ahead and do it ( or, sometimes, refuse hilariously) in the story world, telling you what changed. It was so simple -- just text on the screen, a virtual 'intelligence' and a virtual world to explore.

Being a kid, I pictured myself an ellite hacker-type, typing into the night, peeling away the layers of puzzles to see the core artificial intelligence living in it's artificial world. The glow of just text on the screen made it easy to pretend -- I already was a bookworm, so I was used to imagining my stories anyhow. This took it to another level. It was my story!

Soon, of course, the interactions get silly. I'd try random things ( KICK THE DOG, EAT MUSHROOM ) just to see what the game would say. Often, you'd just get the standard "I couldn't do that! Fido is your best friend!" or "I don't know how to eat that.", but once in a while you'd get a great response: "you chew up the mushroom; it tastes like gooey dirt. Slowly, the colors drain from the walls and the dog begins to quote Glengarry Glen Ross. Funny; he never liked Mamet before."

After spending hours in front of these games, getting horribly stuck in all of them ( Adults need hints for these games; I was 7 or 8 ), what else could I do? I started writing my own. My friend Brian and I started crafting a brilliant piece of interactive fiction called "The Good Day". Brilliant, I tell you! It had three whole rooms! It was written in Applesoft BASIC! You could fart and belch, you could kick stuff, you could use two-word commands! It was very nearly a work of art, ready for publishing... Except that it took about ten minutes to get through all the fart jokes and then ended abruptly, and had no real plot, and...

But it was ours.

So nowadays, that GOTO-laden mess of code seems quaint to me as I write software that processes millions of transactions, but I miss the unbridled enthusiasm for hilarity we had. So in my next program, I think an Easter egg needs to be hidden: from time to time, in the midst of the millions of operations in the code, my fancy processing code will have gas, and leave an "oops, I farted" in the logfile.

Because no, I still haven't grown out of fart jokes. And admit it, neither have you.