For the most part I don’t talk about Wheeler on the blog because I have a hard time communicating what I’m trying to do. It’s also taken far longer to make progress than I originally anticipated. But some things about the project are easy to talk about. One of those is the name, which Steve asked about on Twitter the other day.

From my notes:

Wheeler was supposed to be a placeholder name. It refers to John Archibald Wheeler, the physicist. This was a nod to Bertrand, a constraint-programming language named for Bertrand Russell. I just wanted a name of some kind. Who did I respect? Physicists came to mind. Einstein was obviously problematic. Feynman would have been too arrogant. And I’d heard that for a time Wheeler had this notion that perhaps all subatomic particles are really just electrons. Or something like that. And I identified with that desire to find a simpler underlying model, even though it didn’t pan out. There really wasn’t much more thought given to the name than that.

After I’d done a couple of presentations, someone (I think it was Jesse Hallett, but I’m not 100% sure) asked if I had named it because of Wheeler’s “It From Bit” concept. I was unfamiliar with that, and was amazed how apropos it was to the language concept I was working on.

Later on I found out that Wheeler is an incredibly common family name in the US. I had no idea. Hopefully I’m not pissing off a bunch of people. Next time I’ll just go with Smith. I did try to get suggestions from others to name the language something else but everyone seems to like the name as it is.

At one point I wanted to call the language “What”, so that people could have Who’s On First wordplay with it. “You program in What?” “Yes!” To make things worse I thought the interpreter should be named “huh”.

Other Wheelers (for fun)

There is a Wheeler street in Portland, Oregon, where I live.

The 19th U.S. Vice President was named Wheeler

A notable American mathematician was named Wheeler (from her last husband)

My favorite, and my backup story for when people ask about the name: Wheeler is the surname of Honey Wheeler, a character from the Trixie Belden girl-detective books I read as a child.

Wheeler is not a practical project. It is not intended as a better way forward, or as a better paradigm, or as an improvement in how we program. Wheeler’s sole purpose is to spark questions in your mind. If I am very, very lucky, Wheeler may inspire you to think a little differently about how you program.

Wheeler is a work of conceptual art. Like any art project, there is a vision, and there is also a muse. When the muse is present, things are good. Ideas flow. The path forward is clear. When the muse is absent, the path forward is blocked. I’ve tried to force it. I’ve tried to make the language reveal itself. That only made things worse.

With all of that said, there is plenty of work that can actively be done. I’ve been asked for some sort of tutorial and also for a roadmap. I’m working on both of these now. My hope is that I can accurately communicate my ideas to interested people and get some help bringing what I see in my head into reality.

That video is about how cell membranes work. Did you notice how proteins, enzymes, etc. can only pass through the cell membrane if they are the right shape (and flavor)? That’s how values trigger transitions in Wheeler.

Transitions

If categories are the most minimal representation of state, then transitions are the most minimal representation of action. Transitions are how computation happens in Wheeler. After all, organizing data is only half the battle with programming. Once you have the data in the form you want, you have to actually do something.

You can think of transitions as being very much like an event handler. You define a transition to trigger when an interaction between one or more categories happens.

Since Wheeler is still a work in progress, transitions are not yet native. Instead, transitions are created in Python, the language Wheeler is built on.

Remember our Hello example?

Here’s the transition defined for it in Python:

def printer(category):
	for item in category:
		print item.name[1:-1],
	print
	return []

ROOT.create('print').add_handler( STRING, printer )

(I’ve omitted some unimportant details for clarity.)

What you might be able to suss out here is that there is a ROOT category that all categories live within, and I’ve created a “print” category within that. In addition, I’ve added a transition (with add_handler) which knows to watch for interactions with items in the string category. If the transition finds an interaction that matches, it executes the printer() function, which simply calls Python’s ‘print’ function.

Mutual Dispatch

When more than one transition is triggered by an expression, the transitions all execute AND – at least in concept – they all execute *at the same time*.

This is very much like the real world. If two objects collide you don’t say that one or the other of them collided first. The collision is mutual and simultaneous. In that same way, when categories interact, the interaction is mutual and simultaneous.

Here’s the final snippet of Wheeler for this introduction:

In case it’s not clear what is going on here, we have some numbers, which are in the category ‘number’, some text in the category ’string’, and some other categories (’print’, ‘+’) which give it all meaning with transitions. One transition knows to add all of the numbers in the expression when the plus sign is present. Another transition knows to print all of the strings in the expression to stdout when the ‘print’ category is present.

When presented with this jumble of categories, Wheeler figures out what to do based on the criteria of the transitions. This effectively creates a typed-dispatch mechanism. I call this simultaneous, polymorphic behavior “Mutual Dispatch”.

That sums up Wheeler as currently implemented.

There’s still a lot of work to be done. I’ve covered what Wheeler is currently capable of. There are other planned features that I didn’t cover and hope to implement soon. I will provide more info here as new features are added.

I hope you find it as oddly fascinating as I do! Feedback is not just requested, it is begged for. I also strongly encourage you to grab the code, play, and contribute.

(Thanks to Westside Programmers and #pdxfunc for letting me present on Wheeler a few times over the past year. Having the chance to present and receive feedback has firmed up the concepts in my mind and made them easier to distill into this introduction.)

Someone recently asked me if Wheeler had types. My answer was “No. Uhhh… and yes.” What a terrible answer! I’ll try to do better in this post.

Wheeler has no explicit type system. You will never declare a value to be of a certain type. You might, however, associate a value with a particular category through an interaction. In that way you’re establishing a relationship that will allow typing *behavior*.

What is a value?

Values are the imaginary, interstitial things floating between categories. When you establish a relationship between categories in Wheeler, you’re creating values.

What is a type?

I won’t attempt to answer this in general. I am not a type theorist. From the perspective of Wheeler we might say that a type is determined by a graph’s “shape” and “flavor”. Shape is the actual form of the graph we create in memory (tree, ring, object, etc.). Flavor is what specific categories are being connected by that graph.

What the hell is the difference?

Context. It’s all context. A value will trigger typing behavior when something matching that shape and flavor is being watched for. At that point it could be considered a type. The rest of the time, a value.

Layering values into types

Have you ever seen an artist paint a landscape? First they’ll paint the background… the sky, the horizon, the land. Then they start to layer on more and more detail. At what point does their work become a painting? Existential arguments aside, you might say that the work is a painting when it meets the criteria of the artist. Criteria will vary from artist to artist. Everyone has their own objectives, aesthetics, etc. In other words, everyone brings their own point of view or context to a situation. This idea is so fundamental in Wheeler that it is a core value of the language:

Context Drives Behavior

To help understand this, let’s look at a Venn diagram. (Venn diagrams are quite handy for discussing concepts in Wheeler.)

Here you see we’ve got just a category, Cars. You could think of that as a type. Let’s pile on some more specifics:

Now we’ve got all cars that are Honda Elements. That’s more specific, but it’s still more like a type than anything.

Ah, but now that we have a VIN, the unique Vehicle Identification Number. That’s so unique as to specify a particular vehicle. That seems more like a concrete value now. Yay.

Next time we’ll look at Transitions which allow computation in Wheeler. Then we’ll exercise our type and value scheme.

(You can play along at home by grabbing the latest code and running the examples. You’ll need Python 2.5 and patience.)

First, let’s fire up “bigwheel”, the Wheeler interpreter:

Here is “Hello, world” in Wheeler:

Wheeler is flexible though, so you could also say:

More on that later.

Categories

Wheeler is different from many languages you may be familiar with. All languages have abstractions. Some common examples are functions, lists, collections, stacks, pointers, and objects. In Wheeler, state is the fundamental abstraction.

State is represented by an abstraction called a Category. Categories are lightweight, atomic things. In Wheeler, everything is a category. Here are some sample categories:

• Fred
• blue
• 5.3
• “Hello, world!”
• number
• 3/15/10
• send
• 05:10:59
• AM
• PM
• true
• print

Categories express boolean state. You’re either in a category or you’re not. Here’s an example:

Do you see that? No? Good. What you do not see is ‘apple’ being put into the ‘red’ category. That is happening behind the scenes through an interaction between apple and red.

Categories aren’t containers, but from a practical standpoint they act like containers. This allows you to make statements about the world. We can pile some more attributes on “apple”:

Interactions

Interactions are expressions that combine categories to create new states. Our “Hello, world!” was an example of an interaction. Making our apple red was another interaction. Interaction is a mutual, simultaneous event where a connection (graph edge) is created between each item in the expression.

Wheeler has a “dump” command that will let you see (in GraphViz) the relationships you’ve created. Let’s dump “apple” and see the relationships:

And the relationships as diagrammed in GraphViz:

Here you can see that “apple” is related to “red”, “tasty”, and “sweet”. (You might notice that it is also related to “dump”, the category it interacted with to generate our diagram, and “metadata”, a built-in category.)

You can see that not only is ‘apple’ connected to ‘red’, but ‘red’ is also connected to ‘apple’. In Wheeler all relationships are bidirectional. This may seem odd if you’re used to typical hierarchical relationships in programming. Wheeler doesn’t think about the world that way. Wheeler has a few strongly-held beliefs, and one of these is:

Hierarchy Is Bullshit

Next time we’ll talk about composing categories into types.

From Vonnegut’s “Slaughterhouse Five”:

Billy couldn’t read Tralfamadorian, of course, but he could at least see how the books were laid out – in brief clumps of symbols separated by stars. Billy commented that the clumps might be telegrams.

“Exactly,” said the voice.

“They are telegrams?”

“There are no telegrams on Tralfamadore. But you’re right: each clump of symbols is a brief, urgent message – describing a situation, a scene. We Tralfamadorians read them all at once, not one after the other. There isn’t any particular relationship between all the messages, except that the author has chosen them carefully, so that, when seen all at once, they produce an image of life that is beautiful and surprising and deep. There is no beginning, no middle, no end, no suspense, no moral, no causes, no effects. What we love in our books are the depths of the many marvelous moments seen all at one time.”