A hands-on tour of Java 25's new features for developers, including language upgrades, concurrency tools, and performance improvements.
A deep dive into Java 25's structured concurrency API, covering its features, error handling, and practical application with code examples.
Explains Little's Law from queuing theory and how it applies to system performance, showing why latency increases cause concurrency to balloon under load.
A technical analysis of Java 25's CPU-Time Profiler, focusing on the sampler queue's semantics and synchronization implementation.
A developer investigates a subtle bug in Go's errgroup package, explaining the issue and providing a fix.
A guide to capturing and analyzing Java thread dumps to identify performance bottlenecks, deadlocks, and CPU issues.
Compares PostgreSQL's tuple-based MVCC and append-only updates with Oracle's in-place row updates and undo-based MVCC for database concurrency.
Explores using Java 21+ virtual threads to elegantly convert legacy Future objects into modern, composable CompletableFuture instances.
Explores using Java 21+ virtual threads to elegantly convert legacy Future objects into modern, composable CompletableFuture instances.
Explains how to fix actor-isolated protocol conformance errors in Swift 6.2, focusing on @MainActor usage and avoiding data races.
Analyzes a subtle data race bug in a Go web server middleware, explaining the cause and fix for a concurrency issue without typical synchronization constructs.
Explores naming conventions for mutexes in Go codebases and introduces structural search tools like ast-grep to analyze patterns.
Explains the Double-Checked Locking pattern in Java for thread-safe lazy initialization, covering its pitfalls and correct implementation.
Overview of the revamped structured concurrency API in Java 25, a key feature for managing concurrent tasks with virtual threads.
Explains Go's singleflight package for preventing duplicate work during concurrent requests, improving backend efficiency.
Explores using Swift's defer keyword to manage resources in async and throwing functions, improving code safety and elegance.
Explains Java's new Lazy Constants feature for safe, one-time initialization of immutable values, covering benefits and internal workings.
Explores Swift's concurrency model, focusing on Actors, GlobalActors, and MainActor for safe, data-race-free programming.
Explains scoped values, a new Java 24 feature for safe and efficient thread-local data sharing, as previewed in the Inside Java Newscast.
Java 24 reduces virtual thread pinning in synchronized blocks, improving scalability, with details on remaining pinning cases and thread capture.
