The ThoughtWorks Geek Night


Last Tuesday ThoughtWorks hosted a Geek Night, where I was the headline. My presentation was about Creating languages for the JVM, which as it turns out is a quite broad topic. The London office do these kind of geek nights now and again, and this time we ended up being about full capacity for what the office could hold, which is about 50-60 people. It was really crowded, actually. That is a good problem to have, though. I am glad so many turned up to see me do a two hour rambling presentation that ended up being like a non-stop fire hose of information.

I’m not going to try to summarize the actual presentation. There were way to much information in it for that. Luckily, SkillsMatter had a film camera there, and I’ve been told the video should be up anytime. Once that happens I will post about it here. In the meantime, the slides can be found here: http://olabini.com/presentations/CreatingALanguageForTheJVM.pdf.

It was an interesting subject to present about though. I think this material could easily be a one-day tutorial. I wonder if anyone would be interesting in having such a tutorial at their conference? And whether anyone would show up for such a subject…

It was fun, though. I had a great time, and I hope the people who showed up didn’t end up being disappointed with the material.



QCon London – Summary


All in all, QCon London this year was amazing. I find it interesting that from the first time I attended QCon I thought they were exceptionally good. And every time they keep getting better. Of course, it is fantastic to be able to meet all these great people at the conference, and you get lots of chances to hang out with them, ask questions and have discussions. But if you take a look at the presentations offered, they all feel very fresh and the quality is consistently of a very high level.

I think the system of having track hosts that put together their own track is a fantastic idea, and I think it might be one of the reasons that there are ALWAYS more than one presentation going that you want to see.

The fact that the QCon crew from InfoQ and Trifork are all lovely people is not a negative either.

If you haven’t visited QCon, I really think you should. It is really very good, and I’m privileged to have been asked to present there more than once. I always have a great time and I hope I will be able to continue to come back there.



QCon London – Friday


The last day of any conference can sometimes get a weak schedule, since many organizers feel that people have a tendency to be wiped out after all the previous days of conference, and won’t be able to focus as much on the last day. Luckily, QCon and JAOO never does this – the last day is generally at least as strong as any other day. This time around I felt it was a very good day indeed. I saw Stefan Tilkov do a very deep presentation on his thoughts on the balance between generic and specific in architecture and development. Stefan shared his long experience in a funny and thoughtful way that contained lots of interesting insights. After that I managed to catch the last 10-15 minutes of Joe Armstrongs talk about Erlang. This talk was focused on systems that never stop, and Joe’s presentation was based on this, which changed the focus a bit. Sir Tony Hoare was in the audience during this talk, and one amusing moment was when he asked Joe a question about the tradeoff between timeouts and failing fast. Great stuff. This only happens at QCon and JAOO. (As an aside, the evening before I got the chance to sit down and have beers with Steve Vinoski, Joe Armstrong and Rich Hickey. This never happens at other conferences either.)

After the presentation, Hoare asked me if I was interested in being part of a panel during his after-lunch presentation. The presentation was about null references, which Hoare calls his billion dollar mistake. To be fair, I think it was one of those inevitable things, that would have happened sooner or later anyway. Ulf Wiger became part of the discussion, and presented a much better defense than my point about inevitability.

In the DSL track, Amanda Laucher gave a good overview about what Oslo is and why you might want to use it. What I was looking for here was just enough of a look at the tech to see if this is something worth investing more time in. My conclusion was that at this point in time, it doesn’t seem to give me much new that would help me. Especially the Mgrammar stuff seemed to be a not-invented-here copycat of Antlr. Martin corrected me about that, though, by pointing out that Mgrammar actually handles GLR grammars. My intuition is that ANTLRs LL(*) would be able to handle most of the same parses, but that’s not something I would bet money on. Mgrammar also doesn’t need semantic predicates to avoid left recursion, which can make the grammars more readable.

The last time slot of the day I spent doing some hacking, and peeking in at Glenn Vanderburgs presentation on DSLs in Ruby, which gave a good overview of the available techniques.

The day ended with the totally hilarious Bullseye panel, where my totally insane colleagues Dan North and Jim Webber hosted a gameshow combining darts and zany questions to a panel of Michael T Nygard, Ian Robinson, Martin Fowler and Steve Vinoski. To many great moments to even start to describe, but if I had to choose one, it would probably be Ian Robinsons answer to the question about what tech has the worst man boobs. Ian’s response basically said that the problem wasn’t the man boobs, but that he couldn’t actually get close enough to touch them without lots of clothes getting in the way. Lovely metaphors there.



QCon London – Thursday


I started the second day quite late. There were a few sessions I wanted to see there but not enough to get out of bed early enough. After lunch I saw parts of David Pollaks talk on Lift. Lift is definitely impressive – you can achieve very powerful things very quickly with it.

After that, I saw Rich Hickey talk about Persistent Data Structures. This was without doubt the best presentation at QCon this year. Rich spent lots of time talking about identity, state and value. It was very good – you should go to http://qconlondon.com/london-2009/schedule/thursday.jsp and take a look at the slides for it. It is pretty deep stuff. I heard many other people share my opinion of the quality of this talk. QCon and JAOO could do much worse than getting Rich back for the next time.

Overall, I spent most of the Thursday having chats with interesting people instead of watching presentations. It was a good day in many ways, especially due to Rich’s talk.



QCon London – Wednesday (Emerging Languages)


The first day of the proper QCon conference started out with Sir Tony Hoare doing a keynote about the difference and overlap between the science and engineering of computing. Fairly interesting, but the questions and answers were much more interesting stuff. One of the more interesting points made by Hoare was that in his view, a full specification is a generalization of testing. After the keynote I started out my track called Emerging Languages in the Enterprise. I introduced this track, doing 15 minutes of talking about my views on programming languages. The slides for my piece can be found here: http://olabini.com/presentations/ELITE.pdf. My talk was made much more interesting by Tony Hoare being in the front row. That made the whole thing a bit more daunting, obviously… =)

I then spent the rest of the day in my track – which was very good. I am very happy with all the presentations, and felt the track was a great success. First of was Michael Foord, talking about IronPython, and how Resolver uses IronPython to create a great product. Some interesting lessons and information there.

After lunch Jonas Bonér talked about Real-world Scala. The presentation gave a good grounding in Scala without looking at all small details – instead Jonas talked about more high level concerns and styles.

After that, Rich Hickey did a great presentation about Clojure. Rich did a great presentation, talking about Clojure from the ground up. It was very well received.

Martin Fowler did a fantastic presentation on ThoughtWorks experience with Ruby. The room was packed for this.

The final presentation in my track was Attila Szegedi talking about JavaScript in the Enterprise. This was also a great presentation, and gave me some new insight into what you could achieve with Rhino.

All in all, the full track was excellent, and all the presentations achieved pretty much what I hoped from them. I learned a lot from all of them.

After the final session of my track, Martin Fowler and Zach Exley did the evening keynote, talking about how technology helped the Obama compaign. Very interesting stuff too. At the end of the day, a very good day at QCon.



QCon London – Tutorials


The first two days of QCon London were tutorials. I didn’t actually spend all my time there, since I had to get back to our office at some times too. On the Monday, I attended Jim Webbers tutorial called GET connected, which talked about different ways of using the web for distributing and separation functionality, where REST style SOA is part of it, but also other things like POX. It was a very information rich session, and in the end Jim had to skip several things that I would personally have been interested to find out more about, such as different ways to handle security, and so on. At the end of the day, it was a very good tutorial, but the material was really too much for one half day.

I spent the rest of the day in the office, reconnecting with lots of colleagues. Lovely.

Tuesday I spent running between several tutorials. The morning was mostly in the Advanced Ruby tutorial by Sam Aaron, which was overall very good content. I think I might have ruined it for Sam a bit by sitting there and being annoying. The only thing that could have improved the tutorial would have been some more advanced material in the pieces on functional programming – not that the material Sam was using was bad, it was just a bit more basic than the rest, which made it feel a bit uneven.

In the afternoon, I spent some time in Dan Norths tutorial on BDD. His material is riveting and very useful. In fact, it was so riveting it was hard to find a place to sit, so I ended up not staying the whole time. I then sat down for a while in Joe Armstrongs tutorial on Erlang. Also good stuff, but it was material I already knew. So at the end of the day I went back to Sam Aarons talk on Ruby Aesthetics, which ended up sparkling several really interesting discussions.



QCon San Francisco recap


So, I literally just got back from San Francisco, having attended QCon there. As always, it turned out to be a great event, with fantastic people and a very interesting presentations on the schedule. As it turns out, me and Nick’s tutorial was on the afternoon of the Monday, so after that everything could just get better. … In fact, the tutorial ended up working very well. I was happy to have Nick there, so I didn’t have to do all the talking myself. And Nick is much better at Rails than me anyway. So it was definitely a success.

The morning before out tutorial I spent in the Erlang tutorial, which was fun. Francesco is a very good teacher, and we got through lots of material.

Having finished my stuff the first day, I spent the rest of the week cruising around, relaxing and hanging out with nice people. The Tuesday I ended up in Martin’s, Neal’s and Rebecca’s tutorial on DSLs. I’ve been in this tutorial several times, but it just keeps getting better. Especially Rebecca’s pieces on parsing turned out to be very well polished this time. And of course, they are all great presenters.

The Wednesday keynote with Martin and Rebecca was about architecture, and how agile can help architecture groups with their problems as well as help bridge the gap between developers and architects, that often exist in larger organizations. Very well done.

The rest of the Wednesday I sat in the “Ruby in the Enterprise” track. I found out that Merb 1.0 runs very well on JRuby. Jason Seifer pronounced JRuby the winner among all the existing Ruby implementations, which was nice.

And then I had to run away and do an impromptu JRuby presentation at the nearby Girls In Tech Developer Forum.

At the end of the day, I saw Dean Wampler mix up all the free floating ideas about polyglot programming, and talk about it in something that approached a cohesive whole (which I’ve never been able to do). A well done presentation.

I can’t say I got too much out of Kent’s evening keynote, though. I ended up going out for a quiet dinner instead.

The Thursday began Tim Bray talking about the future of storage mediums. This presentation was too far away from my interests to produce anything stronger than a “meh…”.

After that I have a large gap in the schedule – I was supposed to see some presentations, but ended up hacking on a new language grammar with Kresten instead. Great fun of course.

After lunch I sat in on Brian’s talk on concurrency with the fork-join framework. This one I think I’d already seen, so I ended up working on Ioke during it.

Dennis Byrne gave a very cool talk on DSLs in Erlang. There is some stuff you can do that’s totally unbelievable. Best talk of the day. Possibly of the week.

After Dennis talk I’m not sure what I did actually. No memory. Oh, that’s right, I looked at the JUG panel and then went to the speakers dinner. The JUG panel was among others Rod Johnson, Bob Lee and one of the Seam guys. There were some mention of Rails in a way that meant the persons mentioning it hadn’t actually used it. There was also some static typing bias (especially from Bob who said that static typing was objectively better than dynamic typing).

During the Friday I spent some time in the functional language track (and saw a very nice talk about using Haskell to work with music), and I also saw Eric Evans give a very good talk about Strategic Design.

And that was QCon San Francisco. A very good conference, as usual.



Interviewed by Akita


At QCon SF last week, I had the pleasure of being interviewed by Fabio Akita. It turned out to become an almost 2 hour long interview that touched on many geek subjects, and ended up with some fairly detailed content about Ioke. If you’re interested, and have the energy to hear my opinions about loads of programming languages, you can get it here: http://www.akitaonrails.com/2008/11/22/rails-podcast-brasil-qcon-special-ola-bini-jruby-ioke.



Reverse Cambridge Polish notation for Lisp?


One of the things that still seem unnatural sometimes with Lisp, is the fact that in many cases the actual evaluation need to start quite for into the structure – especially if you’re programming in a heavily functional style. The problem with this is that the way you read code doesn’t go left-to-right. Instead you need to read inside out. To make this less abstract, take a look at this example Lisp code:

(defun foo (x)
  (flux
   (bar
    (conc "foo"
          (get-bar
           (something "afsdfsd")
           (if (= x "foo")
               (conc "foo" "bar")
               (conc "bar" "foo")))))))

As you can see, this is totally bogus code. The nesting makes it possible to identify the parts that will be evaluated first. Compare that to the order it will actually be evaluated. You can see this order by transforming it to Reverse Cambridge Polish notation. This is equivalent – although I know no Lisp that actually does it. As you can see the way you read it, is actually the order it will be evaluated:

(foo (x)
  ((("foo"
     (("afsdfsd" something)
      ((x "foo" =)
       ("foo" "bar" conc)
       ("bar" "foo" conc)
       if)
      get-bar)
     conc)
    bar)
   flux)
  defun)

Well. It’s different, I grant you that. And of course, you need to keep the stack in your head, while reading it. But it’s an interesting experiment.



QCon San Francisco next week


I almost forgot. I’ll be at QCon San Francisco next week. I’m landing late Sunday, and staying around ’til the next Sunday. As usual, I expect QCon to be a blast. Me and Nick Sieger will hold a tutorial on JRuby, which should be fun too.

Hope to see lots of you there!