Java virtual machine

But in order to use it, you still needed to turn it on using a command line flag.

What they've now done is they've said, because people have had long enough to test it, nobody's found any significant issues with introducing, because this is a big change, changing the size of the object header and the way the object header works inside the JVM.

They needed to allow plenty of time for people to run their applications on it and make sure it didn't break anything.

so they're happy with that now and so what they've said is that rather than having a command line flag to turn it on explicitly it will be the default um it's quite a good idea because it's a very good idea um because it actually introduces some some performance benefits as you said so if you look at the jepp itself that describes this um they quote on the spec jbb 2015 benchmark that they get a 22% reduction in heap space and an 8% reduction in CPU utilization.

Is this a change in the runtime, meaning I have a Java 8.11.17 application, a JAR file, which was created many years ago, maybe? If I now run this on this new runtime, will I benefit from it?

Oh, yes.

Yeah, because this is the internal data structures that are used by the JVM.

It doesn't have any impact on the code that you've written.

Yeah, I was going to say, I was hoping you would tell me something like you're running on average about 512 gigs of RAM or something, but no, 2064 gigs is quite the opposite direction.

I remember for the longest time, we had 32-bit JVMs, and then those JVMs could only reasonably address about two gigs of RAM, right? Because after that, the garbage collector would start to...

heave and seize and lurch and hesitate.

And so then we got 64-bit and I remember being like, okay, well, mathematically, there's no reason we couldn't have a lot more RAM now, but the garbage collector was still the constraint.

It is something that has been proven to work through fires, storms, thunders.

Like that thing, whatever it is, that still is in production based on a JVM that has been tested, built.

It can be operated by teams that feel comfortable doing this.

It can be scaled, right? So there is not only...

think that is even more interesting to open the platform up from a programming perspective to new approaches.

And we've seen inventions like Tornado VM.

We've seen frameworks that actually run large language models on the JVM natively in Java.

Wow.

And if it's true, it throws an interrupted exception.

So my question is, if a thread is stuck in an infinite loop, why not just have the JVM ruthlessly terminate the OS thread? Like, why ask politely?

Because ruthless termination at the OS level leaves the application in an unpredictable, often completely corrupted state.

Okay.

Corrupted how?

Well, imagine a thread is midway through a complex database transaction, or it's currently holding a critical lock on some shared memory.

If the JVM just kills it instantly, that lock is never released.

Oh, wow.

The answer was straightforward.

Spark and Flink and other traditional compute engines, they're JVM-based.

And JVM, as you know, doesn't have great interoperability with other programming languages.

And so Python runs out of process.

And you don't have low, low access to hardware.

And it goes deep.

It goes all the way from the semantic analysis to the planning to partition pruning to your catalog metadata management to your physical execution end-to-end.

And so I think Spark... interestingly kind of solidified its position in the world because of how strong of lake house format support there is right the lake house ecosystem is really really strong at spark um And I didn't know this until a Microsoft employee had posted about it, but Lakesail, or rather SAIL, was the first engine to rebuild Delta Lake outside of the JVM.

explicitly had a notion that the important thing was the ABI.

People would talk about it as the JVM.

It's not really JVM, it's like the JVM and the runtime system.

The Java language was one language that could be implemented using the Java runtime system.

And applets were one way that we could make the Java functionality and the cross-platform ability visible to people.

But this was a big leap beyond the things Frank and I were able to do among all the other things we had to do at the time.

Yeah, well, I mean, I imagine it was probably a pretty good foundation that you all built.

Like, the JVM now hosts other languages.