JavaOne 2016 - Day 3

Now I’m starting to reach the phase where I’ve discussed shortly of most things that I’ve seen. I try to avoid being too much repetitive, and add some impressions from Tuesday and Wednesday here at JavaOne San Francisco.

San Francisco

On programming language popularity based on sessions, I made a quick study: Over 400 sessions, most of them on Java. On Scala, there’s 28 sessions. On Groovy, there’s 12. Kotlin is presented in 6 sessions (Clojure got 2 sessions, but this is not really a Clojure conference). There’s a lot of sessions on Angular 2, Node, (about ten each) and JavaScript in general - so front-end is getting more attention even here.

On Microservices, there’s 52 sessions. Docker is mentioned in 23. Perhaps notable is also what’s missing. There’s not much on Android, which is understandable based on current rift between Oracle and Google. There was presentations on the Gluon app, which is much better than the official JavaOne app. Ironically in a conference where core topics are robustness, monitoring, high availability, testing, and quality, the official app keeps on crashing, losing sessions, hangs for no particular reasons. It feels more like it’s a badly written school exercise. The Gluon app is much much better. Sadly it doesn’t synchronize your sessions, but everything else it does suberb.


So here’s wish list for the next version of Oracle JavaOne conference app:

  • Robust: There’s only 50 000 attendees and only one set of details is needed at once, so this should be child’s play. Apply some fail safety and test the application for network on/network off situations that happen here.
  • Better real time information on session availability, so when your plans change, you can always find something to see. Go more real time and feed the attendees with digested, simple to consume data. Apply some data sciences please!
  • Build the badge and tickets in it, so if people forget the papery thingies in the neck, they can still access anything
  • Open source it so others can bask in the awesomeness and apply the goodness
  • Or just let Gluon do the next one

Big players

When I started learning Java, there were some big players on the field that were all enjoying the standards and competing on the products. There was SUN Microsystems, of course, then BEA, Oracle, IBM, SAP, etc. Now not many of these remain, but it seems IBM has made a strong comeback. They are embracing the new Micro profile, which comes from community. Their sessions this year are developer oriented, easy to approach, and it seems, packed. And, I have to say I like Websphere Liberty, I’ve done projects with it, and it has potential to follow the upcoming EE standards. It’s quick and modular, and can be configured easily from the command line.

IBM’s microservices text adventure game has been successful in attracting developers and buzz. It has got developers to sign on to BlueMix for 30 days trial, and the offerings there are impressive. I even saw one Watson bot analyzing my tweets for a personality profile based on tone of my messages ;)

RedHat also made very strong presence, and they also support Microprofile. They actually had a booth across IBM, and had a shared competition to collect some stamps, so you’d get a hoodie. RedHat JBOSS and WildFly are of course well known items already, so I asked what’s new there. As a response, I got two books, that I actually intend to read. And since these days I don’t read much books that’s a lot to say. ;) Openshift + Microprofile = nice PAAS for innovating rapidly, it seems. Of course, I’m also very interested in WilfFly Swarm + Microprofile technologies. Code base for WildFly has been pretty robust and highly modular, so it’s been one of my favorite servers - when you don’t go all embedded.

Java EE 8 and JAX-RS

So I already mentioned the future plans for Java EE 8 and 9. One part of that is JAX-RS 2.1, plans for which remain stable and unchanged. It will still remain on Jersey reference implementation, with some new twists.

Already in JAX-RS 2.0, there was capability for asynchronous calls, using InvocationCallback API, but it was pretty verbose and complex. So there’s now plans to do just that, with better support of Java SE 8 structures, like CompletableFuture. There’s also something called Declarative Reactive Code, or server-sent events, for simplicity and pipelining.

Now async/reactive is not non-blocking, it’s just running in another thread. So another new item in JAX-RS is non-blocking I/O, which you can combine with async. This is still work in progress, and will cause pressure to change MessageBodyReader/MessageBodyWriter APIs.

Finally there’s the upcoming server-sent events model, with a special media type “text/event-stream”. This is part of HTML 5, a W3 standard. So it’s built on top of basic HTTP protocol, server is pumping tiny events with tiny bits of data back, similar to WebSockets model. Currently the main interface is SseEventOutput, which can be used to send data packets. Note that unlike WebSockets, SSE is unidirectional. After opening the channel, server pumps on events, but channel is only going one way. There are benefits to them as well, such as simpler requirements, and support for reconnecting etc. In many cases these make the SSE the right choice over WebSockets, but not all.

JSON-B will be integrated, with official support for application/json data types. There is a lot of configurable binding properties, so while you could earlier get these with 3rd party libraries, now this is integrated on specification/reference implementation side. Finally, OAuth and OpenID Connect support is going to be added, for better declarative security options. Oh, and of course there will be Circuit Breakers. :)

Moar Microservices

I had the pleasure of attending few more good microservices sessions on Tuesday. The one I had been looking forward to was Live-Coding No-Ceremony Microservices. It was delivered by Adam Bien, and he has many ideas on keeping things simple, basic, and pure, that I appreciate. I’ve been dabbling and studying microservices a lot, but everything I’ve done so far is still far from perfect, so new ideas are much welcome, especially ones that don’t include integrating 12 frameworks and extra steps to get something done.

I wasn’t disappointed: Adam showed simple and cool microservices examples with Docker, Payara images, and pure Java EE standards such as JAX-RS, CDI. One takeaway from this is that on longer run, microservices without docker are simply madness. Another point being, that upcoming Micro Profile shows a lot of promise: A lot can be done already with just Java EE 7 - and Java EE 8 and 9 will bring more power and simplicity for Microservices. Circuit breaker? Use interceptor, and few lines of code. Clustering? Use Docker Swarm + HAProxy. This is a simple option for getting started, and much better than what most are using anyway.

Speaking of more heavyweight solutions, I was one minute late of another cool microservices session with Kubernetes, so I’ll have to hunt down the presentation later. As with most years, the arrangements are pretty bad here, sessions being in multiple locations, and scheduling system having no flexibility for changes whatsoever, and with the mobile application not working at all. If you happen to miss your primary, registered session, you pretty much cannot attend anything else in place for it. One thing that is working, is the live feeds, so some sessions can be watched remotely, and this is working surprisingly well, so big thumbs-up there. Also, many of the cool presentations will be available in YouTube, so if you can find some time to sift through them, you can get up to date just by watching some of them.

I attended a session on Microservices for Mortals (Even though I’m not sure I apply to the target demography). It was a refreshing presentation, because it started from less-hype-filled view of what microservices are, using lyrics from Metallica song. Spoiler: The light at the end of the tunnel might be the freight train. Beef of the talk: Many monoliths are actually okay applications. The ones that are not, could be broken to microservices, but the road will not be easy. Many of the challenges were discussed. So unlike many other presentations, that were on the hype or product sales side, this was concentrating on the difficulties and how to overcome them. I highly recommend watching this session, it should be shortly available in Youtube.

Microservices for mortals

Today is going to be a fun day. After microservices, I’ll be getting some insights into Spock testing framework (<3 automated testing!). Some streams, and a lot of hands-on time with Kubernetes. So I’ll be a happy puppy today. I am planning to also go visit Docker headquarters today for some Java and Docker goodness.


Tomorrow I’ll be leaving quite early, so I can only attend the final Keynote session, in the morning. I don’t think my brain could absorb much more. There will be no day 4 report since I’ll be traveling and losing a lot of hours, then suffering from a major case of jet lag. After some reflection I’ll be back with one final, executive summary on the conference, so stay tuned.

Updated Java EE 8 slides

Server-sent events vs Websockets

Java in Flames (Netflix tech blog)

JavaOne Monday Highlights

Sonic pi - Live coding music synth

Adam Biens microservices building blocks goodness

Almost unrelated picture of robots!!!