tl;dr I attended Javaone again this year. It was fun.
The conference kicked off on Sunday, with user group sessions and the main keynote. I was actually unable to attend those, since I was running a Java University training session on the new features in Java SE 7 & 8. This covered project coin, NIO 2 and Fork/Join framework from Java 7. Most of the Java 8 content was lambdas related, including covering the basics of the streams framework. I also covered the new date and time library defined by JSR-310.
It was interesting to get feedback from the attendees on the covered topics as well. I was surprised that several people were using the existing NIO classes and were interested in the upgrade to Java 7 for that feature alone. The attendees of the class were quite a diverse group of people – several Java Web/EE developers but a few people doing more esoteric things including a couple of bioinformatics researchers and a heavy hadoop user. The lambdas-related material was a little bit more challenging for people since it required them to adjust to a somewhat functional programming paradigm. Other the course of the afternoon I think we managed to get everyone onboard.
After the training I attended a couple of the user group sessions and an open meeting of the JCP. This was pretty well attended with a lot of fairly frank questions and answers. Its good to see that a lot of the JCP EC members were recommending that people contribute via adopt-a-jsr, which is the program that enables Java User Groups to contribute to the development and progress of Java standards. We’ve been running a lot of these sessions from London and found them to be very effective.
On Monday I delivered my talk on CPU Cache Optimisation. This is a reasonably niche topic but I think its a good idea to expose the concepts and issues to a wider audience. I’ve given this talk a couple of times before: at DevoxxUK and Geecon but this was the best attended version of the talk with about 200 attendees. It seemed to go well and I had several people come up to me afterwards and ask about how they could apply the techniques to their code which was good.
I also attended the Garbage-First Collector: Current and Future Adaptability and Ergonomics—Manual Tuning afterwards which was a joint session run by Charlie Hunt, Monica Beckwith and John Cuthbertson. This had some great technical content but I always find my brain is really fried once I’ve given my own talk. If I’m being overly critical I’d also say that the transitions between speakers didn’t feel that smooth.
In the evening I attended the JCP Party, where Gil Tene deservedly won the member of the year award.
Tuesday kicked off with a couple of great technical talks. Brian Goetz prsented Lambda: A Peek Under the Hood which was a brief explanation around the implementation and design of the compilation strategy for lambda expressions. The big win here is that they’ve abstracted away the strategy in order to allow different approaches to be chosen in a later JDK version without people needing to change their code.
I followed this up with Building a Quorum on the Usability of Programming Languages which was actually a summary of academic research around measuring the usability of different programming language features and syntaxes. Its good to see people doing this kind of research – when I was doing my PhD so many CS academics would act entirely unscientifically when it came to understanding programming language usability. In fact in discussion with the speaker afterwards he pointed out that he was mostly through analysing the publication output of the International Conference on Functional Programming and was yet to find a single scientific study that had been done. Having read the proceedings of this conference before I can annecdotally attest that its primarily a conference on applied category theory.
I was part of the Where Next with OpenJDK Community Build and Test? panel on Wednesday morning talking about the collaboration that we’ve been running with a couple of companies that helps to get Java developers more involved in its SE reference implementation: Openjdk. As is usually the case with panel sessions people were a little shy in asking questions, so we had some preprepared questions to ask ourselves. Unfortunately a couple of the panel members were unable to make the event due to last minute commitments and I was a little bit late due to the high quality of the Zero Turnaround Party! Massive credit goes to Steve Poole and Daniel Bryant for being troopers and making sure the session still went smoothly.
I covered a couple of sessions on project sumatra: Wholly Graal: Accelerating GPU Offload for Java and the Project Sumatra BoF. The goal of the project is to be able to automatically offload certain Java operations to the GPU. They are basically targetting a few parallel operations from the Java stream library. It was pretty clear from these sessions that whilst Sumatra is an interesting project its currently in a fairly nascent stage of development. For example how to interaction with the GC is listed as an open design question for them.
I continued the theme of looking at openjdk related talks with OpenJDK Porting Experiences: The Good, the Bad, and the Downright Ugly which described the progress being made in the port of openjdk to powerpc which is an effort mainly undertaken by SAP in collaboration with IBM. Great to see more people outside of Oracle working on openjdk. The performance numbers they showed on several benchmarks showed the performance to be competitive with the J9 powerpc version – an impressive achievement for the SAP team.
Permgen removal is a big topic at the moment with quite a lot of discussion about the move to metaspace, so I attended the Permgen removal talk by Coleen Phillmore. This was a really good in depth talk on the topic. I’ve already taken a look at Java 8 GC Logs so I was aware there would be Metaspace entries but I certainly felt that my understanding of the differences between permgen and metaspace improved significantly. I also really appreciated the style of presentation which was informative and engaging.
The conference began to wind down on Thursday, but there were still a couple of good sessions going on. Advanced JVM Tuning covered a few of the common tuning techniques used in the JVM. Even though the title specified JVM tuning the majority of the talk was about Garbage Collection. There was good content covering the ideas of what could be tuned and why you might want to, but I did begin to worry about the number of people taking photographs of slides with lists of tuning parameters on. We’ve found this a couple of times on the friends of jClarity mailing list that some people have a misconception that there are some “magic” JVM tuning parameters which make things faster, rather than using tuning to adapt the hotspot’s already good GC algorithms to the particular scenario of your program. The presenter of the talk was clearly an expert who wouldn’t make this mistake, but I did feel that he didn’t stress the point that his listed tuning parameters were simply examples of how to apply techniques rather than the “magic” numbers.
I also attended Reactive Programming Patterns with Java 8 Futures which was an introductory talk on the CompletableFuture interface in Java 8 which also covered some patterns of how you might use it in order to do asynchronous programming. There was a surprising amount of emphasis on the idea that you get better cache locality using asynchronous programming with the speaker repeatedly referring to “cache corruption” by which I presume he meant poor locality of reference. There was also empirical evidence provided to substantiate claims about scalability or performance. The talk itself was well presented but alongside the large group of very good highly technical talks at javaone I felt slightly disappointed.
If you ever get an opportunity to attend or talk at Javaone I’d highly recommend going. It doesn’t have the community oriented feel of some conference I’ve attended like Geecon or DevoxxUK, but no where else has its breadth or depth of talks. The other thing that I haven’t mentioned is the number of parties at Javaone – I managed to attend the Glassfish Party, The JCP awards ceremony, Zero Turnaround Party and Google JUG Leaders events – if you’re attending a conference events like these all offer a great combination of alcohol and really interesting discussions with people. I also promised that I would say Konrad is awesome on my blog, so “Konrad is awesome”.
Bulletproof Java Code: A Practical Strategy for Developing Functional, Reliable, and Secure Java Code
Use Java? If you do, you know that Java software can be used to drive application logic of Web services or Web applications. Perhaps you use it for desktop applications? Or, embedded devices? Whatever your use of Java code, functional errors are the enemy!
To combat this enemy, your team might already perform functional testing. Even so, you're taking significant risks if you have not yet implemented a comprehensive team-wide quality management strategy. Such a strategy alleviates reliability, security, and performance problems to ensure that your code is free of functionality errors.Read this article to learn about this simple four-step strategy that is proven to make Java code more reliable, more secure, and easier to maintain.