Top 5 Talks I Attended at JavaOne 2016 (Part 1)

With a few other colleagues, I had the chance to be sent to San Francisco last week to attend the JavaOne 2016 conferences by my company.

Here is super short list of the conferences I attended which I found really interesting

Preventing errors before they happen

Werner Dietl & Michael Ernst

Since Java 6, it is possible to pass custom annotation processors to javac. Since Java 8, it is possible to add annotations to types. The guys behind the Checker Framework used this to create custom pluggable type systems for your Java programs. These type systems enforce properties on your program, and will emit warnings or errors at compile time otherwise.

Here are a few example :

  • declare @Immutable MyObject myObject to make sure that myObject won’t be muted
  • declare @NonNull MyObject myObject to make sure that myObject is never null

Under the hood, the compiler behaves as if @Immutable MyObject and MyObject where completely separate types, and it knows and tracks specific ways of converting between the two. The framework provides a simple API to define your own type systems. They did a live demo showing how to quickly define things like @Regex String, @Encrypted String or @Untainted String (which forbids user input strings to avoid SQL injections).

The talk was really interesting, the framework seems lightweight and to integrate well with the typical tool stack. I definitely will give it a try the next time I have a bit of slack time.

Here are the slides and a previous session of the presentation

Keeping Your CI/CD Pipeline as Fast as It Needs to Be

Abraham Marin-Perez

Continuous Delivery and Microservices are what you need to do, aren’t they ? Well, when actually trying to setup a CI / CD pipeline for all your code, things quickly get complicated pretty fast ! The speaker presented how to deal with this complexity by using metrics from your VCS and build servers to draw an annotated graph of your build pipeline.

  • He used the build time to set the size of every node : the longer, the larger
  • The color for the change rate : the more often it was built the warmer the color

It was then possible to determine other metrics such as :

  • the impact time of every node : build time + build time of all the dependencies
  • the weighted impact time : impact time * change rate
  • the overall average impact time : sum of all the weighted impact times
  • the overall max impact time : max of all the impact times

Using this and your SLAs it is possible to define policies for your build times such as “the max build time should not be more than X”. If you want to speed up your build, you can set a target build time and analyzing the graph should help you to understand what architecture changes you need to make to your system in order to meet this build time (this sounds a lot like Toyota’s Improvement Kata …)

I loved this talk ! I found the speaker captivating, he presented novel ideas which is not always the case.

Here are the slides, and the same presentation at Devoxx UK.

To Be Continued

I promised 5, and that’s only 2 talks ! Stay tuned, I’ll write about the 3 others in the coming weeks. Here they are.