robsonkades
- 305 skills
- 0 followers
- 3 repo stars
- 3 days ago last updated
- ▌ Project Valhalla · robsonkades bundleEvaluating Project Valhalla value-class proposals and Early-Access builds without presenting draft syntax or flattening heuristics as released Java behavior. Use when code or documentation claims value classes remove identity, guarantee flattened storage, eliminate boxing, change object layout, or are available in a particular JDK; and when designing an experiment for a future migration. Does not replace current object-layout measurement (object-layout-and-footprint), escape-analysis diagnosis (escape-analysis-internals), or general JDK upgrade planning (jdk-upgrade-impact).
- ▌ Slo And Alerting · robsonkades bundleEngineering service-level contracts and actionable alerting: defining user-centered SLIs and SLOs with explicit populations and windows, negotiating error-budget policy, separating request- and time-based semantics, deriving multi-window burn alerts, handling low traffic and missing data, and routing symptoms or predictive hazards by urgency and actionability. Use when an SLO is ambiguous, an SLA lacks operating margin, alert noise is high, resource thresholds page without context, or PromQL burn rules need review. Instrument design belongs to metrics-and-cardinality; percentile semantics to latency-statistics; overload controls to rate-limiting-and-load-shedding.
- ▌ Capacity Planning · robsonkades bundleEvidence-based capacity decisions for Java services: defining demand and failure scenarios, measuring feasible capacity envelopes, selecting replica and resource configurations, forecasting exhaustion with uncertainty, designing autoscaling headroom, and comparing cost per successful unit of work. Use when deciding pod or instance counts, minimum replicas, scaling signals, saturation dates, infrastructure budgets, rollout or failure-domain headroom, and downstream capacity constraints. Does not own load-test design (load-testing-advanced), queueing-model selection (queueing-models), scalability curve fitting (universal-scalability-law), or overload controls (rate-limiting-and-load-shedding).
- ▌ Feature Discovery · robsonkades bundleSeparating what is actually established about a feature request from what has been filled in: a ledger in which every fact carries its source, every assumption carries what would falsify it, and every unknown carries the impact of getting it wrong. Use at the start of a feature, when a request is one sentence long and the work is not, when a plan or an estimate is being built on statements nobody has checked, when two people describe the same feature differently, when picking up a feature someone else analysed, or when an answer is about to be written as fact because it is probably true. Does not decide which unknowns to ask about or how (feature-requirement-clarification), does not investigate the repository to close them (feature-context-analysis), and does not restate the requirement without its solution or write acceptance criteria (requirements-and-acceptance).
- ▌ Feature Execution · robsonkades bundleImplementing a planned feature one resource at a time: taking a single resource to done, choosing the validation that resource actually warrants, running it and reading the output, and handling the two things that always happen — the plan turning out to be wrong, and a resource turning out to be blocked. Use when a plan exists and implementation is starting, when several resources are half-finished at once, when implementation has diverged from the plan without anyone recording it, when a resource is blocked and the work has quietly stopped, or when a change is about to be reported as done on the strength of it compiling. Does not choose which automated gates a change must pass (quality-gates), does not decide the test level or write the tests (java-testing-strategy, tdd), does not own the status artefacts (feature-progress-tracking), and does not own what may be claimed about the result (coding-agent-discipline).
- ▌ G1 Tuning For Slo · robsonkades bundleDeriving G1 flag values from a latency SLO and proving they helped: what `MaxGCPauseMillis` actually controls, the young size bounds, IHOP and adaptive IHOP with an explicit safety margin, region size as the basis of every region-denominated calculation, `G1OldCSetRegionThresholdPercent` and `G1MixedGCCountTarget`, and the measure-derive-predict-validate loop. Use when GC flags were copied from another service, when `-Xms` differs from `-Xmx` in production, when mixed GC violates the SLO while young GC is healthy, when GC overhead exceeds its explicit service budget, when a full GC follows a marking cycle that finished too late, when an IHOP was set to the theoretical ceiling, when a G1 flag makes the JVM refuse to start, or when a parser reports a promotion rate of zero. Does not cover deciding whether GC is the bottleneck at all or which collector to use (jvm-gc-tuning), why the mechanism responds the way it does (g1-internals), or configuring and parsing the GC log itself (gc-log-analysis).
- ▌ Java Immutability · robsonkades bundleImmutable objects in modern Java: records in depth, defensive copies, immutable collection factories versus unmodifiable views, deep versus shallow immutability, final-field semantics and safe publication (JMM), and the withers pattern. Use when designing a value object, when a record has a List, Map or array component, when an accessor returns internal mutable state, when an "immutable" object is observed changing, or when deciding whether immutability is worth its allocation cost. Does not cover null validation in constructors (java-null-safety) or Optional usage (java-optional).
- ▌ Java Memory Model · robsonkades bundleProving inter-thread visibility, ordering and atomicity under the Java Memory Model. Covers actions/executions, synchronization order, synchronizes-with and happens-before, data races, sequential consistency for correctly synchronized programs, volatile publication, monitor and lifecycle edges, final-field freeze semantics, safe publication, compound invariants, benign races, constructor escape, wait/notify, and architecture/JIT independence. Use for shared-state correctness reviews and intermittent outcomes. VarHandle modes, algorithms, locks and testing mechanics have separate owners.
- ▌ Java Test Doubles · robsonkades bundleChoosing and using test doubles in Java: the stub/mock/fake distinction that actually changes what a test proves, preferring the real collaborator or a hand-written fake over a mock, verifying interactions only when the interaction is the outcome, Mockito's strict stubs, and the rule against mocking types you do not own. Use when a test mocks every collaborator the class touches, when verify is asserted on a query, when a refactoring broke tests that still describe correct behaviour, when deep stubs or static mocking are proposed, when a stubbed repository is hiding a query that does not work, when UnnecessaryStubbingException appears, or when migrating from @MockBean. Does not cover which level to test at (java-testing-strategy), how the test is written (java-test-design), deterministic executors for threading (concurrency-testing), or breaking a dependency so the class can be constructed at all (java-legacy-code-testing).
- ▌ Jvm Class Loading · robsonkades bundleClass loading, class identity and classloader leaks: parent-first delegation, {defining loader, binary name} identity, loading versus linking versus initialisation, Metaspace retention, and CDS/AOT cache for startup. Use when a ClassCastException reports identical type names on both sides, when Metaspace grows monotonically across redeploys or plugin reloads, when ClassNotFoundException and NoClassDefFoundError need to be told apart, when IllegalAccessError mentions "does not export" or InaccessibleObjectException asks for --add-opens, when a startup hangs with "waiting on the Class initialization monitor" in a thread dump, when a static initialiser does I/O, or when reducing cold start. Does not cover the Metaspace budget itself (jvm-memory-regions), JIT warm-up (jit-compilation), or heap object-retention analysis (heap-dump-analysis). Metaspace internals are metaspace-internals and startup caching in depth is startup-cds-crac-leyden.
- ▌ Pause Attribution · robsonkades bundleAttributing an observed production pause to a layer: decomposing it across time-to-safepoint, safepoint operation, cleanup and host effects, correlating the GC log, the safepoint log, JFR and OS signals by timestamp, and proving which layer owns the missing milliseconds. Use when application p99 far exceeds what the GC log accounts for, when "Reaching safepoint" is large while "At safepoint" is small, when two profilers disagree about hot paths, when a safepoint-log analyser reports zero events, when someone sums "Reaching + At" by hand, or when a fix copied from an old war story does not reproduce. Does not cover the safepoint mechanism itself (safepoints), configuring and parsing the GC log (gc-log-analysis), or host-side causes such as CPU throttling, swap and page faults (linux-for-jvm).
- ▌ Skill Engineering · robsonkades bundleDesigning and reviewing agent skills: scope boundaries, the SKILL.md frontmatter contract, progressive disclosure across references and scripts, explicit decision rules, and quality gates. Use when creating a new skill, when reviewing one that is too long or never activates, when deciding what belongs in SKILL.md versus a reference, or when converting an existing prompt into a skill. Does not cover packaging, versioning or distribution, and does not cover writing the domain expertise itself.
- ▌ Ambassador Pattern · robsonkades bundleChoose or review a local outbound proxy when discovery or routing changes require client releases, a canary or shadow needs routing outside the app, or retries overlap across app, proxy and mesh. Define the listener, policy ownership, deadlines and failure behavior. Covers shard-map consumption and experiment routing, not shard algorithms (sharding-and-partitioning), container lifecycle (sidecar-pattern), or output normalization (adapter-sidecar-pattern).
- ▌ Caching Strategies · robsonkades bundleDeciding whether to cache, then doing it safely: saved origin work and latency, bounded size or weight, TTL and jitter, stampede and its four distinct scopes, cache-aside versus refreshAfterWrite, immutable DTOs rather than JPA entities, invalidation across instances, Redis serialisation, and why hit rate alone is a misleading metric. Use when a cache is being added or reviewed, when @Cacheable is called from within the same bean, when a cache has no size limit or no TTL, when entries are preloaded in bulk with one TTL, when hit rate is the only metric on the dashboard, when Old Gen keeps growing, when FLUSHALL appears in a deploy pipeline, or when instances disagree about a value. Does not cover the pool the cache protects (connection-pool-sizing), the queueing arithmetic (littles-law-and-queueing), or GC tuning for the resulting heap (jvm-gc-tuning).
- ▌ Cascading Failures · robsonkades bundleHow one slow dependency becomes a total outage: the amplification loop and the four points that close it — retry storms, unbounded queues, thread and connection exhaustion, an inner timeout longer than the outer one. Covers why cutting offered work is usually the first stabilization step in a cascade, metastability sustained by backlog, recovery herds and criticality separation. Use when one dependency's latency rise took down services that never call it, when the dependency recovered and the system did not, when adding replicas mid-incident made it worse, or when queue depth grows while goodput falls to zero. Does not cover the breaker (circuit-breakers), shedding policy (rate-limiting-and-load-shedding), bulkheads (concurrency-limiting-and-bulkheads), retry policy (retries-and-backoff), queue arithmetic (littles-law-and-queueing), replica routing (load-balancing-and-routing), or the fault model (failure-models).
- ▌ Consistency Models · robsonkades bundleChoosing distributed consistency guarantees as an engineering decision: linearizability, sequential/causal ordering, session guarantees (read-your-writes, monotonic reads), bounded staleness and eventual convergence, stated as observable contracts rather than a false total ladder; CAP stated correctly—the choice between C and A exists only while partitioned—and PACELC, replica paths and transaction isolation boundaries. Use when a user cannot see their own write, when a read after a write returns the previous value, when a design names a model instead of an observable requirement, when reads are being routed to replicas, or when someone cites "pick two". Does not cover multi-service atomicity (distributed-transactions-and-sagas), quorum arithmetic (consensus-and-quorums), caches (caching-strategies), replicated cache topology (cache-sharding-and-replication), or the JMM's happens-before (java-memory-model).
- ▌ Consistent Hashing · robsonkades bundleStable key-to-node placement across membership changes: modulo remapping, consistent-hash rings, virtual points, rendezvous hashing, collision-safe Java implementations, hash contracts, replica selection, weighting, testing and membership handoff. Use when changing node count causes a miss storm or migration, ownership is uneven, or placement relies on Object.hashCode. Does not choose the shard key (sharding-and-partitioning), repair hot keys (hot-partitions-and-rebalancing), define cache topology (cache-sharding-and-replication), or balance interchangeable replicas (load-balancing-and-routing).
- ▌ Cpu Cache And Numa · robsonkades bundleHardware-aware Java: cache-line coherence and locality, false sharing and how it differs from lock contention, object layout measured with JOL, LongAdder versus AtomicLong, data locality in arrays and collections, and NUMA topology. Use when throughput gets **worse** as threads are added, when scaling efficiency collapses, when fields are being added to a class shared between threads, when volatile counters sit next to each other, when @Contended or padding is proposed, when -XX:+UseNUMA is being set, or when someone says a volatile write "flushes the cache". Does not cover happens-before correctness (java-memory-model), pool and queue sizing (littles-law-and-queueing), or kernel and cgroup behaviour (linux-for-jvm). Proving and fixing false sharing is false-sharing-and-contended, and topology and pinning is numa-and-cpu-affinity.
- ▌ Delivery Semantics · robsonkades bundlePrecise end-to-end delivery and processing semantics: acknowledgement placement, loss and duplicate windows, Kafka transactions, visibility leases, ambiguous outcomes and external side effects. Use when reviewing "exactly once", consumer commits, redelivery or a handler that writes outside its broker. Idempotent handler design belongs to idempotency; retries, ordering, poison messages and fault assumptions have their own skills.
- ▌ Gof Factory Method · robsonkades bundleFactory Method in modern Java, and the three different things that share its name: the GoF pattern (a creation hook a subclass overrides inside an inherited algorithm), Effective Java's static factory method (a named constructor, not this pattern), and any method someone called createX. Covers when the subclass hook is genuinely right, why an injected Supplier or a keyed map replaces it in most application code, and the constructor-calls-an-overridable-method trap it invites. Use when a protected createX() hook is proposed, when a class is subclassed only to change which type it instantiates, when tests subclass production code to substitute an object, when a static factory is being called Factory Method in review, or when deciding between a subclass hook and a Supplier. Does not cover families of related products (gof-abstract-factory), the surrounding algorithm skeleton (gof-template-method), or static factory naming conventions (java-object-construction).
- ▌ Heap Dump Analysis · robsonkades bundleTaking and analysing a JVM heap dump: capturing without making the incident worse, dominator tree versus shallow and retained size, path to GC roots excluding weak references, Eclipse MAT and OQL, comparing two dumps, and separating a leak from a large working set. Use when heap grows monotonically with uptime, after an `OutOfMemoryError` or a `-XX:+HeapDumpOnOutOfMemoryError` file appears, when a histogram is being read by shallow size, when `jcmd` or `jmap` hangs against a stuck JVM, when a `WeakHashMap` or `ThreadLocal` cache never empties, when `StackChunk` or `Continuation` tops a dominator tree, or when writing OQL. Does not cover the region budget and which OOM message means what (jvm-memory-regions), why a live set costs what it costs (gc-fundamentals), classloader leaks specifically (jvm-class-loading), or core-dump and Serviceability Agent workflows (jhsdb-and-core-dumps).
- ▌ Java Numeric Types · robsonkades bundleChoosing and using Java's numeric types correctly: binary floating-point limits for exact decimal amounts, BigDecimal construction, scale, rounding and the equals/compareTo split, integer overflow and the exact-arithmetic methods, primitives versus boxed types, the boxed-value caching that makes == appear to work for some values, unboxing NPEs, boxing cost in bulk paths, and what happens to a numeric value when it crosses JSON, a database column or a JavaScript client. Use when money or any exact quantity is held in double or float, when new BigDecimal(double) appears, when divide() has no rounding mode, when BigDecimal values are compared with equals, when boxed types are compared with ==, when a nullable Integer is unboxed, when arithmetic on ids, timestamps or sizes could overflow, or when large longs are serialised to a browser. Does not cover date and time types, string formatting and parsing (java-strings-and-text), or measuring allocation (allocation-profiling).
- ▌ Java Tell Dont Ask · robsonkades bundleDecision ownership: the type that owns an invariant or policy makes the decision. Use when a service reads state with getters, decides, and writes state back (if (acct.getBalance() > x) acct.setBalance(...)), when the same rule is re-derived from the same getters in several places, when an invariant exists but no type enforces it, when a domain model is all getters and setters with the logic in services, or when a getter has side effects. Covers command–query separation and when asking is correct: boundaries, reporting, cross-aggregate orchestration. Does not cover the navigation chains that often carry the asking — that is java-law-of-demeter.
- ▌ Jdk Upgrade Impact · robsonkades bundleMoving a service between JDKs: what breaks, in what order to find it, and what should get faster — running unchanged on the new runtime with warnings visible, classifying each failure as a retired flag, strong encapsulation, a removed API, a changed default or a third-party agent, and measuring the gain claimed for the upgrade. Use when an LTS-to-LTS move is planned, when a build passes and the service will not start on the new JDK, when --add-opens is being added to make something work, when -Djava.security.manager=allow is on the command line, when sun.misc.Unsafe or an instrumentation agent is in the dependency tree, when a mocking or proxy library fails on a new class file version, when generated code goes missing after the move to JDK 23 or later, when a formatted time stopped matching a literal, or when an upgrade is credited with a speedup nobody measured. Not the flag lifecycle in detail (jvm-performance-review), collector changes (jvm-gc-tuning), or automating source edits (refactoring-automation).
- ▌ Jvm Memory Regions · robsonkades bundleThe major memory-accounting domains of a JVM process — heap, Metaspace/class space, code cache, thread stacks, direct/native/JVM-internal memory and mapped/file-backed pages — and how to budget them against a container limit. Use when a pod is OOMKilled with no Java exception, when an OutOfMemoryError names something other than "Java heap space", when -Xmx is set equal to the container limit, when RSS exceeds the heap by more than expected, when a heap above 32 GB is proposed, or when sizing a JVM for Kubernetes. Does not cover collector choice and heap tuning (jvm-gc-tuning), classloader leaks (jvm-class-loading), or kernel-side memory behaviour such as page faults, swap and the OOM killer (linux-for-jvm). Metaspace internals are metaspace-internals, memory outside the heap is off-heap-memory, and heap contents are heap-dump-analysis.
- ▌ Latency Statistics · robsonkades bundleThe statistics of latency measurement: estimands, means and quantiles, histogram aggregation, uncertainty, censoring, dependence, and coordinated omission. Use when an SLO or dashboard reports mean latency, when p99 values are averaged across instances or time windows, when a percentile is quoted without its sample count, when Prometheus buckets are the default set, or when deciding whether two measurements actually differ. Does not cover generating the load (load-testing), sizing systems from throughput (littles-law-and-queueing), or the investigation process itself (performance-methodology). The deep treatment of coordinated omission is coordinated-omission, and tail decomposition is tail-latency-analysis.
- ▌ Lock Free Patterns · robsonkades bundleDesigning and reviewing nonblocking Java algorithms: linearization points, lock-free, wait-free and obstruction-free progress, CAS/RMW loops, success/failure ordering, contention collapse, backoff/helping, ABA/version wrap, node reuse and reclamation, publication, linearizability, starvation and shutdown. Requires comparison with JDK/library and lock-based alternatives plus retry and topology measurement. Use when implementing or diagnosing atomics, striped counters, queues, stacks or ring buffers—not as a synonym for “fast.”
- ▌ Repository Pattern · robsonkades bundleThe repository as a collection-like boundary over domain objects, with aggregate-root write boundaries in DDD: what belongs behind it, where queries and read models fit, and when a redundant CRUD wrapper can be removed without losing a useful contract. Use when a repository is being added for a child entity, when a generic or base repository is proposed, when repository methods carry business verbs (cancelExpired, activateEligible), when a managed entity escapes through the repository interface, when reads and writes both go through the same interface and reads are slow, when a repository interface wraps a Spring Data interface that wraps the ORM, or when someone argues that Spring Data repositories make the pattern unnecessary. Does not cover query composition (query-objects-and-specifications), ORM runtime behaviour (orm-behavioral-patterns), which data-access pattern underlies it (data-source-patterns), or aggregate design itself (domain-logic-organization).
- ▌ Structured Logging · robsonkades bundleDesigning application logs as governed event schemas: choosing events and fields, correlation and context lifecycle, exception and severity semantics, synchronous versus buffered delivery, overload/drop behavior, injection prevention, data minimization, integrity/retention and measurable cost. Use when logs require regex parsing, correlation is missing or stale across async work, events disappear under load, fields drift between services, failures are duplicated, secrets or untrusted text reach logs, or logging appears in latency profiles. Metric labels belong to metrics-and-cardinality; span topology to distributed-tracing-design; JVM -Xlog to unified-logging.
- ▌ Zgc And Shenandoah · robsonkades bundleOperating ZGC and Shenandoah in production: concurrent relocation via coloured pointers and load barriers, the CPU the concurrent phases actually take, allocation stalls, and which flags still exist. Use when a service migrated to a concurrent collector and throughput dropped, when a GC log shows "Allocation Stall", when a pod of 1-2 CPUs runs ZGC or Shenandoah, when a config still carries -XX:+ZGenerational or G1 flags after the migration, when a ZGC-versus-Shenandoah comparison does not declare ShenandoahGCMode, or when RSS from ps/top is being used to size a ZGC container. Does not cover deciding whether GC is the bottleneck or which collector to pick (jvm-gc-tuning), the introductory collector model (gc-fundamentals), or collector source-level internals (zgc-generational-internals, epsilon-and-shenandoah-internals).
- ▌ Code Cache Segments · robsonkades bundleThe JDK 17-25 segmented code cache, GC-driven unloading, fragmentation, segment sizing, and jcmd Compiler.codecache/CodeHeap_Analytics. Use when aggregate usage looks healthy but one CodeHeap is exhausted, compilation stops or restarts, GC logs show a CodeCache cause, startup rejects manual heap sizes, an OutOfMemoryError reports "Out of space in CodeCache", or a long-running service degrades while aggregate free space remains. Covers runtime-shape discovery so tools do not assume exactly three heaps on every mode or release. Excludes the introductory exhaustion signature (jit-compilation), container memory budgeting (jvm-memory-regions), and Metaspace internals (metaspace-internals).
- ▌ Concurrency Testing · robsonkades bundleTesting concurrent Java so failures appear in CI rather than in an incident: what a passing concurrency test does and does not prove, replacing sleeps with latches and deterministic executors, explicitly exercising cancellation, interruption and timeout, stress tests that assert invariants, and soak tests that catch permit and connection leaks. Use when a test uses Thread.sleep to wait for another thread, when a concurrency test is flaky and a retry is proposed, when cancellation or timeout paths have no test at all, when tests assert on thread names or pool sizes and broke after a virtual-thread change, when a race was found in production and nobody can reproduce it, or when a concurrency limit or fallback has never been exercised under failure. Does not cover proving memory-model claims (java-memory-model, varhandles-and-memory-ordering), benchmark methodology (jmh-microbenchmarks), load generation and rates (load-testing), or diagnosing a live system (concurrency-diagnostics).
- ▌ Container Awareness · robsonkades bundleWhat the JVM actually detects inside a container: cgroup v1 versus v2 detection, ActiveProcessorCount and how a CPU quota becomes a processor count, MaxRAMPercentage and every ergonomic derived from it, GC and JIT thread counts sized from the wrong number, and verifying all of it from inside the running container. Use when a pod is OOMKilled while heap usage is well below Xmx, when a Deployment has no resources.limits or sets limits.memory equal to Xmx, when MaxRAMPercentage is pushed to 90, when someone reads ActiveProcessorCount out of PrintFlagsFinal or jcmd VM.flags and gets -1, when a cgroup command reads /sys/fs/cgroup/cpu/cpu.stat and finds nothing, or when latency spikes have no matching GC pause. Does not cover host-side kernel behaviour such as the node OOM killer, page faults, swap, PSI or signals (linux-for-jvm), the memory-region budget itself (jvm-memory-regions), or CPU topology and pinning (numa-and-cpu-affinity).
- ▌ Distributed Systems · robsonkades bundleTriage and routing entry point for cross-process Java systems. Classifies design questions and production symptoms, establishes boundary and fault assumptions, then selects the specialist skill for delivery, consistency, time, overload, partitioning, messaging, coordination, recovery or observability. Use when the next technical owner is unclear; it deliberately does not duplicate specialist guidance.
- ▌ Feature Engineering · robsonkades bundleOwning a Product Feature or Tech Feature from definition intake to completion review: selecting proportionate depth, routing iterative analysis and explicit returns, holding readiness gates, and keeping versioned evidence another engineer can resume. Use when feature implementation is being prepared, resumed, or validated and its scope, contracts, decisions, or completion need a trustworthy lifecycle. Does not co-author the initial feature brief (collaborative-feature-definition), own any specialist phase in depth, orchestrate an arbitrary change (clean-delivery-workflow), or define the ADR record format (architecture-decision-making).
- ▌ Gof Template Method · robsonkades bundleTemplate Method in modern Java: fixing an algorithm's skeleton while named steps vary, and the inheritance coupling that often makes composition preferable. Covers when final protects the sequence, controlled overriding, minimal hook surfaces, the constructor-calls-an-overridable-method trap, protected hooks becoming an API you cannot change, when the pattern is genuinely right (frameworks that instantiate your subclass, contract test base classes), and how to convert one to a class taking its steps as collaborators. Use when an abstract base class with protected hooks is proposed, when a base-class change broke subclasses, when a template has grown past a handful of hooks, or when subclasses override the template method itself. Does not cover choosing a whole algorithm (gof-strategy), creating the product a template needs (gof-factory-method), the general inheritance decision (java-composition-over-inheritance), or pipeline stages contributed independently (gof-chain-of-responsibility).
- ▌ Java Dry Kiss Yagni · robsonkades bundleThe economics of duplication and abstraction in Java: knowledge duplication versus incidental (textual) duplication, what a shared abstraction costs, the wrong-abstraction failure mode, premature abstraction and speculative generality, essential versus accidental complexity. Use when deciding whether two similar pieces of code should be merged, whether a shared helper should be inlined back into its callers, when a utility has grown boolean parameters, or when reviewing code generalised for requirements that do not exist. Does not cover the smell catalogue (java-code-smells) or the mechanics of extracting and inlining (java-refactoring).
- ▌ Java Law Of Demeter · robsonkades bundleNavigation coupling: what the Law of Demeter actually constrains — structure exposure, not dot-counting — and how to tell a train wreck from a legitimate chain. Use when reviewing chains like order.getCustomer().getAddress().getCity(), when a change to one class's shape rippled through files that never mention it, when deciding whether a chain couples the caller to structure or merely reads data, or when a proposed fix would add forwarding methods to every intermediate class. Does not cover designing fluent chains (java-fluent-apis) or where the decision made on the navigated data should live (java-tell-dont-ask).
- ▌ Jmh Microbenchmarks · robsonkades bundleDesigning and auditing JVM microbenchmarks whose workload, observation boundary, compiler context, state topology, lifecycle, units, and statistical comparison match the engineering question. Covers dead-code elimination, constant folding, Blackhole/return values, forks, warm-up, fixture levels, inputs, operations-per-invocation, allocation counters, experimental units, uncertainty, paired comparisons, negative controls, and production extrapolation. Use before trusting a JMH score or replacing a system test with a microbenchmark. Advanced concurrency layouts, profilers, assembly, and regression gates have separate owners.
- ▌ Metaspace Internals · robsonkades bundleMetaspace internals on JDK 16+: chunk and arena allocation per ClassLoaderData, the compressed class space and its separately configured reservation/limit, chunk waste and fragmentation, when memory is actually returned to the OS, and reading `jcmd VM.metaspace` and the nested `VM.native_memory` output. Use when `OutOfMemoryError: Metaspace` or `Compressed class space` is thrown, when a container is OOMKilled with a healthy heap, when metaspace committed grows monotonically, when `MaxMetaspaceSize` is unset or copied from another service, when `waste` in the class space is climbing, or when proxies, hidden classes or a scripting engine generate classes at runtime. Does not cover the process-wide memory map and container budget (jvm-memory-regions), classloader identity, unloading and the retainer hunt for a leak (jvm-class-loading), or anything about compiled code and the code cache (code-cache-segments).
- ▌ Retries And Backoff · robsonkades bundleRetry as a policy with a cost: classifying a failure as transient, permanent or ambiguous before retrying anything; why a timeout is ambiguous and safe to retry only under idempotency or reconciliation; capped jittered backoff; aggregate retry budgets plus per-call limits; one layer owning the end-to-end policy; and honouring 429, Retry-After and the remaining deadline. Use when a catch block retries on Exception or on a message substring, when backoff has no jitter, when several layers each retry the same call, when a POST is retried after a timeout, when a dependency's inbound rate rises as its success rate falls, when a retry sleeps inside a transaction, or when duplicates appear after an outage. Does not cover making the operation safe to repeat (idempotency), the bound itself (timeouts-and-deadlines), tripping (circuit-breakers), retry storms (cascading-failures), load shedding (rate-limiting-and-load-shedding), or the exception type (java-exception-design).
- ▌ Simd And Vector API · robsonkades bundleVectorisation on the JVM: C2 SuperWord auto-vectorisation and the loop shapes that defeat it, the incubating Vector API (species, lanes, masks, loop bound and tail handling), proving that vector instructions were actually emitted, and portability and non-intrinsic fallback risks. Use when someone proposes rewriting a hot loop with jdk.incubator.vector, when a SIMD rewrite produced no measurable gain, when "the Vector API is stable since JDK 21" appears in a PR or design document, when compilation fails with "package jdk.incubator.vector is not visible", when a fixed species is pinned across a heterogeneous fleet, or when a component speedup is being extrapolated to system throughput. Does not cover reading the emitted instructions in general (reading-jit-assembly), the loop optimisations upstream of code generation (c2-sea-of-nodes), or benchmark construction and harness pitfalls (jmh-advanced).
- ▌ Allocation Profiling · robsonkades bundleAttribute Java heap allocation to code and validate reductions in bytes per operation. Use when allocation or GC frequency regresses, JFR allocation events are empty or disagree with counters, large buffers trigger G1 humongous collections or ZGC stalls, or pooling, TLAB tuning, or assumed JIT elimination is proposed without measurements. Covers sampling semantics and allocation-specific triage; general capture selection belongs to jfr-and-async-profiler, retention diagnosis to heap-dump-analysis, and scalar replacement mechanisms to jit-inlining-and-escape-analysis.
- ▌ Architecture Testing · robsonkades bundleWrite or review tests for architectural promises: dependency boundaries, transaction atomicity, persistence mappings, stale-write detection, query budgets and API/event compatibility. Use when green tests missed a lost update or N+1, a boundary exists only in documentation, or an integration test may hide the behavior it claims to verify. Does not choose the architecture or governance thresholds (architecture-fitness-functions), replace general unit-test design, or establish production capacity (load-testing).
- ▌ Continuous Profiling · robsonkades bundleDesigning and operating always-on production profiling: question-driven signal choice, permanent overhead and coverage budgets, in-process versus host collection, context-label propagation, profile schemas, storage and cardinality, retention and incident preservation, deploy-aware comparisons, trust boundaries, and evidence-quality SLOs. Use when historical CPU/allocation/lock evidence must survive an incident, when profile cost or tenant labels can grow without bound, when a backend or agent is being selected, or when two time windows are compared as a regression claim. Does not teach one-off capture mechanics (jfr-and-async-profiler), async-profiler engines (async-profiler-advanced), JFR tuning (jfr-advanced), or graph interpretation (flame-graph-analysis).
- ▌ Coordinated Omission · robsonkades bundleCoordinated omission in depth: response-coupled sampling, open/closed/semi-open workload models, scheduled-versus-actual clocks, generator saturation, correction at recording time versus at generation time, HdrHistogram's recordValueWithExpectedInterval semantics, what wrk2, k6, Gatling, JMeter and Locust each actually do, and the effect on capacity numbers. Use when a load test's p99 is far better than production's for the same endpoint, when a generator misses its planned schedule, when someone proposes applying recordValueWithExpectedInterval to open-loop data, when a latency dashboard improves as a system saturates, or when a benchmark's numbers are about to become an SLO. Does not cover the introductory treatment or the general statistics of latency (latency-statistics), or designing the load test as a whole (load-testing).
- ▌ Data Source Patterns · robsonkades bundleChoosing how code reaches the database — Table Data Gateway, Row Data Gateway, Active Record or Data Mapper — from the shape of the domain logic rather than from framework habit, and knowing what each one couples together. Use when a new module's persistence approach is being chosen, when entities carry both business rules and save() methods, when JPA is being applied to a schema that fights it, when SQL is scattered through service classes, when a "DAO" layer duplicates what the ORM already provides, when the domain model's shape is visibly dictated by the tables, when bulk or reporting work is being forced through an ORM, or when a team is arguing Active Record versus Data Mapper in the abstract. Does not cover where business logic lives (domain-logic-organization), the ORM's runtime behaviour — unit of work, identity map, lazy load (orm-behavioral-patterns), the column-level mapping decisions (orm-structural-mapping), or the collection-shaped abstraction over aggregates (repository-pattern).
- ▌ Database Performance · robsonkades bundleEvidence-first triage and routing for database performance questions across SQL Server, MySQL/InnoDB, PostgreSQL, JDBC pools, ORM behavior, index portfolios, and bulk loading. Use when the symptom spans layers, the owning mechanism is unclear, or a database choice or migration needs structured comparison. This is a router; it does not replace the specialist skills that own a confirmed engine or mechanism.
- ▌ Flame Graph Analysis · robsonkades bundleInterpreting flame graphs as weighted sampled call-path aggregates: identifying the selection event and denominator, separating inclusive from leaf/self attribution, recognizing truncation, inlining, symbol and thread/task artifacts, using bottom-up and differential views, quantifying sample uncertainty, and turning a hotspot into a bounded causal experiment. Use when a graph looks CPU-heavy, idle-heavy, fragmented, changed after a deploy, or tempting to optimize by width alone. Does not collect profiles (jfr-and-async-profiler), configure engines/conversion (async-profiler-advanced), or define benchmark/latency inference (jmh-microbenchmarks, latency-statistics).
- ▌ Gof Abstract Factory · robsonkades bundleAbstract Factory in modern Java: the pattern exists to keep a _family_ of related objects mutually consistent when the family varies, not to centralise construction. Covers the family invariant that justifies it, why dependency injection already resolves the deployment-time case, when per-request or per-tenant selection benefits from a family provider, and how to express it as a record of suppliers or a sealed provider rather than a four-level interface hierarchy. Use when a factory interface is proposed, when profile-specific object graphs are being built by hand, when a family of parser/renderer/validator types must never be mixed across formats, when a plugin SPI must supply several related types at once, or when reviewing a factory whose products have nothing to do with each other. Does not cover single-product creation (gof-factory-method), assembling one complex object (gof-builder), copying an existing instance (gof-prototype), or wiring policy in general (java-dependency-inversion).
- ▌ Gof Pattern Thinking · robsonkades bundleReasoning from a design problem to a design, where a Gang-of-Four pattern is one possible outcome and "no pattern" is an equally valid one: naming the forces, identifying what varies and along how many axes, walking the alternatives ladder from language feature up to architecture, and pricing the indirection before adopting it. The first of two stages — run this, then gof-pattern-selection maps the result to a shortlist. Use when a pattern name is proposed before the problem is stated, when a review must judge whether an abstraction earns its place, when factories and strategies have accumulated that trace to no requirement, when an indirection needs pricing, or when a design is starting and the vocabulary is about to be chosen by habit. Does not cover the individual patterns (the gof-* skills), telling lookalike patterns apart (gof-pattern-confusion), the misuse catalogue (gof-pattern-antipatterns), enterprise/PoEAA patterns (pattern-selection-and-composition), or SOLID as a framing (java-solid).
- ▌ Graalvm Native Image · robsonkades bundleGraalVM Native Image: closed-world reachability, dynamic-feature metadata, class initialization and image-heap state, CPU targeting, GC and PGO choices, observability, and fair comparison with HotSpot. Use when deciding whether AOT fits a workload, diagnosing build or runtime-only failures, or validating startup, footprint, latency, throughput, build-cost, portability, and security trade-offs. Does not cover Graal as a JVM JIT (graalvm-jit), JVM-preserving startup strategies (startup-cds-crac-leyden), or HotSpot warm-up mechanics (jit-compilation).
- ▌ Jhsdb And Core Dumps · robsonkades bundlePost-mortem inspection of a dead or hung JVM: reading hs_err, producing a usable core dump, the jhsdb modes (jstack, jmap, jinfo, clhsdb, hsdb) against a core or a live process, and the build and symbol requirements that make a dump readable. Use when a process died and left an hs_err_pid file, when jstack or jcmd hangs against a wedged JVM, when a container disappeared with exit code 137 and no log, when a crash points at a J/V/C frame, when jhsdb reports DebuggerException or nonsensical pointers, or when someone proposes generating a core dump with `jcmd VM.native_memory summary`. Does not cover heap dumps and retention analysis (heap-dump-analysis), why the process died at the host level (linux-for-jvm), or which memory region the failure was in (jvm-memory-regions).
- ▌ Reading Jit Assembly · robsonkades bundleReading the machine code HotSpot actually emitted: installing hsdis, driving -XX:+PrintAssembly and JMH perfasm, telling the verified entry point and prologue from the method body, and confirming or refuting a hypothesis about an optimisation from the instructions themselves. Use when a claim about an optimisation needs proof at the instruction level, when PrintAssembly prints hex bytes instead of mnemonics, when PrintOptoAssembly on a product JDK unexpectedly prints only banner lines, when the capture must come from a running JVM, when a load has no cmp/test before it and someone concludes the null check was eliminated, when an assembly excerpt from a blog is in the other operand order, or when unexplained runtime calls appear between the expected logic. Does not cover the compiler phases that produced the code (c2-sea-of-nodes), what the compiler decided to inline or compile (compilation-and-inlining-logs), vectorisation as a subject (simd-and-vector-api), or benchmark construction (jmh-advanced).
- ▌ Service Layer Design · robsonkades bundleDesigning the layer that fronts business logic: what an application service owns (transaction boundary, authorisation, orchestration, translation) and what it must not absorb, the difference between application and domain services, and whether the layer is warranted at all. Use when every service method is a single repository call, when a service has become where all rules accumulate, when two services call each other and transactions nest, when authorisation is spread between controller and repository, or when a facade is added over a facade. Does not cover where the rules belong (domain-logic-organization), transaction semantics (enterprise-transactions), remote API design (remote-facade-and-dto), or layer dependency direction (layering-and-boundaries).
- ▌ Consensus And Quorums · robsonkades bundleCrash-fault consensus and quorum reasoning: FLP, safety versus liveness, majority 2f+1, R + W > N intersection and its limits, voter/failure-domain placement, Raft terms and why external fencing still requires resource enforcement, plus the differing read/watch contracts of etcd, ZooKeeper and Consul. Use when a cluster size is being chosen, when nodes are spread across AZs or regions, when application data or a queue is being put in etcd or ZooKeeper, when a coordination store sits on the request path, when a watch is treated as a delivery guarantee, or when a fourth node is proposed for redundancy. Does not cover CAP and the model ladder (consistency-models), mutual exclusion built on top (distributed-locks-and-leases), electing a singleton worker (leader-election), or the fault model itself (failure-models).
- ▌ Database Bulk Loading · robsonkades bundleDesigning and diagnosing high-volume database ingestion from the JVM across PostgreSQL, MySQL, and SQL Server: JDBC batching and statement rewrite, native COPY/LOAD DATA/Bulk Copy, staging, transaction and partial-error semantics, idempotent restart, upsert races, logging, parallelism, and post-load validation. Use when a backfill, import, migration, or batch window is too slow or unsafe. Not routine ORM fetch/write tuning, which belongs to orm-fetch-and-batching-performance.
- ▌ Database Index Design · robsonkades bundleDesigning and governing an index portfolio across SQL Server, MySQL/InnoDB, and PostgreSQL: deriving composite keys from a workload, equality/range/order trade-offs, covering and partial indexes, write amplification, redundant-index consolidation, engine-specific semantics, and safe production creation or removal. Use when changing schema indexes for several queries or reviewing a table's index set. Not the diagnosis of one slow statement, which belongs to sql-query-performance.
- ▌ Feature Decomposition · robsonkades bundleDeciding whether a feature should be split at all and, when it should, into what: child features only where they carry independent value someone can state, Tech Features for independently useful engineering outcomes, and below both a flat list of implementation resources with identifiers, dependencies and their own validation. Use when a feature is about to be implemented as one undifferentiated lump, when a small change is being ceremonially split into items nobody needs, when work has to be ordered because parts depend on each other, when two people or two sessions will share the work, or when progress cannot be reported because there is nothing to report progress against. Does not write the plan around the breakdown (feature-implementation-plan), does not track the resulting statuses (feature-progress-tracking), and does not estimate any of it (estimation-under-uncertainty).
- ▌ Feature Risk Analysis · robsonkades bundleNaming what could go wrong with a specific feature in a form that can be acted on: the failure stated as an event rather than a worry, how anyone would find out it happened, what reduces its probability or its cost, and what is done if it happens anyway. Use before implementation on anything touching data, integrations, concurrency or a released contract, when a plan has a risk section containing only adjectives, when a HIGH risk has no detection signal, when a migration or a breaking change is about to ship, or when a review asks what happens if this fails and there is no answer. Does not catalogue distributed failure modes in general (distributed-failure-catalogue, failure-models), does not decide whether a deliberate shortcut is acceptable (technical-debt-decisions), and does not design the resilience mechanism (timeouts-and-deadlines, retries-and-backoff, circuit-breakers, concurrency-limiting-and-bulkheads).
- ▌ G1 Concurrent Marking · robsonkades bundleG1's concurrent marking cycle: SATB and the pre-write barrier, the cycle phases and the single mark bitmap with TAMS, adaptive IHOP triggering, mark stack overflow and its consequences, humongous allocation and eager reclaim, and mixed-collection candidate selection. Use when the log shows "Concurrent Mark Restart for Mark Stack Overflow", when "Pause Full" follows incomplete marking cycles, when "Concurrent Mark From Roots" grows longer cycle over cycle, when marking starts well away from 45% occupancy, when someone proposes -XX:G1HeapOccupancyPercent or -XX:+G1SummarizeConcMark, or when humongous allocations are frequent. Does not cover regions, remembered sets and the evacuation pause itself (g1-internals), choosing flag values against an SLO (g1-tuning-for-slo), or configuring and parsing the GC log (gc-log-analysis).
- ▌ Gof Pattern Confusion · robsonkades bundleTelling apart the patterns that look alike, so a design is not chosen because a name sounded right. Covers the four wrappers (Adapter, Decorator, Proxy, Facade) and the two questions that separate them, Strategy against State against Template Method against Command, Observer against Mediator, the three creational lookalikes plus the static factory that is not Factory Method, Composite against Decorator, Visitor against Iterator, Command against Event, and Memento against snapshot against event sourcing. Use when two patterns both seem to fit, when a review comment disputes what a class is, when a wrapper's kind must be named, when a class is described with a pattern name that does not match what it does, or when documenting an existing design. Does not cover getting from a problem to a shortlist (gof-pattern-selection), the reasoning discipline (gof-pattern-thinking), any individual pattern's own guidance (the gof-* skills), or misuse catalogues (gof-pattern-antipatterns).
- ▌ Gof Pattern Selection · robsonkades bundleGetting from a stated design problem to a candidate pattern, or to no pattern, without choosing by familiarity. The second of two stages: it assumes the forces are named and the alternatives ladder has already been walked (gof-pattern-thinking), and supplies the mapping. Covers the discriminating questions that actually separate the twenty-three patterns, a selection matrix mapping design problems to candidates with their simpler alternatives, the relationship graph showing which patterns imply, replace or combine with which, and the compositions that reinforce or fight each other. Use when someone asks which pattern fits, when two candidate patterns both seem to fit, when patterns already chosen are producing friction, or when an existing design must be explained as a set of decisions. Does not cover telling lookalike patterns apart (gof-pattern-confusion), any individual pattern's guidance (the gof-* skills), or enterprise and architectural pattern selection (pattern-selection-and-composition).
- ▌ Java Exception Design · robsonkades bundleExceptions as API design in Java: checked versus unchecked as a deliberate decision, hierarchy sizing, translation at layer boundaries with cause preservation, typed failure facts for retry policy, failure atomicity when a method throws partway through, and when a sealed result type beats an exception. Use when designing the exception surface of a service or library, when a catch block swallows a failure or rewraps one without its cause, when a codebase has dozens of exception types nobody catches separately, or when retry logic parses exception messages. Does not cover input validation at trust boundaries (java-defensive-programming) or precondition and postcondition semantics (java-design-by-contract).
- ▌ Java Object Contracts · robsonkades bundleThe four contracts every Java object inherits or opts into — equals, hashCode, toString, Comparable — plus why clone is not one of them. The equals properties and how inheritance breaks symmetry, the hashCode obligation and what is stable across JVMs, records' generated implementations and their array and floating-point edges, entity identity under JPA and Hibernate proxies, total ordering and TimSort contract violations, and copying without Cloneable. Use when equals is overridden without hashCode, when an object is a HashMap key, when an entity's equals is built on a database id, when a TreeSet loses an element, when compareTo subtracts, or when a record's generated toString reaches a log. Immutability is java-immutability, null handling inside these methods is java-null-safety, and cross-process hashing is consistent-hashing.
- ▌ Java Strings And Text · robsonkades bundleText in Java as encoded data rather than a universal type: UTF-16 code units versus code points versus graphemes, charsets and why the platform default is not a policy, locale-sensitive case and formatting including the Turkish-I bug, concatenation cost in loops versus single expressions, text blocks, regex compilation and catastrophic backtracking on untrusted input, interning, and injection through SQL, shells, paths and logs. Use when a String stands in for a type or compound key, when text is truncated by length(), when toLowerCase() or String.format() omits a Locale, when getBytes() omits a charset, when a Pattern is compiled in a loop or applied to user input, or when user text reaches SQL, a command or a log line. Numeric formatting is java-numeric-types, String standing in for a domain type as a smell is java-code-smells, and wire-format throughput is serialization-performance.
- ▌ Java Testing Strategy · robsonkades bundleChoosing which test level earns its cost for a given change: what a unit, integration, contract or end-to-end test can and cannot prove, pushing each test to the narrowest scope where the risk is actually real, what every mocked boundary obliges you to verify elsewhere, and coverage as a diagnostic rather than a target. Use when deciding where to test a change, when a suite is slow or nobody trusts it, when a bug escaped a green suite, when mocks make a test pass while production fails, when a coverage gate is proposed, or when a fix needs a regression test. Does not cover how an individual test is written (java-test-design), doubles and Mockito (java-test-doubles), the red-green-refactor loop (tdd), concurrency (concurrency-testing), distributed behaviour (distributed-systems-testing), architecture rules (architecture-testing), load and benchmarks (load-testing, jmh-microbenchmarks), or getting untestable legacy code into a harness (java-legacy-code-testing).
- ▌ Load Testing Advanced · robsonkades bundleSelecting and executing advanced load profiles—baseline, capacity-envelope, breakpoint, stress, spike, ramp, soak and recovery—using bracketed boundaries, scenario-specific validity, phase isolation and server-side evidence. Use when one steady run is presented as capacity, when overload and SLO boundaries are conflated, when burst/recovery or long-duration resource retention must be tested, or when automation parses generator output. Basic workload validity belongs to load-testing; coordinated omission to coordinated-omission; statistical inference to latency-statistics; provisioning to capacity-planning.
- ▌ Numa And Cpu Affinity · robsonkades bundlePlacing a JVM on real hardware topology: reading the NUMA topology, numactl and taskset pinning strategies, interpreting numastat, which collectors UseNUMA actually governs, how CPU sets interact with the JVM's own NUMA logic, and deciding between pinning and interleaving. Use when a large heap runs on a multi-socket or NPS2/NPS4 host with no binding at all, when a command uses numactl --cpubind, when UseNUMA is set alongside ZGC or Shenandoah and produced nothing, when perf is asked for a numa_miss event, when numastat -p is being read for hit and miss counters, when taskset confines the whole JVM to a couple of CPUs, or when a latency regression followed a hardware change. Does not cover the introductory treatment of cache lines, false sharing and local versus remote latency (cpu-cache-and-numa), what the JVM detects from cgroup limits (container-awareness), or CFS throttling and the rest of the host layer (linux-for-jvm).
- ▌ Reactive Backpressure · robsonkades bundleBackpressure in reactive and asynchronous pipelines: Reactive Streams request semantics, operators that reshape demand, bounded buffers and overflow strategies, blocking inside a non-blocking pipeline, and measuring where demand is actually being throttled. Use when memory grows in proportion to time under load, when a sequence terminates with an unexpected overflow error, when onBackpressureBuffer is used with no size or no BufferOverflowStrategy, when a refactor replaced a Reactor pipeline with unbounded task submission and the concurrency limit vanished, when block() or a JDBC call sits inside a pipeline, or when a dashboard queries a Reactor metric name that returns no series. Does not cover the queueing arithmetic behind a bounded buffer (littles-law-and-queueing), the thread-per-request alternative (thread-sizing-and-virtual-threads), or the scheduler underneath parallel operators (executors-and-task-lifecycle).
- ▌ Remote Facade And Dto · robsonkades bundleDesigning what crosses a remote boundary: a Remote Facade providing coarse, business-shaped operations, and DTOs carrying the data in one round trip — plus when a DTO earns its mapping cost. Use when an API mirrors the domain model method for method, when a client makes five calls to render one screen, when JPA entities are serialised to clients, when a DTO is a field-for-field copy of an entity, when adding a field means editing seven classes, when internal fields appear in a public payload, or when a shared DTO library couples services at compile time. Does not cover whether the boundary should be remote (distribution-boundaries), contract versioning (rpc-and-api-contracts), the view layer (view-and-representation-patterns), or the application service the facade calls (service-layer-design).
- ▌ Rpc And API Contracts · robsonkades bundleThe contract between two services and how it changes without a coordinated deploy: partial failure as a first-class outcome, an error surface a machine caller can act on (stable extensible codes, outcome certainty, retry conditions, RFC 9457), compatibility in both directions and expand-then-contract, versioning only where compatibility is impossible, and choosing REST, gRPC or messaging on observable conditions. Use when a client branches on an error message string, when a field is renamed or a proto field number reused, when a rolling deploy breaks consumers, when a synchronous endpoint fronts a long-running operation, when a new version is proposed for an additive change, or when a consumer fails on an unknown JSON property. Does not cover delivery guarantees (delivery-semantics), the deadline itself (timeouts-and-deadlines), wire-format cost (serialization-performance), the exception hierarchy (java-exception-design), or event contracts (event-driven-architecture).
- ▌ SQL Query Performance · robsonkades bundleMaking one SQL statement fast, from its execution plan rather than a guess: reading estimated against actual rows, finding the operation that actually costs, whether a scan is wrong at all, index selectivity and composite column order, covering indexes, and the predicates that quietly disable an index. Use when a query is slow and the plan has not been read, when "add an index" is the proposed fix, when a predicate wraps the column in a function or compares mismatched types, when OFFSET pagination degrades on later pages, when a query is fast for one parameter and slow for another, when a plan changed with no deploy, or when an index is proposed on a low-cardinality column. Engine-neutral: concept and measurement, not one vendor. Not the ORM issuing the statements (orm-fetch-and-batching-performance), pool sizing (connection-pool-sizing), the request-path budget (architecture-and-performance), caching the result (caching-strategies), or schema change safety (schema-evolution-and-compatibility).
- ▌ Tail Latency Analysis · robsonkades bundleDiagnosing and mitigating end-to-end latency tails: defining the latency population, decomposing stage and queue time with per-request evidence, quantifying fan-out under dependence, attributing correlated JVM/OS/network/dependency events, and selecting bounded tail-tolerance mechanisms such as deadlines, partial results, hedging and load-aware routing. Use when p99/p99.9 regresses, stage percentiles do not explain an end-to-end percentile, deploys create cold tails, wide fan-out amplifies rare stragglers, or a hedge/retry is proposed. Percentile estimation belongs to latency-statistics; queueing models to queueing-models; collector and OS mechanisms to their owning skills.
- ▌ Connection Pool Sizing · robsonkades bundleSizing and diagnosing a JDBC connection pool: L = λ × W where W is connection hold time rather than query latency, the database-side ceiling, HikariCP timeouts and lifetimes, transaction boundaries and idle-in-transaction, N+1 detection, JDBC batching, and what virtual threads change. Use when choosing maximumPoolSize, when connection-timeout is 0 or 30 s, when threads wait for connections under load, when HTTP or queue calls happen inside @Transactional, when connections die silently behind a firewall or load balancer, when hibernate.jdbc.batch_size appears not to work, or when raising the pool is proposed as the fix. Does not cover the general queueing arithmetic (littles-law-and-queueing), thread pool sizing (thread-sizing-and-virtual-threads), or caching to reduce load (caching-strategies).
- ▌ Feature Scope Analysis · robsonkades bundleFixing what a feature includes and, more usefully, what it deliberately excludes: sorting every candidate item into required, recommended, optional, out of scope or future work, tracing each included item back to a requirement or a constraint, and catching the additions that arrived because they seemed like a good idea. Use when a feature is being planned and its edges are undefined, when a plan has grown a dashboard, a refactor or an abstraction nobody asked for, when "while we are in there" appears, when an estimate keeps moving without the requirement changing, or when a reviewer cannot tell which parts of a change were requested. Does not keep an already-written diff honest (coding-agent-discipline), does not decide whether a duplication justifies an abstraction (java-dry-kiss-yagni), and does not decide whether a deliberate shortcut is acceptable (technical-debt-decisions).
- ▌ Io Uring And Zero Copy · robsonkades bundleReducing the cost of moving bytes through a JVM process: sendfile and FileChannel.transferTo, mmap and MappedByteBuffer, direct versus heap buffers at the syscall boundary, io_uring's submission and completion model and the three routes a JVM can actually reach it by, and proving a copy was eliminated. Use when CPU saturates while a service streams files or proxies bytes, when a loop reads into a ByteBuffer only to write it straight back out, when someone claims java.nio uses io_uring underneath, when a Netty io_uring bootstrap fails at runtime with NoSuchMethodError or ClassNotFoundException, when separating generic and io_uring-specific channel options, or when JFR reports no socket events from a service plainly doing network I/O. Does not cover owning and managing native memory (off-heap-memory), the host layer generally (linux-for-jvm), or network-stack tuning (tcp-tuning).
- ▌ Java Cohesion Coupling · robsonkades bundleCohesion and coupling in Java at class, package and module level: cohesion types (functional, communicational, temporal, logical), coupling types in real code, afferent/efferent coupling and instability, package dependency graphs, and JPMS module boundaries as enforced coupling limits. Use when a small change fans out across packages, when a package cycle appears, when deciding which package or module a class belongs in, or when reviewing package architecture. Principle framing lives in java-solid; inverting a specific dependency edge in java-dependency-inversion.
- ▌ Jfr And Async Profiler · robsonkades bundleSelecting the least-perturbing JVM evidence source that matches the question: JFR events and timeline versus async-profiler sampling, CPU versus elapsed/off-CPU, allocation versus retention, lock versus queue/I/O, startup versus steady state, and one-off versus continuous capture. Covers adequacy, positive controls, target scope, version discovery, container access, overhead, artifact integrity, and cross-tool reconciliation. Use before a JVM profile is collected or when an empty/disagreeing recording may be a configuration artifact. Graph interpretation, JFR internals, async-profiler engines, and fleet operations have separate owners.
- ▌ Jvm Performance Review · robsonkades bundleAuditing JVM configuration evidence across the supplied command, effective runtime flags, target JDK build, container/cgroup envelope, workload lifecycle, and stated SLO. Classifies flags by support and origin, detects masking, duplicates and ergonomic interactions, prices heap/non-heap/CPU/startup trade-offs, and emits prioritized falsifiable findings rather than folklore flag lists. Use for JVM options, Kubernetes manifests, JDK upgrades, collector/heap proposals, or claims that a flag fixes latency. Symptom diagnosis, deep GC tuning, profiler selection, and unified-log construction have separate owners.
- ▌ Orm Structural Mapping · robsonkades bundleMapping the structure of an object model onto tables: Identity Field, Foreign Key Mapping, Association Table Mapping, Dependent Mapping, Embedded Value and Serialized LOB. Use when choosing an identifier strategy or when a generated identity breaks batching, when a bidirectional association updates the wrong side and no foreign key is written, when a many-to-many link already has attributes, when child rows are given repositories of their own, when a value type is flattened into columns or hidden in a JSON column, or when a collection is deleted and reinserted on every save. Does not cover subtype mapping (inheritance-mapping-strategies), where the mapping lives (metadata-mapping), runtime fetch behaviour (orm-behavioral-patterns), or which data-access pattern to use in the first place (data-source-patterns).
- ▌ Postgresql Performance · robsonkades bundleDiagnosing and tuning PostgreSQL 17/18 from engine evidence: MVCC tuple versions, VACUUM/freeze and bloat, HOT updates and visibility maps, plans and cardinality, work memory/spills, WAL and checkpoints, locks/SSI, connection processes and PgBouncer session semantics, plus pgjdbc prepared-plan, batch, and fetch behavior. Use when the symptom or change depends on PostgreSQL internals. Not generic query-plan, ORM, or HikariCP sizing guidance.
- ▌ Refactoring Automation · robsonkades bundleApplying a code change by machine rather than by hand: choosing between an IDE refactoring, an OpenRewrite recipe, structural search-and-replace, a compiler-driven change and hand-editing; what each tool can and cannot see; checking rename coverage beyond resolved symbols; making a change spanning hundreds of files reviewable, reproducible and revertible; and proving a mechanical change was mechanical. Use when one edit must land across many files, when a framework or library migration must be applied repo-wide (javax to jakarta, JUnit 4 to 5, a Spring major version), when a rename must reach names that live in strings and configuration, when someone is about to run sed or a regex over Java source, when a tool-generated diff is too large to review line by line, when an automated refactoring changed behaviour, or when a cleanup keeps regressing because nothing stops it coming back. Which refactoring to apply is java-refactoring, what to detect is java-code-smells, and the CI gates the result must pass are qual
- ▌ SQL Server Performance · robsonkades bundleDiagnosing and tuning SQL Server 2022+ from engine evidence: waits, blocking/deadlocks, RCSI and version store, cardinality and parameter-sensitive plans, memory grants and parallelism, clustered/columnstore storage, statistics and index maintenance, tempdb/files/memory, readable replicas, and mssql-jdbc behavior. Use when the symptom or proposed change depends on SQL Server internals. Not generic single-query tuning, ORM behavior, or HikariCP sizing.
- ▌ Structured Concurrency · robsonkades bundleStructuredTaskScope as a lifetime guarantee for a fan-out: fork, join, close, and the rule that no subtask thread outlives the block. Covers the API as it stands on each JDK — still a preview API on every released version, renamed between 25 and 26 and changing again in 27 — the Joiner completion policies, scope timeouts, nesting, and what close actually waits for. Use when writing or reviewing a parallel fan-out inside one request, when a sibling task keeps running after another failed, when code copied from a blog uses ShutdownOnFailure or a StructuredTaskScope constructor, when preview class files fail to run on a different JDK, when a scope fails in milliseconds and closes in seconds, or when Subtask.get is called before join. Not why cancellation fails to arrive (cancellation-and-interruption), context inherited by subtasks (scoped-values), the threads underneath (thread-sizing-and-virtual-threads), or callback graphs (completablefuture-composition).
- ▌ Timeouts And Deadlines · robsonkades bundleBounding how long a call may take and propagating that bound: per-hop timeouts versus an absolute deadline, deadline propagation over HTTP and gRPC, remaining-budget arithmetic and refusing work that cannot finish, cooperative cancellation of abandoned callee work, and keeping connect, read, total and retry timeouts consistent. Use when a client sets a connect timeout but no request timeout, when Future.get() or join() is called with no bound, when a timeout is a round number repeated across services, when three hops each wait five seconds, when a retry policy total exceeds the caller timeout, when a JDBC call has no setQueryTimeout, when a Kafka consumer rebalances during slow processing, or when a timed-out request leaves work running downstream. Does not cover what to do after the timeout fires (retries-and-backoff), percentiles (latency-statistics), tail decomposition (tail-latency-analysis), tripping on repeated timeouts (circuit-breakers), or pool sizing (connection-pool-sizing).
- ▌ Adapter Sidecar Pattern · robsonkades bundleChoose and review Kubernetes telemetry adapters when a legacy or vendor process emits incompatible metrics, logs or health signals, when deciding between per-pod translation and a node agent, or when an application upgrade silently changes parsed telemetry. Covers translation contracts, evidence-backed enrichment and failure behavior. Excludes in-process interface adaptation (gof-adapter), container mechanics (sidecar-pattern), probe configuration (kubernetes-service-lifecycle) and telemetry instrumentation design.
- ▌ Async Profiler Advanced · robsonkades bundleConfigure and validate async-profiler when recordings are empty, idle-heavy, truncated, permission-blocked, containerized, multi-event, or version-sensitive. Choose event weights and engines, bound collection overhead, diagnose missing stacks, and verify conversions and differentials. Does not own initial profiler selection (jfr-and-async-profiler), visual interpretation (flame-graph-analysis), or JDK Flight Recorder configuration.
- ▌ Clean Delivery Workflow · robsonkades bundleThe order of work for a change, and how much of that order a given change actually warrants: understanding before editing, clarifying what is ambiguous, deciding the test approach, implementing in reversible steps, separating refactoring from behaviour where independently valid, running the gates the risk deserves, and verifying before declaring done. Also the entry point that routes a situation to the skill that owns it. Use when starting a change and the order is not obvious, when a change has sprawled and needs re-sequencing, when refactoring and behaviour changes have been mixed in one commit, when work is being declared done without verification, when the same ceremony is being applied to a one-line fix and a migration, or when you know the problem but not which skill covers it. Does not itself cover any step in depth — it routes to requirements-and-acceptance, java-testing-strategy, tdd, java-refactoring, code-review and quality-gates, each of which owns its own.
- ▌ Coding Agent Discipline · robsonkades bundleThe reporting and restraint rules for an AI agent changing someone's codebase: never claiming a result that was not observed, saying which commands ran and what they printed, reporting what could not be verified rather than omitting it, keeping the diff to what was asked, preserving behaviour that was not in scope, checking APIs against the versions the project actually depends on, and refusing to make a test pass by weakening it. Use before reporting that work is complete, when about to write "this should work" or "tests pass", when a change is growing beyond the request, when a test is failing and deleting or disabling it is tempting, when an API is being used from memory rather than checked, or when two instructions cannot both be satisfied. Does not cover the order of work (clean-delivery-workflow), which checks to run (quality-gates), or how to phrase a message to a human (engineering-communication).
- ▌ Concurrency Diagnostics · robsonkades bundleEvidence-led diagnosis of deadlock, starvation, livelock, saturation, leaks and virtual-thread scheduler problems. Compares traditional platform-thread dumps, jcmd all-thread dumps, ThreadMXBean, VirtualThreadSchedulerMXBean, JFR, wall/CPU profiles and application telemetry, including each tool's visibility and consistency limits. Use when progress stops, CPU and latency disagree, tasks disappear, shutdown hangs, or a virtual-thread dump is inconclusive.
- ▌ Distribution Boundaries · robsonkades bundleDeciding whether a boundary should be a process boundary, and designing it when it must be: what distribution actually costs (latency, serialisation, partial failure, lost atomicity, independent deployment), why a remote interface must be coarser than a local one, and choosing between synchronous call, messaging and replication. Use when a module is proposed for extraction into a service, when microservices are being adopted without a named driver, when a service call sits inside a transaction, when one request fans out to a dozen downstream calls, when two services share a database, when a "service" cannot be deployed without another being deployed too, when a synchronous chain has three or more hops, or when a distributed transaction is being designed. Does not cover the remote API's shape and payload types (remote-facade-and-dto), contract compatibility and versioning (rpc-and-api-contracts), transaction mechanics on one database (enterprise-transactions), or in-process layering (layering-and-boundaries).
- ▌ Enterprise Transactions · robsonkades bundleTransaction boundaries as an architectural decision: where a transaction starts and ends, what isolation level actually buys, how propagation and rollback rules behave in practice, the costs of spanning a network call or a user's thinking time, and how to handle effects outside its atomic scope. Use when a use case writes twice and nobody can say whether it is atomic, when @Transactional sits on a repository or a controller, when a transaction stays open across an HTTP call or a message publish, when a rollback did not happen because the exception was checked or the call was self-invoked, when isolation is being raised to fix a race, when a read-only flag is added without knowing what it does, when a long-running batch holds locks, or when a transaction is expected to cover two services. Does not cover locks held across user think time (offline-concurrency-control), what a client may observe across replicas (consistency-models), repeat-safety of an operation (idempotency), or database-specific lock behaviour.
- ▌ Java Design By Contract · robsonkades bundleContracts as the semantics of a Java API, without a contract framework: preconditions, postconditions and invariants defined precisely and mapped to Java 25 mechanisms — constructor and compact-constructor validation, invariants as types that cannot represent invalid states, postconditions via tests and proportionate runtime checks, contracts documented in Javadoc, behavioural subtyping (overrides may weaken preconditions and strengthen postconditions, never the reverse), and contracts across sealed hierarchies. Use when a class's invariants live in its callers' heads, when an override adds a requirement its supertype never made, when deciding what @throws to promise, or when assert is guarding public input. Does not cover where boundary validation belongs (java-defensive-programming) or LSP in its five-principle context (java-solid).
- ▌ Kafka Consumers In Java · robsonkades bundleOperating a Kafka consumer from Java: the log-not-a-queue model where consumption removes nothing and position is an offset; the rebalance as the central operational event, with cooperative assignment as the mitigation and where duplicates enter; why slow processing trips max.poll.interval.ms, not the session timeout; pause/resume for slow work; commit strategies; auto.offset.reset as a data-loss-or-reprocessing decision; and lag as record, byte, time and catch-up signals. Use when a group rebalances repeatedly under load, when records are reprocessed after a deploy, when enable.auto.commit is left on, when a consumer starts from the wrong place after an outage. Not ordering scope (message-ordering-and-partitioning), guarantees (delivery-semantics), repeat-safe handlers (idempotency), the record that never succeeds (poison-messages-and-dlq), deserialisation cost (serialization-performance), in-flight bounds (concurrency-limiting-and-bulkheads), or drain (kubernetes-service-lifecycle).
- ▌ Layering And Boundaries · robsonkades bundleDeciding where an enterprise application's boundaries go and which direction dependencies cross them: the classical presentation / domain / data-source split, the styles that reorganise it (hexagonal, clean, modular monolith, vertical slices), and how a boundary is enforced rather than documented. Use when a package structure is argued about, when a controller contains business rules, when an entity or DTO travels end to end, when a service layer only forwards, when hexagonal is adopted without a driver, or when adding a field requires editing seven files. Does not cover which layer business rules take (domain-logic-organization), whether a boundary should be remote (distribution-boundaries), the data-access patterns (data-source-patterns), or what the application service around a use case owns (service-layer-design).
- ▌ Metrics And Cardinality · robsonkades bundleDesigning bounded, decision-oriented metrics for Java services: selecting counters, gauges and histogram forms; defining RED, USE and business outcomes; budgeting active series and ingestion/query cost; controlling caller-driven dimensions; and planning schema migrations, overflow behavior and exemplars. Use when adding labels, routes, histograms or business metrics, diagnosing series growth or missing gauges, reviewing Micrometer/Prometheus instrumentation, or choosing between classic/native histograms and client quantiles. Percentile inference belongs to latency-statistics, exporter overhead to opentelemetry-performance, alert policy to slo-and-alerting.
- ▌ Orm Behavioral Patterns · robsonkades bundleThe three runtime behaviours that make object-relational mapping work and produce its most confusing failures: Unit of Work, Identity Map and Lazy Load. Use when an entity was modified but never saved and the change appeared anyway, when a change was expected to persist and did not, when LazyInitializationException appears during serialisation or in a job, when the query count scales with rows displayed, when a persistence context grows until flush becomes slow, when a bulk update is invisible to loaded entities, or when Open Session In View is being turned on to make an error disappear. Does not cover the mapping itself (orm-structural-mapping), which data-access pattern to use (data-source-patterns), transaction boundaries (enterprise-transactions), or whether to cache the read at all (caching-strategies).
- ▌ Performance Methodology · robsonkades bundleThe investigation process for performance work: defining an SLO, recording a baseline, characterising before diagnosing, falsifiability, fixed-work speedup bounds, experimental design, and validating by mechanism rather than by coincidence. Use when starting a performance investigation, when a fix is credited to a deploy that also restarted the process, when an optimisation is proposed without a measurement, when a benchmark result changes with the duration of the run, when an investigation has run for days without refuting a hypothesis, or when "it's fine in staging" is the explanation. Does not cover which tool to run (jfr-and-async-profiler), the statistics of the numbers (latency-statistics), or microbenchmark construction (jmh-microbenchmarks).
- ▌ Poison Messages And Dlq · robsonkades bundleWhat happens to a message that cannot succeed: separating the permanently poison message that fails on its own content from the transiently blocked one whose dependency is down, and why an attempt counter cannot tell them apart; the dead-letter queue as a design with an owner, an alert and a redrive path; the record captured beside the payload; and the head-of-line decision in a partitioned log, where skipping a record trades a complete effect sequence for progress. Use when a consumer retries the same record forever, when a DLQ has grown and nobody owns it, when a DLQ record holds only the payload, when a deploy makes every message fail, when a partition stops advancing behind one record, or when dead-lettering is proposed for a dependency outage. Does not cover retry policy (retries-and-backoff), safe replay (idempotency), ordering scope (message-ordering-and-partitioning), the worker pool (task-queues-and-competing-consumers), guarantees (delivery-semantics), or alert thresholds (slo-and-alerting).