All 112 articles, sorted alphabetically
Java Annotations, in depth: Retention, Targets, Reflection, Processors and How Frameworks Read Them
How Java annotations work end to end: declaring them, retention and target rules, class-file storage, reflective reads, compile-time processors, the J…
Read article →AssertJ, in depth: fluent assertions, recursive comparison, soft assertions and custom asserts
How AssertJ works and how to use it well: type-specific assertThat entry points and chaining, collection and extracting checks, recursive comparison, …
Read article →async-profiler for Java: CPU, Wall-Clock, Flame Graphs
async-profiler samples Java with low overhead via perf_events and AsyncGetCallTrace: CPU, wall-clock and allocation modes, flame graphs, and when to u…
Read article →Java Atomic Classes, in depth: CAS, memory modes, ABA in a garbage-collected world, LongAdder and VarHandle
Java atomic classes in depth: compare-and-set underneath, the full AtomicInteger and AtomicReference API, JDK 9 memory modes, ABA in Java, LongAdder i…
Read article →Bazel for Java, in depth: modules and labels, the action graph, Bazel 9 and Bzlmod, strict deps and header jars, caching, queries and when it is worth it
How Bazel builds Java: modules, packages, targets and labels, loading, analysis and execution, a Bazel 9 project with Bzlmod and rules_jvm_external, s…
Read article →Java BlockingQueue, in depth: the contract, the locks inside, sizing with Little's law and clean shutdown
Java BlockingQueue in depth: the four method families, how ArrayBlockingQueue and LinkedBlockingQueue lock, choosing an implementation, sizing a bound…
Read article →Java Class-Data Sharing architecture
Deep-dive on Java Class-Data Sharing (CDS/AppCDS): dump-time archive creation, run-time memory-mapping and validation, shared metaspace across process…
Read article →JVM class loading architecture
Deep-dive on JVM class loading: bootstrap/platform/application loaders and parent delegation, the load-verify-prepare-resolve-initialize pipeline, (na…
Read article →Java Collections Framework
How the Java Collections Framework really fits together: two roots, ArrayList against LinkedList, HashMap internals, fail-fast iterators, and unmodifi…
Read article →Java Collectors, in depth: the Collector contract, grouping and mapping downstreams, parallel merging, toMap traps and writing your own
How java.util.stream.Collectors works: the five-part Collector contract, how sequential and parallel collect use supplier, accumulator, combiner and f…
Read article →Java CompletableFuture, in depth: composition, threads, errors, timeouts and when to use virtual threads
How CompletableFuture works inside, thenApply versus thenCompose, which thread runs callbacks, exception wrapping, timeouts and cancellation, a fan-ou…
Read article →Java Concurrency
Java concurrency from the memory model up: happens-before, locks versus j.u.c, atomics and CAS, thread pool sizing, CompletableFuture, and virtual thr…
Read article →Java ConcurrentHashMap
Java ConcurrentHashMap in depth: bins, lock-free reads, CAS and per-bin locking, treeification, cooperative resizing, striped size counters, atomic co…
Read article →Java Containerization, in depth: how the JVM reads cgroup limits, sizing memory and CPU, building small images, startup caches and lifecycle
Running Java well in containers: how the JVM detects cgroup v1 and v2 limits, how heap, GC and thread pools are sized from them, a worked memory budge…
Read article →Java CountDownLatch, in depth: completion and start gates, timeouts, happens-before and AQS internals
CountDownLatch precisely: the API, how it is built on AbstractQueuedSynchronizer, completion and start gates with correct code, timeouts, interruption…
Read article →Java CRaC architecture
Deep-dive on CRaC (Coordinated Restore at Checkpoint): snapshot a fully JIT-warmed JVM to a CRIU-based process image and restore new instances from it…
Read article →Java Deprecation and Removals, in depth: forRemoval, jdeprscan, what the JDK has removed and how to migrate
How Java deprecation works and how to stay ahead of removals: ordinary versus terminal deprecation, javac removal and deprecation warnings, jdeprscan …
Read article →Dropwizard
Opinionated JSON API framework.
Read article →Java Enhanced For Loop, in depth: what javac generates, mutation during iteration, boxing and iterator costs, writing your own Iterable
A first-principles guide to Java's enhanced for (for-each) statement: the JLS 14.14.2 desugaring for arrays and Iterables, ConcurrentModification…
Read article →Java Epsilon GC, in depth: a collector that never collects, GC-free baselines, allocation budgets and what silently breaks
Epsilon, the no-op garbage collector from JEP 318: how allocation works with TLABs and heap expansion, its experimental flags, why empty barriers make…
Read article →JVM Escape Analysis: Scalar Replacement and Lock Elision
HotSpot escape analysis: NoEscape, ArgEscape and GlobalEscape, scalar replacement instead of heap allocation, lock elision, inlining and deoptimizatio…
Read article →Java ExecutorService, in depth: the admission algorithm, sizing, rejection, shutdown and virtual threads
Java ExecutorService in depth: the API and lifecycle, ThreadPoolExecutor's core-queue-max admission order, what the Executors factories build, po…
Read article →Java Foreign Function + Memory API (Panama), in depth: arenas, segments, layouts, downcalls, upcalls and the rules that keep native code safe
How the Java FFM API (final since JDK 22) works from first principles: arena kinds and lifetimes, MemorySegment bounds and slices, struct layouts and …
Read article →Java FFM API vs JNI: Arenas, MemorySegment, Linker Downcalls
The Java Foreign Function and Memory API (Project Panama): MemorySegment, arenas, layouts, Linker downcalls and upcalls, jextract, and why it replaces…
Read article →Java FFM API, in depth: the API surface, a working libc binding with structs, errno and callbacks, and the idioms that keep it safe
A hands-on tour of the Java Foreign Function and Memory API as you type it: mapping C signatures to FunctionDescriptors, structs with VarHandles, errn…
Read article →Java ForkJoinPool
Java ForkJoinPool in depth: the fork/compute/join idiom, work-stealing deques, helping joins, thresholds, the common pool, ManagedBlocker, a starvatio…
Read article →Java G1 GC architecture
Deep-dive on the G1 garbage collector: the region-based heap, young/mixed/full collections, concurrent SATB marking, remembered sets and the write bar…
Read article →JVM GC architecture
Deep-dive on JVM garbage collectors: regions + TLABs + write barriers, per-collector strategies, tuning and observability.
Read article →Java GC Logs, in depth: the -Xlog grammar, a production setup, reading G1 pauses line by line, other collectors, safepoints, parsing and alerting
How to configure and read JVM garbage collection logs with unified logging: -Xlog selectors, levels, outputs, decorators and rotation, async logging, …
Read article →Java Generics
Java generics in depth: type parameters and bounds, what erasure keeps and throws away, bridge methods, invariance versus array covariance, wildcards …
Read article →GraalVM Architecture in Depth
Deep-dive on GraalVM: the Graal JIT via JVMCI versus Native Image AOT, closed-world points-to analysis, build-time initialisation and the image heap, …
Read article →Gradle, in depth: the three build phases, dependency resolution, incremental tasks and the caches that make builds fast
How Gradle works under the build script: initialization, configuration and execution, a multi-project build with a version catalog and convention plug…
Read article →Java Heap Tuning, in depth: measuring the live set, sizing -Xms and -Xmx, young generation and pause goals in G1, humongous objects and handling OutOfMemoryError
A measurement-driven procedure for tuning the Java heap: what the heap size controls, reading the live set and allocation rate from GC logs, sizing -X…
Read article →Helidon
Oracle's cloud-native Java.
Read article →Hibernate and JPA, in depth: the persistence context, entity states, flush order, identifier strategies and batching, lazy loading, caching and locking
How Hibernate implements Jakarta Persistence underneath Spring Data: factories and persistence contexts, the four entity states, dirty checking and th…
Read article →Java HttpClient, in depth: the java.net.http object model, defaults, timeouts, body handlers, connection pooling, retries and running it in production
A practical guide to the JDK's built-in HTTP client: how HttpClient, HttpRequest and body handlers fit together, the defaults that surprise peopl…
Read article →Jakarta EE (was Java EE), in depth: profiles and specifications, CDI, REST and Jakarta Data in a worked service, virtual threads, and the javax-to-jakarta migration
What Jakarta EE is and how to use it in 2026: specifications, TCKs and compatible runtimes, the Core, Web and Platform profiles, Jakarta EE 11 compone…
Read article →Java Flight Recorder -- always-on, low-overhead profiling
Deep-dive on Java Flight Recorder (JFR): continuous event recording, JFR events (GC/allocation/locks/IO), very low overhead (<1%) enabling always-o…
Read article →JVM JIT Compiler Explained: Tiered Compilation, C1, C2, Graal
How the HotSpot JVM JIT compiler works: tiered compilation from interpreter to C1 and C2, Graal, inlining and inline caches, deoptimization, OSR, code…
Read article →JITWatch, in depth: capturing a complete compilation log, reading TriView, inlining failure reasons and JIT checks in CI
A practical guide to JITWatch, the HotSpot JIT log analyser: the flags that produce a complete LogCompilation log, hsdis for assembly, a worked megamo…
Read article →Java jlink, in depth: building, measuring and shipping custom runtime images
A practical guide to jlink: what a runtime image contains, choosing modules with jdeps, JDK-only images for class-path applications, plugin choices an…
Read article →jOOQ, in depth: code generation, the type-safe SQL DSL, MULTISET, transactions and running it in production
A practical guide to jOOQ for Java: how schema code generation works and how to wire it into a build, writing type-safe and dynamic SQL with DSLContex…
Read article →Java jpackage, in depth: app images, platform installers, the per-OS build matrix, upgrades, signing and notarization
A practical guide to the JDK's jpackage tool: what it builds, package types per operating system, classpath and modular inputs, the app-image lay…
Read article →JUnit 5 (Jupiter), in depth: the Platform and engines, test lifecycle, parameterized tests, the extension model and parallel execution
How JUnit 5 works under the hood and how to use it well: Platform, Jupiter and Vintage, discovery and the per-method instance lifecycle, assertions an…
Read article →JVM Memory Model
How JVM memory is organized: heap generations, stack per thread, metaspace for class metadata, and off-heap for direct buffers.
Read article →Java JVMTI + Instrumentation API, in depth: native agents, Java agents, bytecode transformation and running agents in production
How JVM agents work: JVMTI environments, phases, capabilities and events; the java.lang.instrument layer, manifest attributes and ClassFileTransformer…
Read article →Java Lambda Expressions: How They Work Under the Hood
Java lambda expressions explained: functional interfaces, invokedynamic and LambdaMetafactory, effectively final capture, method references, checked e…
Read article →Project Leyden Architecture in Depth: Training Runs, the AOT Cache and Faster Java Startup
How Project Leyden speeds up Java startup and warmup: why the JVM starts slowly, the shift-and-constrain model, what the AOT cache holds in JDK 24, 25…
Read article →Java LTS Releases, in depth: what long-term support really promises, the 8 to 25 timeline, and how to plan each upgrade hop
How Java long-term support works: the six-month release train, LTS as a vendor commitment rather than an OpenJDK feature, Oracle support dates for 8, …
Read article →MapStruct, in depth: compile-time bean mapping, generated code, null and unmapped-target policies, update mappings, Lombok and Spring
How MapStruct generates Java bean mappers at compile time: reading the generated implementation, nested and custom conversions, ReportingPolicy.ERROR,…
Read article →Apache Maven, in depth
How Maven really works: lifecycles and plugin bindings, the effective POM, nearest-wins dependency mediation, BOMs, reactor flags, enforcer rules, rep…
Read article →Java Memory Model -- happens-before, visibility, and data races
Deep-dive on the Java Memory Model: the visibility/ordering problem from caches and reordering, happens-before, volatile/synchronized/final/atomics es…
Read article →JVM Metaspace architecture
Deep-dive on JVM Metaspace: what replaced PermGen, class vs non-class space, compressed klass pointers, the chunk and arena allocator, MetaspaceSize v…
Read article →Java MethodHandles + VarHandle, in depth: lookups and access, invokeExact typing, combinators, call sites and memory-ordered field access
A first-principles guide to java.lang.invoke: how Lookup controls access, why invokeExact is strict and fast, building behaviour with method handle co…
Read article →Java Method References
Java method references in depth: the four kinds, how javac resolves them against the target type, invokedynamic and LambdaMetafactory, eager receiver …
Read article →Micrometer, in depth: meter identity, timers and histograms, filter ordering, step versus cumulative registries and the Observation API
A practical guide to Micrometer: how meters are identified, choosing counters, gauges, timers and summaries, client-side percentiles versus histograms…
Read article →Micronaut, in depth: compile-time dependency injection, the Netty event loop and thread selection, reflection-free serialization and data, and what changed in Micronaut 5
How Micronaut works: what its annotation processor generates, beans, factories and conditions, the Netty event loop and thread selection with @Execute…
Read article →Mockito, in depth: how mocks are built, stubbing and verification rules, strict stubs, the JDK 21+ agent set-up and tests that stay honest
Mockito explained from first principles: what a mock really is, how the inline mock maker intercepts calls, stubbing, verification, argument matchers …
Read article →Java Module System (JPMS), in depth: the module graph at run time, layers and plugin isolation, services across layers, and strong encapsulation since JDK 17
JPMS beyond module-info: Module, ModuleLayer and Configuration as run-time objects, resolving and defining layers to load two versions of one plugin s…
Read article →Java Modules, in depth: module-info, resolution, strong encapsulation, migration and jlink
How the Java Platform Module System works and how to adopt it: module-info directives, how the resolver builds the module graph, exports versus opens,…
Read article →MyBatis, in depth: mappers, result maps, dynamic SQL, batching and the caches that bite
MyBatis explained for Java developers: how a mapper call becomes a JDBC statement, #{} parameter binding versus ${} substitution, result maps and N+1,…
Read article →Java NIO and Netty
Deep-dive on Java NIO and Netty: selector-driven non-blocking IO, event loops and handler pipelines, codecs for framing, pooled off-heap ByteBuffers, …
Read article →OpenJDK Vendors, in depth: what differs between Temurin, Corretto, Zulu, Oracle JDK and the rest, licensing, support horizons, and how to choose and switch
How OpenJDK distributions relate and what actually differs between them: source and update projects, TCK certification, licences including Oracle JDK …
Read article →OpenTelemetry Java, in depth: agent versus SDK, manual spans, context across threads, metrics, log correlation, sampling and the failures you will hit
A practical guide to OpenTelemetry in Java: how the API, SDK, Java agent and Collector fit together, configuring the agent with environment variables …
Read article →Java Optional, in depth: the API by version, map versus flatMap, orElse versus orElseGet, and where Optional does not belong
Java Optional from first principles: value-based semantics, the API from Java 8 to 11, null handling in map and flatMap, eager orElse, primitive varia…
Read article →Java Overview
What Java is, why the JVM matters, and where Java fits in modern computing after 25+ years.
Read article →OWASP Dependency-Check for Java, in depth: how CPE matching works, Maven and Gradle setup, NVD and OSS Index data, triage and suppressions
A practical guide to OWASP Dependency-Check in Java builds: the evidence, CPE and purl matching pipeline, Maven and Gradle plugin and CLI configuratio…
Read article →Java Parallel GC, in depth: parallel scavenge, parallel mark-compact, ergonomic goals and adaptive sizing, flags, logs and when the throughput collector wins
How HotSpot's Parallel (throughput) collector works: heap layout, parallel young collection with work stealing, parallel mark-compact full GC, GC…
Read article →Java Parallel Streams, in depth: how pipelines split, the common pool, correctness rules, ordering costs and when parallelism pays
A practical guide to Java parallel streams: how a parallel pipeline splits its source and combines results, where the threads come from, which sources…
Read article →Java pattern matching architecture
Deep-dive on Java pattern matching: sealed interfaces, records, switch expressions, type + record patterns, guards, exhaustiveness.
Read article →Java Phaser
java.util.concurrent.Phaser explained: dynamic party registration, phase advance, tiered phasers, onAdvance termination, and when it beats CyclicBarri…
Read article →Play Framework (Java), in depth: Play 3 on Pekko, routes, async controllers, execution contexts, action composition and testing
A practical guide to the Play Framework Java API on Play 3.0: request lifecycle, compiled routes, CompletionStage controllers, CustomExecutionContext …
Read article →Project Amber, in depth: how Java's language features ship, how they compose into data-oriented programming, and how to adopt them release by release
A practical guide to OpenJDK Project Amber: the preview process, every delivered feature with its final JEP and release, a worked refactor from instan…
Read article →Project Babylon, in depth: code reflection, the code model, transformers, and how Java code becomes GPU kernels and ML graphs
A first-principles guide to OpenJDK Project Babylon: why classic reflection and bytecode are the wrong input for GPU and ML translators, what the code…
Read article →Project Leyden, in depth: adopting the AOT cache across a fleet, from measurement and training runs to CI, rollout and the roadmap
An adoption guide to Project Leyden's AOT cache for teams running Java services: measuring startup and warmup properly, designing a training work…
Read article →Project Lilliput, in depth: compact object headers, the 64-bit layout, and measuring what it saves
How OpenJDK Project Lilliput shrinks HotSpot object headers from 96 to 64 bits: the legacy and compact layouts bit by bit, why locking and GC forwardi…
Read article →Project Loom, in depth: continuations, carriers, pinning after JEP 491, scoped values, structured concurrency and migrating a thread-pool service to virtual threads
A practical guide to Project Loom as a whole: which JEPs shipped in which JDK, why platform threads capped throughput, how continuations and carrier t…
Read article →Project Panama, in depth: what it delivers, migrating a C library off JNI, native-access policy, packaging and performance
Project Panama from the project level: the FFM API and Vector API it delivers and the JEP timeline behind them, a zlib binding written with JNI, by ha…
Read article →Java Project Valhalla Architecture in Depth
A 2500-word walkthrough of Java Project Valhalla: value classes, layout, nullability, generic specialization, migration, escape analysis, performance.
Read article →Java Prometheus Monitoring, in depth: instrumenting the JVM and your code with client_java, Micrometer and the JMX exporter
How to monitor Java services with Prometheus: the pull model from the JVM's side, client_java 1.x versus Micrometer versus the JMX exporter agent…
Read article →Quarkus, in depth: build-time augmentation, extensions and ArC, the Vert.x threading model, Dev Services, and packaging for JVM or native
How Quarkus moves framework startup work to build time: Jandex indexing, extension build steps, build items and recorders, ArC dependency injection, b…
Read article →Java records architecture
Deep-dive on Java records: declaration, auto members, immutability, compact ctor, pattern matching, sealed, serialization, interop.
Read article →Java ReentrantLock, in depth: AQS internals, fairness, timed and interruptible locking, conditions and deadlock-free transfers
Java ReentrantLock in depth: the unlock-in-finally idiom, how AQS implements it, fair versus non-fair, tryLock and lockInterruptibly, conditions, a de…
Read article →Java Reflection, in depth: the metadata model, access checks under modules, invocation cost and a working DI container
How Java reflection really works: where Class, Field, Method and Constructor objects come from, getMethods versus getDeclaredMethods, setAccessible an…
Read article →JVM safepoints architecture
Deep-dive on JVM safepoints: how the runtime raises a global poll flag and brings every application thread to a compiler-inserted poll site (method bo…
Read article →Java Scoped Values: Immutable Context for the Virtual-Thread Era
How Java scoped values replace ThreadLocal with an immutable, lexically-scoped binding that structured child threads inherit for free — and why that m…
Read article →Java Semaphore
Java Semaphore in depth: permits and AQS internals, fair versus non-fair, the try/finally permit inflation bug, sizing with Little's law, virtual…
Read article →Java Serial GC, in depth: the copying young collection, sliding mark-compact, the card table, when ergonomics picks it and why JDK 27 stopped, and sizing it for small containers
How HotSpot's Serial garbage collector works and when to use it: heap layout and default ratios, Cheney-style minor collections with aging and pr…
Read article →Shenandoah GC architecture
Deep-dive on the Shenandoah garbage collector: why pause time is a correctness-adjacent property, how concurrent marking, evacuation, and reference-up…
Read article →Spring Boot, in depth: the startup sequence, auto-configuration and conditions, externalized configuration, Actuator, test slices and production settings
How Spring Boot works underneath and how to run it well: what SpringApplication.run does, how auto-configuration and conditional beans back off, writi…
Read article →Spring Data, in depth: how repository proxies are built, query methods, projections, paging versus scrolling, save() and entity state, transactions and fetch planning
Spring Data JPA from the inside: how a repository interface becomes a proxy at startup, query lookup and derived queries, interface and DTO projection…
Read article →Spring Framework, in depth: the IoC container, bean definitions and post-processors, the bean lifecycle, scopes, proxy-based AOP, transactions, events and what 7.0 changed
How the Spring Framework core container actually works: bean definitions versus instances, BeanFactoryPostProcessor and BeanPostProcessor, the lifecyc…
Read article →Spring Security, in depth: the servlet filter chain, authentication and authorization architecture, multiple chains, JWT resource servers, sessions and CSRF, testing and the 7.0 changes
How Spring Security works and how to configure it well: DelegatingFilterProxy, FilterChainProxy and SecurityFilterChain, AuthenticationManager and pro…
Read article →Java Stream operations, in depth: stateless, stateful and short-circuiting operations, how pipelines execute, and custom operations with Gatherers
How Java Stream operations behave and execute: the operation taxonomy, vertical per-element execution, how OpenJDK links stages into a sink chain, str…
Read article →Java Streams API
Java Streams API: the lazy pipeline and terminal operations, collectors, when parallel streams help, and the common misuse patterns that make code slo…
Read article →JVM String Deduplication, in Depth: How the Garbage Collector Shares Backing Arrays, When It Pays Off, and How to Measure It
How JVM string deduplication works: what gets shared (the value array, not the String), how G1 selects candidates, the concurrent dedup thread and tab…
Read article →Java String Templates, in depth: the JDK 21-22 preview, template processors, why the feature was withdrawn, and what to use today
An accurate account of Java string templates: the STR, FMT and RAW processors and custom processors from JEP 430 and JEP 459, how fragments and values…
Read article →Java structured concurrency architecture
Deep-dive on Java structured concurrency: StructuredTaskScope binds forked subtasks to a try-with-resources block, runs each on its own virtual thread…
Read article →Java StructuredTaskScope, in depth: joiners, timeouts, cancellation and the JDK 27 API
A working guide to java.util.concurrent.StructuredTaskScope: how the API changed from JDK 21 to JDK 27, open/fork/join/close, built-in and custom join…
Read article →Java synchronized Keyword
Java synchronized in depth: which monitor is locked, bytecode, reentrancy and inflation, happens-before, wait and notify, pitfalls, deadlock diagnosis…
Read article →Testcontainers, in depth: real dependencies in Java tests, lifecycle scopes, wait strategies, networks, Spring Boot and CI
A practical guide to Testcontainers for Java 2.x: what happens when a container starts, the renamed 2.0 artifacts and packages, a first PostgreSQL tes…
Read article →Java Text Blocks, in depth: the compile-time algorithm, incidental whitespace, escapes and the bugs they cause
Java text blocks from first principles: the three compile-time steps from JEP 378, how the closing delimiter controls indentation, the backslash-newli…
Read article →Java ThreadLocal, in depth: ThreadLocalMap internals, weak-key leaks, thread pools, context propagation and virtual threads
Java ThreadLocal in depth: where values live, why weak keys still leak, scoping on thread pools, carrying context across executors, InheritableThreadL…
Read article →Java var, in depth: how local variable type inference works, what the compiler actually infers, and when it helps or hurts readability
A complete guide to Java local variable type inference: JEP 286 and JEP 323, var as a reserved type name, where var is legal, exactly which type javac…
Read article →Java Vector API architecture
Deep-dive on the Java Vector API from Project Panama: vector values and species, SPECIES_PREFERRED shape selection, masks and loop tails, C2 intrinsif…
Read article →Vert.x, in depth: event loops, verticles, contexts, futures, blocking code and the event bus in Vert.x 5
How Eclipse Vert.x works: the multi-reactor event loops and the golden rule, verticles and contexts, Vert.x 5 futures, executeBlocking with worker and…
Read article →Java Virtual Threads Architecture in Depth: continuations, carriers, pinning and sizing
How Java virtual threads work: continuations, carrier threads, mounting and parking, pinning before and after JDK 24, structured concurrency, sizing w…
Read article →VisualVM, in depth: connecting safely, reading samplers honestly and solving leaks with heap dumps
A practical guide to VisualVM 2.2: how it discovers and attaches to JVMs, JMX and jstatd for remote hosts and containers, what each tab really measure…
Read article →Java volatile Keyword, in depth: happens-before, JIT and CPU reordering, safe publication and VarHandle modes
What Java volatile guarantees under the Java Memory Model, what HotSpot emits on x86 and ARM, stop flags, safe publication, double-checked locking, wh…
Read article →WireMock, in depth: HTTP stubbing for Java tests, matching and verification, scenarios, fault injection, templating, recording and keeping stubs honest
WireMock in depth: how the stub server, request journal and admin API work, JUnit 5 setup with dynamic ports, URL and body matching, priorities, verif…
Read article →YourKit + JProfiler, in depth: agent-based JVM profiling from sampling to unattended snapshots
How YourKit and JProfiler work and how to use them without misleading yourself: JVMTI agents, sampling versus instrumentation and safepoint bias, allo…
Read article →ZGC architecture
Deep-dive on the Z Garbage Collector: colored pointers that carry GC metadata inside references, the load barrier that heals stale references lazily, …
Read article →