Day 1 of JavaOne 2016 was packed with great content. I started it with an early 2-hour tutorial session focused on microservices.

Session 1: Introduction to microservices in Java

Jason Swartz gave the first session of the day. Although categorized as a tutorial, the session turn out to be in a pretty standard slide-based format with basically no hands-on work. Having said that, the talk was very enjoyable, despite the fact that it was supposed to be introductory, and I’ve been in the microservices world for a while. What I really liked about this presentation was the fact that the speaker had a lot of practical experience with microservices, and it showed. Unlike many microservices advocates, he didn’t describe the concept as a solution to all your problems, but took a more pragmatic approach, and even pointed out that monoliths are OK, have advantages in certain situations, and are a good approach in an early stage of a project, until it starts making non-trivial revenue. I think this is a very healthy approach, and one I’ve observed in practice myself.

The talk went into details about options for asynchronous communication, transactions, deployment formats and strategies, management, data storage and more. You can check out the slides from the talk here.

Session 2: Step-by-step high availability with Docker and Java EE

The second session of the day was a panel session with a very interesting topic. I was expecting diving into the depths of Kubernetes, Docker Compose, or other systems making running multicontainer and scalable applications easy, but the session was actually a high-level overview of Docker’s own mechanisms combined with Apache TomEE’s scaling capabilities. If you want to know more, check out this nice write-up from the session and a demo on GitHub.

Session 3: Microservices minus the hype: How to build and why

Mark Heckler gave another talk on microservices. It was a relatively introductory talk, but he showed a few diagrams of microservice architecture, which was interesting. A nice quote that stuck with me is Monolithic applications only look simple from the outside.

In terms of technologies, the talk revolved around Spring. My take-home message is to look deeper into Spring Initializr, Spring Cloud and Hystrix.

You can check out the slides from this talk here.

Session 4: JUnit5: Features, architecture, and extensibility

In the afternoon, I decided to take a step back and try a few sessions outside of the set of things I’m usually interested in. The latest major release of JUnit was the topic of the first talk in this block, and it’s something that affects most if not all Java developers.

The presentation certainly did not lack technical detail, if anything, it was too in-depth. Having said that, JUnit5 introduces a few very nice things. Some of my favourites include dynamic tests, tags and filters, dependency injection through parameters on constructors and methods, interface default methods and extensions.

You can check out the slides from this talk here.

Session 5: Reactive Java: Promises and streams with Reakt

Another interesting session not necessarily related to what I work on was about Reakt, a library for callback coordination and streams. The talk was structured very well and introduced the Reactive Manifesto, basic Reakt concepts (promises, callbacks, breakers, streams etc.) with special emphasis on the Reactor pattern. Everything was put nicely into context, and compared to alternative approaches and technologies.

You can find the slides here.

Session 6: Advanced modular development

The session titled Advanced modular development was, as you would guess, about the module system in JDK 9. It was a follow-up to the introductory session on module development. Although I didn’t go to the prequel, I had no trouble following the talk, as I’ve played around with the module system a bit before. This advanced session described the structure of in detail, clarified the concepts of strong, weak, explicit and automatic modules and introduced some more advanced features of jdeps and jlink.

Session 7: Tools for developers who can’t automate good

The catchy title of the first BoF session of the day could be rephrased as Docker automation stack. This talk was a high-level overview of tools typically used with Docker, including a few lessons-learned and gotchas kind of notes. Several categories of tools were described – database migration tools (Flyway, Liquibase), configuration management tools (Ansible, Puppet, Chef, Salt), orchestration tools (Docker Compose, Dusty, Vagrant), clustering systems (Docker Swarm, Kubernetes, Mesos, Nomad), and continuous integration solutions (Jenkins, Teamcity, Travis, Bamboo). Flyway, Ansible, Docker Compose and Jenkins were described in detail.

You can check out the slides from this session here.

Session 8: REST in peace with Java EE

The last BoF session of the day was focused on implementing good APIs. The talk contained many code samples and some rather low-level implementation details of a particular REST API implemented with Java EE 7 (JAX-RS). The implementation was based on the Command Design Pattern and was relatively nontraditional, with a few mildly controversial design decisions.

You can find the slides here.

For information about other sessions at JavaOne, check out JavaOne: Day 0, JavaOne: Day 2, JavaOne: Day 3 and JavaOne: Day 4.