All categories
Development
Programming, frameworks, implementation, frontend, backend, and app development
- 66,450
- 2,769
Security grades appear on each card once the skill has been scanned. Newly imported skills may briefly show without a grade until the backfill job runs.
Open in full browserBrowse development skills
Showing 14,425–14,448 of 66,450 skills
- Feature Architecture AnalysisEnumerating 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 f...Votes: 0GitHub stars: 2
- False Sharing And ContendedProving 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 when updates to distinct fields scale poorly, when padding is proposed, or when `@Conte...Votes: 0GitHub stars: 2
- Failure ModelsStating 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 ...Votes: 0GitHub stars: 2
- Executors And Task LifecycleEngineering 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 migra...Votes: 0GitHub stars: 2
- Event SourcingEvent 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.Votes: 0GitHub stars: 2
- Event Driven ArchitectureChoosing facts, asynchronous commands or request/response across services; then designing choreography/orchestration, payload authority, evolution horizon and consumer runtime. Use when a broker masks synchronous outcome dependence, workflows are unreconstructable, consumers read back every event, or publish and database commit form a dual write. Delivery, idempotency, ordering, outbox mechanics and schema evolution remain in their owning skills.Votes: 0GitHub stars: 2
- Estimation Under UncertaintyProducing 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 pr...Votes: 0GitHub stars: 2
- Escape Analysis InternalsC2 escape-analysis internals: connection graphs, escape-state propagation, flow insensitivity, bytecode escape summaries, scalar replacement and allocation merges, lock elimination, macro expansion, and deoptimization rematerialization. Use when a hot object still allocates, an inlining boundary changes EA, a product-build diagnostic is misleading, a disabled JFR allocation event is treated as proof, or recurring deoptimization makes eliminated objects costly. Does not cover introductory desi...Votes: 0GitHub stars: 2
- Epsilon And Shenandoah InternalsEpsilon 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...Votes: 0GitHub stars: 2
- Enterprise TransactionsTransaction boundaries as an architectural decision: where a transaction starts and ends, what isolation level actually buys, how propagation and rollback rules behave in practice, the costs of spanning a network call or a user's thinking time, and how to handle effects outside its atomic scope. Use when a use case writes twice and nobody can say whether it is atomic, when @Transactional sits on a repository or a controller, when a transaction stays open across an HTTP call or a message publi...Votes: 0GitHub stars: 2
- Enterprise Base PatternsThe small structural patterns that hold an enterprise application together — Gateway, Mapper, Layer Supertype, Separated Interface, Registry, Special Case, Plugin and Service Stub — with the judgement about when each earns its place and when it is indirection. Use when an external system's API is being called directly from business code, when the same null check appears in twenty callers, when a base class is accumulating unrelated protected helpers, when a Registry or a static holder is bein...Votes: 0GitHub stars: 2
- Enterprise Architecture SmellsDetecting 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" refacto...Votes: 0GitHub stars: 2
- Enterprise Application ArchitectureThe 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 "ho...Votes: 0GitHub stars: 2
- Engineering CommunicationCommunicating engineering facts to people who will act on them: stating what is true, what follows from it, what is still uncertain, and the options and recommendation when needed. Covers raising a risk early, saying no to a request in a way that leaves a yes on the table, resolving technical disagreement by making the checkable claim checkable, escalating without going around someone, and status updates during an incident. Use when bad news has to travel, when a risk is visible but unspoken,...Votes: 0GitHub stars: 2
- Ebpf For JvmUsing 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 ...Votes: 0GitHub stars: 2
- Domain Logic OrganizationChoosing where business rules live — Transaction Script, Domain Model or Table Module — from the shape of the logic rather than from convention, and recognising when the choice made no longer fits. Use when starting a new module and the "standard" layered structure is about to be applied by default, when a service class has grown past a thousand lines of procedural steps, when entities have only getters and setters and every rule sits in a service, when the same business rule is implemented i...Votes: 0GitHub stars: 2
- Distribution BoundariesDeciding whether a boundary should be a process boundary, and designing it when it must be: what distribution actually costs (latency, serialisation, partial failure, lost atomicity, independent deployment), caller-driven remote granularity, and choosing between synchronous call, messaging and replication. Use when a module is proposed for extraction into a service, when microservices are being adopted without a named driver, when a service call sits inside a transaction, when one request fan...Votes: 0GitHub stars: 2
- Distributed Transactions And SagasCoordinating 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.Votes: 0GitHub stars: 2
- Distributed Tracing DesignDesigning 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 mec...Votes: 0GitHub stars: 2
- Distributed SystemsTriage and routing entry point for cross-process Java systems. Classifies design questions and production symptoms, establishes boundary and fault assumptions, then selects the specialist skill for delivery, consistency, time, overload, partitioning, messaging, coordination, recovery or observability. Use when the next technical owner is unclear; it deliberately does not duplicate specialist guidance.Votes: 0GitHub stars: 2
- Distributed Systems TestingTesting 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; checking 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 be...Votes: 0GitHub stars: 2
- Distributed Locks And LeasesCross-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.Votes: 0GitHub stars: 2
- Distributed Failure CatalogueEvidence-oriented recognition index for recurring distributed failure shapes: overload amplification, gray and asymmetric failure, split ownership, stale work, mixed versions, correlated faults, silent stagnation, missing effects 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.Votes: 0GitHub stars: 2
- Distributed Aggregation And BarriersCorrect 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.Votes: 0GitHub stars: 2