Foojay

sort of, there was the original bigann and then they followed up with a couple more specialized contests the following year, i think it's over now ~300M modern-sized vectors is pretty close to jvector's limit in a single index (the Cassandra layer can shard more) https://foojay.io/today/indexing-all-of-wikipedia-on-a-laptop/ that said I think Mariano (new jvector maintainer) is working on ways to handle larger datasets in a single index but I'm not sure where that is on his priority list

I'm not sure scripting-language interop is holding back Swift, but ... > call a swift compiled extension from Python/JS/Ruby/PHP The story there is excellent. Here's a Swift function callable from C @cdecl("myfunc") public static func f(){...} C/C++ types are mostly handled automatically (including sharing memory management), but it can be tricky. To build a library to load and call from any language: swiftc mine.swift -emit-library -o libmine.dylib E.g., calling from java 22 FFI: https://foojay.io/today/java-panama-polyglot-swift-part-2/ But most people instead use a slower json server network interface because (sadly) json is the lingua franca for scripting and Swift Codable makes it trivial to map the json to a swift type.

You mostly need a recent JDK. Leyden has already cut down warmup by a lot and is expected to continue driving it down. https://foojay.io/today/how-is-leyden-improving-java-performance-part-… https://quarkus.io/blog/leyden-1/

A good coverage of all the JEPs included in JDK 20: https://foojay.io/today/its-java-20-release-day-heres-whats-new/

This is exciting, can't wait for the LTS release next year... that said, I don't much care for the "case SomeType t where ..." pattern matching syntax, I don't see the benefit of introducing a new keyword over using "if"... or even just "&&". To pinch the example used in[1]: case Tuner t && guitar.isInTune() -> ...; and case Tuner t if guitar.isInTune() -> ...; both seem as clear as case Tuner t where guitar.isInTune() -> ...; ...am I misunderstanding the reasoning here? Is it being introduced to keep the grammar definition simpler? 1: https://foojay.io/today/its-java-20-release-day-heres-whats-new/

The use case appears to be Java applications that rely on native libraries. Instead of a Java rewrite or using JNI or similar, Endive gives a new deployment model for native libraries (whether the language is garbage-collected or has manual memory-management) as a regular JAR file [1]: > You didn't install a native binary. You didn't configure JNI. You didn't cross-compile anything for your target platform. It just works, because the Wasm module is hiding inside a regular JAR on your classpath. > WebAssembly changes this equation. Take a proven C or Rust library, compile it to Wasm, and run it within JVM boundaries. You keep everything the JVM gives you: guaranteed memory safety, fault isolation, platform independence, advanced JIT, observability, and the "write once, run anywhere" promise. The Wasm module becomes just another artifact inside your JAR, an implementation detail that your users never need to think about. And from TFA[2]: > The previous article focused on wrapping C and Rust libraries. Those languages compile to Wasm straightforwardly because they manage their own memory. But a growing number of languages target the WasmGC proposal instead: Kotlin/Wasm, Dart, and others. Google Sheets already runs its Java-based calculation engine through WasmGC in production. Endive passes the full WasmGC spec testsuite [1] https://foojay.io/today/a-new-generation-of-java-libraries-is-born-was… [2]…

I vibe-coded jvm-hotpath to analyse my vibe-coded output. jvm-hotpath is a JVM agent that instruments Java code and records line-level execution counts. The differentiator is the UX: it generates a single HTML report that updates continuously while your app is running. No server/dashboard — it uses JSONP + polling, so you can open it from file:// and watch hotspots move as you click around. It’s meant for local dev, and there’s a stopwatch-style lap/reset so you can zero counts, do one action, and immediately see the hot path for just that interaction. Why this helps with “vibe coding”: when code is changing faster than your understanding (LLM-assisted or just a new/unfamiliar codebase), the hard bit is answering “what actually ran when I did this?”. This gives a quick runtime map of the paths you really exercised — and it’s also a handy way to learn a codebase by driving the app and watching what lights up. Questions I’m curious about: • What’s the closest thing you’ve seen to this in the JVM world? • Where would this save you the most time: learning a new codebase, validating AI-assisted changes, refactoring safely, or chasing weird behaviour? Project: https://github.com/sfkamath/jvm-hotpath Documentation (README): https://github.com/sfkamath/jvm-hotpath/blob/main/README.md Motivation: https://github.com/sfkamath/jvm-hotpath/blob/main/docs/Motivation.md Foojay article: https://foojay.io/today/runtime-code-analysis-in-the-age-of-vibe-codin… Long-time HN reader,…