Over the last few weeks, there has been a knock-out tournament raging on Twitter, where various Java technologies have battled out which JDK technology is the best. It’s all part of the activities taking place around the celebration of Java turning 25 years. And boy, have those years been interesting.
Like many languages in use today, Java started out with a simple interpreter. That is, by the way, how Java got a reputation for being slow. Today, Java peak performance can surpass that of statically compiled languages, owing to optimizations only possible when runtime information is available. But I digress…
As many of you know, I started out co-founding a company named Appeal – the company that created the JRockit JVM. We did quite a few cool things during that time; some of them relevant to the knock-out competition. We built the world’s first JVM management console, mostly since the application to become a Java licensee (so that JRockit could become a Sun certified JVM) required us to state a value-add. Our original application stated “better performance”, and was summarily turned down. 😉 With the work on the management console we eventually consolidated an API to monitor and manage the JVM – JMAPI (the JRockit Management API), which later inspired – and was superseded by – JSR-174 (java.lang.management).
We also built a tool we called JRA (JRockit Runtime Analyzer). It really started out as a tool for finding out how the JVM was performing at customer installations – we needed information to better understand how to improve the JVM for real world usage. Customers, quite understandably, refused to let us borrow their applications to run them in our labs. To make it easy for them to understand and verify the data they were sharing, it was all emitted as text (XML). It didn’t take long for customers to see us use the tool and the (accidental) value it brought for optimizing their applications – was the tool perhaps for sale? As a startup, we of course said yes, and made it into a product. When we later introduced the JRockit DetGC (deterministic GC), there was a need to be able to prove that the GC was keeping the latency contract, and show where in the customer code any thread halts were caused (e.g. due to bad synchronization). So the JRockit Runtime Analyzer was extended with LAT (the Latency Analysis Tool), which now introduced a binary artifact for the latency data for better data density and less serialization cost. In the end the JRA and LAT was unified into a single model – JFR (JRockit Flight Recorder, later Java Flight Recorder, and finally re-dubbed into JDK Flight Recorder when it was open sourced). We also created an impossibly cool on-line memory analysis tool (which was sadly never ported to hotspot), together with a slew of other little tools and utilities.
Some of these tools converged into Java Mission Control, which became the hub for the cool tools we were developing.
I was happily surprised to see JDK Mission Control included in the “Best of the JDK” feature face off. I was doing little dad-dances (to the embarrassment of my kids) in total astonishment when JDK Mission Control got up against the runtime and language features and ultimately won the whole thing.
Tech Poetry Throw-Down
One of the best parts of this whole competition was when Erik Costlow wrote some poetry in support of JDK Mission Control. This sparked an epic tech-poetry throw-down with little poems in favour of various Java technologies.
Here are a few of my favourites entries for JMC & JFR (in no particular order):
Of JDK Mission Control
whose benefits I will extol:
It watches performance
while still in conformance
So therefore it should win this poll.
(The one which started the it all)
2 am in the morning, my mobile chimed,
The war room conf call had to be primed.
JVM’s are down, the helpdesk said,
Touch troubleshooting road ahead.
CPU? GC? Bad Code?, the questions abound,
The root cause was far from being found.
Tumultuous voiced from Dev to Ops, each one declaring the were clean
No path to the solution was to be seen.
With a prayer, I fired up the Java Flight Recorder,
Hoping this would restore some war room order.
Lo! And behold, the histogram revealed
‘Twas a code deadlock, the system could yet be healed!
Helpful NullPointer messages, I hear you say,
Who will alert you whilst you are away?
To see or not to see (perf data)
That is the question (mission control answers).
Whether ‘tis nobler in the code
To suffer the zings and harrows of outrageous finger pointing
Or to stream events and by analyzing, end it
I have never
had to deal
many people want
but my vote goes to JMC
it is so sweet
and so cold
To think that I could ever see
A tool so lovely: JMC
A tool that streams events all day
Yet still performs without delay.
If you need to control a mission
OpenJDK had an omission
And then JMC
Was suddenly free
Without even rights of rescission
So much value inside JMC
Yet usage was low, tis it wasn’t free
But low and behold
Oracle open sourced it in whole
And now productivity is as easy can be
As I stream through the events of my workload perf pain
I take a look post 8 life and realize this tool should reign
‘cause that’s just perfect for a coder like me
You know we love fancy things like JDK MC
Been spendin’ most our lives livin’ in a coder’s paradise
Here are a few of my favourites for the other technologies:
Null pointer exception
Is a old familiar friend
And she wants to be
more helpful again
With deep information
I can only begin to extol
Love for NPE
For she should win
this Java poll
There was a NullPointerException
Whose message needs amplification
To the VM some hacks
Add the relevant facts
And no longer is it an obsession
As I try to decipher my NPE in grails
The Greater Sage-Grouse wanders the sage brush
The grouse and I are one
For I can’t decipher less helpful NPE’s in grails
Any more than the sage-grouse knows why it wanders the sagebrush
I’m on a boat motherf$%^r take a look at me
Straight floatin’ on a boat debugging NPE
Busting five knots, wind whipping out my coat
You can’t stop me motherf$%^r cause I’m debugging on a boat
The usability of NullPointerExceptions
have historically been an issue
by adding static code to dynamic exceptions
our problems we can diffuse
Let go of your stack trace debugging hate
And vote for JEP Three Fifty Eight!
Many thanks to @costlow, @manicode, @stuartmarks, @perfclarity and @Sharat_Chander for all the laughs! 🙂
Yes, I know this is a silly little Twitter competition. But, if nothing else, this silly little competition provides an excellent opportunity for me to give some overdue thanks:
- Plenty of thanks and love to all of the users of JMC out there, using JMC to solve tricky problems in production systems on a daily basis.
- Many thanks to everyone who voted for JMC. I didn’t think a tool would stand a chance against language and runtime features.
- Huge thanks to all the developers on the JDK Mission Control team, and to all the developers on the JDK serviceability team. You’re a really awesome bunch, and it’s a privilege for me to be working with you.
- Major kudos to Oracle for open sourcing JDK Mission Control and JDK Flight Recorder.
- Many thanks to the main sponsors of the development of JDK Mission Control:
: Sadly, not all of the features in JMAPI got rolled into the standardized API. JMAPI could, for example, change the CPU affinity of the JVM process on the fly, dynamically change the heap size target, and independently (and dynamically) switch the GC to use a nursery or not as well as switch between concurrent and parallel mark and/or sweep phases. Of course differences in GC capabilities etc required the standardized API to be limited to what made sense to most runtimes. That said, I’m still kinda bummed that it became a JMX API (java.lang.management depending on the javax.management specification), instead of a pure local Java API, which could also have been exposed through JMX. See, for example, the JFR APIs, where there is a local API and also a JMX API.