all publishers

robsonkades

@robsonkades source repo

305 published skills · page 3 of 4

  1. ▌
    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).
    3 repo stars
  2. ▌
    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).
    3 repo stars
  3. ▌
    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).
    3 repo stars
  4. ▌
    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).
    3 repo stars
  5. ▌
    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).
    3 repo stars
  6. ▌
    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).
    3 repo stars
  7. ▌
    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).
    3 repo stars
  8. ▌
    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).
    3 repo stars
  9. ▌
    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.
    3 repo stars
  10. ▌
    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).
    3 repo stars
  11. ▌
    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.
    3 repo stars
  12. ▌
    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).
    3 repo stars
  13. ▌
    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).
    3 repo stars
  14. ▌
    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).
    3 repo stars
  15. ▌
    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).
    3 repo stars
  16. ▌
    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).
    3 repo stars
  17. ▌
    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).
    3 repo stars
  18. ▌
    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).
    3 repo stars
  19. ▌
    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.
    3 repo stars
  20. ▌
    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).
    3 repo stars
  21. ▌
    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).
    3 repo stars
  22. ▌
    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).
    3 repo stars
  23. ▌
    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.
    3 repo stars
  24. ▌
    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.
    3 repo stars
  25. ▌
    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.
    3 repo stars
  26. ▌
    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).
    3 repo stars
  27. ▌
    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.
    3 repo stars
  28. ▌
    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).
    3 repo stars
  29. ▌
    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).
    3 repo stars
  30. ▌
    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.
    3 repo stars
  31. ▌
    Distributed Tracing Design · robsonkades bundle
    Designing trace topology and semantics: selecting actionable span boundaries, stable operation names, kinds, status and attributes; modelling synchronous, asynchronous, messaging, batch, retry and long-running workflows with parentage and links; and making traces usable with metrics, logs and profiles during incidents. Use when traces are noisy, fragmented, mis-parented, high-cardinality, misleading about errors, or unable to model batches and asynchronous causality. Sampling, propagation mechanics and overhead belong to opentelemetry-performance; metric cardinality to metrics-and-cardinality.
    3 repo stars
  32. ▌
    Java Defensive Programming · robsonkades bundle
    Where to defend in Java and where defence becomes noise: trust boundaries as the organising idea, preconditions with Objects.requireNonNull and explicit range and state checks, fail-fast over limping on, input normalisation at the edge, and assert for internal invariants only. Use when adding or reviewing validation, when the same invariant is re-checked on every layer, when code silently "corrects" bad input or wraps everything in catch-alls, or when hardening a public API. Does not cover contract semantics and Javadoc documentation (java-design-by-contract), nullability contracts and annotations (java-null-safety), defensive copy mechanics (java-immutability), or the design of the exceptions thrown (java-exception-design).
    3 repo stars
  33. ▌
    Load Balancing And Routing · robsonkades bundle
    Getting a request to a replica that can serve it: L4 versus L7 by capability rather than layer number, why an L4 balancer in front of long-lived HTTP/2 or gRPC connections balances connections instead of requests and pins a client to one replica, the balancing algorithms and what each optimises, power-of-two-choices, health checking and outlier ejection with the fleet-ejection hazard, and connection draining. Use when per-pod request rate is skewed while connection counts look even, when one replica is hot after a scale-up, when gRPC or HTTP/2 crosses a ClusterIP Service, when a dependency blip ejects the whole upstream, or when choosing between an ingress proxy, a mesh and client-side balancing. Does not cover why a replica is interchangeable (stateless-service-design), the in-pod proxy form (ambassador-pattern), what to do when every replica is busy (rate-limiting-and-load-shedding), readiness and drain mechanics (kubernetes-service-lifecycle), or routing a key to its owner (sharding-and-partitioning).
    3 repo stars
  34. ▌
    Zgc Generational Internals · robsonkades bundle
    Generational ZGC internals: coloured pointers without multi-mapping, the load and store barriers, the young and old cycles and their STW phases, the remembered-set bitmap and its double buffering, relocation and page management, allocation stalls, and the generational log and JFR event names. Use when a deploy script still carries -XX:+ZGenerational, when jdk.ZAllocationStall events appear or allocation stalls cluster in traffic peaks, when a pause script greps only "Pause Mark" and reports a suspiciously good p99, when heap sizing was carried over unchanged from G1, when ZGC thread CPU is being read out of a thread dump, or when barrier overhead needs to be attributed to reads versus writes. Does not cover choosing between or operating the concurrent collectors (zgc-and-shenandoah), the introductory collector model (gc-fundamentals), or attributing an observed production pause across layers (pause-attribution).
    3 repo stars
  35. ▌
    Blocking And Nonblocking Io · robsonkades bundle
    Four things routinely conflated into one: a blocking API, a blocked OS thread, non-blocking I/O at the syscall, and an asynchronous programming model. Covers which JDK operations unmount a virtual thread and which capture the carrier, the difference between capture-with-compensation and pinning, the socket poller behind blocking socket calls, file I/O as the case Loom does not fix, and what blocking an event loop costs. Use when someone says virtual threads make I/O non-blocking, when a file-heavy workload on virtual threads grows the carrier pool, when a blocking call sits inside a Netty or Reactor pipeline, when jdk.virtualThreadScheduler.maxPoolSize is raised to fix a symptom, or when an argument turns on whether the model or the syscall is the bottleneck. Not choosing between the two models (reactive-and-virtual-thread-selection), continuation mechanics and pinning diagnosis (virtual-threads-internals), demand signalling (reactive-backpressure), or copy avoidance (io-uring-and-zero-copy).
    3 repo stars
  36. ▌
    Distributed Systems Testing · robsonkades bundle
    Testing the failure behaviour a distributed system claims: injecting latency, errors, partitions and process death; verifying that timeouts, retries, breakers and fallbacks do what their configuration says; proving idempotency against duplicate delivery; and running a controlled experiment in production rather than a chaos tool. Use when resilience configuration exists but has never been exercised, when a timeout or retry budget is being chosen, when an incident was caused by a dependency being slow rather than down, when a consumer is assumed idempotent, when a rollout is protected by a probe nobody has failed on purpose, or when chaos engineering is proposed without a hypothesis. Does not cover the in-process test pyramid and architecture rules (architecture-testing), thread-level race testing (concurrency-testing), throughput and saturation measurement (load-testing), or the remedies themselves (retries-and-backoff, circuit-breakers, timeouts-and-deadlines).
    3 repo stars
  37. ▌
    False Sharing And Contended · robsonkades bundle
    Proving and mitigating cache-line false sharing between independent locations with hot writes. Covers ownership and address/layout hypotheses, coherence/HITM evidence limits, JMH topology, arrays and object placement, `@Contended` module/restriction mechanics, grouping and padding, JOL/address validation, manual padding fragility, striping, compact headers, memory cost and cross-socket/NUMA validation. Use after excluding logical contention; cache fundamentals, lock contention and general object sizing have separate owners.
    3 repo stars
  38. ▌
    Feature Contract Definition · robsonkades bundle
    Defining a versioned API, event, data, integration, security, or operational contract for a feature after its behavior is agreed and before implementation is planned. Use when callers, consumers, stored data, or operators will depend on a changed boundary and its success, failure, ownership, compatibility, and verification must be explicit. Does not choose the architecture or transport (feature-solution-analysis), record the decision (feature-decision-analysis), or implement the contract (feature-execution).
    3 repo stars
  39. ▌
    Feature Implementation Plan · robsonkades bundle
    Assembling everything established about a feature into one document another engineer could execute without re-deriving the architecture: the resources in dependency order, the schema, contract, configuration and security changes named individually, the test strategy per resource, the migration, deployment and rollback story, and acceptance criteria a test can be written from. Use once the decisions are taken and before implementation starts, when a plan is a list of file names, when the plan and the code have drifted apart, when a feature is being handed to someone else or resumed after a break, or when the rollback story is discovered during the rollback. Does not produce the breakdown it orders (feature-decomposition), does not execute it (feature-execution), does not track status against it (feature-progress-tracking), and does not invent dates or effort estimates (estimation-under-uncertainty).
    3 repo stars
  40. ▌
    Gof Chain Of Responsibility · robsonkades bundle
    Chain of Responsibility in modern Java, and the pipeline it is usually confused with: the classical first-accepting form versus middleware where stages may all process and forward conditionally. Covers choosing between them, the unhandled-request policy that silent chains get wrong, ordering discipline when handlers are contributed independently, error propagation and partial state when a stage throws mid-chain, and why servlet filters and interceptor chains are this pattern already implemented. Use when a request must be offered to several possible handlers, when @Order values are tuned to make a chain work, when a request falls off the end of a chain and nothing happens, or when a chain is proposed for three fixed cases. Does not cover the security framework's own filter configuration, the retry and timeout policies applied around a call (gof-decorator, circuit-breakers), or message processing across services (streaming-pipeline-topologies).
    3 repo stars
  41. ▌
    Gof Patterns In Modern Java · robsonkades bundle
    Which Gang-of-Four patterns modern Java and Spring already implement, which they only change the expression of, and which still need writing by hand. Covers records, sealed types and pattern matching against Visitor, State, Composite and Interpreter; lambdas and functional interfaces against Strategy, Command, Factory Method and Observer; the container against Singleton, Abstract Factory and Factory Method; framework mechanisms against Decorator and Proxy; and what virtual threads and ScopedValue change about patterns that carry context or defer work. Use when implementing a pattern from an older text, when a hand-rolled mechanism duplicates something the framework provides, or when deciding whether a pattern is obsolete or merely invisible. Does not cover choosing a pattern (gof-pattern-selection), any individual pattern's guidance (the gof-\* skills), enterprise patterns against frameworks (patterns-and-modern-frameworks), or the inheritance decision (java-composition-over-inheritance).
    3 repo stars
  42. ▌
    Object Layout And Footprint · robsonkades bundle
    Sizing a data structure in bytes before it exists. Use when a shape is chosen for millions of instances — record, class, primitive array, parallel arrays or boxed collection; when an array is proposed to save the header; when HashMap<Integer,Integer> or List<Long> is on a bulk path; when -XX:+UseCompactObjectHeaders is evaluated for footprint; or when smaller objects are expected to buy shorter GC pauses without a collector-specific measurement. Answers in bytes per element; one record-versus-array example reverses under the JDK 27 default (JEP 534, not yet GA). Sizing a replacement belongs here; measuring what exists is heap-dump-analysis. Not flag lifecycle (jvm-performance-review), @Contended padding (false-sharing-and-contended), cache hierarchy (cpu-cache-and-numa), allocation rate (allocation-profiling), container budget (jvm-memory-regions), compressed class space (metaspace-internals), off-heap memory (off-heap-memory), or sharing duplicates (gof-flyweight).
    3 repo stars
  43. ▌
    Offline Concurrency Control · robsonkades bundle
    Protecting data from concurrent edits that span more than one transaction: optimistic offline lock, pessimistic offline lock, coarse-grained locking at the aggregate, and implicit locking applied by the framework. Use when two users overwrite each other's edits, when a version column is being added or removed, when OptimisticLockException reaches the user as a stack trace, when a bulk update silently bypasses versioning, when a lock is held across thinking time by a database transaction, when a lock table has no expiry, or when retry is proposed as the answer to a conflict. Does not cover boundaries and isolation within one transaction (enterprise-transactions), in-process thread locking (java-memory-model), or repeat-safety of a request (idempotency).
    3 repo stars
  44. ▌
    Requirements And Acceptance · robsonkades bundle
    Turning a request into something buildable and checkable before writing code: separating the requirement from the implementation someone already chose, finding the ambiguities that change the work, naming assumptions where they can be contradicted, writing acceptance criteria that a test can be derived from, and surfacing contradictions instead of resolving them silently. Use before implementing a ticket whose edge cases are unstated, when a request names a solution rather than a need, when "fast", "secure" or "reliable" appears without a number, when two requirements cannot both hold, when a change is rejected in review for doing the wrong thing, or when deciding whether to ask or to proceed on a stated assumption. Does not cover how long it will take (estimation-under-uncertainty), how to deliver the message (engineering-communication), the test level (java-testing-strategy), or the order of work (clean-delivery-workflow).
    3 repo stars
  45. ▌
    Architecture And Performance · robsonkades bundle
    Attribute endpoint latency and throughput limits to architectural choices when query counts grow with result size, remote calls are chatty, connections are held across other work, or a cache, layer removal or service extraction is proposed as a performance fix. Compare fetching, call topology, resource occupancy and data movement across the whole request path. Does not replace investigation methodology (performance-methodology), profiling (jfr-and-async-profiler), individual SQL tuning (sql-query-performance), pool configuration (connection-pool-sizing) or load-test construction (load-testing).
    3 repo stars
  46. ▌
    Architecture Characteristics · robsonkades bundle
    Derive and prioritize architectural quality drivers when requirements say only scalable or reliable, too many qualities are called top priority, stakeholders disagree on their meaning, or one list is applied across unrelated services. Define scope, sources, observable scenarios, baseline obligations and reasons for deferring candidates. Covers terminology and quality-model interpretation; excludes choosing design options (architecture-trade-off-analysis), recording ADRs (architecture-decision-making), coupling analysis (architecture-coupling-and-quanta) and operational SLO implementation.
    3 repo stars
  47. ▌
    Architecture Decision Making · robsonkades bundle
    Write, review, reconstruct or supersede architecture decision records when rationale is missing, a decision is repeatedly reopened, a proposal needs an explicit outcome, or an accepted choice changes. Decide how much record is warranted; preserve evidence, alternatives, consequences, decision authority and revisit conditions. Covers ADR scope, lifecycle and traceability; option comparison belongs to architecture-trade-off-analysis, quality-driver elicitation to architecture-characteristics, and shortcut/repayment choices to technical-debt-decisions.
    3 repo stars
  48. ▌
    Distributed Locks And Leases · robsonkades bundle
    Cross-process exclusion through leases, session/transaction locks and fencing: stale holders, owner-safe release, Redis/Redlock assumptions, database advisory locks, resource claims and lock-free alternatives. Use when reviewing SET NX/TTL, watchdog renewal, duplicate workers or a lock around a non-repeatable effect. Consensus implementation, leader election, local JVM locking and user-session concurrency are separate skills.
    3 repo stars
  49. ▌
    Estimation Under Uncertainty · robsonkades bundle
    Producing a software estimate that carries its own uncertainty instead of hiding it: a range with explicit probability assumptions when supported, decomposition, PERT and the limits of summing task estimates, calibrating against what this team has actually done, and keeping estimate, target and commitment as three separate things. Use when asked how long something will take, when a single date is being requested for work that has not been broken down, when an estimate is being treated as a promise, when padding is being added silently, when a plan is slipping and the message has not gone out yet, or when someone asks for a number before the requirement is clear. Does not cover clarifying the requirement itself (requirements-and-acceptance), how to deliver bad news (engineering-communication), or trading quality for time (technical-debt-decisions).
    3 repo stars
  50. ▌
    Executors And Task Lifecycle · robsonkades bundle
    Engineering the full lifecycle of tasks accepted by Java executors: ownership, admission, queue/grow behavior, execution context, result/failure observation, rejection, cancellation, scheduled/periodic semantics, context cleanup, shutdown/drain and recovery. Covers ThreadPoolExecutor, scheduled pools and thread-per-task/virtual-thread executors without treating factory defaults as capacity policy. Use when work disappears, queues grow, rejection or deploy loses work, or a virtual-thread migration removes an implicit bound.
    3 repo stars
  51. ▌
    Java Serialization Hardening · robsonkades bundle
    Java built-in serialization as an attack surface and a permanent API commitment: why readObject is an extra constructor that accepts arbitrary bytes, gadget chains and what deserialization filters (JEP 290/415) can and cannot do, the cost of implementing Serializable, serialVersionUID and the custom serialized form, validating and defensively copying in readObject, the serialization proxy pattern, why records are different, and the same risk in JSON polymorphic typing. Use when Serializable, readObject, readResolve or Externalizable appears, when ObjectInputStream reads bytes from a cache, queue, session store, RMI or JMX, when Jackson default typing is enabled, or when a mixed-version deploy breaks a serialized cache. Format cost is serialization-performance, contract evolution is rpc-and-api-contracts, and the reflective access underneath is java-reflection-and-method-handles.
    3 repo stars
  52. ▌
    Java Thread Safety Contracts · robsonkades bundle
    Specifying and reviewing thread-safety as a caller-visible behavioral contract: ownership and confinement, immutability, atomic operations and compound invariants, consistency/iteration, lock identity and scope, callbacks/alien calls, deadlock ordering, progress/fairness, publication, lazy initialization, cancellation, and lifecycle. Use when a shared class has an ambiguous guarantee or a proposed lock/atomic/concurrent collection may preserve individual methods but violate multi-call semantics. JMM proofs, lock-free algorithms and incident diagnostics have separate owners.
    3 repo stars
  53. ▌
    Kubernetes Service Lifecycle · robsonkades bundle
    A Java service at the edges of its life under Kubernetes: liveness, readiness and startup probes as three different questions, probe timing arithmetic, graceful shutdown as a sequence where endpoint removal races SIGTERM, terminationGracePeriodSeconds as a budget, draining non-HTTP work such as Kafka consumers and scheduled jobs, PodDisruptionBudgets, and limits as availability decisions. Use when 502s appear only during a rolling update, when a liveness probe checks a database and a blip restarts every healthy pod, when initialDelaySeconds was guessed instead of a startupProbe, when a pod exits 137 or loops in CrashLoopBackOff, when a node drain hangs, or when in-flight Kafka or scheduled work is lost on redeploy. Does not cover what the JVM detects in a cgroup (container-awareness), host kernel behaviour (linux-for-jvm), faster startup (startup-cds-crac-leyden), replica disposability (stateless-service-design), routing (load-balancing-and-routing), or API compatibility (rpc-and-api-contracts).
    3 repo stars
  54. ▌
    Cancellation And Interruption · robsonkades bundle
    Designing cooperative cancellation in Java across interruption, Future/CompletableFuture, executor/scope shutdown, deadlines, resource close/abort, CPU loops, blocking APIs, native calls, partial side effects and cleanup. Covers multiple cancellation sources, signal ownership, propagation/translation/restoration, noninterruptible regions, residual work, idempotency and bounded termination tests. Use when timeout/cancel returns but work or resources remain, or when `InterruptedException` handling is ambiguous. Timeout selection and retry policy are separate.
    3 repo stars
  55. ▌
    Compilation And Inlining Logs · robsonkades bundle
    Reading what the JIT actually did: the columns of -XX:+PrintCompilation and its flag characters, -XX:+PrintInlining and its verdict strings, -XX:+LogCompilation with JITWatch, the -Xlog:jit+compilation and JFR forms, targeted compiler directives, and turning a refusal into a code change. Use when a hot method is suspected of not reaching tier 4, when a call site shows "too big" or another inlining refusal, when a method never appears in the compilation log at all, when someone prescribes -XX:CompileThreshold or -Xlog:jit, when a script greps the compilation log and returns nothing, when a directive added with jcmd changed nothing, when JFR shows no compilation events, or when raising FreqInlineSize globally is proposed to fix one method. Does not cover the tiered pipeline, warm-up and the code cache as concepts (jit-compilation), the design rules about inlining and escape (jit-inlining-and-escape-analysis), recompilation and uncommon traps (deoptimization), or C2's internal representation (c2-sea-of-nodes).
    3 repo stars
  56. ▌
    Completablefuture Composition · robsonkades bundle
    Design and diagnose CompletionStage graphs with explicit execution, ownership, failure, timeout, cancellation, context and admission semantics. Use when a continuation runs on an I/O thread, a branch failure disappears, allOf or anyOf has the wrong policy, a timeout leaves work running, or asynchronous fan-out overloads a dependency. Distinguishes Java 17/21 APIs from Java 25 preview structured-concurrency alternatives.
    3 repo stars
  57. ▌
    Distributed Failure Catalogue · robsonkades bundle
    Evidence-oriented recognition index for recurring distributed failure shapes: overload amplification, gray and asymmetric failure, split ownership, stale work, mixed versions, correlated faults, silent stagnation and destructive automation. Use to turn incident observations into discriminable hypotheses and route each to the skill owning diagnosis and remediation. It is not a substitute for the owner skill or causal evidence.
    3 repo stars
  58. ▌
    Feature Architecture Analysis · robsonkades bundle
    Enumerating what a feature actually touches, with paths: which modules, layers, contracts, schemas, message topics, configuration and cross-cutting concerns change, which of those changes are visible outside the component, and where the change crosses a boundary that requires checking compatibility and ownership. Use before writing an implementation plan, when a feature is assumed to be local and might not be, when a change is about to alter a published contract or a stored schema, when the file list in a plan was written from memory, or when nobody can say what breaks if this feature is wrong. Does not choose which layer a responsibility belongs to (layering-and-boundaries), does not decide where a deployable boundary should fall (architecture-coupling-and-quanta), and does not evaluate competing designs (feature-solution-analysis).
    3 repo stars
  59. ▌
    Gof Patterns And Distribution · robsonkades bundle
    What happens to a Gang-of-Four pattern when the collaboration crosses a process boundary, and which additional architectural contracts it may require. Covers process-local, boundary, interaction and algorithm patterns; assumptions that need rechecking at a boundary — shared state, clocks, atomicity, ordering and delivery; the transformations (Singleton to leader election, Observer to pub/sub, Iterator to pagination, Mediator to an orchestrator); and the level confusion that treats a design pattern as a substitute for an architectural one. Use when a local design is being distributed, when a pattern name is applied to a network component, when a "singleton" or a cache is expected to hold across replicas, or when a getter turns out to make a call. Does not cover the individual patterns (the gof-\* skills), saga and outbox mechanics (distributed-transactions-and-sagas, event-driven-architecture), service boundary decisions (distribution-boundaries), or failure taxonomy (failure-models).
    3 repo stars
  60. ▌
    Performance Incident Response · robsonkades bundle
    Coordinating a production performance incident from impact declaration through evidence-preserving triage, one-change mitigation, recovery validation and a blameless causal postmortem. Use when a latency, throughput, saturation or resource regression requires a war room; when responders are changing JVM flags before preserving evidence; or when MTTD, mitigation time and recovery time are being conflated. Evidence acquisition belongs to incident-evidence-capture; technical diagnosis to performance-methodology; this skill owns response sequencing and decision records.
    3 repo stars
  61. ▌
    Streaming Pipeline Topologies · robsonkades bundle
    Composable stage shapes for event-driven pipelines — copier, filter, splitter, sharder, merger — with ordering, semantic parallelism, state, shuffle and recovery boundaries; exactly-once scope across source, state and sinks; bounded joins and windows; watermarks, late-data policy, backlog versus flow control, and reproducible replay. Use when a stage is parallelised, when a join grows state without bound, when a stage re-keys the stream, when late events arrive after a window closed, when a windowed test uses wall-clock, or when reprocessing gives a different answer. Not whether to be event-driven (event-driven-architecture), ordering scope (message-ordering-and-partitioning), barriers (distributed-aggregation-and-barriers), skew (hot-partitions-and-rebalancing), the consumer (kafka-consumers-in-java), or in-process demand (reactive-backpressure).
    3 repo stars
  62. ▌
    Architecture Fitness Functions · robsonkades bundle
    Define or review checks that preserve architectural qualities when a green pipeline misses incidents, inherited rules are skipped or unexplained, a characteristic lacks evidence, or a metric is being promoted to a blocking gate. Choose the measurement or rubric, threshold, execution site, owner and response policy; expose proxy limits and coverage gaps. Excludes selecting quality drivers (architecture-characteristics), implementing application tests (architecture-testing), pipeline composition (quality-gates), performance experiment thresholds (performance-regression-ci) and operational error-budget design (slo-and-alerting).
    3 repo stars
  63. ▌
    Architecture Refactoring Paths · robsonkades bundle
    Sequence a chosen enterprise architecture change into compatible, testable checkpoints: domain and persistence refactoring, remote boundaries, session state, locking or events. Use when old and new paths must coexist, a migration has stalled, code and data changes interact, consumers cannot upgrade together, or rollback and safe pause points are unclear. Does not select target patterns, diagnose the need for change (enterprise-architecture-smells), plan a whole modernization programme (legacy-enterprise-modernization), or implement database migration tooling.
    3 repo stars
  64. ▌
    Cache Sharding And Replication · robsonkades bundle
    Topology for a cache that no longer fits one node: client-side sharded, proxy-fronted, clustered, and fully replicated, compared on failure behaviour, cost and client complexity; and why a read after a write on a replicated cache is not read-your-writes. Estimates origin load when a cache node fails from its measured request share and the surviving copies, routing and capacity — mitigated by replication, warming, coalescing and admission control. Use when choosing between client sharding, a proxy and cluster mode, when a cache node loss or rolling restart took the database with it, when replicas of a cache disagree, or when deciding between sharding the cache and replicating all of it. Does not cover whether to cache, TTL, stampede or invalidation (caching-strategies), the key-to-node mapping (consistent-hashing), a single hot cache key (hot-partitions-and-rebalancing), entry serialisation cost (serialization-performance), or what a replicated read observes (consistency-models).
    3 repo stars
  65. ▌
    Enterprise Architecture Smells · robsonkades bundle
    Detecting structural problems in an enterprise application from evidence, and telling genuine harm apart from unfamiliar-but-fine: anaemic domain models, god services, transaction-script sprawl, generic repositories, excessive layering and DTO mapping, leaky abstractions, distributed monoliths, persistence leakage, and abstractions that only move complexity. Use when reviewing an architecture or a large pull request, when adding a field touches seven files, when a "clean architecture" refactor is being proposed, when an interface has one implementation, when a wrapper adds no behaviour, when a pattern is being applied because it is a pattern, when a codebase feels wrong but nobody can say why, or when deciding whether an abstraction is worth keeping. Does not cover the migration once a smell is confirmed (architecture-refactoring-paths, legacy-enterprise-modernization), performance diagnosis (architecture-and-performance), or the individual patterns' own guidance.
    3 repo stars
  66. ▌
    Feature Feasibility Experiment · robsonkades bundle
    Designing and evaluating the smallest PoC or experiment that resolves one decision-relevant uncertainty in a Product Feature or Tech Feature. Use when feasibility, compatibility, capacity, integration behavior, or a risky technical premise cannot be established from existing evidence and a bounded experiment can decide the next step. Does not produce production implementation, replace an ADR, or run broad exploratory research without a decision and threshold.
    3 repo stars
  67. ▌
    Forkjoinpool And Work Stealing · robsonkades bundle
    Design and diagnose ForkJoinPool workloads using work-stealing topology, task graphs, granularity, common-pool interference, managed blocking, compensation limits and approximate pool telemetry. Use when parallel computation underutilizes CPUs, parallel streams interfere, joins stall, blocking collapses effective parallelism, or copied thresholds and pool constants are being treated as universal policy. Includes Java 25 API changes with version labels.
    3 repo stars
  68. ▌
    Hot Partitions And Rebalancing · robsonkades bundle
    Repairing a partitioned system whose distribution has failed in production: a hash distributes keys uniformly and says nothing about traffic, so one celebrity key or one large tenant saturates a shard while the map is correct. Covers detection — per-shard rate, latency and storage, and the max-to-mean ratio, because an aggregate dashboard hides skew; naming the key by top-K sampling; the read-hot, write-hot, storage-hot and overloaded-fleet signatures; the repairs and their prices; and the rebalance, with its double-ownership window and versioned map. Use when one shard runs far above the others while the fleet average looks fine, when a shard is hot before and after a rehash, when one tenant dominates a shard, or when a rebalance is planned or is itself the incident. Not the mapping function (consistent-hashing), the key choice (sharding-and-partitioning), caching (caching-strategies), capping the caller (rate-limiting-and-load-shedding), the tail (tail-latency-analysis), or the numbers (latency-statistics).
    3 repo stars
  69. ▌
    Inheritance Mapping Strategies · robsonkades bundle
    Mapping a subtype hierarchy onto tables — single table, class table (joined), concrete table per class — and deciding whether the hierarchy should exist at all. Use when an @Inheritance strategy is being chosen, when a single-table mapping is forcing every subtype's columns to be nullable, when a joined mapping's polymorphic query joins six tables to render a list, when adding a subtype requires a migration, when a discriminator column has drifted from the class names, when polymorphic queries are slow or return the wrong rows, when a hierarchy exists only to share three fields, or when composition would serve better than subtyping. Does not cover associations, identity and value mapping (orm-structural-mapping), where the mapping instructions live (metadata-mapping), the runtime fetch behaviour (orm-behavioral-patterns), or the domain question of whether subtypes model the business correctly (domain-logic-organization).
    3 repo stars
  70. ▌
    Java Reference Types And Leaks · robsonkades bundle
    Reachability-driven memory in Java: the strong/soft/weak/phantom levels and exactly when each is cleared, WeakHashMap and its value-holds-key trap, Cleaner as a leak-reporting safety net rather than a release mechanism, finalization deprecation, and the leak catalogue — obsolete references in self-managed structures, listener registries, ThreadLocal on pooled threads, class-loader retention, non-static nested classes holding their enclosing instance, and caches that only grow. Use when heap grows with traffic and never returns after a full GC, when a redeploy raises Metaspace, when someone proposes a WeakReference or SoftReference cache, when a Cleaner or finalize() appears, when a ThreadLocal has no remove(), or when "restarting fixes it" is the operating procedure. Does not cover deterministic release of open resources (java-resource-management), reading a heap dump (heap-dump-analysis), finding allocation sites (allocation-profiling), or off-heap and native memory (off-heap-memory).
    3 repo stars
  71. ▌
    Patterns And Modern Frameworks · robsonkades bundle
    Which classical enterprise patterns a modern Java and Spring stack already implements, which it only partly implements, and which it does not implement at all — plus the modern Java expression of each. Use when a repository interface is written over Spring Data, when a unit of work or identity map is built over JPA, when a front controller is hand-rolled, when a caching layer is written over the caching abstraction, when an entity is written as a mutable bean because "JPA requires it", when a pattern's implementation is copied from an old text, or when deciding whether a pattern is obsolete or merely invisible. Does not cover choosing the pattern (pattern-selection-and-composition) or judging whether an abstraction should exist (enterprise-architecture-smells).
    3 repo stars
  72. ▌
    Varhandles And Memory Ordering · robsonkades bundle
    Designing and proving low-level Java variable access with VarHandle plain, opaque, acquire/release and volatile modes; compare-and-set/exchange, weak CAS, read-modify-write, fences, coordinates, signature-polymorphic typing, supported modes, and mixed-access hazards. Connects each mode to an algorithmic synchronization edge, allowed outcomes, jcstress model, generated-code evidence and target-specific performance measurement. Use only when ordinary volatile, atomics, locks or concurrent utilities do not express the required protocol.
    3 repo stars
  73. ▌
    Architecture Trade Off Analysis · robsonkades bundle
    Compare architectural alternatives when quality goals conflict, a scorecard or case study is being used as a verdict, options mix abstraction levels, advocates disagree, or a benchmark needs a decision rule. Build comparable options, separate constraints from preferences, test domain scenarios and uncertainty, and recommend a choice or a bounded next step. Excludes ADR lifecycle (architecture-decision-making), quality-driver elicitation (architecture-characteristics), domain pattern selection and debt repayment.
    3 repo stars
  74. ▌
    Legacy Enterprise Modernization · robsonkades bundle
    Modernising an enterprise application that is in production and cannot stop: understanding a system nobody fully knows, pinning behaviour before changing it, strangling functionality out incrementally, and defending a new model with an anti-corruption layer. Use when a rewrite is proposed for a system that still earns money, when a shared database has several writers, when business rules live in stored procedures and triggers, when there are no tests and no specification, when a strangler migration has stalled with both systems running, or when a modernisation has run for a year with nothing decommissioned. Does not cover the specific pattern-to-pattern migrations (architecture-refactoring-paths), recognising the problems (enterprise-architecture-smells), whether a boundary should be remote (distribution-boundaries), or class-level seams and dependency breaking (java-legacy-code-testing).
    3 repo stars
  75. ▌
    Performance Engineering Program · robsonkades bundle
    Establishing an organization-wide performance engineering program through measurable maturity evidence, service ownership, SLO and baseline adoption, regression gates, incident learning and a rotating champion model. Use when performance depends on one specialist, teams apply different evidence standards, a maturity assessment needs concrete next actions, or a rollout must turn isolated profiling into a durable operating discipline. Does not design individual SLOs, benchmarks, alerts or profiles; their specialist skills own those artifacts.
    3 repo stars
  76. ▌
    Rate Limiting And Load Shedding · robsonkades bundle
    Two mechanisms kept apart: rate limiting as a fairness and quota policy enforced per client whether or not you are busy, and load shedding as self-protection that refuses work you cannot complete, from your own saturation. Covers token versus leaky bucket, fixed versus sliding windows, burst capacity, distributed limits and local-plus-shared reconciliation, the 429 and Retry-After contract, saturation signals, deadline-aware rejection. Use when a limit is enforced per replica and multiplies by replica count, when a fixed window lets through double the rate intended, when a limiter returns 500 or omits Retry-After, when a service collapses under traffic that broke no limit, or when shed rate alerts as an error. Not queue arithmetic (littles-law-and-queueing), system-wide spread (cascading-failures), the client-side complement (circuit-breakers), the retry side of a 429 (retries-and-backoff), replica spread (load-balancing-and-routing), error budgets (slo-and-alerting), or load generation (load-testing).
    3 repo stars
  77. ▌
    Architecture Coupling And Quanta · robsonkades bundle
    Map release and runtime coupling when services ship together, event-driven components still require coordinated changes, shared data obscures ownership, or a proposed architecture quantum boundary cannot be justified. Distinguish structural dependencies, workflow completion and connascence using contracts, deployment evidence and failure behavior. Does not choose service extractions (distribution-boundaries), diagnose architecture smells (enterprise-architecture-smells), or refactor package dependencies (java-cohesion-coupling).
    3 repo stars
  78. ▌
    Collaborative Feature Definition · robsonkades bundle
    Co-authoring Product Features and Tech Features through focused question-and-revision rounds. For a Product Feature, separates the business definition from an optional engineering analysis owned by an architect or senior engineer, including PoCs, ADRs, contracts, and engineering premises. Use when the deliverable is an agreed feature brief or ticket, not implementation. The completed package is handed to feature-engineering for lifecycle validation and execution planning.
    3 repo stars
  79. ▌
    Component And Release Boundaries · robsonkades bundle
    Deciding what becomes an independently releasable component — a Maven module, a JPMS module, a published library — and what that costs: the tension between reusing code and being able to release it, why a shared jar couples every service depending on it, breaking cycles between components, and judging whether a component is stable enough to depend on. Use when a `common` or `shared` module is proposed or has grown, when extracting code into a library so two services can reuse it, when a dependency cycle appears between Maven modules, when upgrading one library forces a coordinated release of several services, or when services are independently deployable in theory but always ship together. Does not cover cohesion and coupling at class and package level (java-cohesion-coupling), whether a component should become a separate process (distribution-boundaries), the API compatibility of a published type (java-api-design), or wire contract versioning (rpc-and-api-contracts).
    3 repo stars
  80. ▌
    Epsilon And Shenandoah Internals · robsonkades bundle
    Epsilon as a measurement instrument (isolating allocation cost, failing fast against an allocation budget, sizing from time-to-OOM) and Shenandoah internals (the load reference barrier, the concurrent phase sequence, generational mode and its card-table remembered set, the heuristics and their thresholds, pacing, and the degenerated-versus-full fallbacks). Use when a hot path is claimed to be allocation-free, when benchmark numbers are polluted by collection, when an Epsilon catch block never runs, when "Degenerated GC" appears in a Shenandoah log, when Shenandoah latency rises with no pause in the log, when a Shenandoah comparison does not state its ShenandoahGCMode, when the LRB is called a read barrier or charged 8 bytes per object, or when an Epsilon example omits -XX:+UnlockExperimentalVMOptions. Does not cover choosing between or operating the concurrent collectors (zgc-and-shenandoah), finding which code allocates (allocation-profiling), or establishing whether GC is the bottleneck (jvm-gc-tuning).
    3 repo stars
  81. ▌
    Java Application Security Basics · robsonkades bundle
    Application-security judgement for Java 21+: password storage with current memory-hard KDF parameters, constant-time verification, secure randomness, authorisation inside the protected operation, adversarial validation, reversible-cryptography boundaries, and secret-safe types. Use when a password, hash, salt, token, API key or pepper appears in a diff; when MessageDigest, SecureRandom, Random, UUID, Cipher, Mac or PasswordEncoder is called; when a controller annotation is the only authorisation check; when identity comes from the request instead of the principal; or when a generic CryptoUtils wrapper is proposed. Code-level only: layered validation is java-defensive-programming, redaction is structured-logging, ReDoS is java-strings-and-text, and deserialisation is java-serialization-hardening.
    3 repo stars
  82. ▌
    Jit Inlining And Escape Analysis · robsonkades bundle
    Inlining and escape analysis in C2: inlining as the multiplier, scalar replacement versus "stack allocation", flow-insensitivity, turning a PrintInlining verdict into a code change, and measuring with gc.alloc.rate.norm. Use when allocation rate is high on a hot path, when a hot call is refused inlining and the fix is unclear, when an object pool for small objects, @ForceInline on application code or a higher FreqInlineSize is proposed, when an interface gains a third implementation on a critical path, when "the JIT will handle it" or "allocation is expensive" is asserted without a measurement, when a rare branch makes an object escape, when Optional, a stream or a lambda capture is blamed or excused for allocation, or when a hot method never appears in PrintCompilation. Does not cover warm-up and the tiered pipeline (jit-compilation), benchmark construction (jmh-microbenchmarks) or GC cost (gc-fundamentals). The algorithm itself is escape-analysis-internals; byte attribution is allocation-profiling.
    3 repo stars
  83. ▌
    Query Objects And Specifications · robsonkades bundle
    Expressing queries as objects that can be composed, named and tested — Query Object, Specification, criteria builders, derived repository methods and explicit SQL — and choosing between them per query rather than adopting one style everywhere. Use when repository interfaces have grown dozens of findByAAndBAndCOrderByD methods, when a search screen with optional filters is being built by concatenating strings, when a Specification chain has become unreadable or produces a query nobody can predict, when dynamic filtering is needed across several entities, when a criteria query is being written for something a single SQL statement would express, when reads are being forced through the aggregate, or when a query object is being proposed as an abstraction over the database. Does not cover the collection abstraction over domain objects (repository-pattern), fetch strategies and N+1 (orm-behavioral-patterns), where mapping metadata lives (metadata-mapping), or index design and pagination at the database level.
    3 repo stars
  84. ▌
    View And Representation Patterns · robsonkades bundle
    Producing the response: Template View, Transform View and Two Step View as three ways to turn a model into output, and what each becomes in a JSON API, a server-rendered page or a hypermedia fragment. Use when logic is accumulating inside templates, when a template triggers database queries during rendering, when the same data must be rendered in several formats and the mapping is duplicated per format, when a consistent look or envelope must be applied across every screen or endpoint, when entities are being serialised directly to clients, when a response shape is decided by whatever the service happened to return, or when server-rendered fragments and a JSON API are both being served from the same handlers. Does not cover routing and cross-cutting request concerns (mvc-and-request-handling), the remote operation's granularity and its payload contract (remote-facade-and-dto), compatibility and versioning of that contract (rpc-and-api-contracts), or serialisation throughput (serialization-performance).
    3 repo stars
  85. ▌
    Feature Requirement Clarification · robsonkades bundle
    Deciding what to ask the user about a feature, when to ask it, and what stops work until it is answered: proving the repository cannot answer it first, pricing each question by what changes if the answer is the other one, batching questions into rounds instead of interrogating, and marking the few that are genuinely blocking. Use when a feature request is ambiguous and the choice is between asking and assuming, when a long list of questions is about to be sent at once, when work is stalled on a question that has no consequence, when implementation is about to start on a guessed answer, or when a question is being asked that a grep would have answered. Does not investigate the repository itself (feature-context-analysis), does not classify what is known from what is guessed (feature-discovery), and does not own the ambiguity catalogue or acceptance-criteria format (requirements-and-acceptance).
    3 repo stars
  86. ▌
    Java Composition Over Inheritance · robsonkades bundle
    Choosing between inheritance, composition and sealed hierarchies in Java: fragile base classes, self-use of overridable methods, subclass explosion, the costs of delegation and decoration, sealed types with exhaustive switch as the modern middle ground, and the cases where inheritance is genuinely right. Use when reviewing an `extends` between classes you maintain, when a base-class change broke subclasses, when variants multiply along more than one axis, or when designing a new hierarchy. Does not cover behavioural substitutability formalism (java-design-by-contract) or the SOLID framing of LSP (java-solid).
    3 repo stars
  87. ▌
    Message Ordering And Partitioning · robsonkades bundle
    Ordering guarantees and their exact scope/stage: common logs order per partition while a global total order requires a serialized sequencer; per-key ordering depends on key-to-partition mapping remaining stable; why the partition count is nearly a one-way door; what silently breaks order in a consumer or producer; and whether ordering is required at all — version guards, commutative handlers, state-machine guards. Use when a design says messages are processed in order with no scope, when partitions are added to a live topic, when records are produced with no key, when the handler dispatches to an executor in the poll loop, when a retry republishes to the topic's tail, or when an older update overwrites a newer one. Not duplicates (delivery-semantics), repeat-safe handlers (idempotency), consumer offsets (kafka-consumers-in-java), key choice (sharding-and-partitioning), skew (hot-partitions-and-rebalancing), the failing record (poison-messages-and-dlq), or what a reader observes (consistency-models).
    3 repo stars
  88. ▌
    Pattern Selection And Composition · robsonkades bundle
    Choosing enterprise patterns from forces rather than familiarity, and combining them into an architecture whose parts reinforce rather than fight each other: the selection criteria that discriminate, the compositions that work, the pairs that conflict, and the relationship graph. Use when a design is starting and the patterns are about to be chosen by habit, when a pattern name is proposed before the problem is stated, when two chosen patterns produce friction, when a reference architecture is being copied wholesale, when someone asks which enterprise patterns a new module should use, or when an architecture must be explained as a set of decisions. Does not cover the individual patterns' guidance, whether the framework provides one (patterns-and-modern-frameworks), or detecting overuse (enterprise-architecture-smells).
    3 repo stars
  89. ▌
    Thread Sizing And Virtual Threads · robsonkades bundle
    Choose and size platform-thread pools or virtual-thread-per-task execution from workload shape, capacity evidence and lifecycle constraints. Covers CPU versus waiting, queue/admission policy, resource limits exposed by virtual-thread migration, ThreadLocal cost, naming, pinning boundaries after JEP 491, and Java 21/24/25 observability. Use when pool size, virtual-thread adoption or post-migration latency/resource pressure is under review.
    3 repo stars
  90. ▌
    Concurrency Limiting And Bulkheads · robsonkades bundle
    Engineer process-local concurrency limits and bulkheads around scarce resources, with explicit admission deadlines, permit ownership, weighted work, partitioning, fairness, observability and overload validation. Distinguishes concurrency, rate and queue limits and the assumptions behind Little's Law. Use after virtual-thread migrations, during downstream saturation, or when local limits leak, over-release, double-queue or fail to compose across replicas.
    3 repo stars
  91. ▌
    Distributed Transactions And Sagas · robsonkades bundle
    Coordinating a business operation across transactional owners: dual writes, XA/2PC, persisted sagas, compensation, pivot/forward recovery, ambiguous outcomes and manual repair. Use when a local transaction is expected to cover a broker or remote service, or in-flight workflow state cannot survive restart. Outbox delivery, idempotency, consistency, retries and single-database transaction design remain in their owning skills.
    3 repo stars
  92. ▌
    Humble Objects And Functional Core · robsonkades bundle
    Splitting a component into the part that decides and the part that acts, so the decision is pure, deterministic and cheap to test while the effectful part stays thin enough for a small set of boundary/integration tests—the Humble Object pattern and the functional core / imperative shell shape of the same idea. Use when a rule can only be exercised by standing up the framework because the decision lives inside the component that performs the effect, when logic sits in a controller, scheduler, message listener or UI component, when a test needs a mocking framework to reach the branch it cares about, or when retry, fallback or routing policy is entangled with the call it governs. Does not cover which test level to use (architecture-testing, java-testing-strategy), choosing and writing the doubles themselves (java-test-doubles), where business rules belong across layers (domain-logic-organization), the mechanics of immutable types (java-immutability), or module dependency direction (layering-and-boundaries).
    3 repo stars
  93. ▌
    Java Reflection And Method Handles · robsonkades bundle
    Runtime access to code the compiler cannot check: what reflection costs beyond speed — no compile-time checking, invisible to refactoring and dead-code analysis, blocked by module encapsulation, and constrained by closed-world native-image analysis — the alternatives that keep the checking (interfaces, ServiceLoader, annotation processing, code generation), MethodHandles and VarHandles for genuinely dynamic access, and the security boundary around resolving a name that came from outside. Use when reflection appears in application code, when setAccessible needs --add-opens, when a framework works on the JVM and fails under native image, when a class name arrives from configuration or a payload, when Method.invoke or invokeWithArguments sits on a hot path, or when a runbook still sets sun.reflect.inflationThreshold or noInflation. FFM and JNI mechanics are jni-and-ffm, the annotations reflection reads are java-annotations, and deserialisation attack surface is java-serialization-hardening.
    3 repo stars
  94. ▌
    Orm Fetch And Batching Performance · robsonkades bundle
    Making JPA and Hibernate stop issuing the statements you did not ask for, and making the ones they do issue cheap: statement count as the primary number, N+1 from an association and from a collection, join fetch versus entity graph versus batch fetching, the cartesian product two join-fetched collections produce, DTO projections instead of entity graphs, and why write batching silently does nothing under identity id generation. Use when the query count scales with rows rendered, when a page issues hundreds of selects, when LAZY was changed to EAGER to make an exception go away, when open-session-in-view is switched on, when a bulk write is one INSERT per row, when a flush is slow, or when pagination over a join fetch warns about in-memory paging. Not the plan for one statement (sql-query-performance), pool sizing (connection-pool-sizing), the runtime patterns themselves (orm-behavioral-patterns), where the mapping lives (metadata-mapping), or the second-level cache decision (caching-strategies).
    3 repo stars
  95. ▌
    Schema Evolution And Compatibility · robsonkades bundle
    Whether a given schema change is safe, in which deploy order, and what breaks when it is not: the writer/reader pair, the compatibility levels and who upgrades first, the per-format rules for Avro, Protobuf and JSON Schema, registry configuration, and catching a break in CI. Use when AvroTypeException reports a missing required field, when "Can't get the number of an unknown enum value" is thrown, when UnrecognizedPropertyException exposes an unexpected mapper policy, when auto.register.schemas or specific.avro.reader is left at its default, when a proto field is deleted without reserved or its number reused, when BACKWARD leaves retained history unchecked, when a consumer group reset to earliest dies on old records, when an .avsc gains a field with no default, or when a typed property is added to an open JSON schema. Not wire size (serialization-performance), HTTP API versioning (rpc-and-api-contracts), offsets (kafka-consumers-in-java), or upcasters (event-sourcing).
    3 repo stars
  96. ▌
    Enterprise Application Architecture · robsonkades bundle
    The entry point for reasoning about an enterprise application's architecture: what makes these systems distinctive (data that outlives the code, concurrent users, integration, rules that change), the forces that shape every decision, how the kind of application changes the answers, and which specific skill answers which question. Use when starting on an unfamiliar enterprise codebase, when designing a new application or module and the first structural decisions are open, when someone asks "how should this system be structured", when a design review has no shared vocabulary, when a decision needs to be located ("is this a persistence question or a domain question?"), or when an architecture must be explained to people who did not build it. Does not itself contain the pattern guidance — it routes to it — and does not cover team or delivery process.
    3 repo stars
  97. ▌
    Framework Coupling And Independence · robsonkades bundle
    Deciding how much of a system may depend on its framework, and pricing that dependency honestly: which couplings are cheap and correct, which are expensive and reversible, which require staged redesign, and what "framework-independent" actually costs in mapping code. Use when a framework or major version upgrade is being planned or has stalled, when a domain class carries persistence or serialisation annotations, when someone proposes a framework-free domain and the price is not stated, when a base class from the framework appears in business code, or when a framework's programming model is spreading beyond the adapters. Does not cover which patterns a framework already implements (patterns-and-modern-frameworks), layer dependency direction (layering-and-boundaries), the data-access pattern behind the one-model/two-model choice (data-source-patterns), the mapping itself (orm-structural-mapping), releasable component boundaries (component-and-release-boundaries), or testing strategy (architecture-testing).
    3 repo stars
  98. ▌
    Grpc Http2 Service Mesh Performance · robsonkades bundle
    Diagnosing and designing the performance of gRPC and HTTP/2 communication paths, including channel, connection and stream topology, flow control, serialization, Netty event loops, TLS connection churn and service-mesh proxy cost. Use when multiplexed traffic is skewed or stalls, a channel pool or HTTP/2 setting is proposed, mesh overhead consumes a material latency or CPU budget, or retries exist in both client and proxy. API semantics belong to rpc-and-api-contracts; TCP behavior to tcp-tuning; routing ownership to load-balancing-and-routing.
    3 repo stars
  99. ▌
    Task Queues And Competing Consumers · robsonkades bundle
    Distributing work to a pool of interchangeable workers through a queue: the lease and visibility-timeout model, and why an expired lease duplicates work instead of failing it; sizing the timeout from processing plus prefetch wait; heartbeats and their failure mode; admission and retention bounds; priority starvation; and age, backlog, arrival and drain rate as autoscaling signals. Use when two workers process one message although nothing retried or failed, when a lease is relied on for mutual exclusion, when a handler outlives its lease, when a queue has no maximum depth, when autoscaling is driven by queue depth, or when a poll loop feeds an unbounded executor. Not ack placement (delivery-semantics), repeat-safe handlers (idempotency), the message that never succeeds (poison-messages-and-dlq), queue arithmetic (littles-law-and-queueing), the concurrency limit (concurrency-limiting-and-bulkheads), shedding (rate-limiting-and-load-shedding), or the Kafka consumer group, a log (kafka-consumers-in-java).
    3 repo stars
  100. ▌
    Distributed Aggregation And Barriers · robsonkades bundle
    Correct and recoverable aggregation across workers: algebraic laws, duplicate attempts, numeric reproducibility, mergeable summaries, barriers, joins, skew, checkpointing and partial results. Use when totals drift between runs, stragglers set job latency, worker percentiles are averaged, cardinality exhausts memory, or a join stalls on one task. It excludes request fan-out, streaming windows, percentile theory, message ordering and the broader hot-key repair catalogue.
    3 repo stars