20 Years of JavaOne: Highlights from a Developer Point of View

Its the 20th anniversary of JavaOne this year. Its the little brother to Oracle World this week but still attracting thousands of Java Developer that want to learn the latest on how Java can help them build all different types of apps (Internet of Things, Mobile, Cloud Apps, Enterprise Apps, …)

I am in the lucky situation to present my Deep Dive into Top Java Performance Mistakes in 2015 [CON2809] on Wednesday but I also try to capture some other sessions and present my takeaways! I will upload my presentation also to my slideshare account at the end of the conference.

Keynotes: Lots of Marketing Keywords!

I watched half of the Java and half of the Oracle Keynotes. The Java one was much more interesting and technical – yet still not going very deep. The Oracle Keynote on Sunday was all about the main keywords we’ve heard for years: Easier, Cheaper, Faster, Better -> Use the Cloud!! – I am sure the Keynotes are available for you to watch – make up your own mind!

Pirates of DevOps: On Continuous Delivery Tides [CON7676]

Bruno Souza (@brjavaman) & Edson Yanaga (@yanaga) giving their take on DevOps – using Pirates of the Caribbean to relate most of their points.

My Session Score: 3 of 5: High Level DevOps is a Cultural Thing and it starts with you. Good tips in general!

My key takeaways and I also agree with them are their 5 steps they want every developer to work on at least one hour every week:

  • Automation – Eliminate Repetitive Tasks!
  • Dashboards Make it Visible
  • VisibilityGet the Visibility using the right tools
  • TestingTest the right things
  • VirtualizationYeah – we know that 🙂

Highlighting the benefit of Go vs Jenkins as Go focuses on the Software Build Pipeline instead of providing generic support for Jobs.

Other than that it was a general high level presentation on that DevOps is all about cultural change. It starts WITH YOU!!

HotSpot Synchronization: A Peek Under the Hood [CON7570]

David Buck (check Buck’s blog) from Oracle enlightening us on the internals of HotSpot Synchronization and how Java internally implements Monitors.

My Session Score: 5 of 5: Great presentation! Good content! Technical enough for a dev crowd!


  • Avoid premature optimization
  • Understand what is really happening behind the scenes -> we are all geeks – so – we should be interested in the internals
  • Internals on Lock Types: Biased, Thin and Fat Locks and also how and what data is stored per Object!

Tip #1: Watch out for “Tools that Modify Byte Code”

The Java Language ensures that monitors are always entered and exited. There is however no protection of somebody creating byte code with monitorenter and monitorexit in a way that could cause a problem. He mentions a problem with an obfuscation library a while back that generated byte code that caused deadlocks after obfuscation. Guess this is a great input for every type of tool (including APM tools) that modify byte code. Watch out for these situations!

Tip #2: Don’t try to build your own concurrency library -> Use java.util.concurrent!!

Hint #1: BiasedLock is prevented in the JVM Startup Phase (4s)

Tip #3: Profilers & Performance Counters

  • Performance Counters for Locking are mainly useful for the Oracle folks – but of course: feel free to look at them! No perf impact – use jstat if you are really interested in them
  • DTrace: Most flexible, high learning curve, available on some platforms. Check the monitor-contended*, monitor-wait* & monito-notify* probes
  • Java Flight Recorder: Part of Java Mission Control. Works on ALL platforms!

Tip #4: Some more JVM options for your research: PrintConcurrentLocks, UseBiasedLocking

If there are any books you want to every read about concurrency it should be “Concurrent Programming in Java by Doug Lea” and Java Concurrency in Practice by Brian Goetz (and others)

Summary: leave optimization to the JVM. Check java.util.concurrent if simple monitors dont do it. Keep the tools in mind available to you (also Dynatrace of course) 🙂

James Writes Java: What I Have Learned by Reading James Gosling’s Code [CON3563]

Mike Duigou (@mjduigou) sharing his experiences when working with James Gosling on several Java projects to answer the question: “How would you use a language that you designed?” 🙂

My Session Score: 4 of 5: Mostly anecdotal! Showing us that even the “Java God(s)” are just people like we, e.g: not writing JavaDoc

Code example from one of James Goslings Libraries
Code example from one of James Goslings Libraries. Can you find the problem?

My key takeaways:

  • “Very few comments, very little javadoc – but he adds a lot of references to stackoverflow or other wikis” -> maybe not the best thing to share with a large Java Dev Crowd 🙂
  • Cool example of iterating through a list of plugins creating an overview of running and not running plugins: page==0==plugin.isDeployed()
  • List Processing: #1 Recurse In; #2 at the bottom allocate structures; #3 populate on the way up
  • Interesting stories on how some of the code really ended up in the standard class library -> not all was intentional by the original dev -> lets not blame them!
  • Some Java Library contributions from James: java.util.Date, PipedInput/OutputStream, StreamTokenizer and some portions of java.net
  • Please no longer user the anonymous Map Initializer Pattern -> even James doesn’t use it any longer!
  • Consider using Appendable for formatting strings! James hates String.format and printf!
  • Use try { instead of { in every conditional and loop block!

Great question from the guy sitting next to me after seeing some strange code examples: “So – does this mean James doesn’t write unit tests?” 🙂 -> of course he does!

What’s New in the Java Persistence API (JSR 338) [CON7631]

Lukas Jungman from the Oracle Team in Czech Republic giving us an update on whats happening in JPA

My Session Score: 3 of 5: Good content if you are really into JPA! Style of presentation could be improved -> great from Lukas that he asked for feedback. Its hard staying in front of a large dev crowd and present!

My key takeaways:

  • History of JPA and EclipseLink with an overview of available implementations for JPA 2.x
  • Most of the session was around JPA 2.2 MR. Need more details? http://java.net/projects/jpa-spec/
    • @Inject, @PrePersist and Meta annotations!
    • Showing off some data access samples that shows the simplicity of accessing data. I fear though that some folks may do it exactly the way it was presented. Why do I fear? check the screenshot below and see for yourself why this is not efficient for that particular use case
    • Details and Use Cases on CriteriaQuery; AutoCloseable; Pagination Support to JPQL and Criteria APIs; NoSQL Support; Multitenancy
Why is this a bad sample to put out there?
Why is this a bad sample to put out there?

Tuning JavaServer Faces [CON3239]

Kito D. Mann (@kito99) is a consultant for Virtua and an author of the book JavaServer Faces in Action. Looking forward to a lot of technical details on tuning performance of JSF

My Session Score: 4 of 5: Great to see live performance analysis of generated JSF HTML Code! Spent a bit too much time with individual examples!

Key Takeaways

  • Enterprise Java Podcast: http://enterprisejavanews.com
  • What impacts performance? Page size; Session state; Request size; EL Evaluation; Configuration Flags; Accessing FacesContext
  • Bloated Component Tree: especially web apps “migrated” from previous desktop apps tend to have lots of nested controls -> leading to huge DOM + large component tree on the server
  • Good web performance analysis using built-in browser dev tools -> F12 is your friend 🙂
    • Define better default control names -> that will make much shorter IDs instead of IDs containing current Date!
  • Be careful with your “getters”. They might get called more than once per page request!

More useful tips on http://www.jsfcentral.com -> check out the performance articles!

Are Profilers Telling the Truth? How Do They Actually Work? [CON1566]

Fabian Lange (@CodingFabian) with a bold statement. Especially considering that he works for a company that does application performance management and with that need to get some type of profiling data. But he has a good start in making clear he tries not to be too biased -> well done!

My Session Score: 4 of 5: Great session. Great insights into how profilers work and which problems they have to face. Code examples were not that realistic but allowed him to proof his points!

Key Takeaways:

  • “A fool with a tool is still a fool” – Grady Booch
  • Great overview of tools in the space and stats on usage taken from a RebelLabs Report
  • Highlighting the benefit of JVMTI – and the options it gives tool vendors. Compares Native vs. Java Agent approaches
  • Highlighting the problem of “The Observer Effect” and the impact monitoring has on the JVM. Key Items are: Overhead (CPU, Memory, Network, Disk, Threads, …), Accuracy, Data Collection,
  • He had a nice demo profiling tool showing differences between Sampling and Instrumentation. The app he instrumented was however not realistic and just used to proof the point that instrumenting 100000000 methods with 0ms (zero) exec time obviously has overhead. But still – nice demo to show the different approaches.
  • Safepoints are the main issue of incorrect timings of profilers. JVMTI AsyncGetCallTrace allows getting traces asynchronously without waiting for a Safepoint!

Performance Tuning Guide: Start with Sampling; Do not take results to serious; Look for bottlenecks; <10ms is most of the time irrelevant

Scalable Continuous Deployment with Maven [CON1890]

Abraham Marin-Perez (@AbrahamMarin) on Continuous Deployment – giving his insights on how to do it with Maven but presenting use cases that are applicable to any type of tool landscape you have.

My Session Score: 4 of 5: Great Ideas to speed up builds so that feedback loops for developers are actually useful!

Key Takeaways

  • Maven was not built for Continuous Delivery!
  • “Dont use the RELEASE Plugin – but use the VERSIONS Plugin” – mvn versions:set -DnewVersion=**your version**
  • Make sure your builds are not going TOO BIG. If builds get too long no dev will wait on the feedback which totally breaks the feedback loop
  • Idea #1: Test Deprecation Policy: Exclude those tests that always succeed anyways
  • Idea #2: Break your app into smaller components/modules/services that on each own build and test faster! Make sure you optimize your dependencies!
  • Visualize Dependencies and Sizes of Build Modules -> especially interesting when building the cloud where you are charged by CPU Cycles and Bandwidth -> optimizing build time is then not only a time factor any longer but also a cost factor. Also check http:/github.com/quiram/build-hotspots
Interesting idea to visualize build dependencies and finding build hotspots
Interesting idea to visualize build dependencies and finding build hotspots

Java Connection Pool Performance and Scalability with Wait-Free Programming [CON2158]

Jean De Lavarene, Yuri Dolgov and Kuassi Mensah (all from Oracle – but main men was Yuri) talking about the scalability challenges they faced and addressed when implementing connection pools.

My Session Score: 4 of 5: Very interesting details on the internal strategies of Oracle to organize their connection pools. Yuri explained different locking strategies that they implemented. They achieved amazing results as compared to the previous implementations. It was a shorter session and very specific on how they handle this internally. Hence no other key takeaways other then: check out their work and learn how to optimize concurrent access to shared resources

Stay updated