C2B2 logo icon

JAXLondon 2013 Impressions

This was my third year in a row speaking at JAXLondon. As the conference is in London my diary normally fills up with meetings during the conference and I have to dive in and out for my talk and miss most of the sessions. This year however I managed to spend Tuesday afternoon and all day Wednesday at the conference so I thought I'd give you my impressions of some of the sessions I saw.

JAXLondon is a great relaxed conference with plenty of opportunities to talk with speakers over coffee, food or even beer. My only criticism is that most of the talks tend to be by vendors or open source project leads demoing technologies whereas it would be nice to see more "real world" talks like;

"We did this with this technology and this worked and this sucked."






Java EE 7 Platform: Boosting Productivity and Embracing HTML5 - Arun Gupta (Red Hat)

This was the first session I attended on Tuesday afternoon and it was a great whizz through all the new features of JEE7. The main points to take away were;


The key focus for JEE7 is HTML5, WebSockets, Developer productivity with POJOs and meeting enterprise demands with new apis. With the coolest new features being;
1) Websocket support
2) Batch processing
3) JSON support
4) Concurrency utilities with the correct JEE contexts for security, classloading etc.
5) JMS 2.0
6) Transactional annotations for POJOs (EJBs without EJBs)
7) JAX-RS 2.0
8) Default Resources
9) More annotated POJOS
10) Faces flow
JEE7 is now an extremely powerful framework for rapidly building modern applications wthout having to incorporate and manage loads of boiler plate libraries into your war files. Also nowadays there's no XML in sight. Couple with NetBuilder programming in JEE7 is a joy.
Arun is always a great speaker and RedHat have acquired themselves a great advocate for JEE. Checkout Arun's collection of JEE7 samples at  http://github.com/arun-gupta/javaee7-samples. Arun has also been filing bugs against WildFly when he can[t get these samples working which will hopefully improve the quality of WildFly.



From Java Code to Java Heap: Understanding the Memory Usage of Your App - Chris Bailey (IBM)

This was an interesting talk which I was surprised to see on the agenda as it didn't seem "sexy" enough for a conference. It was a great back to basics talk about poor practice in the heap usage of minimally filled Java collections and Java strings. Chris demonstrated how to use MAT to work out how much memory you are wasting in your applications and presented some results for an application with nearly 50% wasted heap just due to poor programming practices.


JVM Support for Multitenant Applications - Steve Poole (IBM)

Another IBM talk this time from Steve Poole, obviously a guy that knows a lot about JVMs. The talk was poorly attended I thought given that there is a fair bit of hype about multitenancy. In traditional IBM fashion the demo was a bit more screencast than real demo but there's some interesting technology here. Essentially a multi-tenant JVM is a JVM that can host multiple application with each application thinking it has got the JVM to itself. Essentially virtualisation for the JVM. So virtual JVMs on real JVMs potentially on VM hypervisors, as if your head didn't hurt enough already. 


We have some experience with multi-tenancy through working with Waratek although I think the multitenancy space is only really of much interest to large scale Java hosting providers such as PAAS providers where there are some real economies of scale.



Past, Present and Future of Data Processing in Apache Hadoop - Chris Harris (Horton Works)

Chris and I go back a few years since his days at Red Hat so it was good to catch up with him and catch up with the direction Hadoop is taking. C2B2 have some experience working with Hadoop and it's an area we track closely, even if we don't market our capabilities too strongly yet. Chris gave a great summary of what's arrived in the new Hadoop 2.0 GA release. 


The key point to take away for me is that Hadoop 2.0 essentially builds a whole pile of middleware on top of HDFS that supports other processing models over and above standard map reduce jobs. The introduction of YARN as "Yet Another Resource Negotiator" now enables more interactive workloads to enable the move away from pure batch applications. This is a very interesting development as it further blurs the line between in-memory data grids and Big Data stores like Hadoop. With YARN we now have application containers (JVMs) managed by node managers on each storage node. With Hadoop 2.0 we essentially now have a big middleware infrastructure to manage.



Perhaps it's time for C2B2 to classify Hadoop as middleware!



Run Your Java Code on Cloud Foundry - Andy Piper (Pivotal)

Andy did a slick demonstration of Cloud Foundry, the Pivotal PAAS environment. I have to admit PAAS environments at this stage in their development leave me a little cold. There's a lot of demos pushing trivial web applications into the cloud that use a simple database. It is slick and fast but not rocket science and I always have the sneaking suspicion that life just isn't that simple in complex applications with complex dependencies between multiple components.


Streams and Things - Darach Ennis (Ubiquiti Networks)

Darach's a clever guy and he can talk! This was a whizz bang keynote to demonstrate the "Internet of Things". Darach demonstrated flying a quadcopter via his Mac, possibly using Scratch (but that wasn't clear) it was good whizz bang entertainment. Not sure I learnt anything but good fun after lunch.


Vert.x 2 - Tim Fox (RedHat)

We have some customers running Vert.x in production and it's a neat framework. The talk actually was again pretty thinly attended which I was surprised about giving the attention Vert.x has had in the press. Tim showed some neat demos of Vert.x and emphasised that it's a light-weight asynch programming platform which can be implemented in many languages. We are also hoping to get Tim to present Vert.x for us at JBUG. Tim's always a very knowledgeable presenter and he gave a great over view of Vert.x. From my point of view I'm still trying to understand where to position Vert.x architecturally with customers. Essentially vert.x is a lightweight non-persistent event bus where little pieces of processing (verticles), written in many languages, execute in response to events received on topics they subscribe to. Vert.x also provides a lightweight http server and the event bus can be extended to web browsers over websockets. Neat but revolutionary?