robsonkades

@robsonkades source repo

275 skills
0 followers
1 day ago last updated

▌
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.

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
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).

0
installs
▌
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.

0
installs
▌
Reactive And Virtual Thread Selection · robsonkades bundle
Choosing between a reactive pipeline and thread-per-request on virtual threads, and deciding where they legitimately coexist: what each model actually gives you, where backpressure comes from in each, memory per in-flight request versus per idle connection, the diagnosability difference, and the framework configuration that decides which model a request runs under. Use when a team proposes migrating away from WebFlux or towards it, when virtual threads are described as making reactive obsolete, when a blocking call is about to be added to a reactive pipeline, when spring.threads.virtual.enabled is being turned on, when Quarkus RunOnVirtualThread is applied per endpoint, or when both models exist in one service and nobody can say which runs what. Not what blocks a carrier (blocking-and-nonblocking-io), demand and overflow (reactive-backpressure), the migration programme (virtual-thread-migration), or thread costs and sizing (thread-sizing-and-virtual-threads).

0
installs
▌
Stream Processing Runtime Performance · robsonkades bundle
Operating Kafka Streams and Apache Flink for predictable throughput, state and recovery: separating their execution models, sizing partitions or operator parallelism, diagnosing backpressure, bounding native state, and relating commits or checkpoints to result visibility. Use when one partition or operator limits a pipeline, checkpoints grow or stall, RocksDB drives RSS outside the heap, exactly-once changes latency, or effective runtime configuration differs from declared settings. Generic topology and event-time semantics belong to streaming-pipeline-topologies; plain Kafka consumer loops to kafka-consumers-in-java.

0
installs
▌
Java Lambdas And Functional Interfaces · robsonkades bundle
Lambdas, method references and the functional interfaces they implement: what a lambda captures and what that costs, why its this differs from an anonymous class's, when a method reference is clearer, choosing among the standard java.util.function interfaces instead of inventing one, primitive specialisations that avoid boxing, checked exceptions inside lambdas, and the runtime shape (invokedynamic, capturing versus non-capturing, megamorphic call sites). Use when a lambda captures mutable state or a large object, when a codebase reinvents Function or Predicate, when checked exceptions force a try/catch inside a pipeline, or when a queued lambda outlives what it captured. Stream pipelines are java-streams, inlining is jit-inlining-and-escape-analysis, and per-request context a lambda must not capture is scoped-values.

0
installs
▌
Database Engine Selection And Migration · robsonkades bundle
Choosing among SQL Server, MySQL/InnoDB, and PostgreSQL for a greenfield system, or planning a migration between them, from explicit semantic, workload, operational, JVM-driver, DDL, cost, and team constraints. Use when an ADR, proof of concept, compatibility inventory, shadow validation, or reversible cutover is needed. Not a generic product ranking or live query-tuning workflow.

0
installs
▌
Concurrent Collections And Synchronizers · robsonkades bundle
Choosing between the members of java.util.concurrent once the family is settled, and the parameter that makes it correct: which BlockingQueue and which of its four insert and remove forms, which ConcurrentHashMap atomic replaces a compound action, copy-on-write's cost, latch versus barrier versus phaser versus semaphore, the Condition await loop, and ReentrantLock versus ReentrantReadWriteLock versus StampedLock. Use when computeIfAbsent loads from a database, when IllegalStateException "Recursive update" is thrown, when new LinkedBlockingQueue<>() appears in a producer, when a thread parks in CountDownLatch$Sync or every worker sits in CyclicBarrier.dowait, when await() sits under an if, or when a read lock is upgraded to a write lock. Not the thread-safety contract (java-thread-safety-contracts), executor lifecycle (executors-and-task-lifecycle), limit sizing (concurrency-limiting-and-bulkheads), CAS loops (lock-free-patterns), monitor contention (lock-inflation), or happens-before (java-memory-model).

0
installs

275 published skills · page 3 of 3