robsonkades

@robsonkades source repo

275 skills
0 followers
1 day ago last updated

▌
Code Cache Segments · robsonkades bundle
The 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).

0
installs
▌
Concurrency Testing · robsonkades bundle
Testing 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).

0
installs
▌
Container Awareness · robsonkades bundle
What 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).

0
installs
▌
Distributed Systems · robsonkades bundle
Triage 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.

0
installs
▌
Feature Engineering · robsonkades bundle
Owning 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).

0
installs
▌
Gof Template Method · robsonkades bundle
Template 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).

0
installs
▌
Java Dry Kiss Yagni · robsonkades bundle
The 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).

0
installs
▌
Java Law Of Demeter · robsonkades bundle
Navigation 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).

0
installs
▌
Jmh Microbenchmarks · robsonkades bundle
Designing 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.

0
installs
▌
Metaspace Internals · robsonkades bundle
Metaspace 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).

0
installs
▌
Retries And Backoff · robsonkades bundle
Retry 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).

0
installs
▌
Simd And Vector API · robsonkades bundle
Vectorisation 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).

0
installs
▌
Allocation Profiling · robsonkades bundle
Attribute 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.

0
installs
▌
Architecture Testing · robsonkades bundle
Write 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).

0
installs
▌
Continuous Profiling · robsonkades bundle
Designing 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).

0
installs
▌
Coordinated Omission · robsonkades bundle
Coordinated 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).

0
installs
▌
Data Source Patterns · robsonkades bundle
Choosing 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).

0
installs
▌
Database Performance · robsonkades bundle
Evidence-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.

0
installs
▌
Flame Graph Analysis · robsonkades bundle
Interpreting 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).

0
installs
▌
Gof Abstract Factory · robsonkades bundle
Abstract 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).

0
installs
▌
Gof Pattern Thinking · robsonkades bundle
Reasoning 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).

0
installs
▌
Graalvm Native Image · robsonkades bundle
GraalVM 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).

0
installs
▌
Jhsdb And Core Dumps · robsonkades bundle
Post-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).

0
installs
▌
Reading Jit Assembly · robsonkades bundle
Reading 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).

0
installs
▌
Service Layer Design · robsonkades bundle
Designing 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).

0
installs
▌
Consensus And Quorums · robsonkades bundle
Crash-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).

0
installs
▌
Database Bulk Loading · robsonkades bundle
Designing 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.

0
installs
▌
Database Index Design · robsonkades bundle
Designing 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.

0
installs
▌
Feature Decomposition · robsonkades bundle
Deciding 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).

0
installs
▌
Feature Risk Analysis · robsonkades bundle
Naming 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).

0
installs
▌
G1 Concurrent Marking · robsonkades bundle
G1'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).

0
installs
▌
Gof Pattern Confusion · robsonkades bundle
Telling 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).

0
installs
▌
Gof Pattern Selection · robsonkades bundle
Getting 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).

0
installs
▌
Java Exception Design · robsonkades bundle
Exceptions 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).

0
installs
▌
Java Object Contracts · robsonkades bundle
The 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.

0
installs
▌
Java Strings And Text · robsonkades bundle
Text 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.

0
installs
▌
Java Testing Strategy · robsonkades bundle
Choosing 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).

0
installs
▌
Load Testing Advanced · robsonkades bundle
Selecting 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.

0
installs
▌
Numa And Cpu Affinity · robsonkades bundle
Placing 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).

0
installs
▌
Reactive Backpressure · robsonkades bundle
Backpressure 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).

0
installs
▌
Remote Facade And Dto · robsonkades bundle
Designing 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).

0
installs
▌
Rpc And API Contracts · robsonkades bundle
The 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).

0
installs
▌
SQL Query Performance · robsonkades bundle
Making 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).

0
installs
▌
Tail Latency Analysis · robsonkades bundle
Diagnosing 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.

0
installs
▌
Connection Pool Sizing · robsonkades bundle
Sizing 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).

0
installs
▌
Feature Scope Analysis · robsonkades bundle
Fixing 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).

0
installs
▌
Io Uring And Zero Copy · robsonkades bundle
Reducing 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).

0
installs
▌
Java Cohesion Coupling · robsonkades bundle
Cohesion 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.

0
installs
▌
Jfr And Async Profiler · robsonkades bundle
Selecting 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.

0
installs
▌
Jvm Performance Review · robsonkades bundle
Auditing 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.

0
installs
▌
Orm Structural Mapping · robsonkades bundle
Mapping 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).

0
installs
▌
Postgresql Performance · robsonkades bundle
Diagnosing 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.

0
installs
▌
Refactoring Automation · robsonkades bundle
Applying 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

0
installs
▌
SQL Server Performance · robsonkades bundle
Diagnosing 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.

0
installs
▌
Structured Concurrency · robsonkades bundle
StructuredTaskScope 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).

0
installs
▌
Timeouts And Deadlines · robsonkades bundle
Bounding 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).

0
installs
▌
Adapter Sidecar Pattern · robsonkades bundle
Choose 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.

0
installs
▌
Async Profiler Advanced · robsonkades bundle
Configure 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.

0
installs
▌
Clean Delivery Workflow · robsonkades bundle
The 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.

0
installs
▌
Coding Agent Discipline · robsonkades bundle
The 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).

0
installs
▌
Concurrency Diagnostics · robsonkades bundle
Evidence-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.

0
installs
▌
Distribution Boundaries · robsonkades bundle
Deciding 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).

0
installs
▌
Enterprise Transactions · robsonkades bundle
Transaction 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.

0
installs
▌
Java Design By Contract · robsonkades bundle
Contracts 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).

0
installs
▌
Kafka Consumers In Java · robsonkades bundle
Operating 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).

0
installs
▌
Layering And Boundaries · robsonkades bundle
Deciding 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).

0
installs
▌
Metrics And Cardinality · robsonkades bundle
Designing 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.

0
installs
▌
Orm Behavioral Patterns · robsonkades bundle
The 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).

0
installs
▌
Performance Methodology · robsonkades bundle
The 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).

0
installs
▌
Poison Messages And Dlq · robsonkades bundle
What 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).

0
installs
▌
Startup Cds Crac Leyden · robsonkades bundle
Cutting JVM startup and warm-up while staying on the JVM: CDS and AppCDS, the Leyden AOT cache (JEP 483/514/515), CRaC checkpoint and restore and its constraints, what each mechanism actually accelerates, verifying the cache is really in use, and measuring time-to-first-good-response instead of time-to-port-open. Use when cold start hurts a serverless or autoscaled deployment, when a CI pipeline pays for hundreds of JVM launches, when a CRaC flag fails with Unrecognized VM option, when an AppCDS archive is ignored after a JAR changes, when an outdated -XX:AOTCache is suspected after a rebuild, when -XX:AOTCacheOutput is in the production start command, when spring-boot:build-image is expected to yield a CRaC image, or when a startup speedup percentage is quoted without a source. Does not cover the warm-up curve and traffic gating (jit-compilation), loading, linking and initialisation (jvm-class-loading), or leaving the JVM behind (graalvm-native-image).

0
installs
▌
Enterprise Base Patterns · robsonkades bundle
The small structural patterns that hold an enterprise application together — Gateway, Mapper, Layer Supertype, Separated Interface, Registry, Special Case, Plugin and Service Stub — with the judgement about when each earns its place and when it is indirection. Use when an external system's API is being called directly from business code, when the same null check appears in twenty callers, when a base class is accumulating unrelated protected helpers, when a Registry or a static holder is being used to reach a collaborator, when an interface is needed on the caller's side of a dependency, when tests are slow because they call a real third-party sandbox, when a plugin mechanism is proposed for a variation that has one implementation, or when a mapper has started making decisions. Does not cover data-access specifics (data-source-patterns), the aggregate boundary abstraction (repository-pattern), overall layering (layering-and-boundaries), or detecting overuse in general (enterprise-architecture-smells).

0
installs
▌
Feature Context Analysis · robsonkades bundle
Reading the repository for one specific feature: which technologies and patterns are actually present, which components the feature can reuse, which questions the code has already answered, and — stated as findings rather than silence — which it has not. Use when a scoped feature needs repository evidence before clarification or technology selection, when it is about to be built in a style the codebase does not use, when "the project uses X" is being asserted without a path, when an abstraction is about to be created that already exists, or when picking up a codebase you have not read. Does not decide whether a found technology may be used for this feature (feature-decision-analysis), does not enumerate what the change will touch (feature-architecture-analysis), and is not a general method for reading an unfamiliar enterprise codebase (enterprise-application-architecture) or auditing it for defects (java-code-smells).

0
installs
▌
Feature Readiness Review · robsonkades bundle
The intake, pre-implementation, and completion gates for a feature: first validating the Product/Engineering or Tech Feature baseline, then checking that nothing implementation depends on is still unresolved, and after, checking that what was built is what was agreed and that the claim of completion is supported. Use before the first line of a planned feature is written, when implementation is about to start with an open blocking question, when a feature is about to be declared done, when "done" is being claimed on a green build, when a feature shipped and the decisions were never written down, or when a reviewer cannot tell which parts of a diff were requested. Does not review the code itself for defects or design (code-review), does not choose the automated checks (quality-gates), and does not own the rules about what an agent may claim (coding-agent-discipline).

0
installs
▌
Gof Pattern Antipatterns · robsonkades bundle
Detecting and removing design-pattern misuse: abstractions that trace to no requirement, patterns chosen because a name sounded right, and the specific failure each overused pattern produces. Covers the detectable signals — an interface with one implementation, a class per constant, a factory whose products are unrelated, a hub with twelve dependencies, a listener never deregistered, a wrapper stack nobody can read, a getInstance() a test must reset — with the cause, the concrete cost, and the removal procedure that does not break callers. Use when reviewing a design that feels over-engineered, when a class name ends in Manager or Helper and nobody can say what it does, when tests need many mocks to construct one object, or when deleting an abstraction and the change must stay safe. Does not cover choosing a pattern (gof-pattern-selection), telling lookalikes apart (gof-pattern-confusion), general code smells (java-code-smells), or enterprise architecture smells (enterprise-architecture-smells).

0
installs
▌
Java Legacy Code Testing · robsonkades bundle
Getting Java code under test before you change it, when you cannot construct the class or reach the method at all: seams and their enabling points, the dependency-breaking catalogue (Parameterize Constructor, Extract Interface, Extract and Override, Introduce Instance Delegator, Break Out Method Object, Expose Static Method), Sprout and Wrap when there is no time, approval testing when the output to pin is too large to assert on, and the disciplines that make a change safe while no test exists. Use when a constructor opens a connection, when a method reads a static singleton, when a test would need the real database, when mockStatic is proposed, when a setXxxForTest is being added, or when 2004-era advice (PowerMock, mockito-inline) is followed. Does not cover characterisation-test mechanics (java-refactoring), strangler work (legacy-enterprise-modernization), doubles (java-test-doubles), test level (java-testing-strategy), the red-green-refactor loop (tdd), or how a test is written (java-test-design).

0
installs
▌
Java Object Construction · robsonkades bundle
Choosing how an object comes into existence in Java: static factory versus public constructor, the of/from/valueOf/getInstance naming conventions, instance control (caching, canonicalisation, value-based classes), enum and holder singletons, noninstantiable utility classes, and passing collaborators in rather than hardwiring them with new. Use when a class has several constructors distinguished only by parameter types, when a constructor does work beyond assigning fields, when a singleton or a static mutable field is proposed, when new appears inside domain logic for something the code can never substitute in a test, or when a factory hands back a type its callers should not be able to name. Does not cover builders and fluent chains (java-fluent-apis), which dependency edge should exist at all (java-dependency-inversion), defensive copying of components (java-immutability), or releasing what construction acquires (java-resource-management).

0
installs
▌
Java Resource Management · robsonkades bundle
Deterministic release of what a Java program holds open: try-with-resources and the exception semantics that make it non-optional, designing an AutoCloseable (ownership, idempotent close, close that fails), decorators and partially constructed resource chains, resources that cross an async or executor boundary, and the difference between closing a resource and returning one to a pool. Use when a close sits in a finally block, when a resource is created inside a try block or inside a lambda that outlives it, when a method closes something it was handed, when connections or file descriptors leak under load, when ExecutorService or StructuredTaskScope is used in try-with-resources, or when a stream from Files.lines or Files.walk is never closed. Does not cover reachability-driven cleanup — WeakReference, SoftReference, Cleaner and the leaks they hide (java-reference-types-and-leaks) — pool sizing (connection-pool-sizing), or native segment lifetimes (off-heap-memory).

0
installs
▌
Littles Law And Queueing · robsonkades bundle
Conservation checks from Little's Law (`L = λW`) and queueing decisions: measurement boundaries, service demand versus residence time, utilisation curves, thread pool and executor sizing, bounded queues and rejection policy. Use when choosing a pool size, when latency is high while CPU is low, when latency grows over the duration of a run, when someone proposes adding threads to a CPU-bound path, or when a ThreadPoolExecutor is not growing past its core size. Does not cover the statistics of the latency numbers themselves (latency-statistics), database pool specifics (connection-pool-sizing), or virtual-thread mechanics (thread-sizing-and-virtual-threads). Model selection and fitting is queueing-models, the scalability model is universal-scalability-law, and forecasting is capacity-planning.

0
installs
▌
Mvc And Request Handling · robsonkades bundle
How a web request is routed and handled: MVC's actual division of responsibilities, Page Controller versus Front Controller, and Application Controller for flows whose next step is a decision. Use when controllers contain business rules or persistence calls, when the same cross-cutting concern is copied into every handler, when a wizard's navigation logic is spread across handlers as if-chains, when a filter, interceptor and handler contend for one concern, when a controller is tested by starting the whole application, or when classical web patterns are mapped onto a REST API. Does not cover how the response is rendered (view-and-representation-patterns), the remote operation and its payload (remote-facade-and-dto), the use-case layer (service-layer-design), or where conversation state lives across requests (session-state-strategies).

0
installs
▌
Mysql Innodb Performance · robsonkades bundle
Diagnosing and tuning MySQL 8.4+ InnoDB from engine evidence: clustered primary-key storage, buffer pool and redo/checkpoint pressure, undo/purge history, next-key/gap locks and deadlocks, optimizer statistics and plans, online DDL, replication durability/lag, and Connector/J prepared statements, batching, fetch, and TLS properties. Use when the symptom or change depends on InnoDB or MySQL behavior. Not generic query-plan, ORM, or pool sizing guidance.

0
installs
▌
Session State Strategies · robsonkades bundle
Placing the state that spans several requests of one conversation: client session state, server session state and database session state, plus signed tokens and external stores. Use when a multi-step wizard loses its data on the second replica, when HttpSession holds an object graph, when sticky sessions are added to keep an application working, when a rolling deploy logs everyone out, when a JWT carries mutable state or cannot be revoked, when session data is pushed into Redis without deciding what happens if Redis is down, or when "make it stateless" is proposed without saying where the state will go. Does not cover making an instance disposable in general (stateless-service-design), cache design (caching-strategies), or locks held across a conversation (offline-concurrency-control).

0
installs
▌
Stateless Service Design · robsonkades bundle
Making a service instance disposable so replicas are interchangeable: what stateless actually means — no correctness/routing dependency on one instance's volatile history; the in-process state inventory; and session state as a placement decision between sticky routing, an external store and a signed token. Use when replicas is raised above 1, when a @Scheduled job suddenly runs N times, when a local cache disagrees between instances, when an in-memory rate-limit counter or idempotency map is the source of truth, when HttpSession holds anything a user would miss, when a service writes to java.io.tmpdir, or when a rolling deploy loses sessions. Does not cover pod replacement and drain (kubernetes-service-lifecycle), reaching a replica (load-balancing-and-routing), cache design (caching-strategies), fleet-singleton work (leader-election), state split by key (sharding-and-partitioning), pool arithmetic (connection-pool-sizing), or what replicas may observe (consistency-models).

0
installs
▌
Technical Debt Decisions · robsonkades bundle
Deciding when a shortcut is a legitimate trade and when it is just damage: separating deliberate and inadvertent debt, constraints delivery pressure does not waive, containing a shortcut so it can be undone, recording it where someone will find it, and choosing which debt to repay by its carrying cost rather than by how much it annoys you. Use when a deadline or an incident is pushing work to be cut, when someone proposes shipping now and cleaning up later, when a spike is about to become production code, when "technical debt" is being used to justify a rewrite, when a debt backlog has grown into a list nobody reads, or when deciding whether to fix something you have just noticed. Does not cover the refactoring mechanics of repaying it (java-refactoring), how to detect the problem (java-code-smells), how to communicate the trade (engineering-communication), or which gates may be skipped (quality-gates).

0
installs
▌
Virtual Thread Migration · robsonkades bundle
Migrating an existing service to virtual threads as a staged programme rather than a flag: inventorying what each thread pool was implicitly limiting, auditing for pinning, file I/O and ThreadLocal caches, declaring the replacement limits before the flip, canarying one workload at a time, re-sizing the connection pool, and the rollback criteria. Use when a team plans to enable virtual threads service-wide, when a single flag is about to be flipped in production, when a migration made latency worse, when the database or a downstream started failing after adoption, when newSingleThreadExecutor is about to be replaced and it was providing ordering, when log correlation or metrics broke after the change, or when a migration is proposed for a CPU-bound service. Not the sizing arithmetic (thread-sizing-and-virtual-threads), continuation and pinning internals (virtual-threads-internals), or choosing between reactive and thread-per-request, and the framework flags for it (reactive-and-virtual-thread-selection).

0
installs
▌
Domain Logic Organization · robsonkades bundle
Choosing where business rules live — Transaction Script, Domain Model or Table Module — from the shape of the logic rather than from convention, and recognising when the choice made no longer fits. Use when starting a new module and the "standard" layered structure is about to be applied by default, when a service class has grown past a thousand lines of procedural steps, when entities have only getters and setters and every rule sits in a service, when the same business rule is implemented in three places, when a domain model is proposed for CRUD screens, when set-based updates are being rewritten as object loops, or when a report needs data that the aggregate boundary makes expensive to reach. Does not cover the application service that wraps whichever choice you make (service-layer-design), the persistence patterns underneath it (data-source-patterns, repository-pattern), transaction boundaries (enterprise-transactions), or the migration between organisations once chosen (architecture-refactoring-paths).

0
installs
▌
Engineering Communication · robsonkades bundle
Communicating engineering facts to people who will act on them: stating what is true, what follows from it, what is still uncertain, and the options and recommendation when needed. Covers raising a risk early, saying no to a request in a way that leaves a yes on the table, resolving technical disagreement by making the checkable claim checkable, escalating without going around someone, and status updates during an incident. Use when bad news has to travel, when a risk is visible but unspoken, when you are being asked to commit to something you believe is not achievable, when a technical argument has gone two rounds without new information, when a message hedges every claim it makes, or when non-engineers need to make a decision that depends on a technical fact. Does not cover the numbers in an estimate (estimation-under-uncertainty), clarifying a requirement (requirements-and-acceptance), review comments specifically (code-review), or deciding to take on debt (technical-debt-decisions).

0
installs
▌
Escape Analysis Internals · robsonkades bundle
C2 escape-analysis internals: connection graphs, escape-state propagation, flow insensitivity, bytecode escape summaries, scalar replacement and allocation merges, lock elimination, macro expansion, and deoptimization rematerialization. Use when a hot object still allocates, an inlining boundary changes EA, a product-build diagnostic is misleading, a disabled JFR allocation event is treated as proof, or recurring deoptimization makes eliminated objects costly. Does not cover introductory design/measurement rules (jit-inlining-and-escape-analysis), general C2 phases (c2-sea-of-nodes), or Graal partial escape analysis (graalvm-jit).

0
installs
▌
Event Driven Architecture · robsonkades bundle
Choosing facts, asynchronous commands or request/response across services; then designing choreography/orchestration, payload authority, evolution horizon and consumer runtime. Use when a broker masks synchronous outcome dependence, workflows are unreconstructable, consumers read back every event, or publish and database commit form a dual write. Delivery, idempotency, ordering, outbox mechanics and schema evolution remain in their owning skills.

0
installs
▌
Feature Decision Analysis · robsonkades bundle
Keeping the decision log for a feature and, before each entry, answering the two questions that make it trustworthy: where the decision came from — the user, the repository, an organisational standard or the agent — and whose it was to take. Use when a technology is about to be chosen for a feature, when "the project already uses X" is being treated as a reason to use X, when a corporate standard is being asserted without a source, when an agent is about to commit to a database, a broker, a contract or a security model on its own judgement, when a decision taken during implementation contradicts one taken during planning, or when nobody can say who decided something. Does not evaluate the options (feature-solution-analysis) and does not own the decision-record format, reversibility pricing or supersession discipline (architecture-decision-making).

0
installs
▌
Feature Progress Tracking · robsonkades bundle
Keeping a feature's state true while it is being built: one status per resource with defined transitions, a validation line required before anything reaches done, and a persisted record current enough that another agent or another session can resume from it without asking. Use when a feature spans more than one sitting, when someone else may pick the work up, when the answer to "where are we" is a summary of the conversation, when resources are marked done because code was written for them, when a blocker has been open long enough that nobody remembers what it needs, or when a plan and the code have silently diverged. Does not implement the resources (feature-execution), does not decide what counts as a resource (feature-decomposition), and does not perform the final review (feature-readiness-review).

0
installs
▌
Feature Solution Analysis · robsonkades bundle
Producing the option set for a feature-level choice and the block that recommends one: always considering the simplest feasible approach, comparing complete options for the same boundary, evaluating the axes this feature is actually sensitive to, and saying what would have to be true for a rejected option to win. Use when a feature has a real choice in it — a mechanism, a storage strategy, a place to put the work — when one approach has already been assumed and nobody wrote down what else was possible, when a design is justified by what a previous system did, or when a decision is about to be taken without an alternative. Does not own the analysis method itself — MECE option sets, qualitative versus quantitative comparison, resisting evangelism (architecture-trade-off-analysis) — does not write the resulting record (architecture-decision-making), and does not choose among design patterns once the forces are fixed (pattern-selection-and-composition).

0
installs
▌
Incident Evidence Capture · robsonkades bundle
Preserving decision-grade JVM incident evidence before remediation destroys it: setting an explicit recovery/evidence budget, selecting representative and control instances, copying existing telemetry first, capturing repeated low-risk state, escalating to JFR, heap, or core evidence only by symptom and approval, surviving containers/restarts, and recording integrity, clocks, provenance, privacy, and capture failures. Use during live degradation, impending restart/OOM, an unresponsive JVM, or runbook design. Owns ordering and safety; artifact-specific analysis belongs to heap-dump-analysis, concurrency-diagnostics, jfr-and-async-profiler, gc-log-analysis, and jhsdb-and-core-dumps.

0
installs
▌
Java Dependency Inversion · robsonkades bundle
Dependency direction in Java: policy versus mechanism, ports and adapters, constructor injection as plain Java, factories, composition roots, and JPMS module edges as physical enforcement. Use when deciding whether to introduce an interface or port, when domain code imports a transport or vendor SDK, when code is only testable with a mocking framework or a live external system, or when reviewing a codebase where every class has a matching interface. Covers when inversion pays and when it is pure indirection. For the wider five-principle review context, use java-solid.

0
installs
▌
Opentelemetry Performance · robsonkades bundle
Designing OpenTelemetry tracing that remains causally useful within an explicit overhead and data-risk budget: auditing automatic/manual coverage, preserving context across asynchronous boundaries, choosing head/tail sampling and collector topology, controlling attributes/baggage, backpressure and export failure, and measuring application plus collector cost. Use when traces fragment, rare tails disappear, Collector memory grows, telemetry drops under incidents, instrumentation duplicates spans, or someone assumes a published agent-overhead figure applies locally. Trace schema design belongs to distributed-tracing-design; statistics to latency-statistics; profiling to continuous-profiling.

0
installs
▌
Performance Regression CI · robsonkades bundle
Designing trustworthy performance-regression gates: defining the decision and smallest important regression, preserving independent experimental units, calibrating noise and power, comparing compatible JMH results, handling multiplicity and drift, separating screening from confirmation, and operating secure baseline promotion. Use when performance results should influence merge, when a threshold or statistical test lacks an empirical error budget, when JMH scoreError is treated as a two-build test, when repeated iterations are mistaken for independent runs, when CI infrastructure changes contaminate comparisons, or when a pipeline can lose a comparator exit status. Does not teach benchmark construction (jmh-advanced), full-system workload design (load-testing), or general latency inference (latency-statistics).

0
installs
▌
Serialization Performance · robsonkades bundle
Engineering serialization cost as a system budget across encode/decode CPU, allocation and retention, wire/storage bytes, copies, buffers, compression, schema evolution, compatibility, security, and rollout. Covers format/library selection by workload and contract, streaming versus materialization, buffer ownership/backpressure, representative JMH/component/load experiments, production attribution, and mixed-version failure tests. Use when serialization is measured hot, a new wire/cache/topic format is chosen, or “zero-copy”/binary-format claims need validation. General benchmark mechanics, schema governance, and Java native-serialization hardening have separate owners.

0
installs
▌
Sharding And Partitioning · robsonkades bundle
Whether to split data across owners at all, and on which key: what sharding buys — write capacity, locality, data volume and isolation — against distributed transactions/indexes, non-local query routing, rebalancing as standing work, and a shard map that is itself a distributed system; the alternatives that usually win; the shard-key scorecard and classic wrong keys. Use when sharding is proposed for future scale with no measured growth curve, when a table is called too big before retention is checked, when a shard key is chosen or changed, when a query appears that does not carry the key, or when cross-shard joins or unique constraints are discussed. Does not cover the mapping function (consistent-hashing), a distribution already gone wrong (hot-partitions-and-rebalancing), sharding a cache (cache-sharding-and-replication), keyless-query fan-out (scatter-gather), replica interchangeability (stateless-service-design), or what a cross-shard read observes (consistency-models).

0
installs
▌
Universal Scalability Law · robsonkades bundle
Fitting and falsifying the Universal Scalability Law (USL): load/resource definition, the scale coefficient gamma, contention alpha, coherency/retrograde beta, peak conditions, identifiability, uncertainty and held-out validation. Use when throughput saturates or falls as threads, users, cores or pods increase; when scale-out is proposed from too few points; or when comparing architectural scalability curves. Does not cover `L = λW`, queue/pool sizing (littles-law-and-queueing), latency-at-load models (queueing-models), or capacity/SLO decisions (capacity-planning).

0
installs
▌
Virtual Threads Internals · robsonkades bundle
Diagnose HotSpot virtual-thread mounting, heap stack chunks, FIFO work-stealing scheduling, carrier capture, residual native/foreign pinning after JEP 491, scheduler compensation boundaries and memory/GC effects without treating implementation details as API guarantees. Use when pin events, scheduler queue/pool growth, native calls, CPU-ready virtual threads or retained suspended stacks explain a scalability regression on Java 21–25.

0
installs

275 published skills · page 2 of 3