Chapter 2 · Java

Java: What is Artificial Intelligence?

Run this example

Edit and run the java example

Change the source and run it here. Use the output panel to compare your result with the expected highlights below.

AiSystemClassifier.java

import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

/**
 * Describe AI systems on six axes, check the descriptions, and price the authority
 * decision. Ports examples/ai_system_classifier.py.
 *
 * Part 1  Four real systems on six axes; authority recorded as the effects an output may
 *         have and mapped to the Sheridan-Verplank scale.
 * Part 2  Consistency checks, including the one behind Moffatt v. Air Canada (2024).
 * Part 3  Expected monthly cost of no review, full review and risk-routed review.
 *
 * Standard library only, JDK 21 single-file mode; prints the same bytes as the Python version.
 */
public class AiSystemClassifier {

record Level(String name, String scale) {}

static final Map<String, Level> EFFECTS = Map.of(
        "display", new Level("inform", "2-3"),
        "suggest", new Level("recommend", "4"),
        "prepare", new Level("draft", "5"),
        "state_policy", new Level("execute: a statement the company must honour", "7"),
        "act_reversible", new Level("execute, reversible", "7-8"),
        "act", new Level("execute", "9-10"));
    static final List<String> ORDER = List.of("display", "suggest", "prepare", "state_policy", "act_reversible", "act");

record Profile(String name, String field, List<String> method, String family, List<String> capability,
                   String application, List<String> effects, List<String> controls) {}

static final List<Profile> SYSTEMS = List.of(
        new Profile("Gmail spam filtering", "AI: natural language processing", List.of("machine learning"),
            "neural text classifier (RETVec vectorizer, 2023)", List.of("classify"), "email client",
            List.of("act_reversible"), List.of("user can move mail back", "spam folder visible")),
        new Profile("GitHub Copilot inline suggestions", "AI: code generation", List.of("machine learning"),
            "large language model", List.of("generate"), "code editor",
            List.of("display", "prepare"), List.of("human approval")),
        new Profile("Waymo Driver", "AI: robotics and perception", List.of("machine learning", "planning", "rules"),
            "neural networks for perception and prediction", List.of("perceive", "predict", "plan", "act"), "ride-hailing",
            List.of("act"), List.of("operational design domain", "remote advice, never remote driving")),
        new Profile("Air Canada website chatbot (2022)", "not disclosed", List.of("not disclosed"),
            "not disclosed", List.of("answer questions"), "airline customer service",
            List.of("display", "state_policy"), List.of("link to policy page")),
        new Profile("Refund bot (a flawed proposal)", "AI", List.of("prompting"),
            "Generative AI", List.of("generate", "act"), "customer refunds",
            List.of("state_policy", "act"), List.of("monitoring")));

static String fmt(String pattern, Object... args) {
        return String.format(Locale.ROOT, pattern, args);
    }

static Level authority(List<String> effects) {
        String top = effects.get(0);
        for (String effect : effects) if (ORDER.indexOf(effect) > ORDER.indexOf(top)) top = effect;
        return EFFECTS.get(top);
    }

static boolean anyOf(List<String> controls, Set<String> wanted) {
        for (String control : controls) if (wanted.contains(control)) return true;
        return false;
    }

static List<String> check(Profile p) {
        java.util.ArrayList<String> problems = new java.util.ArrayList<>();
        if (p.family().equals("Generative AI")) {
            problems.add("'Generative AI' is a capability, not a model family");
        }
        if (p.family().contains("large language model") && !p.method().contains("machine learning")) {
            problems.add("an LLM is a learned model, so the method must include machine learning");
        }
        if (p.effects().contains("act") && !anyOf(p.controls(), Set.of("human approval", "rollback", "operational design domain"))) {
            problems.add("irreversible action with no approval step, rollback or operating envelope");
        }
        if (p.effects().contains("state_policy") && !anyOf(p.controls(), Set.of("answers quote canonical policy", "human approval"))) {
            problems.add("customer-facing policy statements bind the company; ground them in the canonical policy or route them to a person");
        }
        return problems;
    }

static void sixAxes() {
        System.out.println("=== Parts 1 and 2: Five systems on six axes, with consistency checks ===");
        for (Profile p : SYSTEMS) {
            Level level = authority(p.effects());
            System.out.println(p.name());
            System.out.println("  field        " + p.field());
            System.out.println("  method       " + String.join(", ", p.method()));
            System.out.println("  model family " + p.family());
            System.out.println("  capability   " + String.join(", ", p.capability()));
            System.out.println("  application  " + p.application());
            System.out.println("  authority    " + level.name() + "; Sheridan-Verplank level " + level.scale());
            System.out.println("  effects      " + String.join(", ", p.effects()));
            List<String> problems = check(p);
            if (problems.isEmpty()) System.out.println("  checks       consistent");
            for (String problem : problems) System.out.println("  CHECK FAILED " + problem);
        }
    }

// --- Part 3: the review decision -----------------------------------------------------------

static final int CONVERSATIONS = 100_000;  // per month (illustrative)
    static final double RELIED_ON = 0.10;      // share of wrong policy answers acted on (illustrative)
    static final double ERROR_COST = 812.02;   // C$ per relied-upon wrong answer: the Moffatt award
    static final double REVIEW_MINUTES = 1.5;  // per reviewed conversation (illustrative)
    static final double WAGE = 40.0;           // C$ per reviewer hour (illustrative)
    static final double CATCH = 0.90;          // share of wrong answers a reviewer catches (illustrative)
    static final double ROUTED = 0.10;         // share of conversations routed to review
    static final double ROUTED_ERRORS = 0.80;  // share of costly wrong answers in routed conversations

/** Round half up to a whole number, identically in Python and Java. */
    static long whole(double value) {
        return (long) Math.floor(value + 0.5);
    }

static double[] policyCosts(double errorRate) {
        double perReview = REVIEW_MINUTES / 60 * WAGE;
        double expectedErrors = CONVERSATIONS * errorRate * RELIED_ON * ERROR_COST;
        double none = expectedErrors;
        double full = CONVERSATIONS * perReview + expectedErrors * (1 - CATCH);
        double routed = CONVERSATIONS * ROUTED * perReview + expectedErrors * (1 - CATCH * ROUTED_ERRORS);
        return new double[] {none, full, routed};
    }

static void reviewDecision() {
        System.out.println("=== Part 3: Expected monthly cost of three review policies (C$) ===");
        System.out.println(fmt("%,d conversations a month; %.0f%% of wrong answers acted on at C$%,.2f each; "
            + "review %s min at C$%.0f/h catching %.0f%%.", CONVERSATIONS, RELIED_ON * 100, ERROR_COST,
            String.valueOf(REVIEW_MINUTES), WAGE, CATCH * 100));
        System.out.println("error rate      no review    full review   risk-routed   cheapest");
        String[] names = {"no review", "full review", "risk-routed"};
        for (double rate : new double[] {0.001, 0.005, 0.01, 0.02, 0.05, 0.08}) {
            double[] costs = policyCosts(rate);
            int best = 0;
            for (int i = 1; i < costs.length; i++) if (costs[i] < costs[best]) best = i;
            System.out.println(fmt("%9.1f%%   %,11d   %,11d   %,11d   %s", rate * 100, whole(costs[0]),
                whole(costs[1]), whole(costs[2]), names[best]));
        }
        double perReview = REVIEW_MINUTES / 60 * WAGE;
        double unit = RELIED_ON * ERROR_COST * CATCH;
        double fullVsNone = perReview / unit;
        double routedVsNone = ROUTED * perReview / (unit * ROUTED_ERRORS);
        double fullVsRouted = (1 - ROUTED) * perReview / (unit * (1 - ROUTED_ERRORS));
        System.out.println(fmt("Full review beats no review above an error rate of %.2f%%.", fullVsNone * 100));
        System.out.println(fmt("Risk-routed review beats no review above %.2f%%, and full review beats risk-routed above %.2f%%.",
            routedVsNone * 100, fullVsRouted * 100));
    }

public static void main(String[] args) {
        sixAxes();
        System.out.println();
        reviewDecision();
    }
}

Output

Run the code to see output here.

Java - Six-Axis Profiles and the Review Decision

It prints the same bytes as the Python version: the profiles are fixed data, amounts are rounded half-up with the same helper in both languages, and all formatting uses Locale.ROOT.

How the program is organized

public class AiSystemClassifier {
    // Authority comes from the most powerful effect an output may have
    record Level(String name, String scale) {}                 // e.g. ("draft", "5")
    static final List<String> ORDER = List.of("display", "suggest", "prepare",
                                              "state_policy", "act_reversible", "act");

    // One record per system: the six axes plus effects and controls
    record Profile(String name, String field, List<String> method, String family,
                   List<String> capability, String application,
                   List<String> effects, List<String> controls) {}

    static List<String> check(Profile p) { ... }   // category errors and authority rules
    static double[] policyCosts(double errorRate) { ... }   // none, full, routed
}

Modelling authority as a list of effects, instead of a single ranked enum, keeps the reason for a rating visible: a reviewer can see that the Air Canada profile is rated as a binding statement because of state_policy, and that Copilot sits at draft because its strongest effect is prepare.

In a Spring service the Profile record fits naturally as the payload of an architecture-review endpoint: teams submit a profile with each design, and the same check rules run in CI so that a profile claiming execute authority without an approval step or a rollback fails the build.

Expected output

=== Parts 1 and 2: Five systems on six axes, with consistency checks ===
Gmail spam filtering
  field        AI: natural language processing
  method       machine learning
  model family neural text classifier (RETVec vectorizer, 2023)
  capability   classify
  application  email client
  authority    execute, reversible; Sheridan-Verplank level 7-8
  effects      act_reversible
  checks       consistent
GitHub Copilot inline suggestions
  field        AI: code generation
  method       machine learning
  model family large language model
  capability   generate
  application  code editor
  authority    draft; Sheridan-Verplank level 5
  effects      display, prepare
  checks       consistent
Waymo Driver
  field        AI: robotics and perception
  method       machine learning, planning, rules
  model family neural networks for perception and prediction
  capability   perceive, predict, plan, act
  application  ride-hailing
  authority    execute; Sheridan-Verplank level 9-10
  effects      act
  checks       consistent
Air Canada website chatbot (2022)
  field        not disclosed
  method       not disclosed
  model family not disclosed
  capability   answer questions
  application  airline customer service
  authority    execute: a statement the company must honour; Sheridan-Verplank level 7
  effects      display, state_policy
  CHECK FAILED customer-facing policy statements bind the company; ground them in the canonical policy or route them to a person
Refund bot (a flawed proposal)
  field        AI
  method       prompting
  model family Generative AI
  capability   generate, act
  application  customer refunds
  authority    execute; Sheridan-Verplank level 9-10
  effects      state_policy, act
  CHECK FAILED 'Generative AI' is a capability, not a model family
  CHECK FAILED irreversible action with no approval step, rollback or operating envelope
  CHECK FAILED customer-facing policy statements bind the company; ground them in the canonical policy or route them to a person

=== Part 3: Expected monthly cost of three review policies (C$) ===
100,000 conversations a month; 10% of wrong answers acted on at C$812.02 each; review 1.5 min at C$40/h catching 90%.
error rate      no review    full review   risk-routed   cheapest
      0.1%         8,120       100,812        12,274   no review
      0.5%        40,601       104,060        21,368   risk-routed
      1.0%        81,202       108,120        32,737   risk-routed
      2.0%       162,404       116,240        55,473   risk-routed
      5.0%       406,010       140,601       123,683   risk-routed
      8.0%       649,616       164,962       191,892   full review
Full review beats no review above an error rate of 1.37%.
Risk-routed review beats no review above 0.17%, and full review beats risk-routed above 6.16%.