This is my first time out of the USA (barring Canada), so I’m enjoying observing the differences. Although there are some interesting points, it’s more similar than I expected.

• The outlets are those weird european ones, so I can’t plug in my computer (without ganking an adapter from a coworker). I was going to go to a store and buy one, but
• Stores close at or around 17:00! How am I supposed to satisfy my electronics craving after dinner?
• People write times in 24-hour format, there’s no AM/PM.
• There is a different meme at stoplights on foot. In the USA, each person or group of people presses the button. Here, it seems that people only press the button if there’s nobody already waiting. That is, they trust people to have already pushed it… which makes sense.
• I always like trying new weird food. This is made easier when one cannot read the menus.
• “Met” means “with” in Dutch. Other words have other meanings.
• A glass of water costs 1.50€ at restaurants. That could be related to the fact that tap water in this country is not what I would consider drinkable.

It’s actually not that hard to get around not being able to read anything. It’s fun being here.

So far, the team has been great to work with. It’s always nice communicating with smart people who “get” software and don’t have any strange overarhicitectural fantasies. Well, I guess we have yet to find that out, but so far so good.

The project is really interesting, too! I wish I could talk more about it.

Typically I’m starting work around 1AM (which is 9AM in Belgium). Today was the first day I got a “decent work day” in, going until 8ish. The environment is nice; sitting here in my comfy chair or couch with a blanket and a kitty on my lap, discussing linguistic (as opposed to formal) aspects of programming languages!

I’m using FogBugz to track my time and tasks. It’s working well, nice and lightweight.

Yesterday I took two hours to do a freewrite using two of Karen’s instruments: oboe and marimba (instruments I definitely did not focus on in the past). It’s a two minute, four piece ensemble for oboe, marimba, violin, and cello.

Freewrite no. 25: (mp3 / pdf)

In total, this serenade took me about 90 hours over six weeks. It forms my largest, most complex piece to date, and although parts of it are somewhat juvenile and the scores are messy, I am quite proud of it. Its runtime is 22 minutes. It is also listed on my music page.

1. Molto allegro (mp3 / pdf)
2. Adagio (mp3 / pdf)
3. Allegro, Andante (mp3 / pdf)

Recently I had the realization that I don’t want to be a professional programmer. I just made a commitment to program professionally for a while in Belgium, in Haskell, doing FRP (yeah, pretty freaking awesome!), and I’m not about to bail on that. But after that job has run its course, I suspect I won’t be wanting another one.

It’s not because I don’t like programming anymore. Programming is still a wonderful way to keep my mind agile, and I like it very much. Creating or learning a new abstraction requires head-breaking leaps, it’s exciting to master a new concept, and I still feel passionately about the future of programming languages (particularly the completely yet-unrealized potential of dependent types). But such are the pursuits of an academic, not a professional.

When I started college, I wanted to be a professor. It didn’t take long to realize that my work ethic was not insane enough to be a professor. Nevertheless, every semester since my sophomore year I was a TA. I skipped around teaching physics, calculus, and computer science. I was good at it and I loved doing it. It was a delightful sanctuary from the stress of studenthood.

After the fall semester of 2006, I became fed up with school’s bullshit (in fact, an elective voice class of all things was the one to push me over the edge—it’s a long story) and intended to take a year-long hiatus from school to work at NetDevil, a local game studio. That I did, quitting the job seven months later due to the ridiculous “crunch time” (read: mandatory unpaid overtime) policies.

And here we are, mid 2008 and I have not resumed school, and the next year does not expect my return.

It’s unclear what happens next. Maybe I spend a year in Belgium as a programmer, maybe longer. But after that, I don’t know. However, teaching looks to be in my future. And looking back on all my teaching experience in college, there is one thing that will always stand out: physics.

Physics is miraculous to teach. The subject’s depth and beauty has made a zealous atheist like me reconsider God’s nonexistence (converting me, if you will, into an agnostic :-). There is nothing more pleasing than being in the presence of a student who asks question after question as he begins to behold the mathematical masterpiece (except perhaps seeing more of the masterpiece yourself, which students have helped me to do!). I witnessed this with two or three students each semester.

Students come into physics often with a truckload of preconceptions about how the world works. This differs from mathematics and computer science, where the most prominent preconception is that they will not understand (a difficult one to work with). Physics also differs from those two subjects in that the tools to disprove themselves are placed right under the students’ noses. I have experienced the moving, haunting situation where I predicted the outcome of a physical situation and then observed it go down completely unlike I expected. To help a student with a misconception, you don’t tell them they’re wrong, you help them devise an experiment to disprove themselves.

Talking about it excites me, it makes me remember and long for that experience. I can see myself, even with my restless, wandering soul, doing that for the rest of my life. But there is a brief international diversion to explore first, it seems.

On the other hand, I can’t stand Chris Rock and those like him (George Carlin somewhat included in this category), who ostentatiously vomit political and ethical opinions which sound like they’re edgy but everyone agrees with. I didn’t go to a comedy show to hear a liberal sermon (I, too, agree with most of said opinions).

Anyway, where I’m going with this: I just watched Last Comic Standing on Hulu. I was thoroughly impressed: about 80% of the jokes made me laugh out loud (possibly to the extent of waking up my roommate). However, I completely disliked the presentation. It was presented like American Idol: they showed bad comics telling bad jokes and getting rejected by the judges, they showed the good comics boringly telling the camera about themselves (but two of them were quite hillarious in this process), they even did the “who will go on to the next round” needlessly long dramatic pauses with nary a single amusing moment.

I’m watching a comedy show, I don’t want to get to know the comics as people and cheer when they are selected and feel bad for them when they are rejected. It’s a comedy show, I want to laugh my ass off!

So: skip the two semi-final nomination segments, there is nothing good there. The rest has spatterings of pretty funny stuff, and the two live show segments are hillarious. And NBC, stop with the mindless filler!

Originally Flow belonged to Namaste, and now that he has moved away it’s unclear who the owner is. It’s almost like she belongs to this house.

I had my music program open on my computer and was about to start writing a song when Flow walked onto the couch next to me. She put her paws on my lap and lay down. Normally I would have pet her a few times and continued working.

I’ve been thinking a lot about a particular girl recently. Today I fantasized, what if that girl had sat down close next to me and rest her head on my shoulder? I wouldn’t simply hug her and go back to working; she just asked me for some affection!

So instead of seeing “that’s a cat”, I interpreted Flow’s actions as I would a human’s. I closed my computer and sat next to her, petting her softly and listening to her purr. I felt close to her, like she was my friend and she understood me. At the least, I understood her.

I have been pondering recently about the cognitive mismatch between OO and functional approaches. The two have been fused in languages, see O’Caml, but I argue that code in such a fused language will mostly end up looking like one or the other, not a beautiful balance as we would like.

My thesis is that the two support different models of the universe. The functional approach supports a “mathematical” view, where we know a lot about the structure of our data; the object approach supports an “empirical” view, where we know a lot about the data itself. Let’s use something I was playing with today as an example: the SK calculus.

The obvious functional approach is to define a data type representing the cases of the AST:

data AST = S | K | AST :@ AST

(The :@ is the name of an infix constructor; i.e. it is just a node with two subtrees)

Then to implement a function that, say, reduces the top level of a tree, we can analyze the data by pattern matching:

reduce (S :@ x :@ y :@ z) = Just $ x :@ z :@ (y :@ z)
reduce (K :@ x :@ y)      = Just $ x
reduce _                  = Nothing

Here we know a lot about what kind of argument reduce will get. Whatever it gets, we know that it will be either an S, a K, or an application. We then define what it means to reduce data of this form.

Now I could half-bake a standard OO retort showing how much incredibly better functional programming is by how awkward this would be in a typical OO language (and it would be). But that’s trying to apply the functional world-view, that we know a lot about the structure of our data, to an OO setting. I think a good OO design for this same problem would take quite a different form. I see it something like this:

interface Combinator {
    int arguments();
    AST apply(AST[] args);
}
class S implements Combinator {
    override int arguments() { return 3; }
    override AST apply(AST[] args) {
        return new Apply(new Apply(args[0], args[2]), new Apply(args[1], args[2]);
    }
}
class K implements Combinator {
    override int arguments() { return 2; }
    override AST apply(AST[] args) {
        return args[0];
    }
}
...

While I gave a working Haskell program above in four lines, my “good” OO solution (in whatever language this is… looks like C#) has much more than that and is not even complete. I have left out the definition of Apply and the function which actually does the reduction. But I’m not bashing OO here (but please do understand if I bash OO syntax, which as the years go by seems to get more and more verbose). Instead it’s just that this problem is very well-suited to functional programming.

But this program has very different properties from the Haskell version. In particular, it is easy to add a new combinator, a new object, that does something different. Whereas in the Haskell program, adding a new primitive combinator would change the assumptions of every function that worked with combinators. Conversely, adding data manipulation functions which depend on particulars, namely whether something is an S or a K (or whatever else), involves touching every object to add that method. Whereas in Haskell, we can just add a new function. Astute readers will recognize this as the famous “expression problem”.

This trade-off starts to affect the way we proceed. If we were to implement identical functionality in the two programs, our approaches will diverge greatly. For example, today I added a function to invert an application. In Haskell, I just enumerated by cases: this is how you invert an S-reduction, this is how you invert a K-reduction, etc.

In the OO program I wouldn’t add a visitor though, that would be stupid. Instead I would create a new node type for variables, apply the transformation to a number of variables equal to the number of expected arguments, and analyze the positions of the variables in the result. I would end up with a function that can invert any combinator. That is, the natural next step in the OO example is to write more generic code than in the functional example.

Anyway, there’s what I consider a nice side-by-side comparison of the two approaches. Maybe by analyzing these two examples and where they led, you can start to see what I’m saying about the two cognitive models.

And this brings me back to Perl. The slides I read mentioned Moose, an object model module for Perl. It is rich: supports inheritance, role composition, privacy, coersion, and many other tools. I think an OO system needs to have these tools: the OO world view counts on data having many facets, capabilities, constituents, and concerns itself with what is possible when you know about certain ones. An OO programmer must be an expert at creating data with many facets, capabilities, and constituents. This is contrasted to functional programming where everything is known about the data, and the focus is on manipulating it.

Haskell has no support for these tools. Its type system, although powerful, is too static. Haskell provides too many guarantees for OO to work; it wants to know too much about what’s going on. Similarly I don’t consider C++, Java, C# to be “powerful” OO languages. In fact, I might go so far as to say a language with static types and OO is not properly embracing the philosophy. You’re creating rich, smart data. If your superclass guaranteed that a particular method was const, i.e. does not change the object it was called on, how are you supposed to smartly cache the results of that function? Well, with the mutable hack. But that’s a hack, essentially telling the type system that it should go take a hike because you know what you’re doing.

Perl and Smalltalk “get it”, in my opinion. They have simple models, but provide tools for looking inside and changing data on the fly. They are about creating and manipulating smart data, leaving the guarantees up to the naming of the methods and their intended use, because trying to force guarantees would restrict their ability to be smart. If you want guarantees, use Haskell; it will almost prove your code is correct for you. But Haskell has no smart data, that’s the only way it can provide guarantees. You can’t have case analysis of data structures and objects that can reverse-engineer your function at the same time.

That’s it: when you’re in OO, don’t design functionally. Keep your guarantees wide open, and focus on making smart objects.

• 1 - Great funky track. It’s rough going now and then, but has some incredible passages, and is definitely listenable on the whole.
• 2
• 3
• 4
• 5
• 6 - High energy rock/funk.
• 7 - My favorite of the session. A trance track with nice vocals.
• 8 - My “Charlie Hunter” moment (okay, that is an overstatement), playing a complex solo and bass at the same time :-)
• 9
• 10

The lineup:

• Nolan McFadden - guitar, vocal
• Willow - vocal, percussion
• Will - drums
• Luke - keyboard/bass

As the lineup implies, my left hand was on “bass” throughout the session. This was the first time I’ve had to cover the bass part, and I thoroughly enjoyed it (and it overloaded me, indication that I improved greatly that night).

Two weeks ago I attended an open mic night at Cafe Babu, a fabulous musician-supporting cafe in Boulder. Interleaved between the scheduled acts were “open jam sessions”, where anybody who wanted to play could come up and play. Keyboardists being a rare commodity, I played in three of the four such sessions.

After more than a year of playing with excellent improvisers, it was extremely frustrating playing with these folks. Not because they weren’t good musicians—they were, they had good ears and a good sense of groove—but because nobody had musical control. The problem was that the music had the inertia of a freight train, and no matter how hard anyone pushed, it would not change direction. I will refine this statement to be more succinct by the end of the post, but in a good improv session, everyone needs to have control, simultaneously.

What I mean by this is that everyone needs to be looking at everyone else, watching and listening for ideas. Ideas are scarce in improv: because of the hypnotic nature of playing, music can continue on a good groove with no new content happening for many minutes. This makes it suck (ever heard the term “jam band” as derogatory? That’s what it’s referring to.). Music needs to change to make an impression, and if somebody wants to change it, you follow them. No matter if you like where it’s going or not, where it’s going is better than where it is.

Ears are more important than eyes. Especially when you’re around excellent musicians who often play with their eyes closed :-). So you listen for ideas and adapt to them. My personal philosophy as a musician assumes others are doing this: when I have an idea, I do it! No thinking, no testing the waters, no making sure that there is a nice transition or even that anybody is on board: just commit and go! If it doesn’t work out, well, you cross that bridge when you come to it.¹ Other musicians take different tactics to success as well, this is just mine.

But if people aren’t listening, such riskiness will never work. That’s what I found at the open jam. I heard an idea (almost all my ideas come from hearing other people do things) and accentuated it, basically split off a new groove with whoever sparked the idea very coarsely, and nobody else did anything. Same ol’ thing. If I wanted it to stop sounding like noise, I had to shut up.

The best way to get the music to go somewhere new is to give someone control. You can force control on someone by making them solo. Not drum+bass+guitar solo, I mean guitar-only solo (or bass-only, or drum-only). As an extension to this rule, the more people playing, the less control anybody has. Or: the prowess of the musicians involved must increase quadratically with the number of musicians in order for the music to be coherent (each musician needs to be able to simultaneously listen and respond to each other). I explicitly restricted SNW never to grow beyond 4 members, since I didn’t believe that I had the prowess to handle 5.

But there is another way! If I can’t handle 5, there is an easy way to give the coherence of a session with 4. In the words of a favorite pop band, Cake: “Shut the fuck up!” Whaddya know, there are only 4 people playing again. The problem is that if you want it to be a 5 person jam session, one person can’t just refuse to play the whole time. Everyone needs to STFU, frequently. Listen to some Miles Davis fusion records, great improv. And then note the number of people listed on the album versus the number of people you can count playing at once. The ratio is around 3:1.

I am going to be organizing some jam sessions before I leave. And my preface will be just that: STFU. And ideally, you’ll get all numbers of musicians playing at once if you have a good distribution: 4,3,1,5, and (my favorite) 2. And if it’s really flowing for somebody, 6. :-)

But that’s it. Listen for ideas, give everyone control. If you don’t have enough control to introduce a new idea, shut the fuck up and endow your bandmates with more.

¹ I have been working on incorporating such a mentality into my life outlook.