Inside Java

It is also about value types. I think the talk parent is talking about is [this], a bit long but worth watching [this] https://inside.java/2024/12/16/devoxxbelgium-valhalla/

I have an RSS Feed reader where I randomly subscribe to blogs which I find here or on other places. Here's an incomplete list of the pages which I check on a daily basis. Tech: https://lobste.rs/ https://www.infoq.com/ https://simonwillison.net/ https://inside.java/ Art: https://www.artnews.com/ https://www.monopol-magazin.de/ News: https://www.spiegel.de/ (mainly, but others too!)

Loom is the talk of the town (for great reasons!), but let's not forget about Project Amber and Record Patterns [1] ... there's an arc of features moving the platform towards a data-oriented programming model. Brian Goetz talks about this quite a bit [2] including the latest 19 launch podcast [3]. [1] https://openjdk.org/jeps/405 [2] https://inside.java/u/BrianGoetz [3] https://inside.java/2022/09/20/podcast-026

I recommend the "inside Java" podcast. Its from the java developer team at Oracle and worth a listen. https://inside.java/podcast/#:~:text=The%20Inside%20Java%20Podcast%20i…

> If that were true then they wouldn't be heap allocations. "Heap" is a misnomer. It's not called that due to the classic CS "heap" datastructure. It's called that for the same reason it's called a heap allocation in C++. Modern C++ allocators don't use a heap structure either. How the JVM does allocations for all it's collectors is in fact a bump allocator in the heap space. There are some weedsy details (for example, threads in the JVM have their own heap space for doing allocation to avoid contention in allocation) but suffice it to say it ultimately translates into a region check then pointer bump. This is why the JVM is so fast at allocation, much faster than C++ can be. [1] [2] > I don't know what this means. JVM allocations are typically pointer bumps, adding a number to a register. There's really nothing faster than it. If you are implementing an arena then you've already lost in terms of performance. [1] https://www.datadoghq.com/blog/understanding-java-gc/#memory-compactio… [2] https://inside.java/2020/06/25/compact-forwarding/

They wouldn't have had better performance, though. There is no significant performance penalty we're paying, although there's a nuance here that may be worth pointing out. There are two different usecases for coroutines that may tempt implementors to address with a single implementation, but the usecases are sufficiently different to separate into two different implementations. One is the generator use case. What makes it special is that there are exactly two communicating parties, and both of their state may fit in the CPU cache. The other use case is general concurrency, primarily for IO. In that situation, a scheduler juggles a large number of user-mode threads, and because of that, there is likely a cache miss on every context switch, no matter how efficient it is. However, in the second case, almost all of the performance is due to Little's law rather than context switch time (see my explanation here: https://inside.java/2020/08/07/loom-performance/). That means that a "stackful" implementation of user-mode threads can have no significant performance penalty for the second use case (which, BTW, I think has much more value than the first), even though a more performant implementation is possible for the first use case. In Java we decided to tackle the second use case with virtual threads, and so far we've not offered something for the first (for which the demand is significantly lower). What happens in languages that choose to tackle both use cases with the same…

> They just released a proposal that effectively side-steps the problem of checked-exceptions-in-lambdas. Here is a link -- https://inside.java/2023/12/15/switch-case-effect/ This is fine but removes only about 10% of the pain of mandatory exception handling inside typical lambda. Nothing short of making exceptions transparent to lambda receivers will cut it for me. > Kotlin is using an annotation to disambiguate between Java style records and Kotlin style records This is inherent risk of building on top of something you don't control. Don't really see this as fair comparison. It's a known design constraint. The only way to avoid it is to not build on top of Java or not adding any features on top of Java. > To give another example with C#, there has been a lot of recent discussion about finding potential alternatives to their async-await concurrency model. They cite the level of effort it takes to maintain the async await style code and the costs that come from this. I had a very different take-away. They did PoC with virtual threads and decided it's not worth the switch now and async-await that they have is good enough. https://github.com/dotnet/runtimelab/issues/2398 > Some of the languages it gets compared too aren't even that old yet. C# is more than old enough to drink and Scala just had its 20th birthday this weekend :) Java is only 4 years older than C#.

> Most of Java problems come down to unfortunate design choices in the past. E.g. checked exceptions vs lambdas Funnily enough, your example has actually supported my point. They just released a proposal that effectively side-steps the problem of checked-exceptions-in-lambdas. Here is a link -- https://inside.java/2023/12/15/switch-case-effect/ This is still just a proposal, so nothing is hammered out. And we can talk about the merits of this solution. But my point is, by focusing on designing features the way they have, you can minimize intrusion while maximizing the value provided. I think this proposal demonstrates that extremely well. This proposal allows the developer to maintain all the good parts about checked exceptions and lambdas, while being able to side-step the major downside. > Don't think like Java is a good example of that, more like the anti-example. Plenty of more sophisticated languages move way faster without negative effects on long term progress (C#, Kotlin, to some extent Scala) To be clear, when I say long term, I am measuring on the scale of decades. In that respect, I actually don't think your statement is correct. To give an example with Kotlin, someone (I think Brian) talked about Kotlin's release strategy for features being great for short term, but costly in the long term. Kotlin had record-esque classes long before Java ever got theirs, but now that Java finally has theirs, Kotlin is using an annotation to disambiguate between Java style…

Java had an extremely advanced and strict sandbox for many years. It offered of course also the possibility to blacklist everything by default. The problem with such a granular sandbox is that it's too complex for most use cases. When you need to whitelist any and every call to the outside world this becomes very tedious. That's why Java now removes the sandbox… https://inside.java/2021/04/23/security-and-sandboxing-post-securityma… Let's see how this works out for WASM. I guess: Without resorting to using some language(s) with build-in support for capability security a whitelist based sandbox approach won't ever work without issues. First of all you can forget about C/C++. Everything in this languages assumes free access to the system. Rust does not have any support for capabilities either (yet, and for the years to come at least). The best current WASM sandbox implementation, which is in WasmTime not Wasmer, is not more than a FS block. (And the memory safety guaranties you get in any VM language, of course). https://docs.wasmtime.dev/security.html I don't find any such feature mentioned in the Wasmer docs. It seems completely without any sandbox! (To stress it once more: All VM languages are memory safe. That's not sandboxing. All the "sandboxed by default" claims are misleading, at least). https://github.com/wasmerio/wasmer/issues/221 That even people here on HN believe in the currently unfulfilled WASM security promises shows only how good the WASM…

I like: Defn: https://podtail.com/en/podcast/defn/ The REPL: https://www.therepl.net/episodes/ (Seems to have gone quiet) ClojureScript Podcast: https://clojurescriptpodcast.com/ Functional Design in Clojure: https://clojuredesign.club/ (Also seems to have gone quiet since December) LispCast by Eric Normand: https://lispcast.com/ Cognitect, the company behind Clojure also has their own podcast but I haven't found it to be that interesting most of the time, at least yet: https://www.cognitect.com/cognicast/index.html Not specifically Clojure-related but has discussed a few times including wit Rich Hickey (as well as other unrelated great conversations!): CaSe https://www.case-podcast.org/ Completely not at all about Clojure but great software podcasts: Go Time: Even though I hardly ever write Go, I find their conversations to be really great and having lessons beyond Go. It helps that I am interested in the language though: https://changelog.com/gotime Web Development and Development in general - The Bike Shed: https://www.bikeshed.fm/ Software Engineering Radio: https://www.se-radio.net/ CoRecursive: https://corecursive.com/ Inside Java: https://inside.java/

>> you'll begin to naturally decompose every for loop into these five steps Does zig have auto vectorisation? I'm thinking that if you write the code in a vector friendly way, then the compiler can do the boiler plate for you https://llvm.org/docs/Vectorizers.html https://inside.java/2025/08/16/jvmls-hotspot-auto-vectorization/

His question is still valid for latency. That parallel GC in Java still seems to pause threads from a quick search. https://inside.java/2022/08/01/sip062/

They are related but fundamentally different. It is a vital semantic difference (influencing the programming model itself) since destructors are synchronous and deterministic while finalizers are asynchronous and non-deterministic. It is because of all the problems that the finalize method was deprecated in Java 9 and marked "deprecated for removal"(JEP 421) in Java 18. More details at https://stackoverflow.com/questions/56139760/why-is-the-finalize-metho… and https://inside.java/2022/01/12/podcast-021/

Tagged pointers don't buy as much performance as you'd expect in Java. That's because the JVM is highly multithreaded, and the Java memory model guarantees memory safety (unlike in Go, for example). So every pointer load from RAM will need a check for the tag bits. And you end up with your code full of branches. From practical experience, JVMs have had an option to use compressed pointers for inner fields for two decades ( https://wiki.openjdk.org/display/HotSpot/CompressedOops ). It saves a bit of RAM, but often results in slower code. More recently, the new ZGC collector started using colored pointers, there's a good presentation about it: https://inside.java/2025/10/06/jvmls-zgc-colored-pointers/ It's also been a mixed bag, performance-wise.

Maybe "Making illegal state unrepresentable" is the term you're looking for? https://fsharpforfunandprofit.com/posts/designing-with-types-making-il… https://inside.java/2024/06/03/dop-v1-1-illegal-states/ IMO it's doesn't have much relation with dynamic programming though.

Probably. But they still write “On a side note, Oracle's ZGC Generational—GenZGC—is not supported in production yet.” GenZGC is supported on OpenJDK 21 onwards [1]. [1]: https://inside.java/2023/11/28/gen-zgc-explainer/

Then I suggest you have another look =) https://inside.java/2021/02/03/jep380-unix-domain-sockets-channels/

Alan Bateman's FOSDEM presentation that explains this issues and some solutions in the meanwhile: https://inside.java/2024/02/17/virtual-threads-next-steps/

According to https://inside.java/2023/09/19/the-arrival-of-java-21/ Oracle provides roughly 3/4 of the commits and fixed issues. It's a majority, but there are other significant players (always surprised to see SAP higher then Google and Amazon).

I kind of like the inside java website for these kind of things: https://inside.java/2023/09/19/the-arrival-of-java-21/

In addition, this implementation detail might help in gaining some insight: "The synchronous networking Java APIs, when run in a virtual thread, switch the underlying native socket into non-blocking mode. When an I/O operation invoked from Java code does not complete immediately (the native socket returns EAGAIN - “not ready” / “would block”), the underlying native socket is registered with a JVM-wide event notification mechanism (a Poller), and the virtual thread is parked. When the underlying I/O operation is ready (an event arrives at the Poller), the virtual thread is unparked and the underlying socket operation is retried." https://inside.java/2021/05/10/networking-io-with-virtual-threads/

With modern concurrent GCs such as ZGC [1] this is really not an issue for most people anymore. [1] https://inside.java/2022/05/30/sip053/#:~:text=ZGC%20was%20designed%20…

Not the GP, but the Java Sandbox is now deprecated. There is an already closed deprecation ticket at openjdk.java.net.[1] For a blog post at inside.java see here.[2] Both links have some explanatory information. [1] https://openjdk.java.net/jeps/411 [2] https://inside.java/2021/04/23/security-and-sandboxing-post-securityma…

Oracle is proactively suggesting to test such changes in advance, ex. https://inside.java/2021/12/10/quality-heads-up/

The Arrival of Java 18! [1]: https://inside.java/2022/03/22/the-arrival-of-java18/

I would go the other way around - it's entirely Oracle's fault for trying to be too compatible with unfortunate mistakes made in the past. Java Serialization is the root of all these things, and should have been deprecated and more safeguards should have been added. Perhaps even an equivalent of --add-opens for which classes are safe to serialize! This would certainly have broken a large number of software, but it's the right way to go. Whichever way you define the "compatibility promise", I think security overrides that. At least it looks like Oracle is going this way[1], I just wish that it would have been sooner. [1] https://inside.java/2019/11/07/whywehateserialization/

Interesting! This seems a good article on the developments in JVM autovectorization: https://inside.java/2021/01/27/extending-c2-autovectorization-capabili…

yes, Java is adding jextract [1] as a replacement for JNI (Java Native Interface) which directly consumes header files using clang and produces a jar wrapping the native calls. It's not bolted in the compiler so less nice than Zig but the jar produced by jextract is not ABI dependent so more portable. The ABI dependent code is generated by the JIT using the the Foreign Linker API (the equivalent of C# DllImport) at runtime. [1] https://inside.java/2020/10/06/jextract/

Anyone interested in modern Java should listen to their podcast: https://inside.java/podcast/ (I'm not affiliated - just someone coming back to Java after 20+ years of C++ and Python). Recent stuff includes: * Vector API * Record classes * JDK Flightrecorder * Java 16

their blog post as well: https://inside.java/2021/03/16/the-arrival-of-java16/