Last days of JavaOne

The title for this blog entry is actually dual in purpose. I will talk about the two last days of JavaOne, the Thursday and the Friday this week. But one of the big rumors from the news room this year was that it is likely that this JavaOne will be the last one ever. I can’t really comment on that, but this JavaOne did feel a bit less enthusiastic than it used to. Anyway. The last two days were less hectic than the first ones, so this entry won’t be very long.

My first session of the day was Neal Fords talk about design patterns in Groovy and JRuby. I’ve seen this talk before, and it is pretty good – Neal talks about how some of the classic Gang of Four patterns disappear in languages that support more advanced features. So Neal showed some of these. After that he went through some new patterns he has seen in dynamic languages, such as his Type Transmogrification pattern.

After that Tobias Ivarsson talked about how to explot concurrency in dynamic languages. I was a bit surprised to see Scala in this talk, but it did make sense. The content was very good, although Tobias ran out of material quite quickly. It was interesting to see how different the concurrency performance of JRuby and Jython was – but of course this is something the Jython guys easily can fix, once they’re done with the more pressing issue of getting 2.5 compatibility. In fact, they are making rapid progress on this, and this week saw a new release candidate released. Good stuff.

After that Charles and Tom did a talk about scripting Java with JRuby. This was a new version of the classic JRuby talk, and I think it worked really well. Most of the talk concentrated on a larger example instead of looking at small tidbits.

After that me and Charles spent a few hours in the ThoughtWorks Studios, taking a look at how the JIT compiler works with Mingle.

The first and only BOF for the evening was the JSR 292 Cookbook BOF. This session went into some more details on how it works, showed some code that uses MethodHandles and also had Charles talk about his experience with using invoke-dynamic in JRuby.

The Friday started with Gosling’s toy show. Sadly, I missed most of that. My first session was an introduction to the internals of IBM’s Java Virtual Machine. A very interesting presentation that looked at the kind of optimizations their VM does – including showing how the assembly generated will be different depending on how hot the code in question is.

After that Brian Goetz and two other HotSpot engineers talked about the kind of things HotSpot do to make Java code fast. Together, those two talks gave a pretty thorough understanding of how JVMs can be made fast.

This year at JavaOne was pretty good. Lots of fun stuff going on and many interesting sessions.

The Clojure meetup and general geekiness

The Bay Area Clojure user group threw a special JavaOne special, with Rich Hickey as special guest on Wednesday afternoon. I went there and it turned out to be a large collection of former and current ThoughtWorkers there, among all the other Clojure enthusiasts. The model was lightning talks for a while and then general town hall with Rich answering questions. The reality turned out to be a bit different – firstly because people spent quite long on their talks, and people asked many questions and so on. The second problem was that the projector in the place had some serious problems – which basically ended up resulting in everyone projecting pink tinted presentations.

There were several interesting talks. The first one took a look at what the Clojure compiler actually generates. This turned a bit funny when Rich chimed in and basically said “that doesn’t look right” – the presenter had simplified some of what was happening. I don’t envy the presenter in this case, but it all turned into good fun, and I think we all learned a bit about what Clojure does during compilation.

There was a longer talk about something called Swarmli, which was a very small distributed computing network, written in about 300 lines of code. I defocused during that talk since I had to hack some stuff in Ioke.

After that, one of the JetBrains guys showed up the new IntelliJ Clojure plugin. It seems to be quite early days for it still, but there is potential to get good cross language refactoring, joint compilation and other goodies there.

Finally, my colleague Bradford Cross did a very cool talk about some of the work he’s currently doing at a startup. The work seems to be perfectly suited for Clojure, and the code shown was very clear and simple. Very cool stuff, really. ThoughtWorks – actually using Clojure at client projects. Glad to see that.

After that it was time for Rich Hickey. Rich decided to give a lightning talk himself – about chunked sequences. Very cool in concept, but actually one of those ideas that seem very simple and evident after the fact. Chunked sequences really seems to promise even better Clojure performance in many cases – without even requiring changes to client code.

After that there was a general Q&A session, where questions ranged all over the map, from personal to professional. One of the more conentious things said was about Rich’s attitude to testing. This caused lots of discussions later in the evening.

All in all, this was really a great event. We ended up at a nearby bar/restaurant afterwards and had long discussions about programming languages. A great evening.

Second day of JavaOne

The second day of JavaOne ended up being not as draining as the first one, although I had lots of interesting times this day too. I’ve divided it into two blog posts – this is about what happened at JavaOne, and the next one will be about the Clojure meetup.

The first session of the day was Nick Siegers talk about using JRuby in production at Kenai. An interesting talk about some of the things that worked, and some of the things that didn’t work. A surprising number of decisions were given as fiat since they needed to use Sun products for many things.

After that Neal Ford gave a comparison between JRuby and Groovy. I don’t have much to say about this talk except it seemed that some of the things seemed to be a bit more complicated to achieve in Groovy, than in Ruby.

As it turns out, the next talk was my final talk of the day. This was Bob Lee (crazy bob) talking about references and garbage collection on the JVM. A very good talk, and I learned about how the Google Collections MapMaker actually solves some of my Ioke problems. I ended up integrating it during the evening and it works great.

The second day had fewer talks for me – but I still had a very good time and even learned some stuff. Nice.

First days of JavaOne and CommunityOne

I’ve been spending the last few days in San Francisco, attending CommunityOne and JavaOne. We are right now up to the second day of JavaOne, so I felt it would be a good idea to take a look at what’s been going on during the first two days.

I will not talk about the general sessions here since I as a rule avoid going to them. So, I started out CommmunityOne seeing Guilloume talk about what is new in Groovy 1.6. Pretty interesting stuff, and many useful things. Although, one of the things I noted was that many of the default usages of AST transformations actually just make up for the lack of class body code. Things like “@Singleton” that neeeds an AST transformation in Groovy, is a very simple thing to do by executing code in the class body in Ruby.

After that I saw John Rose talk about the Da Vinci machine project. Pretty nice stuff going on there, really. The JVM will really improve with this technology.

Charles Nutter did a reprise of his Beyond Impossible JRuby talk. It’s a really good talk that focuses on the things that you really wouldn’t think possible to do on the JVM, that we’ve had to do to get JRuby working well.

Guido talked about Python 3000 – much of that was really a look at the history of Python, and as such was really interesting. Unfortunately, my jetlag started to get the better of me at that point, so my focus could have been better.

For me, the first day of JavaOne started out with the Script Bowl. This year the languages represented was Jython, Groovy, Clojure, Scala and JRuby. I think they all did a pretty good job of showcasing the languages, although it’s very hard to do that in such a small timeframe. I think I sympathized the most with Rich Hickey (creator of Clojure) – the reason being that the Clojure model is the most dissimilar from the rest of the languages. But this dissimilarity is actually the key to understanding why Clojure is so powerful, so if you don’t understand it, you’re just going to be turned of by Clojure’s weird surface semantics. (Hint: they are not weird, they are necessary and powerful and really cool). Rich did a valiant effort to conveying this by talking a lot about the data structures that is Clojure, but I’m unsure how much of it actually penetrated.

Tom did a great job with the JRuby demos – he had a good flash 3d game running using a JRuby DSL, and then some slides showcasing how much benefit JRuby gets from the Ruby community. Good stuff.

After that I went to Rich’s Clojure talk. I’ve seen him give similar talks several times, but I don’t get tired of seeing this. As usual, Rich did a good job of giving a whirlwind tour of the language.

After lunch I went to the talk by Konstantin about JetBrains MPS. I was curious about MPS since I’ve been spending time with Intentional lately. I came away from the talk with a pretty different view of MPS compared to going in, actually. My initial reaction is that MPS seems to be pretty limited to what you can do with Intentional.

Then it was time to see Yehuda Katz talk about Ruby – this was a great intro to Ruby and I think the audience learned a lot there.

The first evening of JavaOne was really crazy, actually. I ended up first going to Brian Goetz and John Rose’s talk about building a Renaissance VM. This was a bit of an expansion of John’s CommunityOne talk, and gave a good overview of the different pieces we’re looking at in JSR 292, and also other things that should be in the JDK in some way to make a multi-language future possible.

Tobias Ivarsson gave a BOF about language interoperability on the JVM. This ended up being more about the interface injection feature that Tobias has been hacking on. We had some pretty good discussion, and I think we ended up with a feeling that we need to discuss this a bit more – especially if the API should be push or pull based. Good session by Tobias, though.

And then it was finally time for my BOF, called Hacking JRuby. This was actually a pretty mixed things, containing lots of funny small pieces of JRuby knowledge that can be useful if you want to do some weired things with JRuby. The slides can be found here: I think the talk went pretty well, although it was in a late slot so not many people showed up.

The final session of the day was a BOF called JRuby Experiences in the Real World. This ended up being a conversation between about 10-12 people about their JRuby experiences. Very interesting.

After that I was totally beat, and ended up going home and crashing. So that was my first day at JavaOne.

JavaOne 2008, the other half

So, the Thursday got a late start. For some strange reason I didn’t feel motivated to go see the Intel General Session, so I showed up for Nick’s session about JRuby on Rails deployment instead. Nick did a good job of outlining both the problem and the solution, and I have to say that this presentation was a good end cap for the JRuby week at JavaOne.

I had planned to go to some sessions after that, but I ended up hacking on JRuby instead. An interesting parser bug reared its head.

So the next session I went to was the Filthy Rich Clients one. Quite entertaining, although my interest in Swing is not what it used to be.

The final session of the day was the BOF about writing great technology books. This proved highly enjoyable since joining Josh Bloch and Brian Goetz as panelists were Burt Bates and Kathy Sierra. They did a wonderful job talking about how to write books that captures the readers attention and how to correctly use the brains weaknesses against it. I am tempted to say that this was the best session of the whole JavaOne. Brilliant.

On the Friday I was up early and sat in on Goslings Toy Story. Always funny, and some cool things there. For a geek like me, the CERN stuff and jMars was especially cool.

I managed to see quite a lot of sessions during the rest of the day. More Effective Java was useful as always, the Maxine Virtual Machine looks really cool, Neal Ford did an excellent job of comparing JRuby and Groovy, highlighting both the differences and similarities between the two. Finally the Jython session talked about some of the implementation challenges we in the JRuby team have wrestled with too, implementing a highly dynamic language on top of the JVM.

All in all, this JavaOne definitely stood out as the first non-Java-language JavaOne for me. And I didn’t even attend a single one of the gazillions of JavaFX presentations. It was a good year in general, and specifically for dynamic languages.

Oh, and my book is the 5th bestseller in the conference bookstore. Yay!

JavaOne halfway point

To say that I am seriously tired of JavaFX at this point, would be a gross understatement. So let’s not even go there.

CommunityOne was a nice event. I like the feeling of it more and more, and the new open spaces approach seemed to be really successful. The alternative languages presentations were well attended and good. I recommend anyone in the Bay Area, or anyone attending JavaOne, to make the effort to go to CommunityOne next year. It’s definitely worth it.

Tuesday was, for undisclosed reasons, a day where I didn’t attend so many presentations. In fact, I missed both the keynote and Tom&Charlies JRuby talk. Bad on me. I did manage to go to both the technical session and the BOF about upcoming language features in Java 7. Let me say immediately that I don’t want pluggable type systems as a part of Java. Yes, they are useful in certain settings, but they don’t fit Java. Not at all. I’m all for having it possible to have annotations in more places, but not for type systems.

Wednesday was “my” day of the conference. Started out early with the Script Bowl, where Groovy, JRuby, Jython and Scala faced off in three different challenges. I was one of the three judges. It was a actually a great fun. Some people have gotten annoyed at it, but I feel that they are taking it too seriously. This format was a good way of introducing the audience to the capabilities of four languages that are sometimes very much alike and sometimes very different.

It’s also interesting to note that Charles was the only one of the panel who solved his challenges by asking the community for help with it. In fact, Charles didn’t do any of them himself, while the other three did their code in isolation. My opinion is that this shows a difference in attitude between the communities, and it’s very interesting.

After that I took it easy for some time, and then it was time for my JRuby on Rails presentation. It went fairly well and was also well attended. I did a serious mistake in my database configuration, but Tom helped me out and the rest of the demonstrations was good.

I did a book signing session after that and then headed back to the office for a while before coming back and holding my JRuby at ThoughtWorks BOF which was also nice.

Today I’m going to take it easy and relax. I’ll go to Nick’s session in an hour and then I’ll go to Josh and Brian’s BOF tonight. After that we host a party which I’m going to attend for a while. It’s going to be a nice day.

Denmark, QCon and JavaOne

Today is my last day in Sweden for a while. It’s been an incredible time, and I think that my coworkers from ThoughtWorks have had a wonderful experience in Sweden. What will happen regarding a Swedish office is still up in the air, but I’m cautiously optimistic about it all. In fact, if someone knows a possible client please get in touch. =)

Next week I’m going to Denmark, visiting the castle Hindsgavl where the Danish Java User Group (JavaGruppen) is holding a conference. I will do one presentation on JRuby and one tutorial on JRuby on Rails.

The next planned event will be QCon in London where I will present about some of the more exciting upcoming features in the JVM. That’s going to be great fun.

The last week in February I’ll be in San Francisco, possibly helping out with some really cool ThoughtWorks events. I’ll post more about that when I have the information.

I will also present at Developer Summit in April, in Stockholm.

Finally, expect me to do one presentation and one BoF at JavaOne. I might also do a talk at CommunityOne.

It’s going to be a busy spring time.

That gender thing

One of the foci on both JavaOne and RailsConf was the so called “gender problem”; that the current balance between men and women in the technological field is bad and that something needs to be done about it. I’m very happy about this getting awareness, but as my colleague Lars Westergren writes here ( it seems like total hypocrisy when looking at the so called entertainment provided at these two events. We need to do better than this.

JavaOne day 4: the final friday

So, the day started out quite late (since I was way tired after last night…). First session was a very accomplished, though slightly shallow, comparison between doing an application with Java EE 5, Ruby on Rails and Grails. I didn’t really learn anything new in this presentation except that Java EE 5 is even slicker with NetBeans, and that Grails is maddeningly, sickeningly, seriously slow when doing simple stuff like creating scaffolds. I can’t understand why this is so, since it isn’t much do it. Basically just create a file with a few rows of customization.

After that I paired up with Jon to look at Mingle again. Oh boy, the ones who is coming to RailsConf will get a treat, that’s for sure.

The Jython session by Otmar Humbel was really good, and had a great example. Basically the whole demo sessions were done in one single application which he started at the beginning and never stopped. He just hotswapped the Jython code dynamically. Very nice. I think the most interesting part of that talk was in the Q&A when someone asked why you should use Jython instead of Groovy or JRuby. I’m sad to say that I had to literally run at that point, so I didn’t hear the answer… But still, if someone was there and heard, please tell me. For me personally, it’s very impressive that Jython got started in 97, and actually is still alive (due to a recent revival of course, but even so. I’m glad Charles gave up one of his talks to let the Jython guys in). It was also interesting to see the differences in philosophy between JRuby and Jython in terms of Java integration and things like that. Very good stuff.

The bytecode manipulation talk was interesting; it was nice to see what (and how) Terracotta does with ASM. The TopLink parts were nice, but really way to basic to be interesting. Charles stuff was good, of course. We know Charlie always does good things, don’t we? =)

I had great fun at the Java Puzzlers this year. I’m happy about there not being many puzzles incorporating generics, because those are usually boring. The main problem that these guys always exploits, seems to be mostly in the boundary between Java Objects and primitives, and interactions between primitives. That’s what you get when you try to create a language meant for both system development and application development. It just shows in all the seams. A good language should not have seams, unless they’re necessary for the specific domain of that language.

Finally, Rob Harrops talk about exploiting JRuby to create DSL’s was really good. It was great, and Rob is a very accomplished presenter. I had great fun. That said, I think that some of the stuff still went over the head of most Java developers in the audience.

And that seems to be the theme. Most things I enjoy, I think most other people didn’t enjoy. Interesting, that.

So, now it’s off for dinner at the Stinking Rose with the JRuby guys, Dion, Barry Burd and Jon.

JavaOne day 3

The third day of the conference started slow, due to my being dead tired from the day before. But I still managed to get to Charles and Tom’s JRuby on Rails presentation. Obviously, this was a very good presentation and JRuby is very important. But you know all that, already, don’t you?

I then went on to a session giving a technical overview over GlassFish v2. Now, this seemed interesting, but wasn’t really so. There was some nice information about how clustering should be setup so you don’t lose to much data if you have more than one instance on the same machine, but other than that… Nah.

After lunch, I went to the Advanced Groovy talk, expecting to see cool overridings of the MetaObjectProtocol, or how to implement your own AST shufflers. But no. What we instead got was some tidbits here and there, and explanation of how to add new methods to existing Java objects (and this is really gross, you have to wrap the usage of these methods in a block, and the methods are defined on a new class as static methods…) Anyway, on to the demos. I got a real feeling of Deja Vu, since I had seen this exact same demo last year… XMLRPC communication between two Groovy instances, then ActiveX usage of Excel, combining it with Swing. So, yeah. As someone else said “It’s a really great Excel demo, but what has that got to do with Groovy?”.

Next, I took it easy for a while, walked around and did some programming. Finally, it was time for Tor’s and Martin’s talk about Ruby Tooling in NetBeans. And boy, it was an outstanding talk if you’re interested in compilers, type inference, the challenges of dynamic languages and other stuff like that. I loved it, but I think most of it went over the head of most people in the audience.

Then I was of to the Sun Certified Professionals party which is always nice. I met some cool people and Lars won good swag by being smart really fast. Good for him!

The After Dark bash was quite allright, but nothing extraordinary. And it got really tasteless when the showgirl in metal corselet came onto stage with a grinder, which she turned on herself, making sparks fly all over the place.

After that, we went to the JRubME talk, about JRuby on Symbian and Java ME. A great talk and a great project. In fact, it’s really really cool, and if you’re interested in ME, you should download the source and start hacking a way on it! The project needs contributors.

We went back to the After Dark bash finally, took some more beer, and then decided to move on. The quest was for Aquavit, and someone thought that the Starlight Room would be a good place for this, so we headed there just to find out they didn’t have either Aquavit nor any good scotch. Oh well, it was fun anyway, and the view was fantastic. Characteristically, me, Tom and Charles got into a real interesting discussion about the subjectivity of self presentation, and representation of knowledge in terms of probabilities and deltas from ideal knowledge, and how this applies to onthologies. Neat stuff. But maybe the dance floor wasn’t the best place to have this loud discussion…

After that we settled down and decided it would be fun to have a JRuby summit in Minnesota! So, we’ll see if that is possible… Then I crawled home to my hotel. My feet are killing me today, but there are some really interesting presentations, so I’ve gotta go.