Development

Programming, frameworks, implementation, frontend, backend, and app development

skills in category: 66,450
pages available: 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 browser

Browse development skills

Showing 14,329–14,352 of 66,450 skills

Java StreamsAStream 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 o...developmentjavaexpressVotes: 0GitHub stars: 2
Java SolidAThe 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-b...developmentjavarefactoringVotes: 0GitHub stars: 2
Java Serialization HardeningAJava 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, ...developmentrustgoVotes: 0GitHub stars: 2
Java Resource ManagementADeterministic release of what a Java program holds open: try-with-resources and the exception semantics that make it non-optional, designing an AutoCloseable (ownership, idempotent close, close that fails), decorators and partially constructed resource chains, resources that cross an async or executor boundary, and the difference between closing a resource and returning one to a pool. Use when a close sits in a finally block, when a resource is created inside a try block or inside a lambda th...developmentjavagitVotes: 0GitHub stars: 2
Java Reflection And Method HandlesARuntime access to code through dynamic names: what reflection costs beyond speed — weaker ordinary compile-time/refactoring checks, module access requirements, and closed-world native-image constraints — 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, wh...developmentrustgoVotes: 0GitHub stars: 2
Java Reference Types And LeaksAReachability-driven memory in Java: strong/soft/weak/phantom contracts and notification limits, WeakHashMap and its value-holds-key trap, explicit Cleaner cleanup versus automatic fallback, 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 re...developmentrustgoVotes: 0GitHub stars: 2
Skills DirectorySkills Directory 3 slots · $399/mo · one ad per page · sponsors can never buy grades.See placements
Java RefactoringARefactoring 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 ha...developmentrustgoVotes: 0GitHub stars: 2
Java PerformanceAEvidence-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 bounded question to its owning skill. Use for “it is slow,” regressions, saturation, memory/RSS growth, startup, uneven instances, or post-JDK/deploy changes whe...developmentrustgoVotes: 0GitHub stars: 2
Java OptionalAOptional 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-t...developmentjavaexpressVotes: 0GitHub stars: 2
Java Object ContractsAThe four contracts every Java object inherits or opts into — equals, hashCode, toString, Comparable — plus why clone is not one of them. The equals properties and how inheritance breaks symmetry, the hashCode obligation and what is stable across JVMs, records' generated implementations and their array and floating-point edges, entity identity under JPA and Hibernate proxies, total ordering and TimSort contract violations, and copying without Cloneable. Use when equals is overridden without ha...developmentgojavaVotes: 0GitHub stars: 2
Java Object ConstructionAChoosing how an object comes into existence in Java: static factory versus public constructor, the of/from/valueOf/getInstance naming conventions, instance control (caching, canonicalisation, value-based classes), enum and holder singletons, noninstantiable utility classes, and passing collaborators in rather than hardwiring them with new. Use when a class has several constructors distinguished only by parameter types, when a constructor does work beyond assigning fields, when a singleton or ...developmentjavaexpressVotes: 0GitHub stars: 2
Java Numeric TypesAChoosing and using Java's numeric types correctly: binary floating-point limits for exact decimal amounts, BigDecimal construction, scale, rounding and the equals/compareTo split, integer overflow, lossy conversions and exact arithmetic, primitives versus boxed types, the boxed-value caching that makes == appear to work for some values, unboxing NPEs, boxing cost in bulk paths, and what happens to a numeric value when it crosses JSON, a database column or a JavaScript client. Use when money o...developmentjavascriptrustVotes: 0GitHub stars: 2
Java Null SafetyANull 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 ...developmentrustjavaVotes: 0GitHub stars: 2
Java Memory ModelAProving inter-thread visibility, ordering and atomicity under the Java Memory Model. Covers actions/executions, synchronization order, synchronizes-with and happens-before, data races, sequential consistency for correctly synchronized programs, volatile publication, monitor and lifecycle edges, final-field freeze semantics, safe publication, compound invariants, benign races, constructor escape, wait/notify, and architecture/JIT independence. Use for shared-state correctness reviews and inter...developmentgojavaVotes: 0GitHub stars: 2
Java Legacy Code TestingAGetting Java code under test before you change it, when you cannot construct the class or reach the method at all: seams and their enabling points, the dependency-breaking catalogue (Parameterize Constructor, Extract Interface, Extract and Override, Introduce Instance Delegator, Break Out Method Object, Expose Static Method), Sprout and Wrap when there is no time, approval testing when the output to pin is too large to assert on, and the disciplines that make a change safe while no test exist...developmentgojavaVotes: 0GitHub stars: 2
Java Law Of DemeterANavigation coupling: what the Law of Demeter actually constrains — structure exposure, not dot-counting — and how to tell a train wreck from a legitimate chain. Use when reviewing chains like order.getCustomer().getAddress().getCity(), when a change to one class's shape rippled through files that never mention it, when deciding whether a chain couples the caller to structure or merely reads data, or when a proposed fix would add forwarding methods to every intermediate class. Does not cover d...developmentjavarefactoringVotes: 0GitHub stars: 2
Java Lambdas And Functional InterfacesALambdas, 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 st...developmentjavaexpressVotes: 0GitHub stars: 2
Java ImmutabilityAImmutable objects in modern Java: records in depth, defensive copies, immutable collection factories versus unmodifiable views, deep versus shallow immutability, final-field semantics and safe publication (JMM), and the withers pattern. Use when designing a value object, when a record has a List, Map or array component, when an accessor returns internal mutable state, when an "immutable" object is observed changing, or when deciding whether immutability is worth its allocation cost. Does not ...developmentjavaapiVotes: 0GitHub stars: 2
Java GenericsAGenerics 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 varar...developmentrustgoVotes: 0GitHub stars: 2
Java Fluent ApisAFluent 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...developmentjavadebuggingVotes: 0GitHub stars: 2
Java Exception DesignAExceptions as API design in Java: checked versus unchecked as a deliberate decision, hierarchy sizing, translation at layer boundaries with cause preservation, typed failure facts for retry policy, failure atomicity when a method throws partway through, and when a sealed result type beats an exception. Use when designing the exception surface of a service or library, when a catch block swallows a failure or rewraps one without its cause, when a codebase has dozens of exception types nobody ca...developmentrustjavaVotes: 0GitHub stars: 2
Java EnumsAEnums 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() encodes domain identity, when @Enumerated is ...developmentgojavaVotes: 0GitHub stars: 2
Java Dry Kiss YagniAThe economics of duplication and abstraction in Java: knowledge duplication versus incidental (textual) duplication, what a shared abstraction costs, the wrong-abstraction failure mode, premature abstraction and speculative generality, essential versus accidental complexity. Use when deciding whether two similar pieces of code should be merged, whether a shared helper should be inlined back into its callers, when a utility has grown boolean parameters, or when reviewing code generalised for r...developmentrustgoVotes: 0GitHub stars: 2
Java Design By ContractAContracts as the semantics of a Java API, without a contract framework: preconditions, postconditions and invariants defined precisely and mapped to Java 25 mechanisms — constructor and compact-constructor validation, invariants as types that cannot represent invalid states, postconditions via tests and proportionate runtime checks, contracts documented in Javadoc, behavioural subtyping (overrides may weaken preconditions and strengthen postconditions, never the reverse), and contracts across...developmentrustjavaVotes: 0GitHub stars: 2