Imagine a bacon-wrapped Ferrari. Still not better than our free technical reports.

Level up during the holidays: geekLevel++


As it’s getting nearer the holidays and the end of 2016, many of us will be using up the vacation days we have left. I wonder what everyone will spend it doing. Some might be using their time on that project they’ve been thinking about for months, but just not had the time to start. Others may be visiting friends and families for the holidays, trying hard to think up a way to politely excuse yourself and leave. Many will use the time off to learn and educate yourselves so that you can start back in the new year refreshed and with new ideas.

For those who want to level up and learn something new, we have just the thing! A few months ago we ran a 24 hour conference called vJUG24. You can watch all 24 sessions in a sleep free marathon if you like, but I’d recommend taking reasonable breaks!


To give you a taster of the sessions, here are my top five picks (wow, they were really hard to pick as all the sessions were really great!) in the order they were delivered on the vJUG!

1. An introduction to JVM performance by Rafael Winterhalter

Session Abstract: Writing software for a virtual machine allows developers to forget about machine code assembly, interrupts and processor caches. This makes Java a convenient language, but all too many developers see the JVM as a black box and are often unsure of how to optimize their code for performance. This unfortunately adds credence to the myth that Java is always outperformed by native languages. In this talk we’ll take a peek at the inner workings of the HotSpot Virtual Machine, its Just-In-Time Compiler and the interplay with a computer’s hardware. From this, we will understand the more common optimizations that a virtual machine applies to be better equipped to improve and to reason about a Java program’s performance, and how to correctly measure runtime!

2. The Seven (More) Deadly Sins of Microservices by Daniel Bryant

Session Abstract: There is trouble brewing in the land of microservices – today’s shiny technology is tomorrow’s legacy, and there is concern that we will all be dealing with spaghetti services in 2018…

It is often a sign of an architectural approach’s maturity that in addition to the emergence of well established principles and practices, that anti-patterns also begin to be identified and classified. In this talk we introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project…

3. Java 9 Modularity in Action by Sander Mak & Paul Bakker

Session Abstract: With Java 9, modularity comes to your doorstep (whether you ordered it or not). This isn’t your average language feature: making the most out of it may involve rewiring your brain. In this session we explore the benefits of a modular codebase using Java 9 modules. Because who doesn’t like more reliable and secure applications, meanwhile killing the dreaded classpath?

After reviewing the basic concepts of modules, we’ll explore modularity patterns that enhance your design and development skills. We all have existing software, so migration of codebases to a modular world is an important topic as well. Automatic modules and other new concepts are added to your toolbox to this end.

Want examples? We’ve got plenty in this practical and code-driven talk. Even if you intend to use Java 9 without modules, this talk helps you prevent common issues. You’ll be ready for Java 9 before you know it.

4. Using Java 8 Idioms in Existing Code by Trisha Gee

Session Abstract: While we’re drawing ever closer to Java 9, and even hearing about features in Java 10, it’s also true that many of us are still working with an older version. Even if your project has technically adopted Java 8, and even if you’re using it when coding new features, it’s likely the majority of your code base is still not making the most of what’s available in Java 8 – features like Lambda Expressions, the Streams API, and new Date/Time.

In this presentation, Trisha will:

  • Highlight some of the benefits of using Java 8 – after all, you’ll probably have to persuade The Management that tampering with existing code is worthwhile
  • Demonstrate how to identify areas of code that can be updated to use Java 8 features
  • Show how to automatically refactor your code to make use of features like lambdas and streams.
  • Cover some of the pros and cons of using the new features, including the impact on performance.

At the end of this session, you’ll have a better idea of when refactoring can easily be done, and when it may NOT be a good idea.

5. Cloud native Java by Josh Long

Session Abstract: “It is not necessary to change. Survival is not mandatory.” -W. Edwards Deming

Work takes time to flow through an organization and ultimately be deployed to production where it captures value. It’s critical to reduce time-to-production. Software – for many organizations and industries – is a competitive advantage.

Organizations break their larger software ambitions into smaller, independently deployable, feature -centric batches of work – microservices. In order to reduce the round-trip between stations of work, organizations collapse or consolidate as much of them as possible and automate the rest; developers and operations beget “devops,” cloud-based services and platforms (like Cloud Foundry) automate operations work and break down the need for ITIL tickets and change management boards.

But velocity, for velocity’s sake, is dangerous. Microservices invite architectural complexity that few are prepared to address. In this talk, we’ll look at how high performance organizations like Ticketmaster, Alibaba, and Netflix make short work of that complexity with Spring Boot and Spring Cloud.