Code10x
Platformsenior8+ years

A JVM microbenchmark that calls a method once and times it with `System.nanoTime()` reports the method as slow; the same method is fast once the service has been handling real traffic for a minute. What's actually different between those two measurements, and why does HotSpot not just compile everything to machine code immediately at startup?

The microbenchmark is measuring the interpreter — the JVM's default way of running bytecode, which re-decodes each instruction every time it runs and is genuinely slower than compiled machine code. After a minute of real traffic, the methods that actually run often have been noticed and compiled to native machine code by the JIT, which is why they're fast by then. HotSpot doesn't compile everything to native code immediately because compiling takes real time and most methods in a typical program run only a handful of times ever — spending compilation effort on code that will barely run would make every program's startup dramatically slower for a benefit the bulk of the code never earns back. So it interprets first, counts how often each method actually gets called, and only compiles the ones that cross a threshold — literally finding the 'hot spots,' which is where the name comes from.

The lesson behind it →
PreviousGiven a subclass `B extends A`, both with static initializer blocks that print, and a program that never mentions `B` until the very last line where it reads `B.name` — why does `A`'s static initializer definitely run before `B`'s, and why does neither run at program start?Next Two services call each other over HTTP, and a teammate creates a brand-new `HttpClient` on every single outbound call 'to keep things simple.' Why is that a real performance problem, and what is actually happening on the wire before the first byte of an HTTP request is even sent?
More on Platform
You get three different Java errors on three different days: `error: illegal start of type`, `Error: Could not find or load main class Foo`, and `Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5`. How do you tell, from the shape of the message alone, what kind of problem each one is — and why can the compiler never catch the third one?Given a subclass `B extends A`, both with static initializer blocks that print, and a program that never mentions `B` until the very last line where it reads `B.name` — why does `A`'s static initializer definitely run before `B`'s, and why does neither run at program start?