devflow-kit 1.8.3 → 2.0.0

package/src/assets/skills/java/references/modern-java.md

@@ -0,0 +1,335 @@
+# Modern Java Features (17-21+)
+
+Deep-dive on modern Java language features with JEP and literature citations.
+Reference from main SKILL.md.
+
+---
+
+## Records (Java 16+) [4]
+
+Records are transparent carriers of immutable data. The compiler auto-generates
+`equals`, `hashCode`, `toString`, and an accessor method per component. Compact
+constructors validate fields before the record is constructed. — JEP 395 [4]
+
+"Records model the situation where a class's primary purpose is to hold data."
+— Brian Goetz, Data Oriented Programming in Java [9]
+
+### Basic Record [4]
+
+```java
+// Immutable data carrier with auto-generated equals, hashCode, toString [4]
+public record Point(double x, double y) {}
+
+// Usage
+var p = new Point(3.0, 4.0);
+double x = p.x(); // Accessor method, not getX() [4]
+```
+
+### Compact Constructor (Validation) [4]
+
+```java
+// Validation before component fields are sealed [4]
+public record Email(String value) {
+    public Email {
+        Objects.requireNonNull(value, "email must not be null");
+        if (!value.contains("@")) {
+            throw new IllegalArgumentException("Invalid email: " + value);
+        }
+        value = value.toLowerCase().strip(); // Normalize before assignment [4]
+    }
+}
+```
+
+### Record with Custom Methods [4][1, Item 17]
+
+Records can have instance methods; they cannot have mutable state. Return new
+records for "updates" — the immutability contract is preserved. [1, Item 17]
+
+```java
+public record Range(int start, int end) {
+    public Range {
+        if (start > end) throw new IllegalArgumentException("start must be <= end");
+    }
+
+    public int length() { return end - start; }
+    public boolean contains(int value) { return value >= start && value <= end; }
+    public Range overlap(Range other) {
+        int newStart = Math.max(start, other.start);
+        int newEnd = Math.min(end, other.end);
+        return newStart <= newEnd ? new Range(newStart, newEnd) : null;
+    }
+}
+```
+
+### Records as Local Classes [4][9]
+
+Local records are useful for intermediate computation shapes inside a method —
+they scope the type to where it is needed. [9]
+
+```java
+public List<String> processOrders(List<Order> orders) {
+    // Local record for intermediate computation [4]
+    record OrderTotal(String orderId, Money total) {}
+
+    return orders.stream()
+        .map(o -> new OrderTotal(o.id(), o.calculateTotal()))
+        .filter(ot -> ot.total().isGreaterThan(Money.of(100)))
+        .map(OrderTotal::orderId)
+        .toList();
+}
+```
+
+---
+
+## Sealed Classes (Java 17+) [5]
+
+Sealed types close the subtype hierarchy: only `permits`-listed subtypes may
+implement/extend. This enables exhaustive pattern matching — the compiler verifies
+all cases are handled without a `default` branch. — JEP 409 [5]
+
+"Sealed classes expose the constraint that a domain model is closed." — Goetz [9]
+
+### Sealed Interface [5]
+
+```java
+// Closed hierarchy — compiler knows all subtypes [5]
+public sealed interface Shape permits Circle, Rectangle, Triangle {
+    double area();
+}
+
+public record Circle(double radius) implements Shape {
+    public double area() { return Math.PI * radius * radius; }
+}
+
+public record Rectangle(double width, double height) implements Shape {
+    public double area() { return width * height; }
+}
+
+public record Triangle(double base, double height) implements Shape {
+    public double area() { return 0.5 * base * height; }
+}
+```
+
+### Sealed Class with Abstract Methods [5]
+
+```java
+public sealed abstract class Payment permits CreditCard, BankTransfer, Crypto {
+    abstract Money amount();
+    abstract String reference();
+}
+
+public final class CreditCard extends Payment { /* ... */ }
+public final class BankTransfer extends Payment { /* ... */ }
+public final class Crypto extends Payment { /* ... */ }
+```
+
+---
+
+## Pattern Matching (Java 21+) [6]
+
+Pattern matching for `switch` combines type testing, binding, and guarded conditions
+in one expression. Sealed types make the switch exhaustive — no `default` needed. — JEP 441 [6]
+
+### Switch with Patterns [6]
+
+```java
+// Exhaustive — compiler verifies all Shape subtypes covered [5][6]
+public String describe(Shape shape) {
+    return switch (shape) {
+        case Circle c    -> "Circle with radius %.2f".formatted(c.radius());
+        case Rectangle r -> "Rectangle %s x %s".formatted(r.width(), r.height());
+        case Triangle t  -> "Triangle with base %.2f".formatted(t.base());
+    };
+}
+```
+
+### Guarded Patterns [6]
+
+```java
+// when-guards refine pattern match conditions [6]
+public String classifyTemperature(Object obj) {
+    return switch (obj) {
+        case Integer i when i < 0    -> "Freezing";
+        case Integer i when i < 15   -> "Cold";
+        case Integer i when i < 25   -> "Comfortable";
+        case Integer i               -> "Hot";
+        case Double d when d < 0.0   -> "Freezing";
+        case Double d                -> "Warm-ish (%.1f)".formatted(d);
+        case String s                -> "Not a temperature: " + s;
+        case null                    -> "No reading";
+        default                      -> "Unknown type";
+    };
+}
+```
+
+### Record Patterns (Destructuring) [6][4]
+
+Record patterns decompose record components inline in the pattern. Nested destructuring
+collapses what would otherwise be multi-step instanceof + field access. [6]
+
+```java
+// Nested destructuring — components bound directly in pattern [6][4]
+record Address(String city, String country) {}
+record Person(String name, Address address) {}
+
+public String greet(Object obj) {
+    return switch (obj) {
+        case Person(var name, Address(var city, _)) ->
+            "Hello %s from %s".formatted(name, city);
+        default -> "Hello stranger";
+    };
+}
+```
+
+---
+
+## Text Blocks (Java 15+) [3]
+
+Text blocks preserve indentation relative to the closing delimiter. Use `formatted()`
+for interpolation — avoids escape sequences entirely.
+
+```java
+// Multi-line strings with proper indentation [3]
+String json = """
+        {
+            "name": "%s",
+            "email": "%s",
+            "active": true
+        }
+        """.formatted(user.name(), user.email());
+
+String sql = """
+        SELECT u.id, u.name, u.email
+        FROM users u
+        JOIN orders o ON o.user_id = u.id
+        WHERE u.active = true
+          AND o.created_at > ?
+        ORDER BY u.name
+        """;
+```
+
+---
+
+## Virtual Threads (Java 21+) [7]
+
+Virtual threads are lightweight JVM-managed threads that do not pin a platform thread
+during blocking I/O. Enables thread-per-request style with the efficiency of async. — JEP 444 [7]
+
+"Virtual threads are not faster threads — they are cheaper threads. They allow you
+to write blocking code that scales like async code." — JEP 444 [7]
+
+### Basic Virtual Thread [7]
+
+```java
+// Lightweight thread — does not pin platform thread during I/O [7]
+Thread.startVirtualThread(() -> {
+    var result = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+    process(result.body());
+});
+```
+
+### Structured Concurrency (Preview) [7][28]
+
+Structured concurrency treats a group of concurrent tasks as a single unit of work:
+all succeed, or all are cancelled. Prevents thread leaks and orphaned tasks. [28]
+
+```java
+// All subtasks complete or cancel together [28]
+try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
+    Subtask<User> userTask = scope.fork(() -> fetchUser(userId));
+    Subtask<List<Order>> ordersTask = scope.fork(() -> fetchOrders(userId));
+
+    scope.join().throwIfFailed();
+
+    return new UserDashboard(userTask.get(), ordersTask.get());
+}
+```
+
+### ExecutorService with Virtual Threads [7][1, Item 80]
+
+Prefer executors over raw threads. `newVirtualThreadPerTaskExecutor` spawns one
+virtual thread per submitted task. — Effective Java, Item 80 [1, Item 80]
+
+```java
+// Process thousands of concurrent I/O tasks [7][1, Item 80]
+try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+    List<Future<Response>> futures = urls.stream()
+        .map(url -> executor.submit(() -> httpClient.send(
+            HttpRequest.newBuilder(URI.create(url)).build(),
+            HttpResponse.BodyHandlers.ofString()
+        )))
+        .toList();
+
+    List<Response> responses = futures.stream()
+        .map(f -> {
+            try { return f.get(); }
+            catch (Exception e) { throw new RuntimeException(e); }
+        })
+        .toList();
+}
+```
+
+---
+
+## Other Modern Features
+
+### Enhanced instanceof (Java 16+) [3]
+
+Pattern variable binding eliminates explicit cast — the variable is scoped to the
+branch where the type is guaranteed.
+
+```java
+// Pattern variable binding eliminates explicit cast [3]
+if (obj instanceof String s && s.length() > 5) {
+    System.out.println(s.toUpperCase());
+}
+
+// Works with negation [3]
+if (!(obj instanceof String s)) {
+    throw new IllegalArgumentException("Expected String");
+}
+// s is in scope here — type proven by earlier check
+process(s);
+```
+
+### Helpful NullPointerExceptions (Java 14+) [3]
+
+The JVM now identifies exactly which reference was null in the exception message.
+Enabled by default since Java 17.
+
+```java
+// JVM now tells you exactly which reference was null:
+// java.lang.NullPointerException: Cannot invoke "String.length()"
+//   because the return value of "User.name()" is null
+// Enable with: -XX:+ShowCodeDetailsInExceptionMessages (default since Java 17) [3]
+```
+
+### Stream Gatherers (Java 22+ Preview) [3]
+
+Custom intermediate stream operations via the `Gatherers` API — enables sliding
+windows, batch processing, and other stateful operations.
+
+```java
+// Custom intermediate stream operations [3]
+var windowedAverages = temperatures.stream()
+    .gather(Gatherers.windowSliding(5))
+    .map(window -> window.stream().mapToDouble(d -> d).average().orElse(0))
+    .toList();
+```
+
+---
+
+## Data Oriented Programming Summary [9]
+
+Brian Goetz's Data Oriented Programming model combines four features into a
+unified paradigm for modeling immutable data: [9]
+
+| Feature | Role | JEP |
+|---------|------|-----|
+| Records | Immutable data carrier | [4] |
+| Sealed classes | Closed type hierarchies | [5] |
+| Pattern matching | Exhaustive dispatch | [6] |
+| Local records | Scoped intermediate types | [4] |
+
+"Data orientation separates the 'what' (data as records) from the 'how'
+(behavior in functions), leading to simpler, more testable code." — Goetz [9]

package/src/assets/skills/java/references/patterns.md

@@ -0,0 +1,311 @@
+# Extended Java Patterns
+
+Correct patterns for Java development with literature citations. Reference from main SKILL.md.
+
+---
+
+## Builder Pattern (Type-Safe) [1, Item 2]
+
+Use when constructors would have many optional parameters. Records with a nested `Builder`
+class provide compile-time validation of required fields. — Effective Java, Item 2 [1]
+
+```java
+// Compile-time enforcement of required fields [1, Item 2]
+public record EmailMessage(String to, String subject, String body, List<String> cc) {
+
+    public static Builder builder() { return new Builder(); }
+
+    public static class Builder {
+        private String to;
+        private String subject;
+        private String body;
+        private List<String> cc = List.of();
+
+        public Builder to(String to) { this.to = Objects.requireNonNull(to); return this; }
+        public Builder subject(String subject) { this.subject = Objects.requireNonNull(subject); return this; }
+        public Builder body(String body) { this.body = Objects.requireNonNull(body); return this; }
+        public Builder cc(List<String> cc) { this.cc = List.copyOf(cc); return this; }
+
+        public EmailMessage build() {
+            Objects.requireNonNull(to, "to is required");
+            Objects.requireNonNull(subject, "subject is required");
+            Objects.requireNonNull(body, "body is required");
+            return new EmailMessage(to, subject, body, cc);
+        }
+    }
+}
+
+// Usage
+var email = EmailMessage.builder()
+    .to("user@example.com")
+    .subject("Welcome")
+    .body("Hello!")
+    .build();
+```
+
+---
+
+## Strategy via Interfaces [14]
+
+Define behavior as a functional interface. Implementations can be lambdas or classes.
+Compose strategies as constructor arguments — no subclassing. — GoF Strategy [14]
+
+```java
+// Define strategy as functional interface [14]
+@FunctionalInterface
+public interface PricingStrategy {
+    Money calculatePrice(Order order);
+}
+
+// Implementations as lambdas [10]
+PricingStrategy standard = order -> order.subtotal();
+PricingStrategy discounted = order -> order.subtotal().multiply(0.9);
+PricingStrategy tiered = order -> {
+    if (order.itemCount() > 10) return order.subtotal().multiply(0.8);
+    if (order.itemCount() > 5) return order.subtotal().multiply(0.9);
+    return order.subtotal();
+};
+
+// Inject strategy — composition over inheritance [1, Item 18]
+public class OrderService {
+    private final PricingStrategy pricing;
+
+    public OrderService(PricingStrategy pricing) {
+        this.pricing = pricing;
+    }
+
+    public Money calculateTotal(Order order) {
+        return pricing.calculatePrice(order);
+    }
+}
+```
+
+---
+
+## Repository Pattern [1, Item 64]
+
+Refer to objects by their interfaces — Item 64. [1, Item 64] Implementations are
+swappable (JPA, JDBC, in-memory for tests) without changing callers.
+
+```java
+// Interface — callers depend on abstraction, not implementation [1, Item 64]
+public interface UserRepository {
+    Optional<User> findById(String id);
+    List<User> findByEmail(String email);
+    User save(User user);
+    void deleteById(String id);
+    boolean existsById(String id);
+}
+
+// Implementation with constructor injection [1, Item 18]
+public class JpaUserRepository implements UserRepository {
+    private final EntityManager em;
+
+    public JpaUserRepository(EntityManager em) {
+        this.em = em;
+    }
+
+    @Override
+    public Optional<User> findById(String id) {
+        return Optional.ofNullable(em.find(User.class, id));
+    }
+
+    @Override
+    public User save(User user) {
+        return em.merge(user);
+    }
+}
+```
+
+---
+
+## Value Objects [1, Item 17][4]
+
+Immutable value objects with validation in compact constructors. Records are the idiomatic
+Java 16+ choice — `equals`/`hashCode` are value-based automatically. [4][1, Item 17]
+
+```java
+// Value object as record with compact constructor validation [4][1, Item 17]
+public record Money(BigDecimal amount, Currency currency) {
+    public Money {
+        Objects.requireNonNull(amount, "amount must not be null");
+        Objects.requireNonNull(currency, "currency must not be null");
+        if (amount.scale() > currency.getDefaultFractionDigits()) {
+            throw new IllegalArgumentException("Scale exceeds currency precision");
+        }
+    }
+
+    public Money add(Money other) {
+        requireSameCurrency(other);
+        return new Money(amount.add(other.amount), currency);  // new object [1, Item 17]
+    }
+
+    public Money multiply(double factor) {
+        return new Money(
+            amount.multiply(BigDecimal.valueOf(factor))
+                  .setScale(currency.getDefaultFractionDigits(), RoundingMode.HALF_UP),
+            currency
+        );
+    }
+
+    private void requireSameCurrency(Money other) {
+        if (!currency.equals(other.currency)) {
+            throw new IllegalArgumentException(
+                "Cannot combine %s and %s".formatted(currency, other.currency)
+            );
+        }
+    }
+}
+```
+
+---
+
+## Event-Driven Pattern with Sealed Interfaces [5][6][9]
+
+Domain events as sealed interfaces with record subtypes enable exhaustive switch handling.
+No `instanceof` chains, no default fallback, compiler enforces completeness. [5][6]
+
+```java
+// Domain event hierarchy — sealed + records [5][9]
+public sealed interface OrderEvent permits OrderCreated, OrderShipped, OrderCancelled {
+    String orderId();
+    Instant occurredAt();
+}
+
+public record OrderCreated(String orderId, Instant occurredAt, List<LineItem> items)
+    implements OrderEvent {}
+
+public record OrderShipped(String orderId, Instant occurredAt, String trackingNumber)
+    implements OrderEvent {}
+
+public record OrderCancelled(String orderId, Instant occurredAt, String reason)
+    implements OrderEvent {}
+
+// Exhaustive pattern matching — no default needed [6]
+public class OrderEventHandler {
+    public void handle(OrderEvent event) {
+        switch (event) {
+            case OrderCreated e -> notifyWarehouse(e.items());
+            case OrderShipped e -> sendTrackingEmail(e.trackingNumber());
+            case OrderCancelled e -> processRefund(e.orderId(), e.reason());
+        }
+    }
+}
+```
+
+---
+
+## Stream Pipelines [10][26]
+
+Declarative, composable collection processing. Prefer `.toList()` (Java 16+) over
+`collect(Collectors.toList())`. Use `Collectors.groupingBy` for aggregations. [10][1, Item 46]
+
+```java
+// Declarative collection processing [10]
+public List<String> getActiveUserEmails(List<User> users) {
+    return users.stream()
+        .filter(User::isActive)
+        .map(User::email)
+        .filter(email -> email.contains("@"))
+        .sorted()
+        .toList(); // Unmodifiable list (Java 16+) [26]
+}
+
+// Grouping and aggregation [10]
+public Map<Department, Long> countByDepartment(List<Employee> employees) {
+    return employees.stream()
+        .collect(Collectors.groupingBy(Employee::department, Collectors.counting()));
+}
+
+// Reducing to summary [10]
+public record OrderSummary(int count, Money total) {}
+
+public OrderSummary summarize(List<Order> orders) {
+    return orders.stream()
+        .reduce(
+            new OrderSummary(0, Money.ZERO),
+            (summary, order) -> new OrderSummary(
+                summary.count() + 1,
+                summary.total().add(order.total())
+            ),
+            (a, b) -> new OrderSummary(a.count() + b.count(), a.total().add(b.total()))
+        );
+}
+```
+
+---
+
+## Concurrency: Thread-Safe Patterns [2][7]
+
+Use `ConcurrentHashMap` for shared state, virtual threads for I/O concurrency,
+`StructuredTaskScope` for fan-out/fan-in. — Java Concurrency in Practice [2]
+
+```java
+// Thread-safe shared state [2, Ch. 5]
+private final Map<String, Session> sessions = new ConcurrentHashMap<>();
+
+public void addSession(String id, Session s) {
+    sessions.put(id, s); // Thread-safe
+}
+
+// Virtual threads for I/O concurrency — JEP 444 [7]
+try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+    List<Future<Response>> futures = urls.stream()
+        .map(url -> executor.submit(() -> fetch(url)))
+        .toList();
+    return futures.stream().map(f -> uncheck(f::get)).toList();
+}
+
+// Structured concurrency: all subtasks complete or cancel together [28]
+try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
+    Subtask<User> userTask       = scope.fork(() -> fetchUser(userId));
+    Subtask<List<Order>> orders  = scope.fork(() -> fetchOrders(userId));
+    scope.join().throwIfFailed();
+    return new UserDashboard(userTask.get(), orders.get());
+}
+```
+
+---
+
+## Dependency Injection (Manual Composition Root) [1, Item 18]
+
+Wire all dependencies at the entry point. Inner components receive collaborators
+through constructors — no `new` calls buried in business logic. [1, Item 18]
+
+```java
+// Composition root wires everything together [1, Item 18]
+public class Application {
+    public static void main(String[] args) {
+        var config = Config.load();
+        var dataSource = createDataSource(config);
+        var userRepo = new JpaUserRepository(dataSource);
+        var eventBus = new InMemoryEventBus();
+        var userService = new UserService(userRepo, eventBus);
+        var userController = new UserController(userService);
+
+        startServer(config.port(), userController);
+    }
+}
+```
+
+---
+
+## Bean Validation (JSR 380) [11]
+
+Annotation-based validation at API boundaries. Pair with `@Valid` on controller method
+parameters for automatic enforcement. [11]
+
+```java
+public record CreateUserRequest(
+    @NotBlank @Size(max = 100) String name,
+    @Email @Size(max = 255) String email,
+    @Min(0) @Max(150) int age
+) {}
+
+// Spring MVC: @Valid triggers constraint evaluation [11]
+@PostMapping("/users")
+public ResponseEntity<UserDTO> create(@Valid @RequestBody CreateUserRequest req) {
+    // req is guaranteed valid here — ConstraintViolationException thrown if not
+    return ResponseEntity.ok(userService.create(req));
+}
+```

package/src/assets/skills/java/references/sources.md

@@ -0,0 +1,44 @@
+# Java — Sources
+
+## Primary References
+
+| # | Source | Author(s) | Year | Access | Topics |
+|---|--------|-----------|------|--------|--------|
+| 1 | "Effective Java" 3rd Ed. | Joshua Bloch | 2018 | Purchase | Items 1–90: APIs, generics, lambdas, concurrency, serialization — core Java best practices |
+| 2 | "Java Concurrency in Practice" | Goetz, Peierls, Bloch, Bowbeer, Holmes, Lea | 2006 | Purchase | Thread safety, concurrent collections, executors, atomic variables, memory model |
+| 3 | Java Language Specification (JLS 21) | Oracle | 2024 | [Free](https://docs.oracle.com/javase/specs/) | Definitive language semantics: types, expressions, execution, memory model |
+| 4 | JEP 395: Records | OpenJDK | 2021 | [Free](https://openjdk.org/jeps/395) | Immutable data carriers, compact constructors, auto-generated accessors/equals/hashCode/toString |
+| 5 | JEP 409: Sealed Classes | OpenJDK | 2021 | [Free](https://openjdk.org/jeps/409) | Algebraic data types, restricted class hierarchies, exhaustive pattern matching |
+| 6 | JEP 441: Pattern Matching for switch | OpenJDK | 2023 | [Free](https://openjdk.org/jeps/441) | Exhaustive switch on sealed types, guarded patterns, null handling in switch |
+| 7 | JEP 444: Virtual Threads | OpenJDK | 2023 | [Free](https://openjdk.org/jeps/444) | Lightweight concurrency, structured concurrency, loom project goals |
+| 8 | Google Java Style Guide | Google | 2024 | [Free](https://google.github.io/styleguide/javaguide.html) | Formatting, naming conventions, programming practices |
+| 9 | "Data Oriented Programming in Java" | Brian Goetz | 2022 | [Free](https://inside.java/2022/03/09/data-oriented-programming-in-java/) | Records + sealed classes + pattern matching as a programming model |
+| 10 | "Modern Java in Action" 2nd Ed. | Urma, Fusco, Mycroft | 2018 | Purchase | Streams, lambdas, Optional, CompletableFuture, reactive programming |
+| 11 | JSR 380: Bean Validation 2.0 | JCP | 2017 | [Free](https://beanvalidation.org/2.0/spec/) | Annotation-based validation, constraint composition, programmatic validation |
+| 12 | "The JSR-133 Cookbook for Compiler Writers" | Doug Lea | 2004 | [Free](https://gee.cs.oswego.edu/dl/jmm/cookbook.html) | Java Memory Model: happens-before, volatile, synchronization mechanics |
+| 13 | Baeldung Java Guides | Baeldung | 2024 | [Free](https://www.baeldung.com) | Practical tutorials: Spring, streams, testing, concurrency |
+| 14 | "Design Patterns: Elements of Reusable OO Software" | Gamma, Helm, Johnson, Vlissides (GoF) | 1994 | Purchase | Strategy, Observer, Factory, Decorator, Composite — classic patterns |
+| 15 | JEP 430: String Templates (Preview) | OpenJDK | 2023 | [Free](https://openjdk.org/jeps/430) | Type-safe string interpolation, template processors |
+
+## Effective Java Item Index
+
+| # | Item | Bloch | Topic |
+|---|------|-------|-------|
+| 16 | Item 18 | [1] | "Favor composition over inheritance" — Iron Law citation |
+| 17 | Item 17 | [1] | "Minimize mutability" — immutable class design |
+| 18 | Item 1 | [1] | "Consider static factory methods over constructors" |
+| 19 | Item 15 | [1] | "Minimize mutability" companion — limit accessibility |
+| 20 | Item 64 | [1] | "Refer to objects by their interfaces" |
+| 21 | Item 43 | [1] | "Prefer method references to lambdas" |
+| 22 | Item 55 | [1] | "Return optionals judiciously" |
+| 23 | Item 78 | [1] | "Synchronize access to shared mutable data" |
+| 24 | Item 80 | [1] | "Prefer executors, tasks, and streams to threads" |
+
+## API References
+
+| # | Source | Org | Access | Topics |
+|---|--------|-----|--------|--------|
+| 25 | Optional Javadoc | Oracle | [Free](https://docs.oracle.com/en/java/docs/api/java.base/java/util/Optional.html) | Optional usage patterns, API contract, when not to use |
+| 26 | Stream API Javadoc | Oracle | [Free](https://docs.oracle.com/en/java/docs/api/java.base/java/util/stream/Stream.html) | Functional pipeline, collectors, parallel streams |
+| 27 | CompletableFuture Javadoc | Oracle | [Free](https://docs.oracle.com/en/java/docs/api/java.base/java/util/concurrent/CompletableFuture.html) | Async composition, exception handling, combining futures |
+| 28 | StructuredTaskScope Javadoc | Oracle | [Free](https://docs.oracle.com/en/java/docs/api/java.base/java/util/concurrent/StructuredTaskScope.html) | Structured concurrency: fan-out/fan-in, failure policies |