Code10x
Interfacesmedium3-5 years

A platform team adds `boolean healthy();` to their published `Plugin` interface and ships it as a minor release, reasoning "every plugin author will just recompile." Forty third-party plugins, none of them recompiled, are loaded into the platform the next day. What happens, and what should the team have shipped instead?

Every one of the forty plugin jars still compiles fine against nothing (they were built last year, against the old interface, and nobody rebuilt them), and every one of them still loads fine, because the JVM doesn't check whether a class implements every interface method at load time. The failure happens later and separately, at the exact moment the platform actually calls plugin.healthy() on one of those old plugin objects: the JVM looks for a healthy() implementation in that class and its supertypes, finds none, and throws AbstractMethodError — one crash per plugin, in production, the first time each one's health check is invoked, because none of those plugin jars are in the platform's own build and so nothing caught this before release. The fix is a default method — default boolean healthy() { return true; } — which gives every old, unrecompiled class file a working implementation to inherit, so the interface gains a new method without breaking anyone who hasn't rebuilt against it.

The lesson behind it →
PreviousA `ReportView` holding an 8 MB rendered buffer registers `bus.subscribe(new Listener() { public void onEvent(Event e) { refresh(); } })` and is never explicitly unsubscribed. After a few hundred report screens, the heap is gone, and a heap dump's histogram shows `byte[]` as the biggest consumer — which is true and doesn't explain anything. What's actually holding the memory, and what's the one-word category of fix?Next A reporting service declares `private static final SimpleDateFormat FMT = new SimpleDateFormat("yyyy-MM-dd HH:mm")` and reuses it across every request. It passes every test. Under 200 concurrent requests in production, about one row in a thousand carries a date from a *different* request, and occasionally a `NumberFormatException` comes out of `parse`. What's actually happening, and why is `static` — not `SimpleDateFormat` alone — the other half of the bug?
More on Interfaces
A `Plugin` interface adds `default boolean healthy() { return true; }`. A month later, one plugin author reports their health check is being ignored — the platform always treats their plugin as healthy regardless of what their code does. Their class extends a shared `BasePlugin`, which happens to already declare a public `boolean healthy()` method, unrelated to the interface, returning whether the plugin's background thread is alive. No compiler ever mentioned a conflict. Why not, and what actually happens at the call site?