all publishers

robsonkades

@robsonkades source repo

305 published skills · page 1 of 4

  1. ▌
    Spring Transactions And Events · robsonkades bundle
    Implement use-case transaction boundaries and diagnose Spring interception and transaction-bound listeners when rollback differs from intent, after-commit work disappears, or persisted event publications need recovery. Verify proxy entry, rollback rules, listener phases and repeat-safe republication. Excludes general isolation design, ORM tuning and broker delivery topology.
    3 repo stars
  2. ▌
    Online Database Schema Migrations · robsonkades bundle
    Planning and reviewing same-engine relational schema rollouts while old and new application versions coexist. Use for a hot-table column or constraint change, resumable backfill, migration-runner or Spring Boot startup failure, cutover, or contraction with a defined rollback boundary. Covers DDL execution risk and data correctness; not cross-engine migration, ingestion throughput tuning, or API/event schemas.
    3 repo stars
  3. ▌
    Spring Boot Hexagonal Architecture · robsonkades bundle
    Implement or repair an agreed ports-and-adapters boundary in Java 25 and Spring Boot 4 applications. Use when one use case must serve multiple entry points, business rules leak into adapters, or external integration needs an application-owned contract. Owns port semantics, adapter substitution, Spring composition and boundary verification; excludes architecture-style selection, detailed MVC and ORM mechanics.
    3 repo stars
  4. ▌
    Java Ddd Value Objects · robsonkades bundle
    Implement and review domain value objects and typed identifiers using the ddd-example domain conventions. Use for ValueObject, Identifier, CategoryID, CastMemberID, GenreID, VideoID, media factories, equality and hashing, resource aliasing, and value-object unit tests. Preserve the reference's per-type construction and normalization rules. Aggregate lifecycle, Gateway implementations, application orchestration and infrastructure are outside this skill.
    3 repo stars
  5. ▌
    Service Data Ownership · robsonkades bundle
    Define and verify data authority and access contracts when services, jobs or integrations share writers, read private tables, or bypass supported interfaces. Inventory readers and writers, choose supported access paths, enforce credentials and grants, and expire temporary exceptions. Use after identifying a service boundary; does not decide service extraction, implement sagas, tune ORM queries, or execute data-ownership transfer migrations.
    3 repo stars
  6. ▌
    Java Ddd Domain Services · robsonkades bundle
    Implement Java DDD behavior placement, named factories and validation following the ddd-example domain reference. Use when deciding where a domain rule belongs, implementing Validator and ValidationHandler, collecting Notification errors, or preserving validation timing during creation, restoration and update. Covers aggregate and value-object behavior without inventing domain services, policies or specifications; excludes application orchestration and infrastructure.
    3 repo stars
  7. ▌
    Spring Security For Apis · robsonkades bundle
    Configure and review Spring Security Servlet APIs when adding protected operations, changing credential delivery, fixing uncovered routes, validating JWT or opaque tokens, mapping authorities, or diagnosing bypassed method checks and CSRF, CORS or 401/403 failures. Covers access-boundary discovery, resource-server wiring and adversarial security tests; object ownership, tenant policy and transactional authorization belong to java-application-security-basics and service-layer-design. Excludes WebFlux and implementing an identity provider.
    3 repo stars
  8. ▌
    Spring Boot Observability · robsonkades bundle
    Wire Spring Boot metrics, observations, traces and Actuator for a maintained service, or diagnose when a managed HTTP client loses trace context, asynchronous work detaches from its parent, instrumentation duplicates data, metric labels grow, or management endpoints and health groups expose the wrong behavior. Owns Boot integration; metric schema, trace topology, telemetry cost and SLO policy belong to specialists.
    3 repo stars
  9. ▌
    Cross Service Query Design · robsonkades bundle
    Choose API composition or a read model when a query joins data owned by multiple services, a list needs cross-service filtering or ordering, or projection lag changes what a consumer may conclude. Define freshness, completeness, authorization, query bounds and rebuild. Excludes fan-out mechanics, event-store adoption and CDC operations.
    3 repo stars
  10. ▌
    Microservices Architecture · robsonkades bundle
    Coordinate interdependent architecture decisions when a microservices initiative spans domain, data, interaction and operation, or specialist proposals conflict. Build an evidence-backed decision map with owners, unresolved constraints and a first verifiable slice. Does not replace initial system triage, the decision to distribute a boundary, or a specialist's local implementation guidance.
    3 repo stars
  11. ▌
    Service Identity And Trust · robsonkades bundle
    Design trust between services when workloads authenticate, propagate user or tenant identity, delegate authority, or change credential issuance, rotation or revocation. Map trust boundaries, allowed operations and outage behavior; use when an internal network, gateway header or valid token is being treated as sufficient permission. Covers architecture and verification contracts, not Spring filter-chain implementation or identity-provider construction.
    3 repo stars
  12. ▌
    Java Build And Dependencies · robsonkades bundle
    Diagnose and repair Maven or Gradle builds when a managed dependency is missing, a transitive version wins unexpectedly, compilation and runtime classpaths differ, or the launcher JDK, toolchain and release target disagree. Use for dependency conflicts, missing runtime artifacts or generated code, plugin classpath failures and unreliable dependency resolution. Covers focused build repairs and reproducibility checks; intentional JDK upgrades, classloader internals and published-library governance belong to neighboring skills.
    3 repo stars
  13. ▌
    Progressive Service Delivery · robsonkades bundle
    Plan and verify gradual service releases when cohorts, mixed versions and persisted effects affect promotion or recovery. Choose valid cohort signals and explicit promote, pause or abort criteria.
    3 repo stars
  14. ▌
    Change Data Capture Operations · robsonkades bundle
    Operating Debezium source CDC through snapshots, lag, restarts, log retention and failover. Use when PostgreSQL WAL or MySQL binlogs accumulate, a connector cannot resume, a snapshot is interrupted, schema history is missing, or captured tables need controlled resynchronization. Covers source continuity and sink replay consequences; consumer offset resets, transactional outbox design, stream runtime tuning and cross-engine migration belong to neighboring skills.
    3 repo stars
  15. ▌
    Spring Boot Clean Architecture · robsonkades bundle
    Implement or repair Clean Architecture boundaries in Java/Spring Boot when domain policies, use-case orchestration and framework mechanisms are mixed. Allocate rules, distinguish source dependencies from execution flow, choose simple results or output presenters, and preserve transaction and authorization behavior during incremental migration. Excludes architecture-style selection and detailed HTTP, ORM or distributed-system design.
    3 repo stars
  16. ▌
    API Gateway And Bff · robsonkades bundle
    Design or review an API gateway or backend for frontend when client journeys need different representations, too many round trips, an entry policy, or explicit degradation. Decide whether a BFF is warranted; define edge responsibility, bounded composition, identity propagation and failure contracts while keeping domain invariants in their owning services. Excludes replica selection and framework security implementation.
    3 repo stars
  17. ▌
    Java Ddd Aggregates · robsonkades bundle
    Implement and review Java domain aggregates using the ddd-example domain contract. Use when organizing aggregate packages, implementing typed roots, new/with factories, validation timing, lifecycle methods, cross-aggregate IDs or collection ownership. Covers Category, Genre, CastMember and Video patterns with domain unit checks; application orchestration, persistence adapters and concurrency protocols are outside scope.
    3 repo stars
  18. ▌
    Spring Boot Testing · robsonkades bundle
    Configure Spring Boot test harnesses for new service acceptance, or diagnose slices that omit real wiring, rollback that hides behavior, live-server state leaks and cached contexts that outlive test services. Use for executable boundary and lifecycle checks, not general test strategy or application security policy.
    3 repo stars
  19. ▌
    Spring HTTP Clients · robsonkades bundle
    Implement outbound Spring integrations or diagnose RestClient, WebClient and HttpExchange proxies that lose Boot configuration, stall, buffer oversized responses or retry uncertain mutations. Covers transport wiring and response ownership; hands off general retry, deadline and idempotency policy. Excludes server endpoints and automatic framework migration.
    3 repo stars
  20. ▌
    Java Ddd Repositories · robsonkades bundle
    Implement or review domain Gateway interfaces using the ddd-example domain reference. Use when defining aggregate lookups and writes, typed-ID existence queries, pagination, video previews or media resource ports. Preserves the exact domain contracts and package placement; excludes application orchestration, persistence adapters, ORM mappings and transaction implementation.
    3 repo stars
  21. ▌
    Bounded Context Design · robsonkades bundle
    Design or review bounded contexts when the same business term has conflicting meanings, rules change under different owners, or a shared domain model couples unrelated workflows. Establish language, invariants, context relationships and translation contracts. Use before splitting or merging domain models; keep process extraction with distribution-boundaries and internal rule organization with domain-logic-organization. A bounded context does not automatically become a service.
    3 repo stars
  22. ▌
    Java Ddd Domain Events · robsonkades bundle
    Implement and review Java DDD domain events using the ddd-example domain pattern. Use when adding an aggregate event, preserving pending events during copying, checking media event triggers, or testing publication failure and queue cleanup. Covers DomainEvent, DomainEventPublisher, Entity and VideoMediaCreated with simple domain tests without mocks. Excludes application, infrastructure and delivery design.
    3 repo stars
  23. ▌
    Spring Boot Jpa · robsonkades bundle
    Implement, diagnose and review Spring Boot 4 persistence with Spring Data JPA when creating a durable service or verifying entity state, mappings, identifiers, fetching, transactions, locking or datasource configuration. Covers SQL Server and PostgreSQL distinctions. Excludes reactive persistence and deep database execution-plan tuning.
    3 repo stars
  24. ▌
    Spring Boot Web · robsonkades bundle
    Implement, document and diagnose Spring Boot 4 MVC and Servlet APIs when HTTP binding, validation, error responses, Tomcat capacity or consumer contracts need verification. Covers documentation strategy and complete springdoc OpenAPI contracts using the Customer reference's API interfaces, DTO schemas, examples, customizers and error handlers. Excludes WebFlux, identity providers and database query design.
    3 repo stars
  25. ▌
    Java Ddd Testing · robsonkades bundle
    Write and review Java DDD domain unit tests following the ddd-example domain reference: real aggregates and values, validation handlers, typed IDs, exceptions, utilities and local domain events. Use when adding a domain behavior test, checking validation timing or reviewing assertions that may miss a domain defect. Requires no mocks and @DisplayName on every unit test. Does not implement application, persistence, Spring or message-delivery tests.
    3 repo stars
  26. ▌
    Service Discovery · robsonkades bundle
    Design and diagnose endpoint discovery when membership changes, clients cache stale information or bootstrap depends on an unavailable source. Define authority, update, expiry and failure contracts separately from load balancing.
    3 repo stars
  27. ▌
    Java Date And Time · robsonkades bundle
    Model and validate Java date and time values when choosing between civil dates, local date-times and instants, resolving DST gaps or overlaps, applying calendar arithmetic, testing time-dependent rules, or preserving temporal meaning across parsing, JSON and JDBC. Covers java.time types, region versus offset, Duration versus Period, Clock injection and precision contracts. Does not cover calendar job scheduling or operational timeout budgets (timeouts-and-deadlines).
    3 repo stars
  28. ▌
    Java Ddd Use Cases · robsonkades bundle
    Implement or review Java application actions using the catalog reference's category, cast-member, genre, video and media use cases. Use for command/output records, Default implementations, validation and exception differences, gateway sequencing, media cleanup and Mockito unit tests. Preserves the reference's behavior; excludes domain implementation, infrastructure, authorization and transaction protocols absent from that source.
    3 repo stars
  29. ▌
    Java Ddd · robsonkades bundle
    Implement or review a Java DDD domain layer using the ddd-example domain module as the sole technical reference. Use when a capability spans aggregate organization, Entity, AggregateRoot, ValueObject, Identifier, validation, exceptions, utilities, Gateways, events and domain tests. Resolve missing business rules before coding; application orchestration, persistence adapters and HTTP contracts have separate owners.
    3 repo stars
  30. ▌
    Spring Boot · robsonkades bundle
    Create and integrate Spring Boot 4 services, or configure and diagnose bean composition, auto-configuration, external properties and lifecycle. Use for a new service's delivery contract as well as focused wiring changes. Coordinates HTTP, persistence, security and operational specialists; excludes Boot 3 migration and detailed endpoint or ORM query design.
    3 repo stars
  31. ▌
    Tdd · robsonkades bundle
    Test-driven development as a judgement call rather than a doctrine: the red-green-refactor loop and what each step is actually for, the discipline of watching a test fail for the stated reason, step size, and an explicit account of where TDD pays and where test-after or characterisation is the better choice. Use when deciding whether to drive a change with tests, when starting a bug fix, when a design is hard to test and the cause is not obvious, when tests are being written after the fact to satisfy a rule, when the refactor step keeps getting skipped, or when someone claims TDD is mandatory or useless. Does not cover which level to test at (java-testing-strategy), how a test is written (java-test-design), doubles (java-test-doubles), refactoring mechanics and safety (java-refactoring), or breaking a dependency to get untestable code into a harness (java-legacy-code-testing).
    3 repo stars
  32. ▌
    Debugging · robsonkades bundle
    Finding the cause of a fault instead of a change that makes the symptom go away: reproducing before diagnosing, shrinking the reproduction until nothing is removable, stating a hypothesis that predicts an observation, changing one variable at a time, bisecting, and choosing which evidence to collect from a running production system before it is destroyed. Use when a fix is being guessed at, when a change "seems to work", when the same bug keeps coming back, when a fault cannot be reproduced, when a production incident needs a cause rather than a restart, when print statements are being added everywhere, or when several changes were made at once and it now works. Does not cover JVM performance triage (java-performance), GC (jvm-gc-tuning), live thread diagnosis (concurrency-diagnostics), heap dump mechanics (heap-dump-analysis), or deliberately injecting failures (distributed-systems-testing).
    3 repo stars
  33. ▌
    Gof Proxy · robsonkades bundle
    Proxy in modern Java: a stand-in that controls access to another object behind that object's own interface — virtual (lazy), remote, protection and caching variants. Covers the central danger of making a network call look like a method call, how a proxy differs from a decorator, the self-invocation hole that silently disables @Transactional and @Cacheable, JPA lazy proxies and LazyInitializationException, what CGLIB cannot proxy, and safe publication in a virtual proxy. Use when a lazy-loading wrapper is proposed, when a remote call hides behind a plain interface, when an annotation on a self-called method does nothing, when instanceof fails on an injected bean or a JPA entity, or when authorisation is enforced by a wrapper the caller can bypass. Does not cover adding stackable behaviour (gof-decorator), changing an interface (gof-adapter), sharing instances to save memory (gof-flyweight), lazy loading strategy in JPA (orm-behavioral-patterns), or client-side resilience policy (circuit-breakers).
    3 repo stars
  34. ▌
    Gof State · robsonkades bundle
    State in modern Java: making an object's behaviour depend on an explicit state, with the transitions themselves modelled rather than implied by scattered flags. Covers the intent difference from Strategy, where transitions should live — in the state classes, in a table, or in one exhaustive switch — sealed records against enums, rejecting illegal transitions by default, persisting a state through stable codes rather than ordinals, atomic transitions under concurrency, and timeouts as transitions in a durable workflow. Use when boolean flags multiply on an entity, when a status field is checked in scattered ifs, when an illegal transition reaches production, when a workflow must survive a restart, or when two requests transition the same entity concurrently. Does not cover interchangeable algorithms chosen by a caller (gof-strategy), saga orchestration across services (distributed-transactions-and-sagas, gof-mediator), or optimistic locking mechanics (offline-concurrency-control).
    3 repo stars
  35. ▌
    Gof Bridge · robsonkades bundle
    Bridge in modern Java: separating an abstraction hierarchy from an implementation hierarchy so the two vary independently instead of multiplying into N×M classes. Covers the two-axis test that distinguishes it from Strategy, what to do when the matrix has illegal combinations, why the implementor interface must be designed for its slowest and least reliable implementation, and the thread-safety contract that belongs to the interface rather than to each implementation. Use when class names start combining two adjectives, when adding either a variant or a backend requires editing the other side, when a transport or storage backend must be swappable, when one backend is remote and the others are local, or when someone proposes Bridge for a single axis of variation. Does not cover retrofitting an incompatible existing type (gof-adapter), one varying algorithm (gof-strategy), families of matched products (gof-abstract-factory), or choosing a hierarchy shape in general (java-composition-over-inheritance).
    3 repo stars
  36. ▌
    Gof Facade · robsonkades bundle
    Facade in modern Java: one coherent entry point over a subsystem of collaborators, so callers depend on an intention rather than on a sequence. Covers the difference between a facade (simplifies, does not forbid) and a boundary (forbids), the god-facade drift where one class accumulates unrelated use cases, how application services and gateways can play this role while retaining their own boundary responsibilities, and the transaction and fan-out decisions a facade method silently owns. Use when callers repeat the same orchestration sequence, when a legacy subsystem needs fencing, when unrelated responsibilities accumulate in a service, or when a facade method fans out to remote services. Does not cover changing one type's interface (gof-adapter), adding behaviour to one object (gof-decorator), hub-based coordination between peers (gof-mediator), the coarse-grained remote boundary and its DTOs (remote-facade-and-dto), or transaction-boundary mechanics (enterprise-transactions).
    3 repo stars
  37. ▌
    Java Enums · robsonkades bundle
    Enums as types rather than labelled integers: instance fields instead of ordinal, constant-specific behaviour and strategy enums, extensibility through interfaces, EnumSet and EnumMap instead of bit fields and ordinal-indexed arrays, exhaustive switch and what separate compilation does to it, and what happens when an enum value crosses a database, a JSON payload or a topic. Use when int or String constants stand in for a closed set, when ordinal() appears anywhere outside a library, when @Enumerated is declared ORDINAL or left at its default, when a switch over an enum has a default branch that hides new constants, when adding a constant breaks a consumer during a rolling deploy, when values() is called in a loop, or when a set of flags is packed into an int. Does not cover annotations (java-annotations), sealed hierarchies and records as the open-data alternative (java-composition-over-inheritance), or equality and ordering contracts in general (java-object-contracts).
    3 repo stars
  38. ▌
    Java Solid · robsonkades bundle
    The five SOLID principles as decision tools for evidence-based Java review, with depth on single responsibility, open-closed, Liskov substitution and interface segregation. Use when reviewing a design or pull request against SOLID, when a principle is being cited to justify a change, when deciding whether a class has too many responsibilities, or when an override breaks substitutability. Dependency inversion depth lives in java-dependency-inversion, contract formalism for LSP in java-design-by-contract, and cohesion/coupling vocabulary in java-cohesion-coupling.
    3 repo stars
  39. ▌
    Safepoints · robsonkades bundle
    The HotSpot safepoint mechanism on JDK 25: thread-local polling words and where the JIT emits polls, loop strip mining, global safepoints versus thread-local handshakes, the VM operations other than GC that stop the world, time-to-safepoint versus operation time, and reading `-Xlog:safepoint`. Use when measured p99 or p99.9 is far worse than the GC log explains, when GC logs look clean but latency does not match, when a stop-the-world pause has no GC event behind it, when JNI critical regions or runtime/native transitions are suspected, when a profiler's hot path never responds to optimisation, or when someone proposes `-XX:+UseCountedLoopSafepoints`, `UseThreadLocalHandshakes` or blames `RevokeBias` on a modern JDK. Does not cover the introductory TTSP treatment or collector mechanics (gc-fundamentals), attributing an observed production pause across GC phase, safepoint and OS (pause-attribution), or host-side causes such as CPU throttling and page faults (linux-for-jvm).
    3 repo stars
  40. ▌
    Tcp Tuning · robsonkades bundle
    The network stack under a JVM service: listen backlog and accept queues, Nagle and delayed ACK, socket buffer sizing against bandwidth-delay product, congestion control choice, keepalive and timeout alignment along the path, and diagnosing retransmissions and queue drops. Use when a small request/response protocol shows a stable ~40 ms latency floor, when a client throws BindException or EADDRNOTAVAIL under burst, when SYNs are dropped at peak, when one core saturates while the others idle on a multi-core server, when throughput plateaus far below a high bandwidth-delay link, when somaxconn was raised and nothing changed, when TIME_WAIT sockets accumulate, or when someone proposes switching to BBR or DCTCP. Does not cover host memory, CPU and signals (linux-for-jvm), the data-movement path itself (io-uring-and-zero-copy), or application-level connection reuse (connection-pool-sizing).
    3 repo stars
  41. ▌
    Code Review · robsonkades bundle
    Reviewing a change as an engineering activity: setting review depth from the change's risk rather than its size, looking in the order that finds the expensive defects first, refusing to spend human attention on what a formatter or linter should own, writing a finding that can be acted on, separating blocking objections from preferences, and receiving review without either capitulating or defending. Use when reviewing a pull request or a diff, when a review has become a list of style comments, when reviews are slow or rubber-stamped, when a reviewer and an author are deadlocked, when a defect reached production through an approved change, or when deciding what a review must catch versus what CI should. Does not cover the smell catalogue (java-code-smells), SOLID as review criteria (java-solid), readability heuristics (java-clean-code), or which automated gates to run (quality-gates).
    3 repo stars
  42. ▌
    Gof Adapter · robsonkades bundle
    Adapter in modern Java: making an existing type usable through an interface it was not written for, and keeping a foreign model, vocabulary and failure mode from leaking inward. Covers object versus class adapters, why a lambda already adapts a single-method interface, the error-translation duty most adapters omit, when an adapter has quietly become a translator with business rules in it, and when a passthrough should be deleted. Use when integrating a vendor SDK or legacy type behind your own port, when two libraries must interoperate, when an adapter is proposed between types you own, when foreign exceptions or DTOs appear in domain code, or when reviewing a wrapper that renames methods and does nothing else. Does not cover the Kubernetes telemetry sidecar (adapter-sidecar-pattern), simplifying a subsystem you own (gof-facade), adding behaviour to the same interface (gof-decorator), controlling access to an object (gof-proxy), or layering rules in general (layering-and-boundaries).
    3 repo stars
  43. ▌
    Gof Builder · robsonkades bundle
    Builder in modern Java: distinguish the original GoF separation of construction process from representation from the Effective Java fluent value builder. Covers selection signals rather than parameter-count thresholds, staged builders, invariant placement, mutable-builder concurrency hazards, Lombok/JPA boundaries, performance evidence, and test data builders. Use for ambiguous or telescoping construction, incremental input, multiple representations, or a builder that permits invalid combinations. Does not cover product-type selection (gof-factory-method, gof-abstract-factory), copying (gof-prototype), fluent APIs generally (java-fluent-apis), or value semantics (java-immutability).
    3 repo stars
  44. ▌
    Gof Command · robsonkades bundle
    Command in modern Java: turning an invocation into an object so it can be queued, logged, scheduled, retried or undone — and the distinction from an event, which is a fact rather than a request. Covers when reifying a call earns its cost and when a method reference is enough, undo through inverses versus mementos versus compensation, what changes when a command is persisted or sent to a broker (versioning, at-least-once delivery, idempotency), and the captured-state hazard when a command executes later than it was created. Use when an operation must be deferred, queued, audited or undone, when a command bus is proposed, when a class is created per method with no queue or undo behind it, or when commands and events are being used interchangeably. Does not cover domain and integration events and the outbox (event-driven-architecture), broker delivery semantics (delivery-semantics), executor and task lifecycle (executors-and-task-lifecycle), or algorithm selection (gof-strategy).
    3 repo stars
  45. ▌
    Gof Memento · robsonkades bundle
    Memento in modern Java: capturing an object's state so it can be restored later, without exposing that state to whoever holds the capture. Covers the encapsulation techniques Java offers, why an immutable object is its own memento, the memory cost of an undo stack and the alternatives (inverses, diffs, structural sharing), the torn capture when the source mutates mid-copy, and the distinction from a durable snapshot and from event sourcing. Use when undo, drafts, what-if branches or checkpoints are being designed, when a getState/setState pair is proposed on a domain object, when an undo stack grows without bound, or when someone calls a persisted snapshot a memento. Does not cover the operations being undone (gof-command), copying an object for reuse (gof-prototype), event-sourced aggregates and projections (event-sourcing), or distributed checkpoint barriers (distributed-aggregation-and-barriers).
    3 repo stars
  46. ▌
    Gof Visitor · robsonkades bundle
    Visitor in modern Java: adding operations over a stable set of element types without editing them, and how a sealed hierarchy with an exhaustive switch competes with the classical double-dispatch version. Covers the expression problem—new operations cheap versus new element types cheap — the cases where classical Visitor still wins (types you do not compile, libraries whose API is accept()), stateful visitors that are unsafe to share, recursion depth on deep structures, and unknown element types from a newer producer. Use when several operations must run over one object structure, when instanceof chains grow over a closed hierarchy, when adding an operation means editing every element class, or when an accept/visit pair is proposed. Does not cover the structure being traversed (gof-composite), traversal protocols (gof-iterator), sealed hierarchy design (java-composition-over-inheritance), or value semantics (java-immutability).
    3 repo stars
  47. ▌
    Graalvm Jit · robsonkades bundle
    Graal as a JIT compiler compared with C2: partial escape analysis, graph-size inlining and speculation, where Graal wins and where it loses, JVMCI and what JEP 410 removed, libgraal versus jargraal, and how to evaluate the swap with a fair measurement. Use when someone proposes switching to GraalVM for throughput, when a Graal-versus-C2 benchmark shows Graal "slower" with no warm-up control, when `-XX:+UseJVMCICompiler` or `-XX:+UseGraalJIT` is set on a stock OpenJDK, when a `-Dgraal.*` flag is copied from old material, when an Oracle JDK 24 deployment relied on its bundled Graal JIT, when a Truffle language warns about a fallback runtime, when a percentage gain is quoted with no source or workload, when GraalVM JIT is being confused with native image, or when picking a distribution and its licence. Does not cover how C2 itself works (c2-sea-of-nodes), ahead-of-time compilation as a separate product decision (graalvm-native-image), or running the comparison benchmark correctly (jmh-advanced).
    3 repo stars
  48. ▌
    Idempotency · robsonkades bundle
    Making an operation safe to apply more than once: natural idempotency versus an idempotency key plus durable operation state; choosing and scoping the key, and why a broker message id covers only one redelivery scope; handling concurrent in-flight duplicates; replaying the stored response instead of returning a conflict; and why idempotent is not commutative. Use when a retry produces a second row, charge or email, when a handler starts with an exists() check before a write, when an Idempotency-Key header is being added or ignored, when two identical requests arrive concurrently, or when a dedup table has no TTL. Does not cover why duplicates arrive (delivery-semantics), compensating actions (distributed-transactions-and-sagas), what the dedup store's own consistency must be (consistency-models), or caching (caching-strategies).
    3 repo stars
  49. ▌
    Jni And Ffm · robsonkades bundle
    Crossing into native code: JNI call overhead, critical sections and what they block, the FFM downcall and upcall path, `Linker` and method handles, why a native frame pins a virtual thread, and measuring the boundary cost. Use when a native call sits inside a tight loop, when someone proposes migrating JNI to Panama to fix pinning, when `Linker.Option.critical()` is applied without a measured duration, when `jdk.VirtualThreadPinned` events point at a `native` method or `MethodHandle.invokeExact`, when `WARNING: A restricted method ... has been called` appears after a JDK upgrade, when a runbook still references `-Djdk.tracePinnedThreads` or `--enable-preview` for FFM, when `jextract` is assumed to ship with the JDK, when a downcall fails with `WrongThreadException` on a confined arena, or when `GCLocker Initiated GC` appears as a cause in the GC log. Does not cover holding native memory (off-heap-memory), pinning as scheduling (virtual-threads-internals), or the native memory budget (jvm-memory-regions).
    3 repo stars
  50. ▌
    Ebpf For Jvm · robsonkades bundle
    Using eBPF/bpftrace to measure kernel-visible behavior around a JVM without inventing attribution: selecting stable tracepoints versus kprobes/uprobes/USDT, scoping by process/thread/cgroup, tracking syscall/futex/scheduler/block-I/O lifecycles, managing BPF map loss and cardinality, resolving native and time-varying JIT code, and correlating—not summing—kernel, JFR, profile, and application evidence. Use when scheduler delay, kernel I/O, faults, networking, or cross-process interference may explain JVM symptoms, or when a BPF script is empty/plausible-but-wrong. Does not own ordinary host diagnosis (linux-for-jvm), JVM-local profiling (jfr-and-async-profiler), or continuous profile operations (continuous-profiling).
    3 repo stars
  51. ▌
    G1 Internals · robsonkades bundle
    How G1 actually works: uniform regions and the ergonomic sizing formula, remembered sets and the card table with its write barrier, SATB and the pre-write barrier, the phases of an evacuation pause, humongous allocation and why it bypasses the young generation, and how the collection set is chosen for a mixed collection. Use when a pause is longer than the live-set size explains, when `Merge Heap Roots` or `Merge RS` dominates `-Xlog:gc+phases`, when legacy `To-space exhausted` or current `Evacuation Failure` appears, when the old generation grows without the application retaining anything, when `Humongous regions` climbs in the log, when someone sets `-Xmn` under G1, or when mixed GC is being described as a full GC. Does not cover the introductory collector mental model and generational hypothesis (gc-fundamentals), choosing values for the flags against a latency SLO (g1-tuning-for-slo), or the concurrent marking cycle in depth (g1-concurrent-marking).
    3 repo stars
  52. ▌
    Gof Iterator · robsonkades bundle
    Iterator in modern Java: traversing an aggregate without exposing it, and choosing between Iterator, Stream and Spliterator — external pull versus internal lazy pipeline versus the parallel decomposition primitive. Covers when a Spliterator can adapt to both, what fail-fast really promises and how weakly consistent iterators differ, streams that hold a resource and must be closed, remote pagination as iteration with page drift, and the characteristics that decide whether a stream can be sized or split. Use when exposing a collection from a type, when a custom traversal is being written, when ConcurrentModificationException appears, when a stream over a file or a result set leaks, when paging through a remote API, or when a parallel stream is not faster. Does not cover stream pipeline design and collectors in general, the tree being traversed (gof-composite), adding operations over it (gof-visitor), or database paging strategy.
    3 repo stars
  53. ▌
    Gof Mediator · robsonkades bundle
    Mediator in modern Java, treated as high-risk: replacing many-to-many collaboration with a hub that owns the interaction protocol, and the god object that hub becomes when nothing bounds it. Covers the direction test that separates it from a facade, why an event bus is the decoupled alternative and what it gives up, the reentrancy loop when a colleague notifies the hub that notifies it back, the hub as a serialisation point, and orchestration versus choreography with the availability coupling an orchestrator introduces. Use when collaborators reference each other in a web, when a coordinator class keeps growing, when a command bus is called a mediator, when a saga orchestrator is designed, or when a notification loops between two components. Does not cover one-way notification to unknown subscribers (gof-observer, event-driven-architecture), a simplifying entry point (gof-facade), request dispatch to one handler (gof-command), or saga mechanics (distributed-transactions-and-sagas).
    3 repo stars
  54. ▌
    Gof Observer · robsonkades bundle
    Observer in Java: choosing and reviewing in-process listener contracts for ordering, errors, threads, registration lifetime, reentrancy and notification outside locks. Use when adding listeners, investigating retained listeners or missed callbacks, or assessing a move from local notifications to a broker. Covers migration contract changes; detailed transaction/outbox design belongs to event-driven-architecture, broker guarantees to delivery-semantics, demand protocols to reactive-backpressure, and hub coordination to gof-mediator.
    3 repo stars
  55. ▌
    Gof Strategy · robsonkades bundle
    Strategy in modern Java, separated into three things that are usually conflated: the design concept (an algorithm varies), the classical class hierarchy, and the lambda or functional interface that expresses it today. Covers when a function value is enough and when a named type earns its keep, selecting a strategy by key instead of an if-else chain, the trap of strategies that differ only in constants and may be configuration, how shared state changes concurrency obligations, and the contract test implementations can share. Use when an algorithm must vary at runtime, when a switch over a type code keeps growing, when a class hierarchy exists whose members are one-line methods, or when strategy classes differ only in a rate or a threshold. Does not cover behaviour that changes with the object's own state (gof-state), two independently varying hierarchies (gof-bridge), an algorithm skeleton with varying steps (gof-template-method), or choosing which object to create (gof-factory-method).
    3 repo stars
  56. ▌
    Java Streams · robsonkades bundle
    Stream pipelines as a design decision: when a stream is clearer than a loop and when it is not, side-effect-free stages and mutable reduction with collectors, the toMap and groupingBy traps, Collection versus Stream as a return type, streams that hold an open resource, parallel streams and the shared common pool, and Gatherers for custom intermediate operations. Use when a pipeline mutates state outside itself or uses forEach to accumulate, when Collectors.toMap throws IllegalStateException or NullPointerException, when a method returns a Stream that callers iterate twice, when a stream over Files.lines or a JDBC cursor is never closed, when parallelStream() appears — especially with blocking I/O — or when a loop is being rewritten as a stream for its own sake. Does not cover lambda capture and functional interfaces (java-lambdas-and-functional-interfaces), ForkJoinPool internals (forkjoinpool-and-work-stealing), or collection choice and complexity.
    3 repo stars
  57. ▌
    Jfr Advanced · robsonkades bundle
    Engineering JDK Flight Recorder evidence beyond stock settings: discovering event schemas and settings on the target build, designing threshold/period/throttle/stack trade-offs, composing and validating JFC configurations, accounting for concurrent recordings, defining low-cost custom events and relational metadata, operating Recording/RecordingStream/MXBean consumers, and validating loss, parsing, retention, privacy, and Java 25 JFR features. Use when an event is absent, a field/parser is guessed, fine events are thresholded away, custom instrumentation or live export is proposed, or recording overhead/coverage is uncertain. Does not own first-tool selection, async-profiler, or fleet continuous-profiling operations.
    3 repo stars
  58. ▌
    Jmh Advanced · robsonkades bundle
    Designing advanced JMH experiments: shared and asymmetric state topologies, groups, parameter matrices, auxiliary counters, fixture arbitration, fork/JVM controls, profilers, hardware counters, annotated assembly, compiler controls, cold-state protocols, and multi-modal variance diagnosis. Uses runtime capability discovery and separates diagnostic profiled runs from decision runs. Use when a benchmark is concurrent, fork-dependent, profiler-sensitive, cold/startup-oriented, or produces unexplained clusters. Basic benchmark validity, statistical gates, assembly interpretation, and load tests have separate owners.
    3 repo stars
  59. ▌
    Jvm Bytecode · robsonkades bundle
    Reading and reasoning about JVM bytecode: javap -c -p -v, operand stack and local slots, the constant pool and resolution timing, descriptors versus Signature, the invoke* family with invokedynamic and inline caching, verification and the StackMapTable, the class-file limits, what javac desugars, and what bytecode does and does not say about performance. Use when a VerifyError appears after instrumentation by an agent, proxy or mock library, when UnsupportedClassVersionError names two class file versions, when javac reports "code too large", when a coverage or mocking agent fails with "Unsupported class file major version" after a JDK upgrade, when auditing what a lambda, record, sealed switch or synchronized block compiled to, when checking for hidden boxing in a hot method, or when a cycles-per-bytecode table is quoted. Does not cover tiered compilation or warm-up (jit-compilation), what the JIT did with the code (compilation-and-inlining-logs), or loading, linking and initialisation (jvm-class-loading).
    3 repo stars
  60. ▌
    Load Testing · robsonkades bundle
    Designing valid service load experiments: choosing open or closed workload models, defining offered, admitted and successful work, controlling generator and environment bias, representative workload and data, state-based warmup, run validity, uncertainty, and reproducible evidence. Use when designing or reviewing k6, Gatling, JMeter or similar tests, diagnosing a throughput plateau, validating a baseline, or deciding whether a run measured the target rather than the generator. Profile selection and breakpoint, burst, stress and soak procedures belong to load-testing-advanced; coordinated omission belongs to coordinated-omission; inference belongs to latency-statistics.
    3 repo stars
  61. ▌
    Gof Composite · robsonkades bundle
    Composite in modern Java: treating a leaf and a tree of leaves through one interface, and the hazards that come with a recursive structure. Covers the transparent-versus-safe trade-off and when a sealed interface with exhaustive pattern matching changes that trade-off, unbounded depth and StackOverflowError, cycles introduced by parent pointers and the infinite recursion they cause in equals, hashCode and toString, mutation during traversal, and why a tree whose children live in other services is not this pattern. Use when a part-whole hierarchy is being modelled, when a leaf class is forced to implement add() and throw, when a recursive walk overflows the stack on production data, when nested structures arrive from untrusted input, or when someone proposes Composite for a flat group of items. Does not cover adding operations over a tree (gof-visitor), traversal protocols (gof-iterator), adding behaviour to one object (gof-decorator), or aggregate boundaries in a domain model (domain-logic-organization).
    3 repo stars
  62. ▌
    Gof Decorator · robsonkades bundle
    Decorator in modern Java: wrapping an object in something of its own interface to add behaviour, stackably, at runtime — and the fact that the stacking order changes the semantics. Covers the ordering of retry, timeout, circuit breaker, cache, metrics and logging and what each arrangement means, retry amplification across layers, the identity loss that breaks ==, instanceof and listener deregistration, when a framework interceptor is the same pattern already provided, and the thread-safety a stateful decorator introduces. Use when resilience or observability layers are added around a client, when a wrapper chain is reordered, when a decorated object fails an instanceof check, when retries appear at two levels, or when a wrapper is proposed that changes the interface. Does not cover changing an interface (gof-adapter), controlling access to an object (gof-proxy), one entry point over a subsystem (gof-facade), or the retry and timeout policies themselves (circuit-breakers, retries-and-backoff).
    3 repo stars
  63. ▌
    Gof Flyweight · robsonkades bundle
    Flyweight in modern Java: sharing one immutable instance across many logical occurrences to reduce retained memory, with benefits dependent on duplicate lifetimes and lookup cost. Covers the intrinsic/extrinsic split, why cheap TLAB allocation does not make reclamation free, the memory arithmetic deciding whether a cache entry costs more than the object it saves, string deduplication and boundary canonicalisation as cheaper alternatives, the unbounded intern map as a leak, and the == trap. Use when object pooling or interning is proposed, when a heap dump shows millions of duplicate values, when someone suggests caching small objects for speed, when a shared instance is mutable, or when a flyweight cache is described as a distributed cache. Does not cover application-level caching policy (caching-strategies), finding the duplicates (heap-dump-analysis), allocation cost in general (allocation-profiling), or one-instance-with-global-access (gof-singleton).
    3 repo stars
  64. ▌
    Gof Prototype · robsonkades bundle
    Prototype in modern Java: producing a new object from an existing instance's state, when the configuration is expensive or the concrete type is unknown to the caller. Covers why Cloneable/clone() needs an explicit contract and what replaces it, the deep-versus-shallow decision on graphs with identity and cycles, when immutable values can be shared, the torn-copy hazard under concurrency, and the identity rules when copying persisted objects. Use when clone() or Cloneable appears, when an object is duplicated by serialising and deserialising it, when a configured template must be instantiated many times, when a JPA entity is copied with its id still set, or when a "copy" turns out to share a mutable list with its original. Does not cover constructing from parameters (gof-builder), selecting a type to create (gof-factory-method), sharing rather than copying (gof-flyweight), or snapshot semantics for undo (gof-memento).
    3 repo stars
  65. ▌
    Gof Singleton · robsonkades bundle
    Singleton in modern Java, treated as a high-risk pattern: it conflates "one instance" with "reachable from anywhere", which must be justified separately. Covers why dependency injection gives uniqueness as a consequence of wiring, the scale ladder showing a Java singleton is unique per class loader and never per cluster, the safe lazy-initialisation idioms and the class-initialisation deadlock they invite, the static-state leakage that makes tests order-dependent, and the distributed mechanisms that give system-wide singularity. Use when getInstance() appears, when a scheduled job must run once across replicas, when someone says "singleton" meaning Spring's singleton scope, when tests pass alone and fail together, or when a cache or registry is being made global. Does not cover shared immutable instances for memory (gof-flyweight), wiring in general (java-dependency-inversion), cluster-wide leadership (leader-election), or once-only scheduling across replicas (distributed-locks-and-leases).
    3 repo stars
  66. ▌
    Java Generics · robsonkades bundle
    Generics as a compile-time contract over an erased runtime: raw types and what they disable, eliminating unchecked warnings rather than suppressing them, why arrays and generics do not mix, generic types and methods, bounded wildcards for API flexibility (PECS), generic varargs and @SafeVarargs, and typesafe heterogeneous containers with class tokens. Use when a raw type, a cast to a generic type, or an unchecked warning appears; when code creates an array of a generic type or a generic varargs parameter; when a collection parameter forces callers to convert before calling; when ClassCastException surfaces far from any visible cast; when a deserialised list of strings turns out to contain something else; or when designing a container that must hold values of several types safely. Does not cover null contracts (java-null-safety), collection choice and stream pipelines (java-streams), or the wider API-shape decisions (java-api-design).
    3 repo stars
  67. ▌
    Java Optional · robsonkades bundle
    Optional as designed: a return type for "no result is a normal outcome". Covers orElse versus orElseGet (eager versus lazy), orElseThrow over get, map/flatMap/filter chains versus a plain conditional, or(), ifPresentOrElse, stream() integration, the costs of Optional in fields, parameters or collections, valid exceptions, and when Optional makes an API worse. Use when reviewing Optional.get() without a guard, orElse with a costly or side-effecting fallback, isPresent()+get() pairs, Optional-typed fields or parameters, or when deciding whether a lookup should return Optional, null or throw. Nullability contracts and annotations are java-null-safety.
    3 repo stars
  68. ▌
    Jvm Gc Tuning · robsonkades bundle
    Deciding whether GC is the actual bottleneck, then choosing a collector and sizing the heap. Use when GC pauses appear on the critical path of a latency profile, when full collections show up, when the heap grows toward its limit, when sizing a JVM for a container, or when a collector change is being proposed. Start from java-performance instead when the symptom is latency or CPU and GC has not been confirmed as the cause. Does not cover how collectors work internally (gc-fundamentals), configuring and reading the GC log (gc-log-analysis), the non-heap memory budget (jvm-memory-regions), or allocation profiling (allocation-profiling) or leak hunting (java-reference-types-and-leaks). Deriving G1 flag values from an SLO is g1-tuning-for-slo and operating the concurrent collectors is zgc-and-shenandoah.
    3 repo stars
  69. ▌
    Linux For Jvm · robsonkades bundle
    The Linux side of a JVM incident: RSS versus virtual memory, page faults and swap, AlwaysPreTouch, transparent huge pages, cgroup CPU throttling, the two OOM killers, file-descriptor and process limits, signals and graceful shutdown, and PSI as a direct stall signal. Use when a process dies with exit code 137 or no log at all, when a GC pause in the log does not match the pause the client felt, when "too many open files" or "unable to create native thread" appears, when THP or swappiness is being changed by reflex, when kill -9 is the first response, or when container CPU limits may be throttling the JVM. Does not cover the JVM-side memory budget (jvm-memory-regions), collector behaviour (gc-fundamentals), or CPU cache and NUMA topology (cpu-cache-and-numa). What the JVM detects inside a cgroup is container-awareness, kernel-side tracing is ebpf-for-jvm, and the network stack is tcp-tuning.
    3 repo stars
  70. ▌
    Quality Gates · robsonkades bundle
    Choosing which automated checks a change must pass, and making them cheap enough that they stay switched on: matching the gate set to the change's risk rather than running everything on everything, where each gate belongs (pre-commit, pull request, main, release), the Java toolchain that enforces each class of defect, ratcheting a gate onto a codebase that already violates it, and what to do when a gate goes red. Use when setting up or trimming a pipeline, when the build is slow enough that people push without running it, when a check is routinely bypassed or its failures ignored, when a defect class keeps reaching production, when a coverage or static-analysis threshold is being proposed, or when deciding whether a small change really needs the full pipeline. Does not cover writing the tests (java-testing-strategy), architecture rules (architecture-testing), performance thresholds (performance-regression-ci), or human review (code-review).
    3 repo stars
  71. ▌
    Scoped Values · robsonkades bundle
    ScopedValue as one-way, immutable, lexically bounded context: where/run/call, rebinding in a nested scope, inheritance by StructuredTaskScope subtasks and by nothing else, and the cases where ThreadLocal is still the right answer. Final in JDK 25 (JEP 506) after four preview rounds, with callWhere and runWhere removed along the way. Use when a ThreadLocal carries per-request context under virtual threads, when context is empty inside a forked subtask or a pool thread, when a ThreadLocal is never removed and leaks across pooled tasks, when code calls ScopedValue.get outside any binding and gets NoSuchElementException, when callWhere or runWhere appears in an example, or when MDC or SecurityContextHolder must keep working. Not the fan-out that inherits (structured-concurrency), ThreadLocal-as-cache sizing (thread-sizing-and-virtual-threads), deadlines (timeouts-and-deadlines), or context across CompletableFuture stages (completablefuture-composition).
    3 repo stars
  72. ▌
    Deoptimization · robsonkades bundle
    Deoptimisation and recompilation on HotSpot: uncommon traps and their reason codes, the none / maybe_recompile / reinterpret / make_not_entrant / make_not_compilable actions, jdk.Deoptimization in JFR, -XX:+TraceDeoptimization, the per-method trap limits and recompilation cutoffs, and diagnosing a method that never stabilises. Use when a method repeatedly shows "made not entrant" in the compilation log, when latency spikes correlate with class loading or a deploy, when a burst of "marked for deoptimization" follows a deploy or a plugin load, when a feature flag or APM agent is suspected of invalidating compiled code, when "made not compilable" or a flood of action "none" appears for a hot method, when someone proposes raising PerMethodRecompilationCutoff, or when -Xlog:jit+deoptimization produced an empty file. Does not cover the tiered pipeline and warm-up (jit-compilation), reading the compilation log itself (compilation-and-inlining-logs), or C2's internal representation (c2-sea-of-nodes).
    3 repo stars
  73. ▌
    Event Sourcing · robsonkades bundle
    Event streams as authoritative state: adoption criteria, stream boundaries, expected-version appends, command idempotency, snapshots, projection correctness/rebuild, temporal replay, schema evolution and erasure. Use when event sourcing is proposed, projections drift, old payloads must evolve, or write/read visibility surprises users. Integration messaging, delivery, sagas, mutable-row locking and replica consistency remain separate skills.
    3 repo stars
  74. ▌
    Failure Models · robsonkades bundle
    Stating a system's fault model before designing against it: crash-stop, crash-recovery, omission, timing and Byzantine faults; partial failure and the third outcome of every remote call (unknown); gray failure and the slow node whose health check stays green; the eight fallacies as a checklist; blast radius, correlated versus independent failure, and the availability arithmetic of a dependency chain. Use when a design says "if the service is down" without defining down, when a retry is added to a call whose outcome is unknown, when a node is slow rather than dead, when replicas share a host, an AZ or a database, or when an availability target is quoted for a service built on ten others. Does not cover what the model implies about messages (delivery-semantics) or reads (consistency-models), how a failure spreads (cascading-failures), the named shapes (distributed-failure-catalogue), what an orchestrator does with a failed pod (kubernetes-service-lifecycle), or failures as types (java-exception-design).
    3 repo stars
  75. ▌
    Lock Inflation · robsonkades bundle
    Diagnosing and engineering Java intrinsic-monitor contention across fast and inflated monitor states without freezing one HotSpot release's internals. Covers ownership, recursion, wait sets, entry queues, inflation/deflation, virtual-thread behavior, JFR/thread-dump evidence, threshold/censoring, convoys, fairness, lock graphs, critical-section redesign, partitioning and validation. Use when `synchronized` wait/hold time is suspected; JMM correctness, explicit locks, false sharing and lock-free algorithms have separate owners.
    3 repo stars
  76. ▌
    Scatter Gather · robsonkades bundle
    Fanning one request out to N workers and combining answers: order-statistic latency, choosing N against tail exposure, all-of-N/first-of-N/k-of-N completion, safe hedging, partial-result completeness and watermarks, deadline propagation, and cancelling losers. Use when a keyless query fans out to every shard, when leaf dashboards are green but user-facing p99 is not, when more leaves made the request slower, when a fan-out gives no way to tell no-data from no-answer, when a hedge is proposed, or when an in-flight gauge stays high after the caller gave up. Not StructuredTaskScope (structured-concurrency), bounding in-flight work (concurrency-limiting-and-bulkheads), tail arithmetic (tail-latency-analysis), percentiles (latency-statistics), retry policy (retries-and-backoff), offline fan-out (distributed-aggregation-and-barriers), deadlines (timeouts-and-deadlines), or shard keys (sharding-and-partitioning).
    3 repo stars
  77. ▌
    C2 Sea Of Nodes · robsonkades bundle
    How HotSpot actually executes and compiles: the runtime-generated template interpreter, C2's sea-of-nodes IR, a release-scoped diagnostic map of compilation phases, and why a given transformation fired or did not. Use when a method is believed to be "not optimised", when an allocation that looks eliminable still shows up in allocation profiling, when a hot call site reports `too large` or stays non-inlined, when `made not entrant` repeats on the same method, when someone prescribes `-XX:CompileThreshold` under tiered compilation, or when explaining why the JIT did not fix an O(n^2) loop. Does not cover the tiered pipeline, warm-up and code cache sizing (jit-compilation), reading the compiler's own decision logs end to end (compilation-and-inlining-logs), the emitted machine code (reading-jit-assembly), or the bytecode the compiler consumes (jvm-bytecode).
    3 repo stars
  78. ▌
    Gc Fundamentals · robsonkades bundle
    How JVM garbage collectors work, as the mental model behind every GC diagnosis: the generational hypothesis and where it fails, mark-sweep versus mark-compact versus copying, how survivors, allocation and roots affect collection cost, write barriers, safepoints and Time-To-SafePoint, and the JDK 25 collector landscape. Use when explaining why a collection is expensive, when the reported pause does not match the latency the client feels, when a young pause is long although little survived, when a cache or pool breaks the generational assumption, when humongous allocations appear, or when comparing collectors written before JDK 23. Does not cover choosing a collector or sizing the heap (jvm-gc-tuning), parsing the log (gc-log-analysis), or the non-heap regions (jvm-memory-regions). Per-collector internals are g1-internals and zgc-and-shenandoah, and the safepoint mechanism is safepoints.
    3 repo stars
  79. ▌
    Gc Log Analysis · robsonkades bundle
    Configuring and reading JVM unified GC logs: the -Xlog:gc* baseline with decorators and rotation, the cause field, the before->after->capacity triple and headroom, pause distribution, Eden-refill and old-region-growth estimates derived from region lines, adaptive tenuring pressure via gc+age, and correlation with -Xlog:safepoint. Use when a log needs to be interpreted, when GC logging is not enabled and the right GC tag-sets have to be chosen, when full collections or Metadata GC Threshold appear, when the heap floor rises after equivalent reclamation points, when an allocation or promotion proxy has to come from the log rather than a profiler, when a log starts above zero uptime, or when an analysis script reports zero pauses. Does not cover collector mechanics (gc-fundamentals), collector choice and heap sizing (jvm-gc-tuning), or allocation profiling (jfr-and-async-profiler). Syntax is unified-logging; cross-layer pause attribution is pause-attribution.
    3 repo stars
  80. ▌
    Gof Interpreter · robsonkades bundle
    Interpreter in modern Java: representing a small language as a typed tree and evaluating it, expressed today as a sealed AST with an exhaustive switch rather than an eval() method per node. Covers parsing as a separate problem the pattern does not solve, when an existing expression language beats writing one, how general expression engines become code-execution surfaces when exposed with unsafe capabilities, the resource bounds an interpreter over untrusted input needs, and closure compilation when tree walking is too slow. Use when a filter, rule or formula language is designed, when configuration has grown conditionals, when someone proposes embedding an expression evaluator, or when an expression from a request is passed to a template or EL engine. Does not cover adding operations over an existing tree (gof-visitor), the tree structure itself (gof-composite), query specifications over a database (query-objects-and-specifications), or JIT compilation of Java (jit-compilation).
    3 repo stars
  81. ▌
    Java API Design · robsonkades bundle
    Naming and API design for Java code that others call: names carrying domain vocabulary, method and boolean naming conventions, arity and parameter objects, overload hazards, discoverability, public versus internal surface (package-private, JPMS exports), and API evolution — binary, source and behavioural compatibility, deprecation, semantic versioning. Use when designing or reviewing a public type, when a signature has grown past three parameters, when adding a method, overload or record component to a published API, or when deciding what a module exports. Does not cover builder and fluent-chain mechanics (java-fluent-apis) or exception contracts (java-exception-design).
    3 repo stars
  82. ▌
    Java Clean Code · robsonkades bundle
    Readability and intention-revealing structure in Java: method and class sizing — including the point where splitting becomes harmful fragmentation — abstraction levels within a method, comments, hidden side effects, temporal coupling and hidden dependencies. Use when reviewing or refactoring for clarity, when a method has grown past comprehension or a class has shattered into fragments that only make sense together, or when callers must know an unwritten call order. Does not cover naming and API shape (java-api-design), the smell catalogue (java-code-smells), exception handling (java-exception-design) or null handling (java-null-safety).
    3 repo stars
  83. ▌
    Jit Compilation · robsonkades bundle
    HotSpot JIT compilation and warm-up: tiered policy, C1/C2 queues and profiling, OSR, deoptimization, code-cache pressure, compiler resources in containers, and warm-up as a workload-dependent curve rather than a clock delay. Use when p99 is bad for the first minutes after a deploy, when performance degrades permanently until a restart, when "CodeCache is full" appears, when a startup probe or traffic gate needs a warm-up criterion, when -XX:-TieredCompilation or -Xcomp is proposed, when scaling out a low-traffic service makes latency worse, when a 1-2 CPU pod warms up far slower than a workstation, or when an autoscaler keeps adding cold replicas. Does not cover inlining and escape analysis (jit-inlining-and-escape-analysis), microbenchmarks (jmh-microbenchmarks), or the code cache in the memory budget (jvm-memory-regions). Reading the compiler output is compilation-and-inlining-logs, recompilation is deoptimization, and per-segment exhaustion is code-cache-segments.
    3 repo stars
  84. ▌
    Leader Election · robsonkades bundle
    Electing one active instance for work that must not run concurrently: the lease renewal model and the rule that failed renewal never extends the leader's conservative deadline; split-brain and resource-side fencing/idempotency; failover time as detection, election and warm-up; coordination-store leases, Kubernetes Lease objects and ShedLock rows, and what each is adequate for; and when not to elect. Use when a @Scheduled job runs once per replica after scaling out, when two instances both believe they lead, when a leader keeps working after its lease expired, when failover takes a minute nobody budgeted, or when ShedLock is described as leader election. Not lease and fencing mechanics (distributed-locks-and-leases), how the election is decided (consensus-and-quorums), why a scheduled job duplicates (stateless-service-design), splitting work by key (sharding-and-partitioning), or pod termination (kubernetes-service-lifecycle).
    3 repo stars
  85. ▌
    Low Latency Jvm · robsonkades bundle
    Designing and validating JVM systems whose primary objective is bounded jitter rather than low average latency: latency-distribution budgets, allocation strategy, GC choice, warm-up and deoptimization, CPU/NUMA placement, busy-spin cost and evidence for kernel bypass. Use when p99.99-to-p50 spread matters, a trading or real-time path claims to be GC-free, CPUs are isolated, Epsilon or busy waiting is proposed, or an optimization shifts jitter between JVM, OS and network. General tail diagnosis belongs to tail-latency-analysis; individual JVM and OS mechanisms retain their specialist owners.
    3 repo stars
  86. ▌
    Off Heap Memory · robsonkades bundle
    Memory outside the Java heap: direct `ByteBuffer` and its Cleaner-driven release, `MemorySegment` and `Arena` in the FFM API, lifetime and thread confinement, when off-heap actually pays, and diagnosing native growth no heap dump explains. Use when RSS grows while the Java heap stays flat, on `OutOfMemoryError: Direct buffer memory` or an OOMKilled container with no Java exception, when `-XX:MaxDirectMemorySize` is unset or copied from another service, when `ByteBuffer.allocateDirect` sits on a per-request path, when `Unsafe.allocateMemory` appears without a matching `freeMemory`, on a `WrongThreadException` from a segment, or on a JEP 498 `sun.misc.Unsafe` runtime warning. Does not cover the six-region container budget and which OOM means what (jvm-memory-regions), calling into native code as opposed to holding native memory (jni-and-ffm), or on-heap retention (heap-dump-analysis).
    3 repo stars
  87. ▌
    Queueing Models · robsonkades bundle
    Choosing, parameterising and falsifying queueing models: M/M/1, M/M/c, M/G/1, finite/loss and closed networks; Erlang C/B, Pollaczek–Khinchine, Kingman/Allen–Cunneen, variability, queue topology and what model assumptions permit. Use when a predicted wait time disagrees with the measured one, when latency is far worse than utilisation suggests, when service times are bimodal or GC-spiked, when arrivals are retries or cron bursts rather than independent users, when Erlang C must be computed for a large number of servers, when routing or partitioning changes the queue topology, or when deciding whether a measured tail can be inferred from an analytical model. Does not cover the `L = λW` conservation law or operational pool sizing (littles-law-and-queueing), the alpha/beta scalability model (universal-scalability-law), or the statistics of the measured numbers themselves (latency-statistics).
    3 repo stars
  88. ▌
    Sidecar Pattern · robsonkades bundle
    Composing a second container into the same pod to add a capability to a container you cannot or will not modify: the shared network namespace and volumes that make this different from a library, native sidecar containers (an init container with restartPolicy Always) and the startup and shutdown ordering they fix, per-container requests against pod-level QoS, and the failure matrix of a two-container pod. Use when a proxy, TLS terminator, config reloader or log shipper is added beside an application, when requests fail in the first seconds after a pod starts because the app came up before its proxy, when a Job's pod stays Running because the sidecar never exits, or when a sidecar is up but broken and the app cannot tell. Does not cover probes and graceful shutdown (kubernetes-service-lifecycle), mediating outbound traffic (ambassador-pattern), normalising what the app emits (adapter-sidecar-pattern), or JVM cgroup detection (container-awareness).
    3 repo stars
  89. ▌
    Unified Logging · robsonkades bundle
    Constructing, validating and operating HotSpot unified JVM logging: exact versus wildcard tag-set selection, levels, outputs, decorators, file rotation, asynchronous drop/stall modes, runtime VM.log changes, environment-injected options and legacy-flag migration. Use when -Xlog is empty, excessive, missing after restart, rejected at startup, changed live with jcmd, mixed with container logs, or evaluated for overhead. Producing and preserving the intended evidence belongs here; interpretation belongs to GC, safepoint, JIT, class-loading and other owning skills.
    3 repo stars
  90. ▌
    Circuit Breakers · robsonkades bundle
    The breaker as a state machine that stops calling a failing dependency: closed, open and half-open; choosing rate windows versus consecutive failures; why half-open admits a bounded number of probes; the failure predicate—classifying correlated dependency failures rather than blindly counting status classes—and the distinction between protecting caller resources by failing fast and providing a semantically valid fallback. Use when a breaker trips on consecutive failures, when it never trips or trips on one client's bad requests, when half-open sends full traffic at a recovering dependency, when a breaker sits on a call with no timeout under it, or when a dependency is slow rather than failing. Does not cover bulkheads (concurrency-limiting-and-bulkheads), retry policy (retries-and-backoff), the bound itself (timeouts-and-deadlines), the system-wide loop (cascading-failures), shedding (rate-limiting-and-load-shedding), or serving a cached fallback (caching-strategies).
    3 repo stars
  91. ▌
    Java Annotations · robsonkades bundle
    Annotations as metadata that only means something if code reads it: retention policies and what each one costs, targets and where an annotation on a record component actually lands, @Inherited and its limits, marker interfaces versus marker annotations, @Override as a correctness check rather than decoration, and the gap between annotating something and enforcing it. Use when defining a custom annotation, when an annotation appears to have no effect, when validation or security annotations are trusted without a validator or a proxy invoking them, when @Override is missing on an override, when a naming convention encodes behaviour that an annotation should carry, when annotation scanning slows startup or breaks under native image, or when deciding between a marker interface and a marker annotation. Does not cover nullability annotation contracts (java-null-safety), reflective access mechanics (java-reflection-and-method-handles), or the enum type itself (java-enums).
    3 repo stars
  92. ▌
    Java Code Smells · robsonkades bundle
    The detection catalogue for Java code smells: Long Method, God Object, Feature Envy, Primitive Obsession, Data Clumps, Shotgun Surgery, Divergent Change, Mysterious Name, Mutable and Global Data, Data Class, Loops, Lazy Element, Refused Bequest, boolean blindness, null-heavy APIs and leaky abstraction, plus how modern Java changes the list and the routing table from a finding to the refactoring that fixes it. Use when auditing code for structural problems, before planning a refactoring, when one change keeps fanning out across many files, when several refactorings could address one finding, when a switch over a sealed type carries a default branch, or when deciding whether a suspect pattern is actually a problem. Detection and severity only — refactoring mechanics are java-refactoring, navigation-chain depth is java-law-of-demeter, and the economics of duplication and premature abstraction are java-dry-kiss-yagni.
    3 repo stars
  93. ▌
    Java Concurrency · robsonkades bundle
    Entry point for designing or triaging concurrency inside one JVM. Classifies work by lifecycle, blocking and CPU demand, state ownership, arrival shape, ordering, cancellation, failure, and scarce-resource bounds, then routes to executors, virtual threads, structured concurrency, futures, reactive streams, memory-model correctness, diagnostics, or testing. Use before selecting a concurrency abstraction or when “more threads,” “async,” or “reactive” is proposed as a performance fix. Detailed construct internals and distributed coordination have separate owners.
    3 repo stars
  94. ▌
    Java Fluent Apis · robsonkades bundle
    Fluent interfaces and builders as API decisions: when a builder pays for itself versus a record, constructor or static factory; staged builders and their compatibility cost; immutable wither-style APIs; and the debugging and binary compatibility consequences of method chaining. Use when designing or reviewing a type with a costly constructor call site, several optional values, or adjacent parameters of the same type; when someone proposes a builder, staged builder or DSL; or when a long chain has become hard to read, debug or evolve. Does not cover navigation chains through other objects' structure (java-law-of-demeter) or general naming and parameter design (java-api-design).
    3 repo stars
  95. ▌
    Java Null Safety · robsonkades bundle
    Null as a semantic problem, not a syntax problem: what each null means (absence, error, uninitialised), nullability as an API contract, JSpecify @NullMarked and @Nullable, where Objects.requireNonNull belongs, empty collections over null, and the boundaries where null leaks in (deserialisation, ORMs, Map.get, arrays). Use when an NPE surfaces far from its cause, when hardening a service or module boundary, when adopting nullability annotations, or when reviewing constructors and public entry points. Does not cover the Optional API — orElse/orElseGet, chaining, where Optional belongs — which is java-optional, nor general validation strategy at trust boundaries — range and state checks, normalisation — which is java-defensive-programming.
    3 repo stars
  96. ▌
    Java Performance · robsonkades bundle
    Evidence-first triage and routing for ambiguous Java/JVM performance symptoms: defining the affected population and work, separating latency/throughput/resource/error dimensions, checking measurement and recent-change validity, preserving live-incident evidence, mapping competing hypotheses to discriminating signals, and handing each confirmed mechanism to its owning skill. Use for “it is slow,” regressions, saturation, memory/RSS growth, startup, uneven instances, or post-JDK/deploy changes when the cause is unknown. This is a router, not a substitute for performance-methodology or specialist JVM/OS/database/distributed skills.
    3 repo stars
  97. ▌
    Java Refactoring · robsonkades bundle
    Refactoring mechanics for Java: characterisation tests, small reversible steps, what behaviour preservation actually covers, risk classification, and the catalogue — Extract/Inline, Split Phase, guard clauses, Remove Flag Argument, Pull Up and Push Down, Replace Conditional with Polymorphism or sealed types. What to detect is java-code-smells; evolution rules for published APIs are java-api-design. Use when restructuring code without changing behaviour, when a change is needed in code that has no tests, when a method resists extraction because everything shares locals, when inverting a condition into a guard clause, when converting an instanceof chain to a switch, when moving members through a hierarchy, or when you need to know whether a step crosses a lock, transaction, serialisation or published boundary and must stop. Getting a class that constructs its own dependencies into a harness in the first place is java-legacy-code-testing.
    3 repo stars
  98. ▌
    Java Test Design · robsonkades bundle
    Writing a Java test that survives refactoring and says why it failed: naming the behaviour rather than the method, one reason to fail, test data builders over shared mutable setup, choosing the assertion that produces a readable failure, parameterised and nested tests, and removing every input the test does not control — clock, ordering, locale, randomness. Use when a test name does not say what broke, when a failure message has to be decoded by reading the test, when setup is shared across unrelated tests, when a test sleeps, when tests pass alone and fail together, when a flaky test is about to be retried or disabled, or when the same assertions are being copied across cases. Does not cover which level to test at (java-testing-strategy), stubs and mocks (java-test-doubles), the red-green-refactor loop (tdd), or threading (concurrency-testing).
    3 repo stars
  99. ▌
    Jvm Ml Inference · robsonkades bundle
    Engineering CPU and accelerator-backed ML inference from JVM applications: choosing in-process versus remote serving, bounding native sessions and predictors, coordinating engine and request parallelism, batching under a latency deadline, reusing direct buffers, warming deployments and diagnosing native memory outside NMT. Use when DJL, ONNX Runtime or another native inference engine loses throughput as concurrency rises, leaks RSS, overloads a model pool or needs graceful degradation. Model quality and training pipelines are outside scope.
    3 repo stars
  100. ▌
    Metadata Mapping · robsonkades bundle
    Expressing the object-to-schema mapping as metadata rather than hand-written code: where the mapping lives (annotations, external XML, programmatic), what reflection costs versus generated code, and how metadata drifts from the schema it describes. Use when persistence annotations accumulate on a domain class that is supposed to be framework-free, when the same mapping is expressed twice, when a schema change is discovered at runtime instead of at startup, when ddl-auto generates a schema in an environment that has migrations, when string literals name columns across the codebase, or when a fully metadata-driven model is proposed. Does not cover the mapping decisions themselves (orm-structural-mapping, inheritance-mapping-strategies) runtime ORM behaviour (orm-behavioral-patterns), or migrating from one mapping approach to another (architecture-refactoring-paths).
    3 repo stars