My purpose for attending was largely to present the Hardcore Concurrency for Beginners talk that Mike and I debuted at an LJC event a few weeks back. Almost as important was catching up with the aforementioned LJCers and meeting with as many people as would talk to me. After the disappointment of the sessions at Java One, sitting in a room being talked at was quite low down on my list of priorities. Sometimes it's nice to be wrong.
The sessions at JAX were of a very high standard, and I learnt something from every one. I was pleasantly surprised by the calibre of international speakers that were there, and the sessions seemed to be pitched right for me personally, which was nice.
- I'm going to cover these first because I like to end on a high note. Firstly, although I was interested in the Open JDK session at the community night, it was really on way too late (and after too much beer - i.e. more than none) to get the most out of it.
- It's a bit of a shame that our session was the last presentation on the final day, by that time people's brains are fried and we didn't get as many questions, or as much interaction, as we usually would. Maybe that's because everyone understood and agreed with us. But we did get great feedback so I could be scraping the barrel for things to complain about.
The following sections outline the main takeaway points for me.
Software Craftsmanship / Design
Sandro did a great job emphasising that Software Craftsmanship is about professionalism, not beauty. We should be doing the right thing because we want to, because it makes everyone's lives easier in the long run, and because it is the right thing to do, not because some process dictates that we do it. The other thing that really struck me was how having a craftsman's mindset leads to us taking ownership of our career and investing in it. He also challenged us to stop being miserable and negative. If we're happy, we'll attract more (presumably happy) people into our circle.
Jason Gorman's Slow and Dirty presentation showed that ignoring quality slows down delivery not just in the long run, in terms of maintainability, but also in the short run - a TDD exercise of approximately 30 minutes took less time to get right when done in a test driven fashion, despite that fact that we all still think writing tests takes too much time. He pointed out that Twitter and Facebook are statistical aberrations - not every startup can afford to assume they will be bought out of their scalability problems. There was lots of interesting stuff here about quality, which was pretty inspiring at the time but in retrospect, as a team that already does Test Driven Development almost to the extreme, I wonder what's next for us to improve our quality even further.
Simon Ritter's keynote stated that code should be a joy to read, not simply easy to read, and Adam Bien's presentation talking about simplifying code: thinking about design, and not getting bogged down in unnecessary design patterns in order to implement something simple.
Concurrency / Parallelism / Performance
Russel Winder's session around message passing had me thinking. It was particularly interesting to see him say things that are possibly the opposite of what we (the LMAX/Disruptor types) are preaching. For example, that programmers shouldn't care about the low-level details; that we should be using models (i.e. abstraction) to deal with parallelism; that you should let the JVM deal with thread management. However, I think he's fundamentally coming from the same place as us: "concurrency" in the past was not a good model, it was designed for old hardware that was trying to run multiple processes on a single core. With multi-core systems you need to be running code in parallel instead.
Dan Hardiker's performance testing presentation was another one that reinforced that testing first, finding what the real performance is, profiling and then targeted experimentation are all fundamental to getting good performance. There was a lot of good advice to how to write good performance tests too.
Another point from Simon Ritter's keynote reiterated that the performance free lunch was over, and we need to get better at writing parallel code.
Both the Open JDK session and Ben and Martijn's "Spring cleaning your code base with Java 7" had me attempting to do things with my mac I never intended to do (i.e. write code). Thanks to Ben and Martijn's patience, I finally got IntelliJ playing nicely on the mac with Java 7, which was a challenge but I'm pretty pleased I've achieved it. The Open JDK one was not as successful for me personally, but I got a good feel for the process of building it (i.e. it's hard and it takes a very long time).
Other great stuff:
- The keynote by James Governor from Redmonk was really thought-provoking. So thought-provoking I wrote no notes and can't remember any of it.
- As last time, the Community night was really great. I met new people and I hung out with some old favourites. Dear God I must stop drinking with those guys. Hotel bars are particularly awful for losing track of time.
- I heard about the Java 7+ features enough times from various people to be able to give an overview of the release plan to my geek friends in the pub on Friday (hey, they asked).
- I learnt how to use twitter to bridge that gap between me and other attendees, and made new friends without having to do the scary thing of approaching strangers.
- The lunches we rather good.
- Going to a conference 20 minutes from home is a bonus. Nice to meet other London devs as well as the European ones too.
- To me, it seems as if the relevance of the JCP is starting to seep out into the real(er) world.
- The tables for laptops at the front of the rooms was an awesome idea. For a start, it encouraged people to get into the room early to get one of those seats.
I had a great time at the conference, I learnt stuff and met people, which is all I really want.
For once, the photos aren't mine. Images courtesy of JAX London.