javac --release 21 --enable-preview MyClass.java
java --enable-preview MyClass

java --list-modules

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
...

src/
  module-info.java
  com/nexussoftware/bibliotech/
      BiblioTechApp.java
      domain/
      service/
      persistence/
      network/
      internal/

/**
 * Main BiblioTech module.
 */
module com.nexussoftware.bibliotech {

    // --- WHAT I NEED ---
    requires java.logging;              // java.util.logging (06-07)
    requires java.net.http;             // HttpClient (09-06)
    requires java.sql;                  // JDBC, for module 11

    // transitive: whoever requires me also gets this
    requires transitive com.nexussoftware.common;

    // static: needed to compile, optional at runtime
    requires static com.nexussoftware.tools;

    // --- WHAT I OFFER ---
    exports com.nexussoftware.bibliotech.domain;
    exports com.nexussoftware.bibliotech.service;

    // Qualified export: ONLY to these modules
    exports com.nexussoftware.bibliotech.persistence
            to com.nexussoftware.bibliotech.tests;

    // com.nexussoftware.bibliotech.internal is NOT exported:
    // it is unreachable from outside even though its classes are public

    // --- REFLECTION ---
    // opens allows DEEP reflection (setAccessible on private members)
    opens com.nexussoftware.bibliotech.domain;

    // Qualified opening
    opens com.nexussoftware.bibliotech.persistence to com.fasterxml.jackson.databind;

    // --- SERVICES (ServiceLoader) ---
    uses com.nexussoftware.bibliotech.service.FinePolicy;
    provides com.nexussoftware.bibliotech.service.FinePolicy
            with com.nexussoftware.bibliotech.internal.StandardPolicy;
}

Field value = String.class.getDeclaredField("value");
value.setAccessible(true);
byte[] bytes = (byte[]) value.get("Effective Java");

Exception in thread "main" java.lang.reflect.InaccessibleObjectException:
    Unable to make field private final byte[] java.lang.String.value accessible:
    module java.base does not "opens java.lang" to unnamed module @0x1b6d3586

# Open a specific package to all code with no module
java --add-opens java.base/java.lang=ALL-UNNAMED -cp app.jar com.example.App

# Export (normal use, not deep reflection)
java --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED ...

# Several at once
java --add-opens java.base/java.lang=ALL-UNNAMED \
     --add-opens java.base/java.util=ALL-UNNAMED \
     -jar app.jar

module com.nexussoftware.bibliotech {
    requires java.logging;

    exports com.nexussoftware.bibliotech.domain;

    // Our AnnotatedExporter from 10-03 calls setAccessible on the
    // private fields of the entities: it needs opens.
    opens com.nexussoftware.bibliotech.domain;
}

# CLASSPATH: the classic mode. Everything goes into the "unnamed module".
javac -cp lib/*.jar -d classes $(find src -name "*.java")
java -cp classes:lib/*.jar com.nexussoftware.bibliotech.BiblioTechApp

# MODULEPATH: modular mode
javac -d classes --module-source-path src $(find src -name "*.java")
java --module-path classes -m com.nexussoftware.bibliotech/com.nexussoftware.bibliotech.BiblioTechApp

# Find out which modules the application needs
jdeps --print-module-deps --ignore-missing-deps classes/bibliotech.jar

java.base,java.logging,java.net.http

# Build the minimal runtime
jlink --add-modules java.base,java.logging,java.net.http \
      --strip-debug \
      --compress=zip-6 \
      --no-header-files \
      --no-man-pages \
      --output bibliotech-runtime

# And run with it
./bibliotech-runtime/bin/java -m com.nexussoftware.bibliotech/...BiblioTechApp

du -sh $JAVA_HOME bibliotech-runtime

315M    /usr/lib/jvm/jdk-21
44M     bibliotech-runtime

List<String> employees = List.of("Marta Ruiz", "Diego Alonso", "Nuria Vidal");
Set<String> isbns = Set.of("978-0000000001", "978-0000000002");
Map<String, Integer> loans = Map.of("Marta Ruiz", 4, "Diego Alonso", 2);

Map<String, Integer> many = Map.ofEntries(
        Map.entry("Marta Ruiz", 4),
        Map.entry("Diego Alonso", 2),
        Map.entry("Nuria Vidal", 3));

// Immutable copy of an existing collection (Java 10)
List<String> copy = List.copyOf(modifiableList);

Set<String> set = Set.of("a", "b", "c", "d");
System.out.println(set);   // a different order on every run of the program

public interface LoanService {

    Result<Loan> lend(String isbn, String employee);

    default Result<Loan> lendValidating(String isbn, String employee) {
        if (!isValidIsbn(isbn)) {
            return Result.failure("Malformed ISBN: " + isbn);
        }
        if (!isValidEmployee(employee)) {
            return Result.failure("Invalid employee");
        }
        return lend(isbn, employee);
    }

    // PRIVATE: logic shared between the defaults, invisible from outside
    private boolean isValidIsbn(String isbn) {
        return isbn != null && isbn.matches("978-\\d{10}");
    }

    private static boolean isValidEmployee(String employee) {
        return employee != null && !employee.isBlank();
    }
}

String title = "  Effective Java  ";

System.out.println(title.strip());           // "Effective Java"  (Unicode-aware)
System.out.println(title.stripLeading());    // "Effective Java  "
System.out.println(title.stripTrailing());   // "  Effective Java"
System.out.println("   ".isBlank());          // true
System.out.println("".isEmpty());             // true
System.out.println("=".repeat(40));           // separator line
System.out.println("one\ntwo".lines().count()); // 2  (returns Stream<String>)
System.out.println("text".indent(4));         // indentation (Java 12)

long nonEmptyLines = wholeText.lines()
        .map(String::strip)
        .filter(l -> !l.isBlank())
        .count();

// BEFORE
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
String content = String.join("\n", lines);

// NOW
String content = Files.readString(path, StandardCharsets.UTF_8);
Files.writeString(path, content, StandardCharsets.UTF_8);

List<Book> catalog = new ArrayList<>(...);

// BEFORE: every collection had its own way
Book first = catalog.get(0);
Book last = catalog.get(catalog.size() - 1);
Book firstOfDeque = deque.getFirst();
Book firstOfSet = sortedSet.iterator().next();              // like that!

// NOW: SequencedCollection unifies them
Book first2 = catalog.getFirst();
Book last2 = catalog.getLast();
catalog.addFirst(newOne);
catalog.addLast(another);
List<Book> backwards = catalog.reversed();                  // a view, not a copy

// And it works the same on LinkedHashSet, TreeSet, Deque, LinkedHashMap
LinkedHashMap<String, Book> byIsbn = new LinkedHashMap<>();
var firstEntry = byIsbn.firstEntry();

String publisher = catalog.findByIsbn(isbn).getPublisher().getName().strip();

Exception in thread "main" java.lang.NullPointerException
    at com.nexussoftware.bibliotech.BiblioTechApp.main(BiblioTechApp.java:42)

Exception in thread "main" java.lang.NullPointerException:
    Cannot invoke "String.strip()" because the return value of
    "com.nexussoftware.bibliotech.domain.Publisher.getName()" is null
    at com.nexussoftware.bibliotech.BiblioTechApp.main(BiblioTechApp.java:42)

var catalog = new ArrayList<Book>();                    // ArrayList<Book>
var title = "Effective Java";                           // String
var pages = 412;                                        // int
var date = LocalDate.of(2026, 8, 5);                    // LocalDate

// Where it shines most: long generic types
var byEmployeeAndType = new HashMap<String, Map<MaterialType, List<Loan>>>();

// In loops
for (var entry : byEmployeeAndType.entrySet()) { }
for (var i = 0; i < 10; i++) { }

// In try-with-resources
try (var lines = Files.lines(path, StandardCharsets.UTF_8)) { }

var title = "Effective Java";
// title = 42;          // DOES NOT COMPILE: String does not accept an int

// var field = "x";                 // class fields: NO
// public var method() { }          // method return type: NO
// void m(var parameter) { }        // parameters: NO (except in lambdas, Java 11)
// var noValue;                     // no initialiser: NO
// var nothing = null;              // there is nothing to infer: NO
// var array = { 1, 2, 3 };         // array initialiser: NO

// GOOD: the type is obvious from the right-hand side
var catalog = new ArrayList<Book>();
var reservation = new Reservation("R-001", "Madrid-A", "Marta Ruiz", start, duration);
var counter = new AtomicInteger(0);

// GOOD: the explicit type would be unreadable
var index = new HashMap<String, Map<MaterialType, List<Loan>>>();

// BAD: the type is not implied by the method name
var result = service.process(data);             // what is 'result'?
var x = compute();                              // int? double? BigDecimal?

// BAD: you lose the abstraction to the interface
var list = new ArrayList<Book>();               // the type is ArrayList
List<Book> list2 = new ArrayList<>();           // the type is List: a better API

// DANGEROUS: the empty diamond infers Object
var empty = new ArrayList<>();                  // ArrayList<Object>

list.forEach((@NonNull var book) -> System.out.println(book.getTitle()));

// CLASSIC: verbose and full of traps
String description;
switch (severity) {
    case HIGH:
        description = "Requires immediate action";
        break;
    case MEDIUM:
        description = "Review this week";
        break;
    case LOW:
        description = "Log it and carry on";
        break;
    default:
        throw new IllegalStateException("Unknown severity: " + severity);
}

// EXPRESSION: returns a value, no break, no fall-through
String description = switch (severity) {
    case HIGH   -> "Requires immediate action";
    case MEDIUM -> "Review this week";
    case LOW    -> "Log it and carry on";
};

double fine = switch (severity) {
    case HIGH -> {
        double base = days * 0.50;
        double surcharge = days > 30 ? 10.0 : 0.0;
        yield Math.min(base + surcharge, 50.0);    // yield returns the block's value
    }
    case MEDIUM -> days * 0.25;
    case LOW -> 0.0;
};

int termDays = switch (type) {
    case "BOOK"     -> 21;
    case "MAGAZINE" -> 7;
    case "DVD"      -> 3;
    default -> throw new IllegalArgumentException("Unknown type: " + type);
};

// BEFORE: unreadable, full of escapes and concatenation
String json = "{\n"
        + "  \"isbn\": \"978-0000000001\",\n"
        + "  \"title\": \"Effective Java\",\n"
        + "  \"available\": true\n"
        + "}";

// NOW
String json = """
        {
          "isbn": "978-0000000001",
          "title": "Effective Java",
          "available": true
        }""";

public class Example {
    public String query() {
        String sql = """
                SELECT l.reference, l.isbn, m.title
                  FROM loans l
                  JOIN materials m ON m.isbn = l.isbn
                 WHERE l.return_date IS NULL
                 ORDER BY l.due_date
                """;
        return sql;
    }
}

// The closing delimiter to the left of the content: more indentation is kept
String a = """
        line
  """;                    // the common margin is 2: "      line\n"

// The closing delimiter aligned with the content: all indentation is removed
String b = """
        line
        """;              // the common margin is 8: "line\n"

// The closing delimiter on the same line: no trailing newline
String c = """
        line""";          // "line"  (no \n at the end)

// \ at the end of a line: JOINS the lines (no line break)
String singleLine = """
        This text is written across several lines \
        of source code but ends up as a single \
        line of output.""";

// \s: a space that is NOT stripped as trailing indentation
String withSpaces = """
        column1    \s
        column2    \s""";

public class BiblioTechQueries {

    static final String OVERDUE_LOANS = """
            SELECT l.reference,
                   l.isbn,
                   m.title,
                   l.employee,
                   l.due_date,
                   CURRENT_DATE - l.due_date AS days_late
              FROM loans l
              JOIN materials m ON m.isbn = l.isbn
             WHERE l.return_date IS NULL
               AND l.due_date < CURRENT_DATE
             ORDER BY days_late DESC
            """;

    static String metadataRequest(String isbn) {
        return """
                {
                  "jsonrpc": "2.0",
                  "method": "catalog.query",
                  "params": { "isbn": "%s" },
                  "id": 1
                }""".formatted(isbn);          // formatted: like String.format
    }
}

public record Card(String isbn, String title, boolean available) { }

public record Loan(String reference, String isbn, String employee,
                   LocalDate loanDate, LocalDate dueDate) {

    /** COMPACT constructor: validates and normalises before assigning. */
    public Loan {
        Objects.requireNonNull(reference, "reference");
        Objects.requireNonNull(isbn, "isbn");
        if (dueDate.isBefore(loanDate)) {
            throw new IllegalArgumentException("Due date before the loan date");
        }
        employee = employee.strip();       // the parameter can be NORMALISED
    }

    /** Additional constructor. */
    public Loan(String reference, String isbn, String employee, LocalDate from) {
        this(reference, isbn, employee, from, from.plusDays(21));
    }

    /** Derived methods. */
    public long daysLate(LocalDate today) {
        return Math.max(0, ChronoUnit.DAYS.between(dueDate, today));
    }

    /** "Modifying" a record = creating another one. */
    public Loan withDueDate(LocalDate newDate) {
        return new Loan(reference, isbn, employee, loanDate, newDate);
    }

    /** Static methods and fields ARE allowed. */
    public static final Period TERM = Period.ofDays(21);

    public static Loan create(String ref, String isbn, String employee, LocalDate from) {
        return new Loan(ref, isbn, employee, from, from.plus(TERM));
    }
}

// BEFORE: the cast repeats what the instanceof already checked
if (material instanceof Book) {
    Book book = (Book) material;
    System.out.println(book.getPages());
}

// NOW: the pattern variable is declared and assigned at once
if (material instanceof Book book) {
    System.out.println(book.getPages());
}

// With && : the variable is available on the right-hand side
if (material instanceof Book book && book.getPages() > 400) {
    System.out.println("Long book: " + book.getTitle());
}

// With negation: available AFTER the if (early exit)
public String describe(Object object) {
    if (!(object instanceof Material material)) {
        return "Not a material";
    }
    // 'material' is in scope here, because otherwise we would already have returned
    return material.getTitle() + " (" + material.getType() + ")";
}

// With || : it is NOT available, and the compiler forbids it
// if (o instanceof Book b || b.getPages() > 0) { }   // DOES NOT COMPILE

@Override
public boolean equals(Object other) {
    return other instanceof Material material
            && isbn.equals(material.getIsbn());
}

// In another project, without anybody approving it
public class VideoGame extends Material { }

package com.nexussoftware.bibliotech.domain;

/**
 * CLOSED hierarchy: only these three materials exist.
 * No other class can extend Material, neither in this
 * project nor in any other.
 */
public sealed abstract class Material
        permits Book, Magazine, Dvd {

    private final String isbn;
    private final String title;

    protected Material(String isbn, String title) {
        this.isbn = isbn;
        this.title = title;
    }

    public String getIsbn()  { return isbn; }
    public String getTitle() { return title; }

    public abstract MaterialType getType();
}

/** final: nobody extends Book. This is the most common case. */
public final class Book extends Material {
    private final int pages;
    private final String author;
    // ...
}

/** sealed: Magazine has a closed hierarchy of its own. */
public sealed class Magazine extends Material permits MonthlyMagazine, QuarterlyMagazine {
    // ...
}

/** non-sealed: Dvd is open to anybody again. */
public non-sealed class Dvd extends Material {
    // ...
}

// All in one file: implicit permits
public sealed interface Event {
    record Lent(String isbn, String employee, LocalDate when) implements Event { }
    record Returned(String isbn, LocalDate when, boolean late) implements Event { }
    record Lost(String isbn, String employee, double amount) implements Event { }
}

// NO default: the compiler checks that all three are there
String label = switch (material) {
    case Book b     -> "Book of " + b.getPages() + " pages";
    case Magazine m -> "Magazine no. " + m.getNumber();
    case Dvd d      -> "DVD of " + d.getMinutes() + " minutes";
};

error: the switch expression does not cover all possible input values
    String label = switch (material) {
                   ^

package com.nexussoftware.bibliotech.domain;

import java.time.LocalDate;

/**
 * The status of a loan modelled as a sum type.
 * Every status carries EXACTLY the data it makes sense
 * for it to carry, instead of one class with fields that are sometimes null.
 */
public sealed interface LoanStatus {

    record Active(LocalDate dueDate) implements LoanStatus { }

    record Overdue(LocalDate dueDate, long daysLate, double fine)
            implements LoanStatus { }

    record Returned(LocalDate when, boolean onTime) implements LoanStatus { }

    record Lost(LocalDate declaredOn, double replacementCost)
            implements LoanStatus { }
}

// BEFORE: a chain of instanceof, with a cast in every branch
public String describe(Object object) {
    if (object instanceof Book) {
        Book b = (Book) object;
        return "Book: " + b.getTitle() + " (" + b.getPages() + " pp.)";
    } else if (object instanceof Magazine) {
        Magazine m = (Magazine) object;
        return "Magazine: " + m.getTitle() + " no. " + m.getNumber();
    } else if (object instanceof Dvd) {
        Dvd d = (Dvd) object;
        return "DVD: " + d.getTitle() + " (" + d.getMinutes() + " min)";
    } else if (object == null) {
        return "(nothing)";
    }
    return "Unknown";
}

// NOW
public String describe(Object object) {
    return switch (object) {
        case null       -> "(nothing)";
        case Book b     -> "Book: " + b.getTitle() + " (" + b.getPages() + " pp.)";
        case Magazine m -> "Magazine: " + m.getTitle() + " no. " + m.getNumber();
        case Dvd d      -> "DVD: " + d.getTitle() + " (" + d.getMinutes() + " min)";
        default         -> "Unknown: " + object.getClass().getSimpleName();
    };
}

public String classify(Material material) {
    return switch (material) {
        case Book b when b.getPages() > 500      -> "Long book";
        case Book b when b.getPages() > 200      -> "Standard book";
        case Book b                              -> "Short book";
        case Magazine m when m.isSpecial()       -> "Special issue";
        case Magazine m                          -> "Ordinary magazine";
        case Dvd d                               -> "Audiovisual material";
    };
}

case Book b                              -> "...";
case Book b when b.getPages() > 500      -> "...";   // ERROR: unreachable

public sealed interface Event {
    record Lent(String isbn, String employee, LocalDate when) implements Event { }
    record Returned(String isbn, LocalDate when, boolean late) implements Event { }
    record Lost(String isbn, String employee, double amount) implements Event { }
}

public String record(Event event) {
    return switch (event) {

        // The record is DECONSTRUCTED: isbn, employee and when come out directly
        case Event.Lent(String isbn, String employee, LocalDate when) ->
                String.format("%s lent %s on %s", employee, isbn, when);

        // With a guard over a deconstructed component
        case Event.Returned(String isbn, LocalDate when, boolean late) when late ->
                String.format("%s returned on %s LATE", isbn, when);

        case Event.Returned(String isbn, LocalDate when, boolean late) ->
                String.format("%s returned on time on %s", isbn, when);

        case Event.Lost(String isbn, String employee, double amount) ->
                String.format("%s declared %s lost (replacement: %.2f EUR)",
                        employee, isbn, amount);
    };
    // NO default: the interface is sealed and all three cases are there
}

case Event.Lent(var isbn, var employee, var when) ->
        employee + " lent " + isbn + " on " + when;

public record Point(int x, int y) { }
public record Line(Point start, Point end) { }

public String describe(Object o) {
    return switch (o) {
        // NESTED deconstruction at two levels
        case Line(Point(var x1, var y1), Point(var x2, var y2)) when x1 == x2 ->
                "Vertical line at x=" + x1;
        case Line(Point(var x1, var y1), Point(var x2, var y2)) when y1 == y2 ->
                "Horizontal line at y=" + y1;
        case Line(Point p1, Point p2) ->
                "Line from " + p1 + " to " + p2;
        case Point(int x, int y) ->
                "Point (" + x + ", " + y + ")";
        default -> "Something else";
    };
}

if (event instanceof Event.Lent(String isbn, String employee, LocalDate when)) {
    System.out.println(employee + " -> " + isbn + " (" + when + ")");
}

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.*;

/**
 * OLD VERSION: open hierarchy, manual casts,
 * if-else chains and a default that hides the new cases.
 */
public class LegacyTermCalculator {

    public int termDays(Material material) {
        if (material instanceof Book) {
            Book book = (Book) material;
            if (book.getPages() > 500) {
                return 30;
            } else if (book.getPages() > 200) {
                return 21;
            } else {
                return 14;
            }
        } else if (material instanceof Magazine) {
            Magazine magazine = (Magazine) material;
            if (magazine.isSpecial()) {
                return 14;
            }
            return 7;
        } else if (material instanceof Dvd) {
            return 3;
        }
        // And if somebody adds a new type, it lands HERE in silence
        throw new IllegalArgumentException("Unknown type: " + material.getClass());
    }

    public String shelfLabel(Material material) {
        String prefix;
        if (material instanceof Book) {
            prefix = "B";
        } else if (material instanceof Magazine) {
            prefix = "M";
        } else if (material instanceof Dvd) {
            prefix = "D";
        } else {
            prefix = "X";
        }
        return prefix + "-" + material.getIsbn().substring(4, 8);
    }

    public double replacementValue(Material material) {
        if (material instanceof Book) {
            return ((Book) material).getPages() * 0.08;
        } else if (material instanceof Magazine) {
            return 12.0;
        } else if (material instanceof Dvd) {
            return ((Dvd) material).getMinutes() * 0.15;
        }
        return 0.0;
    }
}

package com.nexussoftware.bibliotech.domain;

/** SEALED hierarchy: the compiler knows only three materials exist. */
public sealed abstract class Material permits Book, Magazine, Dvd {

    private final String isbn;
    private final String title;
    private final double rating;

    protected Material(String isbn, String title, double rating) {
        this.isbn = isbn;
        this.title = title;
        this.rating = rating;
    }

    public String getIsbn()   { return isbn; }
    public String getTitle()  { return title; }
    public double getRating() { return rating; }
}

public final class Book extends Material {
    private final int pages;
    private final String author;

    public Book(String isbn, String title, String author, int pages, double rating) {
        super(isbn, title, rating);
        this.author = author;
        this.pages = pages;
    }
    public int getPages()     { return pages; }
    public String getAuthor() { return author; }
}

public final class Magazine extends Material {
    private final int number;
    private final boolean special;

    public Magazine(String isbn, String title, int number, boolean special, double rating) {
        super(isbn, title, rating);
        this.number = number;
        this.special = special;
    }
    public int getNumber()     { return number; }
    public boolean isSpecial() { return special; }
}

public final class Dvd extends Material {
    private final int minutes;
    private final String director;

    public Dvd(String isbn, String title, String director, int minutes, double rating) {
        super(isbn, title, rating);
        this.director = director;
        this.minutes = minutes;
    }
    public int getMinutes()     { return minutes; }
    public String getDirector() { return director; }
}

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.*;

/**
 * MODERN VERSION: exhaustive switch with no default,
 * no casts, with guards. If a fourth material is added,
 * THESE THREE METHODS STOP COMPILING and the compiler
 * takes you to each one.
 */
public class TermCalculator {

    public int termDays(Material material) {
        return switch (material) {
            case Book b when b.getPages() > 500 -> 30;
            case Book b when b.getPages() > 200 -> 21;
            case Book b                         -> 14;
            case Magazine m when m.isSpecial()  -> 14;
            case Magazine m                     -> 7;
            case Dvd d                          -> 3;
        };
    }

    public String shelfLabel(Material material) {
        String prefix = switch (material) {
            case Book b     -> "B";
            case Magazine m -> "M";
            case Dvd d      -> "D";
        };
        return prefix + "-" + material.getIsbn().substring(4, 8);
    }

    public double replacementValue(Material material) {
        return switch (material) {
            case Book b     -> b.getPages() * 0.08;
            case Magazine m -> m.isSpecial() ? 25.0 : 12.0;
            case Dvd d      -> d.getMinutes() * 0.15;
        };
    }

    /** With blocks and yield when there is logic. */
    public String fullCard(Material material) {
        return switch (material) {
            case Book b -> {
                String length = b.getPages() > 400 ? "long" : "standard";
                yield """
                        BOOK
                          Title:       %s
                          Author:      %s
                          Pages:       %d (%s)
                          Term:        %d days
                          Replacement: %.2f EUR"""
                        .formatted(b.getTitle(), b.getAuthor(), b.getPages(),
                                   length, termDays(b), replacementValue(b));
            }
            case Magazine m -> """
                    MAGAZINE
                      Title:       %s
                      Number:      %d%s
                      Term:        %d days"""
                    .formatted(m.getTitle(), m.getNumber(),
                               m.isSpecial() ? " (SPECIAL)" : "", termDays(m));
            case Dvd d -> """
                    DVD
                      Title:       %s
                      Director:    %s
                      Duration:    %d min
                      Term:        %d days"""
                    .formatted(d.getTitle(), d.getDirector(), d.getMinutes(), termDays(d));
        };
    }
}

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.LoanStatus;

import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class StatusDescriber {

    private static final DateTimeFormatter DATE =
            DateTimeFormatter.ofPattern("d MMMM", Locale.forLanguageTag("en-GB"));

    public String describe(LoanStatus status) {
        return switch (status) {

            case LoanStatus.Active(var dueDate) ->
                    "Active, due on " + dueDate.format(DATE);

            case LoanStatus.Overdue(var dueDate, var days, var fine) when fine == 0 ->
                    "Overdue by " + days + " days (still within the grace period)";

            case LoanStatus.Overdue(var dueDate, var days, var fine) ->
                    String.format("OVERDUE by %d days -- fine accrued: %.2f EUR", days, fine);

            case LoanStatus.Returned(var when, var onTime) ->
                    "Returned on " + when.format(DATE) + (onTime ? " on time" : " late");

            case LoanStatus.Lost(var declared, var amount) ->
                    String.format("LOST since %s -- replacement: %.2f EUR",
                            declared.format(DATE), amount);
        };
    }

    /** Handling priority: a switch that returns an int. */
    public int priority(LoanStatus status) {
        return switch (status) {
            case LoanStatus.Lost l                                    -> 100;
            case LoanStatus.Overdue(var d, var days, var f) when days > 30 -> 90;
            case LoanStatus.Overdue o                                 -> 50;
            case LoanStatus.Active a                                  -> 10;
            case LoanStatus.Returned r                                -> 0;
        };
    }
}

List<LoanStatus> statuses = List.of(
        new LoanStatus.Active(LocalDate.of(2026, 8, 26)),
        new LoanStatus.Overdue(LocalDate.of(2026, 8, 3), 2, 0.0),
        new LoanStatus.Overdue(LocalDate.of(2026, 5, 22), 75, 18.25),
        new LoanStatus.Returned(LocalDate.of(2026, 8, 1), true),
        new LoanStatus.Lost(LocalDate.of(2026, 7, 15), 42.50));

StatusDescriber describer = new StatusDescriber();

statuses.stream()
        .sorted(Comparator.comparingInt(describer::priority).reversed())
        .forEach(s -> System.out.printf("  [%3d] %s%n",
                describer.priority(s), describer.describe(s)));

  [100] LOST since 15 July -- replacement: 42.50 EUR
  [ 90] OVERDUE by 75 days -- fine accrued: 18.25 EUR
  [ 50] Overdue by 2 days (still within the grace period)
  [ 10] Active, due on 26 August
  [  0] Returned on 1 August on time

// Create a single one
Thread virtual = Thread.ofVirtual().name("worker-1").start(() -> {
    System.out.println("I am a virtual thread: " + Thread.currentThread());
});
virtual.join();

// Not started
Thread notStarted = Thread.ofVirtual().unstarted(task);

// Virtual thread factory
ThreadFactory factory = Thread.ofVirtual().name("bibliotech-", 0).factory();

// THE MOST IMPORTANT ONE: an executor with one virtual thread PER TASK
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return "done";
        });
    }
}   // close() waits for them all to finish: the executor is AutoCloseable

package com.nexussoftware.bibliotech;

import java.time.Duration;
import java.util.concurrent.*;
import java.util.stream.IntStream;

public class VirtualThreadDemo {

    private static final int TASKS = 10_000;

    public static void main(String[] args) throws Exception {
        System.out.println("Tasks: " + TASKS + ", each blocked for 1 second");
        System.out.println("Cores: " + Runtime.getRuntime().availableProcessors());
        System.out.println();

        measure("Platform pool (200 threads)",
                Executors.newFixedThreadPool(200));

        measure("One VIRTUAL thread per task",
                Executors.newVirtualThreadPerTaskExecutor());

        // And THIS cannot be done with platform threads
        System.out.println();
        System.out.println("--- 1,000,000 virtual threads ---");
        long start = System.currentTimeMillis();
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            IntStream.range(0, 1_000_000).forEach(i ->
                    executor.submit(() -> {
                        Thread.sleep(Duration.ofSeconds(1));
                        return i;
                    }));
        }
        System.out.printf("One million tasks in %d ms%n",
                System.currentTimeMillis() - start);
    }

    private static void measure(String label, ExecutorService executor) throws Exception {
        long start = System.currentTimeMillis();
        try (executor) {
            for (int i = 0; i < TASKS; i++) {
                executor.submit(() -> {
                    Thread.sleep(Duration.ofSeconds(1));   // simulates an I/O wait
                    return null;
                });
            }
        }
        System.out.printf("%s -> %6d ms%n", label, System.currentTimeMillis() - start);
    }
}

Tasks: 10000, each blocked for 1 second
Cores: 8

Platform pool (200 threads) ->  50238 ms
One VIRTUAL thread per task ->   1104 ms

--- 1,000,000 virtual threads ---
One million tasks in 2871 ms

// BAD: it contradicts the whole point
ExecutorService bad = Executors.newFixedThreadPool(200, Thread.ofVirtual().factory());

// GOOD: one per task
ExecutorService good = Executors.newVirtualThreadPerTaskExecutor();

Semaphore limit = new Semaphore(50);

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (String isbn : isbns) {
        executor.submit(() -> {
            limit.acquire();
            try {
                return metadataClient.query(isbn);
            } finally {
                limit.release();
            }
        });
    }
}

package com.nexussoftware.bibliotech.network;

import java.io.IOException;
import java.net.*;
import java.util.concurrent.*;
import java.util.logging.Logger;

/**
 * MODULE 9 VERSION: a capped pool.
 *
 * The pool limits us to 50 simultaneous clients. With 51 connections,
 * the 51st waits in the queue; if the queue fills up, it is REJECTED.
 * And you cannot raise it much: each thread is ~1 MB of stack.
 */
public class PooledCatalogServer {

    private static final Logger LOG = Logger.getLogger(PooledCatalogServer.class.getName());

    private static final int PORT = 9090;
    private static final int MAX_CLIENTS = 50;       // <-- the limit
    private static final int QUEUE = 100;

    private final ExecutorService pool = new ThreadPoolExecutor(
            MAX_CLIENTS, MAX_CLIENTS,
            60L, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(QUEUE),
            new ThreadPoolExecutor.CallerRunsPolicy());

    private volatile boolean running = true;

    public void start() throws IOException {
        try (ServerSocket server = new ServerSocket(PORT)) {
            server.setSoTimeout(1000);
            LOG.info("Server on port " + PORT + " (max. " + MAX_CLIENTS + " clients)");

            while (running) {
                try {
                    Socket client = server.accept();
                    pool.submit(() -> serve(client));
                } catch (SocketTimeoutException e) {
                    // cycle to re-check 'running'
                }
            }
        } finally {
            pool.shutdown();
        }
    }

    private void serve(Socket client) { /* BTCP/1 protocol */ }
}

package com.nexussoftware.bibliotech.network;

import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * VIRTUAL THREAD VERSION.
 *
 * One virtual thread per connection, with no pool and no artificial limit.
 * The code in serve() is SEQUENTIAL and BLOCKING, which is how it
 * should be written, and it still scales to tens of thousands of clients.
 */
public class CatalogServer implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(CatalogServer.class.getName());

    private static final int PORT = 9090;
    private static final Duration IDLE_TIMEOUT = Duration.ofSeconds(30);
    private static final int MAX_LINE = 4096;

    /**
     * One VIRTUAL thread per task. There is no longer a pool size to tune,
     * nor a queue, nor a rejection policy.
     */
    private final ExecutorService handlers = Executors.newVirtualThreadPerTaskExecutor();

    private final AtomicLong totalConnections = new AtomicLong();
    private final AtomicLong activeConnections = new AtomicLong();

    private volatile boolean running = true;
    private ServerSocket server;

    public void start() throws IOException {
        server = new ServerSocket(PORT);
        server.setSoTimeout(1000);

        LOG.info(() -> "CatalogServer listening on port " + PORT
                + " (one virtual thread per connection, no pool limit)");

        // A dedicated virtual thread that reports the state
        Thread.ofVirtual().name("monitor").start(this::monitor);

        while (running) {
            try {
                Socket client = server.accept();

                // One virtual thread PER CONNECTION. Creating it costs microseconds.
                handlers.submit(() -> serve(client));

            } catch (SocketTimeoutException e) {
                // normal cycle
            } catch (IOException e) {
                if (running) {
                    LOG.log(Level.WARNING, "Error accepting a connection", e);
                }
            }
        }
    }

    /**
     * SEQUENTIAL and BLOCKING code: exactly the same as in 09-03.
     * readLine() blocks, and that is fine: the virtual thread unmounts.
     */
    private void serve(Socket client) {
        long number = totalConnections.incrementAndGet();
        activeConnections.incrementAndGet();

        // Naming the thread makes traces and dumps readable
        Thread.currentThread().setName("client-" + number);

        try (client;
             var in = new BufferedReader(new InputStreamReader(
                     client.getInputStream(), StandardCharsets.UTF_8));
             var out = new PrintWriter(new OutputStreamWriter(
                     client.getOutputStream(), StandardCharsets.UTF_8), true)) {

            client.setSoTimeout((int) IDLE_TIMEOUT.toMillis());

            out.println("BTCP/1 WELCOME BiblioTech");

            String line;
            while ((line = readBoundedLine(in)) != null) {

                String response = switch (line.split(" ", 2)[0].toUpperCase()) {
                    case "QUERY"  -> query(line);
                    case "LEND"   -> lend(line);
                    case "STATUS" -> "200 OK ACTIVE=" + activeConnections.get()
                                     + " TOTAL=" + totalConnections.get();
                    case "QUIT"   -> "221 BYE";
                    default       -> "400 BAD REQUEST";
                };

                out.println(response);

                if (response.startsWith("221 BYE")) {
                    break;
                }
            }

        } catch (SocketTimeoutException e) {
            LOG.fine(() -> "Client " + number + " dropped for inactivity");
        } catch (IOException e) {
            LOG.log(Level.FINE, e, () -> "Error with client " + number);
        } finally {
            activeConnections.decrementAndGet();
        }
    }

    private String readBoundedLine(BufferedReader in) throws IOException {
        StringBuilder sb = new StringBuilder();
        int c;
        while ((c = in.read()) != -1) {
            if (c == '\n') {
                return sb.toString().strip();
            }
            if (sb.length() >= MAX_LINE) {
                throw new IOException("Line too long: possible attack");
            }
            sb.append((char) c);
        }
        return sb.isEmpty() ? null : sb.toString().strip();
    }

    private void monitor() {
        while (running) {
            try {
                Thread.sleep(Duration.ofSeconds(10));
                LOG.info(() -> String.format("Connections: %d active, %d total",
                        activeConnections.get(), totalConnections.get()));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
        }
    }

    private String query(String command) { return "200 OK ..."; }
    private String lend(String command)  { return "200 OK ..."; }

    @Override
    public void close() throws IOException {
        running = false;
        if (server != null) {
            server.close();
        }
        handlers.close();          // waits for the clients in flight to finish
        LOG.info("Server stopped");
    }

    public static void main(String[] args) throws IOException {
        try (var server = new CatalogServer()) {
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                try { server.close(); } catch (IOException ignored) { }
            }));
            server.start();
        }
    }
}

// PROBLEM: blocking inside synchronized
public class ProblematicCache {

    private final Map<String, Card> cache = new HashMap<>();

    public synchronized Card get(String isbn) {        // synchronized
        return cache.computeIfAbsent(isbn, key -> {
            return metadataClient.query(key);          // BLOCKS on the network -> PINNING
        });
    }
}

// SOLUTION: ReentrantLock, which DOES allow unmounting
public class CorrectCache {

    private final Map<String, Card> cache = new ConcurrentHashMap<>();
    private final ReentrantLock lock = new ReentrantLock();

    public Card get(String isbn) {
        Card existing = cache.get(isbn);
        if (existing != null) {
            return existing;
        }

        lock.lock();                        // ReentrantLock (08-04): no pinning
        try {
            return cache.computeIfAbsent(isbn, metadataClient::query);
        } finally {
            lock.unlock();
        }
    }
}

java -Djdk.tracePinnedThreads=full -jar bibliotech.jar

Thread[#31,ForkJoinPool-1-worker-1,5,CarrierThreads]
    com.nexussoftware.bibliotech.service.ProblematicCache.get(ProblematicCache.java:12)
    <== monitors:1

// POINTLESS: the task never blocks
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> computeExpensiveHash(data));   // pure CPU
    }
}

// With StructuredTaskScope: the scope CONTAINS the subtasks
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

    Subtask<Card> card = scope.fork(() -> metadataClient.query(isbn));
    Subtask<byte[]> cover = scope.fork(() -> coverClient.download(isbn));
    Subtask<List<String>> reviews = scope.fork(() -> reviewClient.find(isbn));

    scope.join();                  // waits for all three
    scope.throwIfFailed();         // if any failed, it throws and CANCELS the rest

    return new FullCard(card.get(), cover.get(), reviews.get());
}   // close() guarantees that no subtask is still alive

public class BiblioTechContext {

    // Immutable and scoped, unlike ThreadLocal
    public static final ScopedValue<String> EMPLOYEE = ScopedValue.newInstance();

    public void handleRequest(String employee, Runnable task) {
        ScopedValue.where(EMPLOYEE, employee).run(task);
        // Outside here, EMPLOYEE is not bound
    }

    public void somewhereDeepDown() {
        if (EMPLOYEE.isBound()) {
            LOG.info("Operation by " + EMPLOYEE.get());
        }
    }
}

jshell

jshell> var catalog = new java.util.ArrayList<String>()
catalog ==> []

jshell> catalog.add("Effective Java")
$2 ==> true

jshell> catalog.stream().map(String::toUpperCase).toList()
$3 ==> [EFFECTIVE JAVA]

jshell> java.time.LocalDate.now().plusDays(21)
$4 ==> 2026-08-26

jshell> /exit

java Hello.java

jpackage --name BiblioTech \
         --input dist/ \
         --main-jar bibliotech.jar \
         --main-class com.nexussoftware.bibliotech.BiblioTechApp \
         --runtime-image bibliotech-runtime \
         --type deb \
         --app-version 3.2

jwebserver -p 8000 -d /home/joan/bibliotech/reports

jdeps --jdk-internals bibliotech.jar

# 1. Detect uses of internal APIs BEFORE touching anything
jdeps --jdk-internals --multi-release 21 bibliotech.jar

# 2. Compile with the new version but an old target
javac --release 11 ...

# 3. Run with the new JVM and the old code, watching the warnings
java --illegal-access=warn -jar bibliotech.jar     # up to Java 16

# 4. Update dependencies ONE at a time, not all at once

# 5. Raise the compilation target
javac --release 21 ...

# 6. Modernise the code (optional and gradual):
#    var, expression switch, records, text blocks, streams

package com.nexussoftware.bibliotech.domain;

import java.util.List;

/**
 * SEALED root of the catalogue. An item is either a concrete material
 * or a collection that groups other items.
 */
public sealed interface CatalogItem permits Material, CatalogCollection {

    String getIsbn();
    String getTitle();
}

package com.nexussoftware.bibliotech.domain;

import java.util.List;
import java.util.Objects;

/**
 * A grouping of items. It can contain nested collections:
 * it is a recursive structure (the Composite pattern, formalised in 12-02).
 */
public record CatalogCollection(String isbn, String title, List<CatalogItem> items)
        implements CatalogItem {

    public CatalogCollection {
        Objects.requireNonNull(isbn, "isbn");
        Objects.requireNonNull(title, "title");
        items = List.copyOf(items);              // immutable defensive copy
    }

    @Override public String getIsbn()  { return isbn; }
    @Override public String getTitle() { return title; }
}

package com.nexussoftware.bibliotech.domain;

/**
 * Material hierarchy, CLOSED to four types.
 * Every subclass explicitly declares whether it can be extended.
 */
public sealed abstract class Material
        implements CatalogItem
        permits Book, Magazine, Dvd, AudioBook {

    private final String isbn;
    private final String title;
    private final double rating;

    protected Material(String isbn, String title, double rating) {
        this.isbn = isbn;
        this.title = title;
        this.rating = rating;
    }

    @Override public String getIsbn()  { return isbn; }
    @Override public String getTitle() { return title; }
    public double getRating()          { return rating; }
}

/** final: completely closed. */
public final class Book extends Material {
    private final String author;
    private final int pages;

    public Book(String isbn, String title, String author, int pages, double rating) {
        super(isbn, title, rating);
        this.author = author;
        this.pages = pages;
    }
    public String getAuthor() { return author; }
    public int getPages()     { return pages; }
}

/** sealed: its own closed hierarchy of two frequencies. */
public sealed class Magazine extends Material
        permits MonthlyMagazine, QuarterlyMagazine {

    private final int number;

    protected Magazine(String isbn, String title, int number, double rating) {
        super(isbn, title, rating);
        this.number = number;
    }
    public int getNumber() { return number; }
}

public final class MonthlyMagazine extends Magazine {
    private final java.time.Month month;
    public MonthlyMagazine(String isbn, String title, int number,
                           java.time.Month month, double rating) {
        super(isbn, title, number, rating);
        this.month = month;
    }
    public java.time.Month getMonth() { return month; }
}

public final class QuarterlyMagazine extends Magazine {
    private final int quarter;
    public QuarterlyMagazine(String isbn, String title, int number,
                             int quarter, double rating) {
        super(isbn, title, number, rating);
        this.quarter = quarter;
    }
    public int getQuarter() { return quarter; }
}

/** final. */
public final class Dvd extends Material {
    private final String director;
    private final int minutes;
    public Dvd(String isbn, String title, String director, int minutes, double rating) {
        super(isbn, title, rating);
        this.director = director;
        this.minutes = minutes;
    }
    public String getDirector() { return director; }
    public int getMinutes()     { return minutes; }
}

/** non-sealed: DELIBERATELY open to extension by third parties. */
public non-sealed class AudioBook extends Material {
    private final String narrator;
    private final int minutes;
    public AudioBook(String isbn, String title, String narrator, int minutes, double rating) {
        super(isbn, title, rating);
        this.narrator = narrator;
        this.minutes = minutes;
    }
    public String getNarrator() { return narrator; }
    public int getMinutes()     { return minutes; }
}

package com.nexussoftware.bibliotech.domain;

import java.util.List;

/** Sum type for the result of a search. */
public sealed interface SearchResult {

    record Found(Material material) implements SearchResult { }

    record NotFound(String query, List<String> suggestions) implements SearchResult { }

    record Ambiguous(String query, List<Material> candidates) implements SearchResult { }
}

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.*;

/**
 * Every switch is EXHAUSTIVE and has no default.
 * If a fifth material is added, none of them compiles.
 */
public class CatalogService {

    public int termDays(Material material) {
        return switch (material) {
            case Book b when b.getPages() > 500     -> 30;
            case Book b when b.getPages() > 200     -> 21;
            case Book b                             -> 14;
            case MonthlyMagazine m                  -> 7;
            case QuarterlyMagazine q                -> 14;
            case Dvd d when d.getMinutes() > 180    -> 5;
            case Dvd d                              -> 3;
            case AudioBook a                        -> 21;
        };
        // Magazine is sealed: the compiler accepts covering its two subtypes
        // instead of Magazine, and checks that both are there.
    }

    public double replacementValue(Material material) {
        return switch (material) {
            case Book b               -> Math.max(15.0, b.getPages() * 0.08);
            case MonthlyMagazine m    -> 8.0;
            case QuarterlyMagazine q  -> 14.0;
            case Dvd d                -> Math.max(10.0, d.getMinutes() * 0.15);
            case AudioBook a          -> Math.max(20.0, a.getMinutes() * 0.10);
        };
    }

    public String shelfLabel(CatalogItem item) {
        String prefix = switch (item) {
            case Book b               -> "BOO";
            case MonthlyMagazine m    -> "MMG";
            case QuarterlyMagazine q  -> "QMG";
            case Dvd d                -> "DVD";
            case AudioBook a          -> "AUD";
            case CatalogCollection c  -> "COL";
        };
        return prefix + "-" + item.getIsbn().substring(4, 8);
    }

    /** A card with text blocks and formatted (Java 15). */
    public String card(CatalogItem item) {
        return switch (item) {

            case Book b -> """
                    ┌─ BOOK ──────────────────────────────
                    │ %s
                    │ Author:      %s
                    │ Pages:       %d
                    │ Shelf:       %s
                    │ Term:        %d days
                    │ Replacement: %.2f EUR
                    └─────────────────────────────────────"""
                    .formatted(b.getTitle(), b.getAuthor(), b.getPages(),
                               shelfLabel(b), termDays(b), replacementValue(b));

            case MonthlyMagazine m -> """
                    ┌─ MONTHLY MAGAZINE ──────────────────
                    │ %s no. %d (%s)
                    │ Shelf:       %s
                    │ Term:        %d days
                    └─────────────────────────────────────"""
                    .formatted(m.getTitle(), m.getNumber(), m.getMonth(),
                               shelfLabel(m), termDays(m));

            case QuarterlyMagazine q -> """
                    ┌─ QUARTERLY MAGAZINE ────────────────
                    │ %s no. %d (Q%d)
                    │ Shelf:       %s
                    │ Term:        %d days
                    └─────────────────────────────────────"""
                    .formatted(q.getTitle(), q.getNumber(), q.getQuarter(),
                               shelfLabel(q), termDays(q));

            case Dvd d -> """
                    ┌─ DVD ───────────────────────────────
                    │ %s
                    │ Director:    %s
                    │ Duration:    %d min
                    │ Term:        %d days
                    └─────────────────────────────────────"""
                    .formatted(d.getTitle(), d.getDirector(), d.getMinutes(), termDays(d));

            case AudioBook a -> """
                    ┌─ AUDIOBOOK ─────────────────────────
                    │ %s
                    │ Narrator:    %s
                    │ Duration:    %d min
                    │ Term:        %d days
                    └─────────────────────────────────────"""
                    .formatted(a.getTitle(), a.getNarrator(), a.getMinutes(), termDays(a));

            case CatalogCollection(var isbn, var title, var items) -> """
                    ┌─ COLLECTION ────────────────────────
                    │ %s
                    │ Items:       %d direct, %d in total
                    │ Shelf:       %s
                    └─────────────────────────────────────"""
                    .formatted(title, items.size(),
                               countMaterials(item), shelfLabel(item));
        };
    }

    /**
     * RECURSIVE with a record pattern: the collection is deconstructed
     * and we descend through its items.
     */
    public int countMaterials(CatalogItem item) {
        return switch (item) {
            case Material m -> 1;
            case CatalogCollection(var isbn, var title, var items) ->
                    items.stream()
                         .mapToInt(this::countMaterials)          // recursion
                         .sum();
        };
    }

    /** Maximum nesting depth. */
    public int depth(CatalogItem item) {
        return switch (item) {
            case Material m -> 0;
            case CatalogCollection(var isbn, var title, var items) ->
                    1 + items.stream()
                             .mapToInt(this::depth)
                             .max().orElse(0);
        };
    }

    /** The search result, also with an exhaustive switch. */
    public String describeSearch(SearchResult result) {
        return switch (result) {

            case SearchResult.Found(Material m) ->
                    "Found: " + m.getTitle();

            case SearchResult.NotFound(var query, var suggestions)
                    when suggestions.isEmpty() ->
                    "No results for \"" + query + "\"";

            case SearchResult.NotFound(var query, var suggestions) ->
                    "No results for \"" + query + "\". Did you mean: "
                    + String.join(", ", suggestions) + "?";

            case SearchResult.Ambiguous(var query, var candidates) ->
                    candidates.size() + " matches for \"" + query + "\": "
                    + candidates.stream().map(Material::getTitle)
                                .collect(java.util.stream.Collectors.joining(", "));
        };
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domain.*;
import com.nexussoftware.bibliotech.service.CatalogService;

import java.time.Month;
import java.util.List;

public class SealedCatalogTest {

    public static void main(String[] args) {

        CatalogService service = new CatalogService();

        Book effective = new Book("978-0000000001", "Effective Java", "Joshua Bloch", 412, 4.85);
        Book patterns = new Book("978-0000000002", "Design Patterns", "GoF", 395, 4.60);
        Book refactor = new Book("978-0000000003", "Refactoring", "M. Fowler", 448, 4.72);
        MonthlyMagazine javaMag = new MonthlyMagazine("978-0000000010", "Java Magazine",
                                                      142, Month.AUGUST, 3.90);
        Dvd springCourse = new Dvd("978-0000000020", "Spring Course", "N. Vidal", 240, 4.10);
        AudioBook audio = new AudioBook("978-0000000030", "Clean Code (audio)",
                                        "D. Alonso", 480, 4.30);

        // NESTED collection
        CatalogCollection essentials = new CatalogCollection("978-1000000001", "Java Essentials",
                List.of(effective, patterns, refactor));

        CatalogCollection multimedia = new CatalogCollection("978-1000000002", "Multimedia Training",
                List.of(springCourse, audio));

        CatalogCollection whole = new CatalogCollection("978-1000000000", "Nexus Technical Library",
                List.of(essentials, multimedia, javaMag));

        System.out.println(service.card(effective));
        System.out.println(service.card(javaMag));
        System.out.println(service.card(audio));
        System.out.println(service.card(whole));

        System.out.println();
        System.out.println("Total materials: " + service.countMaterials(whole));
        System.out.println("Depth:           " + service.depth(whole));

        System.out.println();
        System.out.println(service.describeSearch(
                new SearchResult.Found(effective)));
        System.out.println(service.describeSearch(
                new SearchResult.NotFound("kotlin", List.of())));
        System.out.println(service.describeSearch(
                new SearchResult.NotFound("javaa", List.of("Effective Java"))));
        System.out.println(service.describeSearch(
                new SearchResult.Ambiguous("java", List.of(effective, audio))));
    }
}

┌─ BOOK ──────────────────────────────
│ Effective Java
│ Author:      Joshua Bloch
│ Pages:       412
│ Shelf:       BOO-0000
│ Term:        21 days
│ Replacement: 32.96 EUR
└─────────────────────────────────────
┌─ MONTHLY MAGAZINE ──────────────────
│ Java Magazine no. 142 (AUGUST)
│ Shelf:       MMG-0000
│ Term:        7 days
└─────────────────────────────────────
┌─ AUDIOBOOK ─────────────────────────
│ Clean Code (audio)
│ Narrator:    D. Alonso
│ Duration:    480 min
│ Term:        21 days
└─────────────────────────────────────
┌─ COLLECTION ────────────────────────
│ Nexus Technical Library
│ Items:       3 direct, 6 in total
│ Shelf:       COL-1000
└─────────────────────────────────────

Total materials: 6
Depth:           2

Found: Effective Java
No results for "kotlin"
No results for "javaa". Did you mean: Effective Java?
2 matches for "java": Effective Java, Clean Code (audio)

public sealed abstract class Material
        implements CatalogItem
        permits Book, Magazine, Dvd, AudioBook, MapSheet { }

public final class MapSheet extends Material { /* ... */ }

CatalogService.java:14: error: the switch expression does not cover all possible input values
        return switch (material) {
               ^
CatalogService.java:27: error: the switch expression does not cover all possible input values
        return switch (material) {
               ^
CatalogService.java:37: error: the switch expression does not cover all possible input values
        String prefix = switch (item) {
                        ^
CatalogService.java:49: error: the switch expression does not cover all possible input values
        return switch (item) {
               ^
4 errors

package com.nexussoftware.bibliotech.network;

import java.time.Duration;
import java.util.*;
import java.util.concurrent.*;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Catalogue enricher with VIRTUAL THREADS.
 * It replaces the CompletableFuture-based version from 09-06.
 */
public class VirtualEnricher implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(VirtualEnricher.class.getName());

    /** Sum type for the result of each ISBN. */
    public sealed interface EnrichmentResult {
        String isbn();

        record Complete(String isbn, String metadata, int coverBytes, long ms)
                implements EnrichmentResult { }

        record Partial(String isbn, String metadata, String coverFailureReason, long ms)
                implements EnrichmentResult { }

        record Failed(String isbn, String reason, long ms)
                implements EnrichmentResult { }
    }

    /**
     * A semaphore, NOT a pool size: the constraint belongs to the
     * external service, not to our threads.
     */
    private final Semaphore externalLimit;

    private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

    private final MetadataClient metadata;
    private final CoverClient covers;

    public VirtualEnricher(MetadataClient metadata, CoverClient covers,
                           int simultaneousRequests) {
        this.metadata = metadata;
        this.covers = covers;
        this.externalLimit = new Semaphore(simultaneousRequests);
    }

    public List<EnrichmentResult> enrich(List<String> isbns) {

        List<Future<EnrichmentResult>> futures = new ArrayList<>(isbns.size());

        // ALL of them are launched: one virtual thread per ISBN, be it 100 or 100,000
        for (String isbn : isbns) {
            futures.add(executor.submit(() -> processOne(isbn)));
        }

        List<EnrichmentResult> results = new ArrayList<>(isbns.size());
        for (int i = 0; i < futures.size(); i++) {
            try {
                results.add(futures.get(i).get());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            } catch (ExecutionException e) {
                results.add(new EnrichmentResult.Failed(
                        isbns.get(i), "unhandled exception: " + e.getCause(), 0));
            }
        }
        return results;
    }

    /**
     * SEQUENTIAL, BLOCKING CODE. Not a single thenCompose, not a
     * thenCombine, not a callback. It reads top to bottom.
     */
    private EnrichmentResult processOne(String isbn) {

        long start = System.nanoTime();
        Thread.currentThread().setName("enrich-" + isbn);

        try {
            // 1. Metadata: it blocks, and that is fine
            String data;
            externalLimit.acquire();
            try {
                data = metadata.query(isbn);             // BLOCKING call
            } finally {
                externalLimit.release();
            }

            // 2. Cover: it can fail without invalidating the result
            int bytes;
            try {
                externalLimit.acquire();
                try {
                    bytes = covers.download(isbn).length;
                } finally {
                    externalLimit.release();
                }
            } catch (Exception e) {
                return new EnrichmentResult.Partial(
                        isbn, data, e.getClass().getSimpleName(), ms(start));
            }

            return new EnrichmentResult.Complete(isbn, data, bytes, ms(start));

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new EnrichmentResult.Failed(isbn, "interrupted", ms(start));

        } catch (Exception e) {
            LOG.log(Level.FINE, e, () -> "Failure enriching " + isbn);
            return new EnrichmentResult.Failed(
                    isbn, e.getClass().getSimpleName() + ": " + e.getMessage(), ms(start));
        }
    }

    private long ms(long startNanos) {
        return (System.nanoTime() - startNanos) / 1_000_000;
    }

    /** Report with an exhaustive switch over the sealed type. */
    public String report(List<EnrichmentResult> results) {

        Map<String, Long> byType = results.stream()
                .collect(java.util.stream.Collectors.groupingBy(
                        r -> switch (r) {
                            case EnrichmentResult.Complete c -> "complete";
                            case EnrichmentResult.Partial p  -> "partial";
                            case EnrichmentResult.Failed f   -> "failed";
                        },
                        java.util.TreeMap::new,
                        java.util.stream.Collectors.counting()));

        double averageMs = results.stream()
                .mapToLong(r -> switch (r) {
                    case EnrichmentResult.Complete c -> c.ms();
                    case EnrichmentResult.Partial p  -> p.ms();
                    case EnrichmentResult.Failed f   -> f.ms();
                })
                .average().orElse(0);

        return """
                Enrichment of %d ISBNs
                  %s
                  Average time per ISBN: %.1f ms"""
                .formatted(results.size(), byType, averageMs);
    }

    @Override
    public void close() {
        executor.close();        // ExecutorService is AutoCloseable since Java 19
    }
}

package com.nexussoftware.bibliotech;

import java.time.Duration;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.IntStream;

public class EnrichmentComparison {

    /** Simulates a network call: a 50 ms wait. */
    private static String simulatedQuery(String isbn) throws InterruptedException {
        Thread.sleep(Duration.ofMillis(50));
        return "{\"isbn\":\"" + isbn + "\"}";
    }

    public static void main(String[] args) throws Exception {

        System.out.printf("%-10s %14s %14s %14s%n",
                "ISBN", "PLATFORM (200)", "VIRTUAL", "COMPL.FUTURE");
        System.out.println("-".repeat(56));

        for (int n : new int[] { 100, 1_000, 10_000 }) {
            List<String> isbns = generate(n);

            long platform = measure(() -> withPlatformPool(isbns));
            long virtual  = measure(() -> withVirtualThreads(isbns));
            long futures  = measure(() -> withCompletableFuture(isbns));

            System.out.printf("%-10d %11d ms %11d ms %11d ms%n",
                    n, platform, virtual, futures);
        }

        System.out.println();
        demonstratePinning();
    }

    private static List<String> generate(int n) {
        return IntStream.rangeClosed(1, n)
                .mapToObj(i -> String.format("978-%010d", i))
                .toList();
    }

    private static long measure(Runnable task) {
        long start = System.currentTimeMillis();
        task.run();
        return System.currentTimeMillis() - start;
    }

    private static void withPlatformPool(List<String> isbns) {
        try (var executor = Executors.newFixedThreadPool(200)) {
            List<Future<String>> futures = isbns.stream()
                    .map(isbn -> executor.submit(() -> simulatedQuery(isbn)))
                    .toList();
            futures.forEach(EnrichmentComparison::get);
        }
    }

    private static void withVirtualThreads(List<String> isbns) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = isbns.stream()
                    .map(isbn -> executor.submit(() -> simulatedQuery(isbn)))
                    .toList();
            futures.forEach(EnrichmentComparison::get);
        }
    }

    private static void withCompletableFuture(List<String> isbns) {
        try (var executor = Executors.newFixedThreadPool(200)) {
            List<CompletableFuture<String>> futures = isbns.stream()
                    .map(isbn -> CompletableFuture.supplyAsync(() -> {
                        try {
                            return simulatedQuery(isbn);
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            return null;
                        }
                    }, executor))
                    .toList();
            CompletableFuture.allOf(futures.toArray(CompletableFuture[]::new)).join();
        }
    }

    private static <T> T get(Future<T> f) {
        try {
            return f.get();
        } catch (Exception e) {
            return null;
        }
    }

    // ------------------------------------------------------------------
    // PINNING demonstration
    // ------------------------------------------------------------------

    static class WithSynchronized {
        private final Map<String, String> cache = new HashMap<>();

        /** synchronized + blocking -> PINNING of the carrier thread. */
        public synchronized String get(String isbn) throws InterruptedException {
            String v = cache.get(isbn);
            if (v == null) {
                v = simulatedQuery(isbn);
                cache.put(isbn, v);
            }
            return v;
        }
    }

    static class WithReentrantLock {
        private final Map<String, String> cache = new ConcurrentHashMap<>();
        private final ReentrantLock lock = new ReentrantLock();

        /** ReentrantLock lets the virtual thread unmount. */
        public String get(String isbn) throws InterruptedException {
            String v = cache.get(isbn);
            if (v != null) {
                return v;
            }
            lock.lock();
            try {
                v = cache.get(isbn);
                if (v == null) {
                    v = simulatedQuery(isbn);
                    cache.put(isbn, v);
                }
                return v;
            } finally {
                lock.unlock();
            }
        }
    }

    private static void demonstratePinning() {
        System.out.println("--- Pinning (run with -Djdk.tracePinnedThreads=full) ---");
        List<String> isbns = generate(500);

        WithSynchronized withSync = new WithSynchronized();
        long t1 = measure(() -> {
            try (var e = Executors.newVirtualThreadPerTaskExecutor()) {
                isbns.forEach(isbn -> e.submit(() -> withSync.get(isbn)));
            }
        });

        WithReentrantLock withLock = new WithReentrantLock();
        long t2 = measure(() -> {
            try (var e = Executors.newVirtualThreadPerTaskExecutor()) {
                isbns.forEach(isbn -> e.submit(() -> withLock.get(isbn)));
            }
        });

        System.out.printf("  synchronized:  %5d ms%n", t1);
        System.out.printf("  ReentrantLock: %5d ms%n", t2);
    }
}

ISBN       PLATFORM (200)        VIRTUAL   COMPL.FUTURE
--------------------------------------------------------
100                  62 ms          58 ms          64 ms
1000                306 ms          71 ms         301 ms
10000              2571 ms         139 ms        2559 ms

--- Pinning (run with -Djdk.tracePinnedThreads=full) ---
  synchronized:  25142 ms
  ReentrantLock: 25089 ms

package com.nexussoftware.bibliotech.tools;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Detects modernisation opportunities in Java code.
 *
 * This is a regular-expression analysis: fast and approximate.
 * A real analyser would work on the AST (javax.lang.model, 10-02).
 */
public class ModernisationAnalyser {

    /** Sealed type for the finding categories. */
    public sealed interface Finding {
        Path file();
        int line();
        int javaVersion();
        String suggestion();

        record MultilineConcatenation(Path file, int line) implements Finding {
            public int javaVersion() { return 15; }
            public String suggestion() { return "Use a text block \"\"\"...\"\"\""; }
        }
        record ClassicSwitch(Path file, int line) implements Finding {
            public int javaVersion() { return 14; }
            public String suggestion() { return "Use an expression switch with ->"; }
        }
        record CastAfterInstanceof(Path file, int line, String type) implements Finding {
            public int javaVersion() { return 16; }
            public String suggestion() { return "Use instanceof " + type + " variable"; }
        }
        record LegacyDateApi(Path file, int line, String className) implements Finding {
            public int javaVersion() { return 8; }
            public String suggestion() {
                return switch (className) {
                    case "SimpleDateFormat" -> "Use DateTimeFormatter (immutable and thread-safe)";
                    case "Calendar"         -> "Use LocalDate / LocalDateTime";
                    case "Date"             -> "Use Instant or LocalDate as appropriate";
                    default                 -> "Migrate to java.time";
                };
            }
        }
        record PlatformPool(Path file, int line) implements Finding {
            public int javaVersion() { return 21; }
            public String suggestion() {
                return "If the tasks block, use Executors.newVirtualThreadPerTaskExecutor()";
            }
        }
        record AccumulatorLoop(Path file, int line) implements Finding {
            public int javaVersion() { return 8; }
            public String suggestion() { return "Consider stream().filter(...).map(...).toList()"; }
        }
        record RecordCandidate(Path file, int line, String className) implements Finding {
            public int javaVersion() { return 16; }
            public String suggestion() { return "Class " + className + " could be a record"; }
        }
    }

    // --- Patterns ---
    private static final Pattern CONCATENATION = Pattern.compile("^\\s*\\+\\s*\"");
    private static final Pattern CLASSIC_SWITCH = Pattern.compile("\\bcase\\s+[^>]+:\\s*$");
    private static final Pattern INSTANCEOF_NO_PATTERN =
            Pattern.compile("instanceof\\s+(\\w+)\\s*\\)\\s*\\{?\\s*$");
    private static final Pattern CAST = Pattern.compile("\\(\\s*(\\w+)\\s*\\)\\s*\\w+");
    private static final Pattern LEGACY_DATES =
            Pattern.compile("\\bnew\\s+(SimpleDateFormat|Date|GregorianCalendar)\\b"
                          + "|\\bCalendar\\.getInstance\\(\\)");
    private static final Pattern FIXED_POOL =
            Pattern.compile("Executors\\.newFixedThreadPool|Executors\\.newCachedThreadPool");
    private static final Pattern LIST_DECLARATION =
            Pattern.compile("(List|Set|Map)<[^>]+>\\s+\\w+\\s*=\\s*new\\s+(ArrayList|HashSet|HashMap)");
    private static final Pattern FOR_EACH = Pattern.compile("\\bfor\\s*\\(\\s*\\w+.*:\\s*\\w+");

    public List<Finding> analyse(Path root) throws IOException {
        try (Stream<Path> files = Files.walk(root)) {
            return files
                    .filter(Files::isRegularFile)
                    .filter(p -> p.toString().endsWith(".java"))
                    .filter(p -> !p.getFileName().toString().equals("module-info.java"))
                    .flatMap(this::analyseFile)
                    .toList();
        }
    }

    private Stream<Finding> analyseFile(Path file) {
        try {
            List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);
            List<Finding> findings = new ArrayList<>();

            String possibleInstanceofType = null;
            int instanceofLine = 0;
            int declarationLines = 0;
            int declarationStart = 0;

            for (int i = 0; i < lines.size(); i++) {
                String line = lines.get(i);
                int number = i + 1;

                if (CONCATENATION.matcher(line).find()) {
                    findings.add(new Finding.MultilineConcatenation(file, number));
                }
                if (CLASSIC_SWITCH.matcher(line).find()) {
                    findings.add(new Finding.ClassicSwitch(file, number));
                }
                if (LEGACY_DATES.matcher(line).find()) {
                    var m = LEGACY_DATES.matcher(line);
                    m.find();
                    String className = m.group(1) != null ? m.group(1) : "Calendar";
                    findings.add(new Finding.LegacyDateApi(file, number, className));
                }
                if (FIXED_POOL.matcher(line).find()) {
                    findings.add(new Finding.PlatformPool(file, number));
                }

                // instanceof on one line, a cast to the same type on the next
                var mi = INSTANCEOF_NO_PATTERN.matcher(line);
                if (mi.find()) {
                    possibleInstanceofType = mi.group(1);
                    instanceofLine = number;
                } else if (possibleInstanceofType != null) {
                    var mc = CAST.matcher(line);
                    if (mc.find() && possibleInstanceofType.equals(mc.group(1))) {
                        findings.add(new Finding.CastAfterInstanceof(
                                file, instanceofLine, possibleInstanceofType));
                    }
                    possibleInstanceofType = null;
                }

                // A collection declaration followed by a for-each loop: a stream candidate
                if (LIST_DECLARATION.matcher(line).find()) {
                    declarationLines = 1;
                    declarationStart = number;
                } else if (declarationLines > 0 && declarationLines < 4) {
                    if (FOR_EACH.matcher(line).find()) {
                        findings.add(new Finding.AccumulatorLoop(file, declarationStart));
                        declarationLines = 0;
                    } else {
                        declarationLines++;
                    }
                } else {
                    declarationLines = 0;
                }
            }

            detectRecordCandidate(file, lines).ifPresent(findings::add);
            return findings.stream();

        } catch (IOException e) {
            System.err.println("Could not read " + file + ": " + e.getMessage());
            return Stream.empty();
        }
    }

    /** Heuristic: only final fields, getters, equals, hashCode and toString. */
    private Optional<Finding> detectRecordCandidate(Path file, List<String> lines) {
        String content = String.join("\n", lines);

        boolean hasSetters = content.contains("public void set");
        boolean hasNonFinalFields = Pattern
                .compile("private\\s+(?!final)\\w+\\s+\\w+\\s*;").matcher(content).find();
        boolean hasEquals = content.contains("public boolean equals(Object");
        boolean hasHashCode = content.contains("public int hashCode()");
        boolean extendsSomething = Pattern.compile("class\\s+\\w+\\s+extends").matcher(content).find();

        if (!hasSetters && !hasNonFinalFields && hasEquals && hasHashCode && !extendsSomething) {
            String name = file.getFileName().toString().replace(".java", "");
            int line = 1 + (int) lines.stream()
                    .takeWhile(l -> !l.contains("class " + name))
                    .count();
            return Optional.of(new Finding.RecordCandidate(file, line, name));
        }
        return Optional.empty();
    }

    // ------------------------------------------------------------------

    public String report(List<Finding> findings, int targetVersion) {

        Map<String, List<Finding>> byType = findings.stream()
                .collect(Collectors.groupingBy(f -> f.getClass().getSimpleName(),
                         TreeMap::new, Collectors.toList()));

        Map<Integer, Long> byVersion = findings.stream()
                .collect(Collectors.groupingBy(Finding::javaVersion,
                         TreeMap::new, Collectors.counting()));

        long applicable = findings.stream()
                .filter(f -> f.javaVersion() <= targetVersion)
                .count();

        StringBuilder sb = new StringBuilder();
        sb.append("""
                ════════════════════════════════════════════════════
                  MODERNISATION REPORT -- target: Java %d
                ════════════════════════════════════════════════════
                  Total findings:        %d
                  Applicable today:      %d
                  Require migrating:     %d
                """.formatted(targetVersion, findings.size(),
                              applicable, findings.size() - applicable));

        sb.append("\nBY MINIMUM VERSION REQUIRED\n");
        byVersion.forEach((v, n) -> sb.append(String.format(
                "  Java %-3d %4d  %s%s%n", v, n, "▇".repeat((int) Math.min(n, 40)),
                v <= targetVersion ? "" : "   (requires migrating)")));

        sb.append("\nBY TYPE\n");
        byType.forEach((type, list) -> {
            sb.append(String.format("  %-26s %4d%n", type, list.size()));
            list.stream().limit(3).forEach(f -> sb.append(String.format(
                    "      %s:%d  %s%n",
                    f.file().getFileName(), f.line(), f.suggestion())));
            if (list.size() > 3) {
                sb.append(String.format("      ... and %d more%n", list.size() - 3));
            }
        });

        return sb.toString();
    }

    public static void main(String[] args) throws IOException {
        Path root = Path.of(args.length > 0 ? args[0] : "src");
        int target = args.length > 1 ? Integer.parseInt(args[1]) : 21;

        ModernisationAnalyser analyser = new ModernisationAnalyser();
        List<Finding> findings = analyser.analyse(root);

        System.out.println(analyser.report(findings, target));
    }
}

════════════════════════════════════════════════════
  MODERNISATION REPORT -- target: Java 21
════════════════════════════════════════════════════
  Total findings:        47
  Applicable today:      47
  Require migrating:     0

BY MINIMUM VERSION REQUIRED
  Java 8     14  ▇▇▇▇▇▇▇▇▇▇▇▇▇▇
  Java 14     9  ▇▇▇▇▇▇▇▇▇
  Java 15    11  ▇▇▇▇▇▇▇▇▇▇▇
  Java 16     8  ▇▇▇▇▇▇▇▇
  Java 21     5  ▇▇▇▇▇

BY TYPE
  AccumulatorLoop                5
      BiblioTechStatistics.java:19  Consider stream().filter(...).map(...).toList()
      BiblioTechMenu.java:88  Consider stream().filter(...).map(...).toList()
      ... and 3 more
  CastAfterInstanceof            8
      LegacyTermCalculator.java:14  Use instanceof Book variable
      CsvCatalogExporter.java:41  Use instanceof Material variable
      ... and 6 more
  ClassicSwitch                  6
      BiblioTechMenu.java:52  Use an expression switch with ->
      ... and 5 more
  LegacyDateApi                  9
      SessionManager.java:34  Use DateTimeFormatter (immutable and thread-safe)
      LoanStore.java:57  Use LocalDate / LocalDateTime
      OperationLog.java:22  Use Instant or LocalDate as appropriate
      ... and 6 more
  MultilineConcatenation        11
      BiblioTechQueries.java:12  Use a text block """..."""
      MetadataClient.java:73  Use a text block """..."""
      ... and 9 more
  PlatformPool                   5
      PooledCatalogServer.java:24  If the tasks block, use Executors.newVirtualThreadPerTaskExecutor()
      ... and 4 more
  RecordCandidate                3
      Card.java:8  Class Card could be a record
      SessionSummary.java:11  Class SessionSummary could be a record
      ... and 1 more