When I first tried Smalltalk, one thing that really struck me about it was that not only was the source “open”, but it was right there in front of me. If I wanted to see the source code for one of the classes in the Smalltalk standard library, I didn’t have to go to the web and find the project’s source-code repository and download the code. I just clicked on the class’s name in the Class Browser, and there it was. Making changes or additions to the standard library was as easy as making changes to my own code – everything was right there in the Class Browser, and changes took effect immediately.

The Morphic user-interface system, originally created for Self and later ported to Squeak and then Lively Kernel, took things even further. With Morphic, I could right-click on anything I saw on the screen and ask to see the source code for it. If I pressed a button and it did something neat and I wanted to see how it worked, I could find out with just a few clicks. If I wanted to make a second button that did something similar, I just right-clicked the first button and said Duplicate.

Convenience matters. When I feel the Urge To Tinker, only rarely does it feel like a loud voice shouting in my brain with enough energy to propel me to find the website and download the source code and figure out how to find the part of the code that corresponds to the thing I’m looking at on the screen and make the change and restart the program and retrace my steps. Much more often it’s just a quiet voice mumbling, “Hey, it’d be kinda neat if…” and then I think, “Well, it’s Open Source, I guess I could go download the source code… but… meh, it’s so far out of my way, not worth it,” and the urge fizzles out. I think that a lot of potential human creativity is being wasted this way.

But here’s what I see when I look at modern programming environments:

When I look at that, I don’t see my objects. I see a tool. A tool with a bunch of knobs and dials that I can fiddle with. I get the sense that my objects are behind the scenes somewhere, hiding deep in the bowels of my computer, and that the tool’s knobs and dials are somehow connected to the objects.

In contrast, here’s what Avocado looks like:

(Those gray boxes are objects. I made a JavaScript object with an ‘x’ attribute pointing to the number 3, a ‘y’ attribute pointing to the number 4, and an ‘add’ attribute containing a function. And the object inherits from Object.prototype, which is the standard root of the JavaScript inheritance hierarchy.)

This is how programming is done in Avocado – by getting your hands on the objects and doing things to them. If I want to change the object (say, by adding an attribute), I go right up to the object and tell it to add a new attribute. If I want to ask the object a question (i.e. call one of its functions), I go to the object and type in my question. If I ask the object how it fits into the inheritance hierarchy, the objects whoosh around on the screen to arrange themselves into a tree shape.

My program is made of objects. I want it to look and feel like it’s made of objects.

If you’re a computer programmer who doesn’t come from a Smalltalk background, this seems to you like a very strange way to write a program. Like jumping off a cliff holding a box of spare parts and trying to build an airplane around yourself in midair. But it only seems strange because your expectations have been warped by every other programming system in existence. The truth is, all those other systems are strange, and liveness is normal. I don’t recommend trying the airplane trick, but for most computer programs, building the program while it’s running is actually pretty awesome.

In non-live programming environments, building your program is like drawing blueprints – you draw the blueprint, and then someone else (the compiler or interpreter) uses your blueprints to build the house (the running program). Then you realize that you need to change the layout of the kitchen, so you tear down the house, change the blueprints, and rebuild the house.

In a live environment, you can rearrange the kitchen without tearing down the house.

Part of the appeal is that you get quicker feedback. Even in a language like JavaScript where you can just hit Refresh and there’s no compile phase to wait through, you still need to get the program back to the state it was in when you left off. In a live environment, you just make your change and see the results right away.

But the subtler psychological appeal of a live environment is that that’s how the real world works. The real world is always running – you don’t shut down the universe and rerun the Big Bang every time you want to make a change. Our brains have had millions of years of evolution learning to deal with a world where everything is always running. (On the other hand, if you’re already a computer programmer, your own personal brain has had years of experience warping itself to think that shutting down a program and fixing the source code and restarting the program is normal. But who doesn’t like unlearning things?)

This emphasis on making the objects in your program feel real, in order to take advantage of all this hard-wired stuff in your brain, is one of the ideas that Avocado has stolen from Self. I plan on writing up Avocado-centric blog posts about these ideas, but there’s also lots of great stuff to read on the Self website, plus there’s the Self video.

So I should say it: I don’t hate JavaScript. I even kinda like it.

I’ve been a Smalltalk (and later Self) fan for years. I like my languages simple and clean and dynamic. And JavaScript is definitely not simple or clean. But as Douglas Crockford points out, inside JavaScript is a core of really good stuff: a prototype-based object system, dynamic typing, closures that work (almost) right. As long as I stick to that part of the language and avoid the really messed-up parts, I can actually feel at home in JavaScript. If you’re familiar with other dynamic OO languages like Ruby or Python, you might like JavaScript too.

I’ll have lots to say in the future about JavaScript’s weirdnesses and deficiencies. So I figured I’d start out by saying that I’m actually enjoying myself.

It incorporates a bunch of ideas and principles from Self and Smalltalk, and I’m building it on top of Dan Ingalls’ Lively Kernel. It’s called Avocado. (You win a prize if you can guess the origin of that name.)

I like playing with live objects rather than editing dead text files. I like getting my hands directly on my objects rather than using “tools” to manipulate them. I like prototype-based object systems, though I like classes too. I like computer systems that are designed to fit my brain, rather than to fit the machine or to be easy to write papers about.

So I’m building something like that. And it runs inside a standard web browser.

I’ll have a lot more to say later.