Open Conferences, sometimes called Un-conferences, are where there is no set schedule, other than perhaps, as here, a key-note to start. It's left to the participants to organise the presentations and workshops. This is what makes it cheap, but you get what you pay for.
The Conference Key-note: 20 Years of Java
Starting off with the key note by Simon Ritter and Steve Elliot, both former employees of Sun Micro-Systems (Steve still works for Oracle, Simon does not). This covered Java since it's launch in 1995, showing how the language has evolved from the 200 odd classes in version 1 to the 4000+ in the latest version, 8. They commented that this bloated situation would improve with the introduction of "Jigsaw", the modularisation of the JDK.
Performance by the Numbers with Simon Maple
The first presentation I attended concerned a survey conducted by Simon and his company to see how much performance testing was done by the profession and what effect it had. Unsurprisingly, few tested regularly and most tested in reaction to performance bottlenecks when they were found in production. Most performance bugs were connected to databases as much, if not slightly more, than the applications themselves: JPA and Hibernate being the worse culprits in this regard. The lesson here being performance test early, often and with the right tools.
Microservices in the Real World with Chris Batey
Given the popularity at the moment, and linked, to some extent, with the previous talk, Chris took us through his experiences with microservices, especially dealing with outages and his efforts to make the applications more robust (he recommended Netfix's Hysterix). His slides of the talk can be found here.
Lightning Talks and Lunch
Both before and after lunch there were lightning talks, five minutes where anyone could talk about almost anything. One involved the use of Microsoft's Kinetix to create ghostly 3D images, like a cut-price 3D scanner. Another mentioned a book called "Godel, Escher, Bach: An Eternal Golden Braid" by Douglas Hofstadter, with a view to writing every algorithm that ever could be written.
JDK8 Lambdas and Streams: Beyond the Basics with Simon Ritter
The first proper presentation after lunch was regarding the new features of JDK 8. Simon gave us a few examples of how he has changed his style of programming from the procedural style to the new functional style using lambdas and, especially, streams. In particular, he showed how using the Supplier interface could allow lazy evaluation, something normally only available in interpreted or functional languages such Scala, and how to design and use accumulators for use with Streams.
IoT 4 Java with Carl Jokl
Having been to the presentation earlier in the week on the BBC micro:bit, I was interested to see what the LJC was doing about this. Unfortunately, it's all at the very early stages at the moment and Carl didn't have much to show other than a few concepts: it would have been nice to see some actual things.
Generics: Past, Present and Future with Richard Warburton
Lastly, Richard gave a short presentation on the use of Generics and how they might evolve with future versions. Generics are Java's way of implementing meta-classes, classes built around other classes, Collections being a usual example. Java 7 introduced intersection types to generics, which can make things even more confusing, so you get code like this:
private static <I extends DataInput & Closeable> PersonWithGenerics read(I source)
Allowing any object that implements both DataInput and Closable in it's hierarchy of classes and interfaces to be used. It's a bit like a multiple inheritance workaround.
Richard also showed us was an actual use of the "super" keyword in Generics, something you don't often get. I won't go into it here, as it was somewhat involved, but he put the code for the session on Github.
He also mentioned some ideas for future versions, including Generics for primitive types (not just the objects of types, as at the moment).
Conclusion
Was it worth the £25? Yes, I think so, and 200 other people thought so too. The presentations were of reasonable quality, what I saw, and better than you would expect. Perhaps because it's less contrived than a more expensive conference.
An impression I did get was that Java is starting to be very retrospective: the key-note said nothing about the future, only the past, and it's new features added with JDK 8 are struggling to be accepted. A concern I have with our profession, and Java in particular, is this conservatism and resistance to change.
