Learn Java & Kotlin from absolute zero

public class Hello {
    public static void main(String[] args) {
        String name = args.length > 0 ? args[0] : "world";
        System.out.printf("Hello, %s!%n", name);
    }
}

javac Hello.java          # step 1: source -> Hello.class (BYTECODE, not machine code)
java Hello Ashton         # step 2: JVM loads the bytecode and runs it
# Hello, Ashton!

javap -c Hello | head -12 # look at the actual bytecode instructions

# SDKMAN — version manager for Java, Kotlin, Gradle (macOS / Linux)
curl -s "https://get.sdkman.io" | bash
sdk list java | grep -m6 tem        # Temurin builds, pick a 21.x id
sdk install java 21.0.5-tem
sdk default java 21.0.5-tem

# Debian / Ubuntu — Ubuntu 24.04+ and Debian 13 ship OpenJDK 21
sudo apt update && sudo apt install -y openjdk-21-jdk-headless

# macOS
brew install --cask temurin@21

# Any platform: Temurin tarball straight from Adoptium's API
BASE="https://api.adoptium.net/v3/binary/latest/21/ga/linux/x64/jdk"
curl -L -o jdk21.tar.gz "$BASE/hotspot/normal/eclipse?project=jdk"
tar -xzf jdk21.tar.gz && export PATH="$PWD"/jdk-21*/bin:$PATH

# Verify — all three must agree on 21
java -version                       # runtime (prints to stderr)
javac -version                      # compiler
echo "$JAVA_HOME"                   # IDEs & build tools read this one

public class Hello {
    public static void main(String[] args) {
        String who = args.length > 0 ? args[0] : "world";
        System.out.println("Hello, " + who + "!");
        System.out.println("Running Java " + Runtime.version().feature());
    }
}

java Hello.java                   # Java 11+: compiles in memory, runs, discards
# Hello, world!
# Running Java 21

javac Hello.java && java Hello    # the classic two-step: compile, then run
java Hello Ada                    # args work identically both ways
# Hello, Ada!

javap -c Hello                    # dissect the class file you just produced
#   public static void main(java.lang.String[]);
#     Code:
#        0: aload_0
#        1: arraylength
#        2: ifle        11         # args.length > 0 ? args[0] : "world"
#        5: aload_0
#        6: iconst_0
#        7: aaload
#        8: goto        13
#       11: ldc         #7         // String world
#       13: astore_1

$ jshell
|  Welcome to JShell -- Version 21
|  For an introduction type /help intro

jshell> int x = 21 * 2
x ==> 42
jshell> "byte".concat("code")
$2 ==> "bytecode"
jshell> for (int i = 1; i <= 3; i++) System.out.println(i * i);
1
4
9
jshell> /exit
|  Goodbye

my-app/
├── pom.xml                    # Maven; Gradle uses build.gradle.kts
├── src/
│   ├── main/
│   │   ├── java/com/example/App.java    # your code — folders ARE the package
│   │   └── resources/                   # config, messages, images
│   └── test/
│       └── java/com/example/AppTest.java
└── target/                    # compiled output (build/ in Gradle)

java -Xmx512m -jar app.jar        # cap the heap at 512 MB
java -Xms1g -Xmx4g -cp target/classes com.example.App
java -ea -Dfile.encoding=UTF-8 App # assertions on, one system property
java --enable-preview App          # opt in to preview features
javac --enable-preview --release 21 App.java   # ...and match it at compile

import java.util.Scanner;

public class Greeter {
    public static void main(String[] args) {
        String name = args.length > 0 ? args[0] : prompt();
        System.out.printf("Hello, %s!%n", name);
    }

    static String prompt() {
        System.out.print("Who are you? ");
        return new Scanner(System.in).nextLine().trim();
    }
}

public class Primitives {
    public static void main(String[] args) {
        byte    b = -128;          // 8-bit  ·  -128..127
        short   s = 32_000;        // 16-bit
        int     i = 2_000_000_000; // 32-bit · the default for whole numbers
        long    l = 9_000_000_000L; // 64-bit · note the L suffix
        float   f = 3.14f;         // 32-bit · note the f suffix
        double  d = 3.14159;       // 64-bit · the default for decimals
        boolean ok = true;         // true or false — never 0/1
        char    c = 'A';           // 16-bit Unicode code unit, in single quotes

        System.out.printf("%d %d %d%n", b, s, i);
    }
}

double wrong = 0.1 + 0.2;
System.out.println(wrong == 0.3);          // false
System.out.println(0.1 + 0.2);             // 0.30000000000000004

import java.math.BigDecimal;
BigDecimal a = new BigDecimal("0.10");
BigDecimal b = new BigDecimal("0.20");
System.out.println(a.add(b).equals(new BigDecimal("0.30"))); // true

int x = 1;
int y = x;
y = 99;
System.out.println(x);   // 1 — primitives copy the value

int[] p = {1, 2, 3};
int[] q = p;
q[0] = 99;
System.out.println(p[0]); // 99 — both names point at the SAME array

String s1 = new String("hi");
String s2 = new String("hi");
System.out.println(s1.equals(s2));  // true  — content comparison
System.out.println(s1 == s2);       // false — different objects

String a = "hello";
String b = "hello";
String c = new String("hello");

System.out.println(a == b);   // true  — same pooled literal
System.out.println(a == c);   // false — c is a fresh object
System.out.println(a.equals(c)); // true

// Immutability: each call returns a NEW string
String upper = a.toUpperCase();
System.out.println(a);        // "hello" unchanged
System.out.println(upper);    // "HELLO"

// Concatenation in a loop: O(n²) churn
String acc = "";
for (int i = 0; i < 10_000; i++) acc += i;   // avoid

StringBuilder sb = new StringBuilder();        // do this
for (int i = 0; i < 10_000; i++) sb.append(i);
String done = sb.toString();

String raw = "  Ashton Tink  ";

raw.strip()                       // "Ashton Tink" — preferred over trim()
   .toLowerCase()                 // "ashton tink"
   .replace(' ', '-')             // "ashton-tink"
   .split("-")[0];                // "ashton"

"abc".repeat(3);                  // "abcabcabc"
"42".isBlank();                   // false
"  ".isBlank();                   // true
"key=1".split("=");               // ["key", "1"]
String.join(", ", "a", "b");      // "a, b"
"abc".chars().forEach(System.out::println);  // 97, 98, 99

"template %s and %d".formatted("x", 7);      // "template x and 7"

int score = 87;

// if / else if — no implicit truthiness, the condition MUST be boolean
if (score >= 90)      System.out.println("A");
else if (score >= 80) System.out.println("B");
else                  System.out.println("C");

// Enhanced for — the default for anything iterable
for (int n : new int[]{1, 2, 3}) System.out.println(n);

// Classic for — when you need the index
for (int i = 0; i < 5; i++) { /* ... */ }

// While / do-while
int i = 5;
while (i-- > 0)   { /* runs while true */ }
do               { /* runs at least once */ } while (false);

// Ternary — expression only, never a statement
String grade = score >= 60 ? "pass" : "fail";

// if with pattern binding — replaces the old instanceof dance
static String handle(Object obj) {
    if (obj instanceof String s && s.length() > 3) {
        return s.toUpperCase();     // s is bound and narrowed here
    }
    if (obj instanceof int[] arr) {
        return "array of " + arr.length;
    }
    return "unknown";
}

// Pre-Java-16 equivalent, for reference:
// if (obj instanceof String) {
//     String s = (String) obj;      // cast, then hope
//     ...
// }

int[] nums = {5, 3, 9, 1};          // declaration + init
int[] more = new int[4];            // [0, 0, 0, 0]
String[] names = new String[3];     // all null

System.out.println(nums.length);    // 4 — field, no parens
nums[0] = 42;

// Sorting and searching — use Arrays, never hand-roll
java.util.Arrays.sort(nums);
System.out.println(java.util.Arrays.toString(nums)); // [1, 3, 9, 42]
int idx = java.util.Arrays.binarySearch(nums, 9);     // 2
int[][] grid = {{1,2},{3,4}};       // jagged, rows can differ

public record Point(int x, int y) {
    // Optional compact constructor — validation runs from every constructor
    public Point {
        if (x < 0 || y < 0) throw new IllegalArgumentException("negative");
    }

    // Optional extra methods
    public double magnitude() {
        return Math.sqrt(x * x + y * y);
    }

    // Optional additional constructors must delegate
    public Point() { this(0, 0); }
}

var p = new Point(3, 4);
p.x();                 // accessor is x(), not getX() — unless @AutoProperty
p.magnitude();         // 5.0
new Point(3, 4).equals(new Point(3, 4));  // true
System.out.println(p); // Point[x=3, y=4]

public class BankAccount {
    private final String owner;      // set once, at construction
    private long balanceCents;  // long, not double: money is not a float

    public BankAccount(String owner, long opening) {
        if (owner == null || owner.isBlank())
            throw new IllegalArgumentException("owner required");
        this.owner = owner;    // 'this' = this object's copy of the field
        this.balanceCents = opening;
    }

    public void deposit(long cents) {
        if (cents <= 0)
            throw new IllegalArgumentException("cents must be > 0");
        balanceCents += cents;
    }

    public void withdraw(long cents) {
        if (cents > balanceCents)
            throw new IllegalStateException("overdrawn");
        balanceCents -= cents;
    }

    public long balance() { return balanceCents; }
}

# What the compiler actually emits for a class with no constructors:
$ javap -p Empty.class
public class Empty {
  public Empty();
}

# Add ONE constructor to BankAccount and the free no-arg one is gone:
$ javac Use.java
Use.java:5: error: constructor BankAccount in class BankAccount cannot be
  applied to given types
    new BankAccount();
    ^
  required: java.lang.String,long
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error

class Widget {
    private static int instances;   // ONE copy — shared by every Widget
    private final int id;           // one per object

    Widget() {
        this.id = ++instances;      // 1, 2, 3 … for this JVM run
    }

    static int instanceCount() {    // no hidden 'this' — cannot see 'id'
        return instances;
    }
}

class Demo {
    public static void main(String[] args) {
        new Widget();
        new Widget();
        System.out.println(Widget.instanceCount());   // 2
        // widget.id — a static method has no 'widget' at all
    }
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;         // same object: cheap win
    if (!(o instanceof BankAccount other))   // Java 16 pattern matching
        return false;
    return balanceCents == other.balanceCents
        && owner.equals(other.owner);
}

@Override
public int hashCode() {
    return Objects.hash(owner, balanceCents);       // never hand-roll badly
}

@Override
public String toString() {
    return "BankAccount[owner=" + owner
         + ", balanceCents=" + balanceCents + "]";
}

public final class Invoice {       // final: no subclass can weaken it
    private final String id;         // final: set once, in the ctor
    private final List<Line> lines;

    public Invoice(String id, List<Line> lines) {
        this.id = Objects.requireNonNull(id);
        this.lines = List.copyOf(lines);  // defensive COPY at the boundary
    }

    public List<Line> lines() {
        return lines;           // already immutable — safe to share
    }
}

data class BankAccount(val owner: String, var balanceCents: Long) {
    init {                  // runs with the primary constructor
        require(owner.isNotBlank()) { "owner required" }
    }
    fun deposit(cents: Long) {
        require(cents > 0) { "cents must be > 0" }
        balanceCents += cents
    }
}

class Widget {              // no 'static' anywhere in Kotlin
    companion object {
        private var instances = 0
        fun instanceCount() = instances  // as Widget.instanceCount()
    }
    init { instances++ }
}

object Json                // declaration = singleton, one INSTANCE field
fun demo() {
    val a = BankAccount("Ashton", 10_000)
    val b = a.copy()
    println(a == b)                         // true  — == CALLS equals()
    println(a === b)                        // false — === is Java's ==
}

abstract class Shape {
    private final String name;          // parent state, private to Shape

    protected Shape(String name) { this.name = name; }

    abstract void draw();          // no body — subclasses must supply one

    @Override public String toString() { return name; }
}

final class Circle extends Shape {
    private final double r;

    Circle(double r) { super("circle"); this.r = r; }  // super(...) FIRST

    @Override void draw() { System.out.println("circle r=" + r); }
}

class Paint {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(1), new Square(2) };  // many types
        for (Shape s : shapes) s.draw();   // dispatch on RUNTIME type
    }
}

class Rectangle {
    private int w, h;
    Rectangle(int w, int h) { this.w = w; this.h = h; }
    void setSize(int w, int h) { this.w = w; this.h = h; }
    int area() { return w * h; }
}

final class Square extends Rectangle {        // compiles. Breaks the world.
    Square(int side) { super(side, side); }
    @Override void setSize(int w, int h) {   // a square can't move one side
        super.setSize(Math.max(w, h), Math.max(w, h));
    }
}

static void widen(Rectangle r) {
    r.setSize(5, 3);
    assert r.area() == 15;  // every caller of Rectangle relies on this
}

// widen(new Rectangle(2, 2))  → 15  ✅
// widen(new Square(2))        → 25  ❌ and it changes with argument order

interface Named {
    default String hello() { return "hi " + name(); }
    String name();
}

interface Loud {
    default String hello() { return "HEY " + name(); }   // the diamond
    String name();
}

// class Person implements Named, Loud   ❌ compile error:
//   types Named and Loud are unrelated; class must override hello()

class Employee implements Named, Loud {            // ✅ resolve it yourself
    public String name() { return "Ashton"; }
    @Override public String hello() {
        return Named.super.hello() + " (" + name() + ")";  // explicit parent
    }
}

public sealed interface Shape
        permits Circle, Rect, Triangle {}

public record Circle(double r) implements Shape {}      // implicitly final
public record Rect(double w, double h) implements Shape {}
public record Triangle(double b, double h) implements Shape {}

static double area(Shape s) {
    return switch (s) {
        case Circle c   -> Math.PI * c.r() * c.r();
        case Rect r     -> r.w() * r.h();
        case Triangle t -> 0.5 * t.b() * t.h();
        // no 'default' — the compiler PROVED all three of them
    };
}

// BEFORE — a base class. Each cross-cutting need MULTIPLIES the subclasses:
// Card + PayPal × fraud on/off × retry on/off = 8 near-identical classes
abstract class PaymentProcessor { abstract void pay(long cents); }
class CardProcessor extends PaymentProcessor { /* card plumbing */ }
class PaypalProcessor extends PaymentProcessor { /* paypal plumbing */ }

// AFTER — one contract, small single-purpose pieces you nest like sentences
interface PaymentProcessor { void pay(long cents); }

record FraudChecked(PaymentProcessor next) implements PaymentProcessor {
    @Override public void pay(long cents) {
        Fraud.check(cents);              // written once, used anywhere
        next.pay(cents);
    }
}

record Retrying(PaymentProcessor next, int attempts)
        implements PaymentProcessor {
    @Override public void pay(long cents) {
        for (int i = 0; i < attempts; i++) next.pay(cents);
    }
}

// var p = new FraudChecked(new Retrying(new CardProcessor(), 3));

abstract class Shape { abstract fun draw() }

open class Circle(private val r: Double) : Shape() {  // 'open' opts in
    override fun draw() = println("circle r=$r")  // override needs 'open'
}

interface PaymentProcessor { fun pay(cents: Long) }

class CardProcessor : PaymentProcessor {
    override fun pay(cents: Long) { /* card plumbing */ }
}

// 'by' = delegation: inherit the implementation from a held instance
class LoggingProcessor(private val inner: PaymentProcessor)
    : PaymentProcessor by inner {
    override fun pay(cents: Long) {
        println("paying $cents"); inner.pay(cents)  // explicit beats 'by'
    }
}

sealed interface Shape2 {                      // Kotlin: sealed since 1.0
    data class Circle(val r: Double) : Shape2
    data class Rect(val w: Double, val h: Double) : Shape2
}

fun area(s: Shape2): Double = when (s) {
    is Shape2.Circle -> Math.PI * s.r * s.r
    is Shape2.Rect   -> s.w * s.h
    // no 'else': "when must be exhaustive" is a compile ERROR
}

public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6);

    private final double mass;     // enums are classes — fields are fine
    private final double radius;

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    private static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }

    public double weight(double otherMass) {
        return otherMass * surfaceGravity();
    }

    public static Planet fromName(String name) {
        // values() gives the fixed set — switch can then prove exhaustiveness
        for (Planet p : values())
            if (p.name().equalsIgnoreCase(name)) return p;
        throw new IllegalArgumentException("unknown: " + name);
    }
}

System.out.println(EARTH.weight(70));   // 686.0-ish newtons
System.out.println(Planet.valueOf("MARS")); // IllegalArgumentException if absent

public enum Operation {
    ADD      { public double apply(double a, double b) { return a + b; } },
    MULTIPLY { public double apply(double a, double b) { return a * b; } },
    MAX      { public double apply(double a, double b) { return Math.max(a, b); } };

    public abstract double apply(double a, double b);
}

// ...replaces a switch, a strategy map, or a whole class hierarchy
double r = Operation.ADD.apply(2, 3);

public record Money(long cents, Currency currency) {

    public Money {   // compact constructor: runs before assignment sticks
        if (cents < 0) throw new IllegalArgumentException("negative amount");
    }

    public static Money of(long units, Currency c) {
        return new Money(units * 100, c);   // static factory reads better
    }

    public Money plus(Money other) {
        if (!currency.equals(other.currency))
            throw new IllegalArgumentException("currency mismatch");
        return new Money(cents + other.cents, currency);
    }

    public Money scale(double factor) {
        return new Money(Math.round(cents * factor), currency);
    }
}

Money a = Money.of(20, Currency.USD);
Money b = Money.of(25, Currency.USD);
System.out.println(a.plus(b));                    // Money[cents=4500, currency=USD]
System.out.println(a.equals(Money.of(20, Currency.USD))); // true — value equality
Set<Money> seen = new HashSet<>();                // correct as a map key, too

public class HttpClientConfig {
    private final String baseUrl;
    private final int timeoutMs;             // required
    private final int retries;               // optional
    private final Map<String, String> headers;

    private HttpClientConfig(Builder b) {
        this.baseUrl  = b.baseUrl;
        this.timeoutMs = b.timeoutMs;
        this.retries  = b.retries;
        this.headers  = Map.copyOf(b.headers);
    }

    public static Builder builder(String baseUrl) { return new Builder(baseUrl); }

    public static final class Builder {
        private final String baseUrl;
        private int timeoutMs = 5_000;        // sensible defaults
        private int retries = 3;
        private final Map<String, String> headers = new LinkedHashMap<>();

        private Builder(String baseUrl) { this.baseUrl = Objects.requireNonNull(baseUrl); }

        public Builder timeoutMs(int v)   { this.timeoutMs = v; return this; }
        public Builder retries(int v)     { this.retries = v;   return this; }
        public Builder header(String k, String v) { headers.put(k, v); return this; }

        public HttpClientConfig build() { return new HttpClientConfig(this); }
    }
}

var cfg = HttpClientConfig.builder("https://api.acme.com")
        .timeoutMs(2_000)
        .header("X-Trace", "abc")
        .build();

import java.io.Serializable;
import java.util.List;

public class Generics {
    // A generic CLASS: T is a type PARAMETER, resolved at each use site
    public static class Box<T> {
        private T value;
        public void set(T value) { this.value = value; }
        public T get()           { return value; }
    }

    // Generic METHOD: the <T> lives on the method, and inference finds it
    public static <T extends Comparable<T>> T max(List<T> list) {
        T best = list.get(0);
        for (T t : list) {
            if (t.compareTo(best) > 0) best = t;
        }
        return best;
    }

    // Multiple bounds: at most ONE class, then interfaces, joined by &
    // (the class goes first because it is the most restrictive slot)
    public static <T extends Number & Comparable<T> & Serializable>
    void export(T t) {
        System.out.println(t + " is comparable to itself: "
                + (t.compareTo(t) == 0));
    }

    public static void main(String[] args) {
        Box<String> b = new Box<>();   // diamond: infer <String> from the left
        b.set("hello");

        List<Integer> nums = List.of(3, 9, 4);
        System.out.println(max(nums)); // 9 — T inferred as Integer
        export(42);                    // T inferred as Integer
    }
}

public class Erased<T> {
    // T[] make()          { return new T[10]; }   // ❌ generic array creation
    // static T first(...) { ... }                 // ❌ static cannot see T
    // boolean bad(Object o) {
    //     return o instanceof List<String>;       // ❌ illegal generic type
    // }
    // boolean ok(Object o) {
    //     return o instanceof List<>;             // ✅ Java 9+ unbounded only
    // }

    // What actually happens: the compiler inserts a CAST at every read.
    // It writes this for String s = box.get();:
    public String getAndCast() {
        return (String) (Object) getRaw();   // the invisible cast, made visible
    }
    private Object getRaw() { return "hello"; }
}

cat > MyInt.java <<'EOF'
public class MyInt implements Comparable<MyInt> {
    private final int value;
    public MyInt(int v) { this.value = v; }
    public int compareTo(MyInt other) {
        return Integer.compare(value, other.value);
    }
}
EOF
javac MyInt.java
javap -p MyInt

# Compiled from "MyInt.java"
# public class MyInt implements java.lang.Comparable<MyInt> {
#   private final int value;
#   public MyInt(int);
#   public int compareTo(MyInt);                 <-- what you wrote
#   public volatile int compareTo(java.lang.Object);  <-- SYNTHETIC BRIDGE
# }

public class Unchecked {
    // Raw type returned by a pre-generics library
    @SuppressWarnings("unchecked")  // we promise the runtime list is List<T>
    static <T> List<T> legacyQuery(Class<T> type) {
        List raw = new java.util.ArrayList();   // raw — no type info
        raw.add("built for " + type.getSimpleName());
        return raw;
    }

    // SAFER alternative when you have the Class token: a checked copy
    static <T> List<T> checkedCopy(Class<T> type, List<?> in) {
        List<T> out = new java.util.ArrayList<>();
        for (Object o : in) {
            if (!type.isInstance(o)) {
                throw new ClassCastException(
                        "expected " + type.getName() + ", got " + o.getClass());
            }
            out.add(type.cast(o));   // the cast happens HERE, with a real check
        }
        return out;
    }
}

public class ArrayStore {
    public static void main(String[] args) {
        // Covariance: an Integer[] IS a Number[] as far as javac is concerned
        Number[] nums = new Integer[3];
        nums[0] = 10;                     // ✅ fine

        // ...and here is the hole. The compiler accepted this because
        // Integer is a Number. The JVM remembers the real component type
        // and refuses at RUNTIME:
        nums[1] = 3.14;                   // 💥 ArrayStoreException
        // java.lang.ArrayStoreException: java.lang.Double

        // Generics close this hole by refusing to compile it at all:
        // List<Number> l = new ArrayList<Integer>();  // ❌ incompatible types
    }
}

import java.util.ArrayList;
import java.util.List;

public class Pecs {
    // CONSUMER: we only put Numbers in → "? super Number" (PECS)
    static void fill(List<? super Number> sink, Number... values) {
        for (Number n : values) sink.add(n);   // ✅ adding Number is safe
    }

    // PRODUCOR: we only take Numbers out → "? extends Number" (PECS)
    static double sum(Collection<? extends Number> src) {
        double total = 0;
        for (Number n : src) total += n.doubleValue();  // ✅ reads as Number
        return total;
    }

    public static void main(String[] args) {
        List<Number> nums = new ArrayList<>();
        List<Object> any  = new ArrayList<>();
        fill(nums, 1, 2.5, 3L);   // ✅ List<Number> is within "? super Number"
        fill(any,  1, 2.5, 3L);   // ✅ List<Object> too — Object is a supertype

        // List<Integer> ints = ...; fill(ints, ...);   // ❌ Integer is a SUBtype
        //                                            //    you'd get Integers,
        //                                            //    not Numbers. Correctly
        //                                            //    rejected.

        System.out.println(sum(nums));   // 6.5
        System.out.println(sum(any));    // 6.5 — same call, wider argument
    }
}

// out T = covariant ("produce only"). in T = contravariant ("consume only").
interface Source<out T> { fun next(): T }        // T in out position ✅
interface Sink<in T>   { fun put(t: T) }         // T in in position  ✅
// interface Bad<out T> { fun put(t: T) }        // ❌ out-projected type
//                                                 //    used in in position

fun main() {
    val names: List<String> = listOf("Ada", "Grace")

    // Kotlin's List IS declared `List<out E>` — so covariance is free:
    val asAny: List<Any> = names          // ✅ no wildcard, no ceremony
    val first: Any = asAny[0]

    // Mutable lists stay invariant, exactly like Java:
    // val w: MutableList<Any> = mutableListOf<String>()  // ❌ type mismatch

    // Star projection: "I know the shape, not the argument"
    val star: List<*> = names
    println("${star.size} items, first = ${star[0]}")   // element type = Any?

    // Reified type parameters — the thing Java genuinely cannot do:
    val mixed: List<Any> = listOf(1, "two", 3.0)
    println(mixed.filterIsInstance<Int>())   // [1] — survives erasure!
    println(isA<String>(mixed[0]))           // false
}

// `inline` + `reified` copies the body into the caller with T substituted,
// so `is T` and `::class` work. Only possible in functions, never classes.
inline fun <reified T> isA(value: Any): Boolean = value is T

List<String> names = new ArrayList<>();       // diamond infers type args
names.addAll(List.of("ada", "grace", "alan"));

Set<Integer> seen  = new HashSet<>();
Map<String, Integer> counts = new HashMap<>();
counts.merge("ada", 1, Integer::sum);          // idiomatic frequency count
counts.computeIfAbsent("grace", k -> new ArrayList<>().size());

// Immutable factories — Java 9+, prefer these for fixed data
var fixed    = List.of("a", "b", "c");
var kv       = Map.of("a", 1, "b", 2);
var ordered  = Map.entry("k", "v");            // single entry
var copy     = List.copyOf(names);             // truly immutable snapshot
var nullish  = new ArrayList<>();              // List.of rejects null

Deque<Integer> stack = new ArrayDeque<>();
stack.push(1); stack.push(2);
System.out.println(stack.pop());   // 2 — LIFO

Deque<Integer> queue = new ArrayDeque<>();
queue.add(1); queue.add(2);
System.out.println(queue.remove()); // 1 — FIFO

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.addAll(List.of(5, 1, 3));
System.out.println(pq.poll());      // 1 — smallest first

List<String> users = new ArrayList<>(List.of("a", "b", "c"));

// ❌ for (String s : users) if (s.equals("b")) users.remove(s);

users.removeIf(s -> s.equals("b"));      // ✅ one pass, no CME
users.removeAll(Set.of("c"));            // ✅ set-based, faster

// Replace the whole list rather than mutating in place
users = users.stream().filter(s -> !s.isEmpty()).toList();

record User(String name, int age, String dept) {}

List<User> users = List.of(
    new User("Ada", 36, "eng"),
    new User("Grace", 45, "eng"),
    new User("Alan", 41, "research"),
    new User("Katherine", 34, "ops"));

// Pipeline: filter → map → sort → collect
List<String> engOver40 = users.stream()
    .filter(u -> u.dept().equals("eng"))
    .filter(u -> u.age() > 40)
    .map(User::name)
    .sorted()
    .toList();                          // [Grace]

// Grouping — the killer feature over imperative loops
Map<String, List<User>> byDept = users.stream()
    .collect(Collectors.groupingBy(User::dept));

// Counts, sums, averages in one expression
Map<String, Long> headcount = users.stream()
    .collect(Collectors.groupingBy(User::dept, Collectors.counting()));

OptionalDouble avg = users.stream().mapToInt(User::age).average();

// Reduce to a single value
String all = users.stream().map(User::name).collect(Collectors.joining(", "));

// Short-circuiting
users.stream().filter(u -> u.age() > 40).findFirst();
users.stream().anyMatch(u -> u.dept().equals("ops"));

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Input {
    public static void main(String[] args) throws Exception {
        // Scanner — easy, line-oriented, great for puzzles and scripts
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();          // whole line
        if (sc.hasNextInt()) {
            int n = sc.nextInt();
        }
        sc.close();

        // BufferedReader — for real programs reading many lines fast
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String each;
        while ((each = br.readLine()) != null) {   // null = end of input
            System.out.println(each);
        }
    }
}

String name = "Ashton";
int    age  = 30;
double pi   = 3.14159265;

// printf / String.format — printf-style, position-aware
System.out.printf("Hi, %s, you are %d%n", name, age);
System.out.printf("|%10.2f|%n", pi);        // |      3.14|
System.out.printf("|%-10.2f|%n", pi);       // |3.14      |
System.out.printf("%,d%n", 1000000);        // 1,000,000
System.out.printf("%08.3f%n", pi);          // 003.142

// Reordering — useful for i18n, where word order differs by language
System.out.printf("%2$s is %1$d years old", 30, "Ada");

// formatted() on String — same engine, returns a String
String s = "%s scored %.1f%%".formatted("Ada", 97.5);

// text blocks — Java 15+, preserves formatting
String html = """
        <div class="card">
            <p>Hello, %s</p>
        </div>
        """.formatted(name);

// Streaming a file into a summary — no intermediate String churn
long bytes = 0;
StringBuilder out = new StringBuilder();
try (var lines = Files.lines(Path.of("app.log"))) {
    for (var it = lines.iterator(); it.hasNext(); ) {
        String line = it.next();
        bytes += line.length();
        if (line.startsWith("ERROR")) out.append(line).append('\n');
    }
}
Files.writeString(Path.of("errors.log"), out);   // one final write

import java.util.regex.*;

public class Regex {
    // Compile ONCE as a static field
    private static final Pattern LOG = Pattern.compile(
        "^\\s*(?<time>\\d{2}:\\d{2}:\\d{2})\\s+"
      + "(?<level>INFO|WARN|ERROR)\\s+"
      + "(?<msg>.*)$");

    public static void main(String[] args) {
        String line = "14:03:22 ERROR database timed out";

        Matcher m = LOG.matcher(line);
        if (m.matches()) {
            System.out.println(m.group("level"));  // ERROR — named groups
            System.out.println(m.group("msg"));    // database timed out
        }

        // find() searches anywhere; matches() requires the WHOLE string
        System.out.println(Pattern.compile("\\d+").matcher("a12b345")
                                  .find());                    // true

        // Replacing with a lambda — captured text flows back in
        String masked = line.replaceAll(
            Pattern.quote("database"), "REDACTED");

        // Splitting with a limit
        String[] parts = "a,b,,c".split(",", -1);   // [a, b, , c]

        // Quick validation without Pattern boilerplate
        System.out.println("ada@example.com".matches("[\\w.]+@[\\w.]+")); // true
    }
}

public class Throwing {

    // Checked: the signature forces callers to deal with it
    static int parseAge(String raw) throws NumberFormatException {
        if (raw == null || raw.isBlank())
            throw new NumberFormatException("blank input");
        return Integer.parseInt(raw);   // throws on garbage
    }

    // Unchecked: no declaration — signals a programming mistake
    static String lookup(String[] table, int i) {
        if (i < 0 || i >= table.length)
            throw new IndexOutOfBoundsException("index " + i + " out of bounds");
        return table[i];
    }

    // Custom checked exception: real domain failure
    public static class InsufficientFunds extends Exception {
        private final long shortfall;
        public InsufficientFunds(long shortfall) {
            super("short by " + shortfall + " cents");
            this.shortfall = shortfall;
        }
        public long shortfall() { return shortfall; }
    }

    static void withdraw(long balance, long amount) throws InsufficientFunds {
        if (amount > balance) throw new InsufficientFunds(amount - balance);
    }
}

// Multiple resources, reverse-order close, no finally block
try (var in  = Files.newInputStream(path);
     var out = Files.newOutputStream(dest)) {
    in.transferTo(out);
} catch (IOException e) {
    log.error("copy failed from {}", path, e);
}   // both closed here, guaranteed, even on exception

// Scoped lock — same pattern for synchronization
synchronized (lock) { /* ... */ }   // releases on every exit path

// Custom resource
class Session implements AutoCloseable {
    private final Socket s = connect();
    public void close() { s.close(); }
}
try (var session = new Session()) {
    session.send("hi");
}   // session.close() runs automatically

try {
    parse(config);
} catch (ParseException e) {
    // Add context WITHOUT losing the original stack trace
    throw new IllegalStateException("bad config at line " + e.getLine(), e);
}

// Printing — pass the throwable as the LAST arg to the formatter
log.error("failed to write {}: {}", path, e);   // message, arg, throwable

// Read a trace programmatically
e.getStackTrace();          // StackTraceElement[]
e.getCause();               // the chained original
e.getSuppressed();          // extra failures (try-with-resources adds these)

import java.util.function.*;

public class Lambdas {
    public static void main(String[] args) {
        // Explicit type — verbose, occasionally useful for clarity
        Runnable r1 = () -> System.out.println("hi");

        // Inferred — the target type gives the compiler everything it needs
        Function<String, Integer> len = s -> s.length();
        Predicate<String>           long1 = s -> s.length() > 4;
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;

        System.out.println(len.apply("hello"));   // 5
        System.out.println(long1.test("hi"));     // false
        System.out.println(add.apply(2, 3));      // 5

        // Blocks, when the body needs more than one expression
        Comparator<String> byLenThenAlpha = (a, b) -> {
            int d = Integer.compare(a.length(), b.length());
            return d != 0 ? d : a.compareTo(b);
        };

        // Effectively final captured variables
        String prefix = "log: ";       // cannot be reassigned after this line
        Consumer<String> out = s -> System.out.println(prefix + s);
        out.accept("started");
    }
}

// 1. Static method — args become the parameters
Function<String, Integer> parse = Integer::parseInt;
// same as s -> Integer.parseInt(s)

// 2. Instance method of a particular object
String greeting = "hello";
Supplier<String> upper = greeting::toUpperCase;
// same as () -> greeting.toUpperCase()

// 3. Instance method of the argument — very common in streams
Function<String, Integer> len = String::length;
// same as s -> s.length()

// 4. Constructor — an object factory
Function<String, StringBuilder> newSb = StringBuilder::new;
// same as s -> new StringBuilder(s)

// In practice
List.of("b", "a", "c").stream()
    .map(String::toUpperCase)
    .sorted(Comparator.comparingInt(String::length))
    .forEach(System.out::println);

Comparator<User> byName = Comparator.comparing(User::name)
    .thenComparing(User::age);

Predicate<String> notBlank = s -> !s.isBlank();
Predicate<String> hasAt    = s -> s.contains("@");
Predicate<String> isShort  = s -> s.length() < 100;

Predicate<String> validEmail = notBlank.and(hasAt).and(isShort.negate());

// Function composition — apply right-to-left like maths
Function<Integer, Integer> doubleIt = x -> x * 2;
Function<Integer, Integer> plusOne  = x -> x + 1;
Function<Integer, Integer> pipeline = doubleIt.andThen(plusOne);
System.out.println(pipeline.apply(5));   // 11  (5*2, then +1)

Function<Integer, Integer> reverse = doubleIt.compose(plusOne);
System.out.println(reverse.apply(5));    // 12  (+1 first, then *2)

Optional<User> found = repo.find("ada");

// ✅ Declare absences as Optional (return types, fields of a config)
// ✅ Chain the decision instead of branching
String name = found
    .map(User::name)
    .filter(n -> n.length() > 2)
    .orElse("anonymous");

found.ifPresent(u -> log.info("hit {}", u.name()));
found.ifPresentOrElse(
    this::render,
    () -> response.status(404));

long count = found.stream()            // 0 or 1 elements — elegant for streams
    .filter(u -> u.age() > 18)
    .count();

// Supplier for expensive fallbacks — runs only when absent
User fallback = found.orElseGet(() -> User.anonymous());

// ❌ Never: Optional fields, Optional parameters, .get() without a guard
// private Optional<String> name;   // use a plain null OR a plain field
// String s = opt.get();            // that's just NullPointerException with steps

import java.lang.reflect.*;

public class Reflect {

    record User(String name, int age) {}

    public static void main(String[] args) throws Exception {
        Class<?> c = User.class;                    // literal — cheap and direct
        Class<?> d = Class.forName("Reflect$User"); // by name — resolved at runtime
        Object   e = new User("Ada", 36).getClass();

        System.out.println(c.getName());    // Reflect$User
        System.out.println(c.getSimpleName()); // User

        // Constructors
        for (Constructor<?> ctor : c.getDeclaredConstructors()) {
            System.out.println(ctor + "  params=" + ctor.getParameterCount());
            for (Parameter p : ctor.getParameters())
                System.out.println("   " + p.getName());  // needs -parameters
        }

        // Build an instance reflectively
        Constructor<?> chosen = c.getDeclaredConstructor(String.class, int.class);
        Object u = chosen.newInstance("Grace", 45);

        // Private field access
        class Secret { private String key = "hidden"; }
        Field f = Secret.class.getDeclaredField("key");
        f.setAccessible(true);                          // open the door
        Secret s = new Secret();
        System.out.println(f.get(s));                  // "hidden"
        f.set(s, "changed");
        System.out.println(s.key);                     // "changed" (compile error if direct)

        // Methods: find by name, then invoke
        Method m = c.getMethod("name");                // public only
        Method[] all = c.getDeclaredMethods();         // incl. private
        try {
            System.out.println(m.invoke(u));           // "Grace"
        } catch (InvocationTargetException ex) {
            throw (RuntimeException) ex.getCause();    // unwrap the real failure
        }
    }
}

import java.lang.annotation.*;
import java.lang.reflect.*;

// 1. Declaring an annotation with retention + target
@Retention(RetentionPolicy.RUNTIME)   // keep it in the class file
@Target(ElementType.METHOD)           // only on methods
@interface Route {
    String value();                   // annotation members look like methods
    String method() default "GET";    // defaults make callers terse
}

// 2. Using it
class Controller {
    @Route("/users")
    public List<User> all() { return store.all(); }

    @Route(value = "/users/{id}", method = "POST")
    public User create(String body) { return store.create(body); }
}

// 3. Reading it — this IS how frameworks discover routes
public static void scan(Class<?> c) {
    for (Method m : c.getDeclaredMethods()) {
        Route r = m.getAnnotation(Route.class);   // null if absent
        if (r != null) {
            System.out.println(r.method() + " " + r.value() + " → " + m.getName());
        }
    }
}
scan(Controller.class);
// GET  /users     → all
// POST /users/{id} → create

import java.lang.reflect.*;

interface Greeting { String hi(String who); }

public class Proxy {
    public static void main(String[] args) {
        Greeting real = who -> "Hello, " + who + "!";

        Greeting traced = (Greeting) java.lang.reflect.Proxy.newProxyInstance(
            Greeting.class.getClassLoader(),
            new Class<?>[]{ Greeting.class },
            (proxy, method, methodArgs) -> {
                long t0 = System.nanoTime();
                try {
                    return method.invoke(real, methodArgs);   // forward
                } catch (InvocationTargetException e) {
                    throw e.getCause();                       // preserve semantics
                } finally {
                    System.out.printf("%s took %d ns%n",
                        method.getName(), System.nanoTime() - t0);
                }
            });

        System.out.println(traced.hi("Ada"));   // Hello, Ada! + a timing line
    }
}

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

public class ThreadsDemo {
    public static void main(String[] args) throws Exception {
        // (1) a bare Thread wrapping a Runnable
        Thread t = new Thread(
            () -> System.out.println("hi from " + Thread.currentThread()));
        t.start();                   // NEW OS thread — this is the magic
        t.join();                    // main blocks until t is TERMINATED

        // (2) Runnable: no result. Callable: returns a value.
        Runnable job = () -> System.out.println("fire and forget");
        Callable<Integer> sum = () -> IntStream.range(0, 100).sum();

        ExecutorService pool = Executors.newFixedThreadPool(4);
        Future<Integer> f = pool.submit(sum);
        System.out.println(f.get()); // 4950 — blocks main until ready
        pool.shutdown();
    }
}

public class Counter {
    private int count;                       // guarded by `this`
    private static int instances;            // guarded by Counter.class
    private final Object gate = new Object(); // a private, dedicated lock

    public synchronized void bump() {        // (1) method → locks `this`
        count++;
    }

    public static synchronized void resetAll() {  // (2) static → locks the
        instances = 0;                            //     Class object itself
    }

    public int read() {
        synchronized (gate) {                // (3) block: you choose the
            return count;                    //     exact object to lock
        }
    }
}

public class DirtyFlag {
    private volatile boolean running = true; // ← delete this keyword: hang
    private int port = 8080;                 // written once, before start

    public void stop() {                     // called from another thread
        running = false;
    }

    public void run() {
        while (running) {                    // re-read on every iteration
            Thread.onSpinWait();             // JDK 9+ polite yield hint
        }
        System.out.println("clean exit on " + port);
    }
}

public class Deadlock {
    private final Object a = new Object();
    private final Object b = new Object();

    void aThenB() {                      // thread 1 takes a, then b
        synchronized (a) {
            synchronized (b) { work(); }
        }
    }

    void bThenA() {                      // thread 2 takes b, then a 💀
        synchronized (b) {
            synchronized (a) { work(); } // circular wait: both BLOCKED
        }
    }

    // FIX 1 — one lock order, everywhere, no exceptions
    // FIX 2 — bounded acquisition: never wait forever
    boolean tryAB() throws InterruptedException {
        ReentrantLock la = new ReentrantLock();
        ReentrantLock lb = new ReentrantLock();
        if (!la.tryLock(50, TimeUnit.MILLISECONDS)) return false;
        try {
            if (!lb.tryLock(50, TimeUnit.MILLISECONDS)) return false;
            try { return work(); }
            finally { lb.unlock(); }     // unlock in finally, always
        } finally { la.unlock(); }
    }

    void work() { /* ... */ }
}

final class Box {
    private int items = 0;
    private static final int FULL = 16;

    void produce() throws InterruptedException {
        synchronized (this) {
            while (items == FULL) wait();   // WHILE — never `if`
            items++;
            notifyAll();                    // wake everyone, they recheck
        }
    }

    void consume() throws InterruptedException {
        synchronized (this) {
            while (items == 0) wait();      // re-test after EVERY wakeup
            items--;
            notifyAll();
        }
    }
}

void shutdown(Thread worker) throws InterruptedException {
    worker.interrupt();                    // ask politely; do not kill
    worker.join(1_000);                    // wait up to 1s for TERMINATED
    if (worker.isAlive()) log.warn("worker ignored its interrupt");
}

void loop() {
    while (!Thread.currentThread().isInterrupted()) {
        process(queue.take());             // throws when interrupted
    }
}

// When you cannot propagate the exception, put the flag back:
catch (InterruptedException e) {
    Thread.currentThread().interrupt();     // restore it
    throw new IllegalStateException("shut down", e);  // or return
}

import java.util.concurrent.atomic.AtomicInteger

class SharedState {
    @Volatile var ready = false          // kotlin.jvm.Volatile → JVM volatile
    var payload: String? = null
        private set
    private val lock = Any()             // private dedicated monitor
    private val hits = AtomicInteger()

    fun publish(data: String) {
        synchronized(lock) {             // inline: locks, runs, returns block
            payload = data               // write payload first...
            ready = true                 // ...volatile write creates the edge
        }
    }

    fun record(): Int = hits.incrementAndGet()   // lock-free CAS, as ever

    fun stop() {
        // Threads, monitors and InterruptedException are all JVM-native here.
        // The REAL Kotlin answer to "many concurrent tasks" is coroutines.
    }
}

ExecutorService pool = new ThreadPoolExecutor(
    8,                                  // core
    16,                                 // max — hard ceiling
    60, TimeUnit.SECONDS,               // idle threads reaped
    new ArrayBlockingQueue<>(1000),     // BOUNDED: back-pressure
    r -> {                              // named, daemonised threads
        Thread t = new Thread(r, "worker");
        t.setDaemon(true);
        return t;
    },
    new ThreadPoolExecutor.CallerRunsPolicy()); // reject = slow the caller

pool.execute(() -> work());            // void: failures hit the handler
Future<Integer> f = pool.submit(() -> compute());  // Future + exceptions
pool.shutdown();                       // stop accepting…

Future<User> u  = pool.submit(() -> loadUser(id));
Future<Orders> o = pool.submit(() -> loadOrders(id));

// Two tasks already running… and now you stall a THREAD waiting:
User  user  = u.get();     // blocks — throws ExecutionException on failure
Orders ord  = o.get();     // blocks again — no "combine these two"

// "Run both, then join" needs a third submit + CountDownLatch + manual
// exception plumbing. Future has no thenApply, no allOf, no composition.

record Page(String name, String body) {}

CompletableFuture<String> page(String url) {
    return CompletableFuture.supplyAsync(
        () -> httpClient.body(url), POOL);      // never the common pool
}

Page loadAll() {
    CompletableFuture<String> a = page("https://a.example");
    CompletableFuture<String> b = page("https://b.example");
    CompletableFuture<String> c = page("https://c.example");

    // zip two independent futures — no thread waits for the other
    CompletableFuture<Page> header =
        a.thenCombine(b, (x, y) -> new Page("head", x + y));

    // fan out the rest, then join — still zero blocked threads
    CompletableFuture.allOf(header, c).join();
    return new Page("home", header.join().body() + c.join());
}

// ThenApplyWrapper is the bug: nested futures
CompletableFuture<Profile> nested =
    fetchUser(id)
        .thenApply(u -> fetchProfile(u.id()))   // CF<CF<Profile>> ❌
        .join().join();

// Flat: one level, one join — this is what you meant
CompletableFuture<Profile> flat =
    fetchUser(id)
        .thenCompose(u -> fetchProfile(u.id())) // CF<Profile> ✅
        .exceptionally(ex -> Profile.anonymous()) // recovery
        .whenComplete((p, ex) -> log(p, ex));     // side effect, passes on

// thenApply   = map     (function returns a plain value)
// thenCompose = flatMap (function returns a future)
// thenCombine = zip     (two independent futures, one function)

// (1) plain as a Thread — but it costs kilobytes, not 1 MB
Thread vt = Thread.ofVirtual().name("vt", counter)
                  .start(() -> handleRequest());
vt.join();

// (2) the idiomatic form: one virtual thread per task, no queue at all
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    List<Future<String>> results = urls.stream()
        .map(u -> executor.submit(() -> httpClient.body(u)))
        .toList();
    for (Future<String> f : results) System.out.println(f.get());
}

// 50 000 concurrent HTTP calls, ~50 000 virtual threads,
// a handful of carriers (default = number of CPU cores).

suspend fun loadAll(urls: List<String>): String =
    coroutineScope {                       // structured: waits for children
        val deferred = urls.map { url ->
            async(Dispatchers.IO) {        // IO pool — made for blocking
                httpClient.body(url)
            }
        }
        deferred.awaitAll().joinToString("")   // allOf(...).join()
    }

suspend fun profile(id: Long): Profile =
    runCatching { fetchProfile(fetchUser(id).id) }
        .getOrElse { Profile.anonymous }       // exceptionally

// Failure in any child cancels the scope — you get that for free.

cat Point.java
public class Point {
    private final int x;
    public Point(int x) { this.x = x; }
    private int scaled(int v) { return v * 2; }
    public int sum(int y) { return this.x + scaled(y); }
}

javac Point.java
javap -c Point                    # -c = show the code attribute

public int sum(int);
  Code:
     0: aload_0          // push `this` (local var 0) onto the stack
     1: getfield      #7  // Field x:I — pop `this`, push this.x
     4: aload_0          // `this` again, as the receiver of the call
     5: iload_1          // push argument y
     6: invokevirtual #13 // Method scaled:(I)I — pop receiver + arg
     9: iadd             // x + scaled(y)
    10: ireturn          // pop an int and return it

int[] primitives = new int[1_000_000];     // ~4 MB, contiguous, SIMD-friendly
Integer[] boxed   = new Integer[1_000_000]; // 4 MB of REFERENCES + 1M objects
for (int i = 0; i < boxed.length; i++) {
    boxed[i] = primitives[i];   // 1,000,000 allocations, 16 B each ≈ 16 MB
}                               // plus one pointer chase per element

// The JIT can make allocations disappear — if they never escape:
static long hotLoop(int n) {
    long acc = 0;
    for (int i = 0; i < n; i++) {
        Point p = new Point(i, i + 1);  // never leaves this method
        acc += p.x();                   // → scalar-replaced: NO allocation
    }
    return acc;
}
// Watch it happen: -XX:+UnlockDiagnosticVMOptions -XX:+PrintEscapeAnalysis

# Setting the heap — the only flags most services ever need
java -Xms4g -Xmx4g -XX:+UseG1GC -Xlog:gc*:file=gc.log MyService
#      ^min  ^max   ^the default since 9    ^everything, timestamped

[1.203s][info][gc] GC(0) Pause Young (Normal) G1 Evacuation Pause
           1024M->187M(4096M) 12.4ms
                  ^before->after(heap)  ^what you actually care about

# Diagnose before you touch a single tuning flag:
jcmd <pid> GC.heap_info          # occupancy by generation
jstat -gc <pid> 1000             # live numbers every second
jcmd <pid> GC.run_histogram      # what's holding the heap open

# Watch compilation happen (JDK 9+; -XX:+PrintCompilation still works)
java -Xlog:jit+compilation:file=jit.log MyService
  142   3       4       java.util.HashMap::getNode (39 bytes)
  143   4       3       java.util.HashMap::getNode (39 bytes)
  901   5       4       java.util.HashMap::getNode (39 bytes)   # C2, tier 4

# ...and watch optimisations being made (or undone)
java -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining MyService

# If speculation fails — a branch flips, a class loads — C2's code is
# thrown out and the method drops back to the interpreter: that's the
# deoptimisation cliff, a sudden latency spike right after warm-up.

plugins {
    id 'me.champeau.jmh' version '0.7.2'
}

jmh {
    benchmarkMode = ['avgt']     // average time per operation
    timeUnit     = 'us'
    fork         = 2             // fresh JVM per run — honest isolation
    warmupIterations = 5         // let the JIT reach C2 first
    iterations   = 5
}

// ./gradlew jmh  — never System.currentTimeMillis() in a for-loop.

cat Greet.kt
fun greet(name: String): String = "Hi, $name"
internal fun helper() = 42          # mangled: helper$main

javap -c -p GreetKt | head -20

public static final java.lang.String greet(java.lang.String);
  Code:
     0: aload_0
     1: ldc           #12        // String name
     3: invokestatic  #19        // Method kotlin/jvm/internal/
                                 //   Intrinsics.checkNotNullParameter
     6: invokedynamic #26        // makeConcatWithConstants
    11: areturn

$ javap -v GreetKt | grep NotNull
   RuntimeVisibleAnnotations: 0 org/jetbrains/annotations/NotNull

hello/
├── pom.xml                 # Maven: deps, plugins, versions
├── build.gradle.kts         # Gradle: the same, in Kotlin
└── src/
    ├── main/java/com/acme/App.java
    └── test/java/com/acme/AppTest.java

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.acme</groupId>
  <artifactId>hello</artifactId>
  <version>1.0</version>

  <properties>
    <maven.compiler.release>21</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.11.3</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

mvn -q test              # compile + run all tests
mvn -q package           # produce target/hello-1.0.jar
mvn -q verify            # tests + integration checks
mvn dependency:tree      # who pulled in what, and why

# Gradle equivalents
./gradlew test build dependencies

import static org.junit.jupiter.api.Assertions.*;

class AppTest {

    @Test
    void adds_two_numbers() {
        assertEquals(4, Calculator.add(2, 2));
    }

    @ParameterizedTest
    @CsvSource("0,0", "1,1", "-3,-3")
    void identity(int n, int expected) {
        assertEquals(expected, Calculator.identity(n));
    }

    @Test
    void rejects_negative() {
        assertThrows(IllegalArgumentException.class,
                     () -> Calculator.factorial(-1));
    }
}

module com.acme.hello {
    requires java.net.http;          // what I use
    exports  com.acme.hello.api;     // what others may see
    opens    com.acme.hello.model
        to com.fasterxml.jackson.databind;  // reflection only, for Jackson
}

mvn -q spotless:apply test   # or: ./gradlew spotlessApply test
# wire the same line into a git pre-commit hook and into CI

fun main() {
    val score = 10          // read-only binding — cannot be reassigned
    var count  = 0          // mutable
    count += 1

    // score = 20           // ❌ compile error: val cannot be reassigned

    println("$score, $count")   // 10, 1
    println("sum = ${score + count}")  // ${} for expressions
}

val a = 10                 // inferred Int
val b = 10L                // inferred Long
val pi = 3.14              // inferred Double
val msg: String = "hi"     // explicit when it helps
val n: Int? = null         // nullable — must be declared as such

fun add(x: Int, y: Int): Int = x + y   // return type on a single expression fun

// Single-expression functions: the return keyword is optional
fun square(n: Int): Int = n * n

// Block body: return required
fun describe(n: Int): String {
    return if (n > 0) "positive" else "non-positive"
}

// Default and named arguments — replaces most overloading
fun greet(name: String, greeting: String = "Hello") =
    "$greeting, $name!"

greet("Ashton")                    // "Hello, Ashton!"
greet("Ashton", greeting = "Yo")   // named argument
greet(greeting = "Hi", name = "Sam")  // order doesn't matter

// varargs
fun sum(vararg nums: Int): Int = nums.sum()

fun describe(user: User?): String {

    // 1. Safe call — ?.  returns null if the receiver is null
    val city: String? = user?.address?.city
    // chains freely; the whole chain is null if ANY link is null

    // 2. Elvis — ?:  give a default when the left side is null
    val name: String = user?.name ?: "anonymous"

    // 3. Not-null assertion — !!  "I guarantee this is non-null"
    val forced: String = user!!.name   // throws NPE if user is null

    // 4. Smart cast — compiler narrows after a null check
    if (user != null) {
        return user.name               // no !!, no ?., no cast
    }
    return "anonymous"
}

data class Address(val city: String?)
data class User(val name: String, val address: Address?)

fun main() {
    val u: User? = User("Ada", Address("London"))

    // Safe call chain: any null link short-circuits to null
    val city: String? = u?.address?.city
    println(city)            // London

    // Elvis at the end: give the whole chain a default
    val shown: String = u?.address?.city ?: "unknown"
    println(shown)           // unknown when u or address is null

    // let: act only inside the non-null branch
    u?.let {
        println("hello ${it.name}")
    }

    // let + ?. : handle the null case explicitly
    val greeting = u?.name?.let { "hi $it" } ?: "who?"

    // ?: with a lazy default — don't build the expensive value unless needed
    val config = loadConfig() ?: defaultConfig()

    // Chain Elvis operators for layered fallbacks
    val theme = prefs.theme ?: env.theme ?: "dark"
}

// Java: public String getName() { return maybeNull; }

val a: String  = javaObj.name   // compiles — you promised it's non-null
val b: String? = javaObj.name   // compiles — you're being cautious
val c = javaObj.name            // platform type String!

// Rule of thumb:
//   Java API you don't control  → treat as String? (defensive)
//   Java API you've verified    → String is fine
//   Your own Kotlin called from Java → declare ? or non-null explicitly

class Session {
    lateinit var user: User          // injected later — throws if read too early
    val config: Config by lazy {     // built on first use, then cached
        Config.load()                // expensive — but only if someone asks
    }

    fun ready() = ::user.isInitialized
}

// Optional wrapper — Kotlin's answer to java.util.Optional
val maybeName: String? = findName()          // preferred for nullable
val boxed: Optional<String> = Optional.of("hi")   // only when you need Optional's API

// Primary constructor lives in the class header
class Person(val name: String, val age: Int) {

    // Property with a custom getter — computed, not stored
    val isAdult: Boolean
        get() = age >= 18

    // Secondary constructor must delegate to the primary
    constructor(name: String) : this(name, 0)

    // init blocks run in declaration order alongside property initializers
    init {
        require(age >= 0) { "age must not be negative: $age" }
    }

    // Member function
    fun greet() = println("Hi, I'm $name")
}

fun main() {
    val p = Person("Ada", 36)
    println(p.name)      // property, not getName()
    println(p.isAdult)   // getter runs each access
    p.greet()
    println(p)           // Person(name=Ada, age=36) — toString is generated
}

data class User(val name: String, val age: Int, val city: String?)

fun main() {
    val a = User("Ada", 36, "London")
    val b = a.copy(age = 37)                 // named args — partial update in one line

    println(a)                                // User(name=Ada, age=36, city=London)
    println(a == b)                           // false — structural equality
    println(a.equals(b))                      // same as ==

    // Destructuring: component1() = name, component2() = age, ...
    val (name, age, city) = a
    println("$name is $age in $city")

    // Component access without naming
    println(a.component2())                   // 36

    // Works in maps for small records
    val (_, ageOnly) = a
}

// Sealed: every subtype is known at compile time (same package/module, Kotlin 1.5+)
sealed interface Result<out T>
data class Ok<T>(val value: T) : Result<T>
data class Err(val message: String, val cause: Throwable?) : Result<Nothing>

fun <T> compute(x: T): Result<T> = when {
    x == null -> Err("null input", null)
    else      -> Ok(x)
}

// Exhaustive when — add a subtype and THIS becomes a compile error
fun describe(r: Result<*>): String = when (r) {
    is Ok   -> "ok: ${r.value}"
    is Err  -> "failed: ${r.message}"
    // no else needed — the compiler proved it's exhaustive
}

// when as an expression, with smart casts inside
val (label, detail) = when (val r = compute(41)) {
    is Ok  -> "success" to r.value.toString()
    is Err -> "error" to r.message
}

interface Clickable {
    fun click()                       // abstract
    fun focus() { println("focused") } // default implementation — no separate class
}

interface Draggable { fun drag() }

// Multiple interface inheritance
class Button : Clickable, Draggable {
    override fun click()  = println("click")
    override fun drag()   = println("drag")
}

// by = class delegation: implement by forwarding to another object
class Panel(clickable: Clickable) : Clickable by clickable

// Object declarations: singletons without a static holder
object Json {
    fun encode(v: Any): String = """{"v":"$v"}"""
}
Json.encode(42)

// Companion — the Kotlin replacement for static members
class Counter private constructor() {
    companion object {
        var created = 0
        fun create() = Counter().also { created++ }
    }
}
Counter.create()

// Named + default args remove most factory methods
data class Request(val url: String, val method: String = "GET", val timeout: Int = 5000)
Request(url = "/users")                      // GET, 5000
Request("/users", method = "POST")           // order irrelevant

// Immutable by default — these are the ones to reach for
val fixed   = listOf("a", "b", "c")
val noDupes = setOf(1, 1, 2, 3)          // [1, 2, 3]
val lookup  = mapOf("a" to 1, "b" to 2)   // LinkedHashMap, insertion order
val empty   = emptyList<String>()

// Mutable when you genuinely need it
val names  = mutableListOf("ada")
val seen   = mutableSetOf<Int>()
val counts = mutableMapOf<String, Int>()

// Converting
val fromJava = javaList.toKotlinList()
val frozen   = names.toList()             // snapshot — safe to share
val copy     = names.toMutableList()      // independent mutable copy
val pairs    = mapOf("a" to 1).toMutableMap()

// Ranges and steps — a signature Kotlin feature
val oneToTen  = 1..10                     // IntRange, inclusive
val down      = 10 downTo 1               // 10, 9, …, 1
val evens     = 0..100 step 2
val noTop     = 0 until 10                // excludes 10
repeat(3) { print(it) }                   // 012

data class User(val name: String, val age: Int, val dept: String)

val users = listOf(
    User("Ada", 36, "eng"),
    User("Grace", 45, "eng"),
    User("Alan", 41, "research"),
    User("Katherine", 34, "ops"))

// filter → map → sorted — each line is one clear idea
val engNames = users
    .filter { it.dept == "eng" }
    .filter { it.age > 40 }
    .map { it.name }
    .sorted()                              // [Grace]

// Grouping — one call where Java needed Collectors.groupingBy
val byDept: Map<String, List<User>> = users.groupBy { it.dept }

// Counting, aggregation
val headcount = users.groupingBy { it.dept }.eachCount()   // eng=2, …
val avgAge    = users.map { it.age }.average()             // 39.0
val oldest    = users.maxByOrNull { it.age }
val anyEng    = users.any { it.dept == "eng" }
val first50   = users.takeWhile { it.age < 40 }

// associate: build a map in one pass
val byName: Map<String, User> = users.associateBy { it.name }

// flatMap: expand each element into many
val allDepts = users.map { it.dept }.toSortedSet()

// fold: the general-purpose accumulator
val shout = users.fold(StringBuilder()) { acc, u ->
    acc.append(u.name.uppercase()).append(' ')
}.toString().trim()

// List: 5 intermediate lists created
val a = (1..1_000_000)
    .map { it * 2 }        // allocates a full list
    .filter { it % 3 == 0 } // another
    .take(3)
    .toList()

// Sequence: lazy, one pass, stops early
val b = (1..1_000_000)
    .asSequence()
    .map { it * 2 }
    .filter { it % 3 == 0 }
    .take(3)
    .toList()              // terminal — pipeline runs here, and only until 3 found

// generateSequence: infinite sources, stopped by take/first
val fibs = generateSequence(Pair(0, 1)) { (a, b) -> Pair(b, a + b) }
    .map { it.first }
val first10 = fibs.take(10).toList()

// sequenceOf for a small literal
sequenceOf(1, 2, 3).map { it + 1 }.toList()

val double: (Int) -> Int = { it * 2 }
val sum: (Int, Int) -> Int = { a, b -> a + b }

fun apply(f: (Int) -> Int, v: Int) = f(v)    // functions as parameters
fun makeDoubler(): (Int) -> Int = { it * 2 } // and as return values

println(apply(double, 21))                   // 42
println(listOf(1, 2, 3).map(double))         // [2, 4, 6]

// Local functions — name a chunk of logic without a class
fun process(input: String): Int {
    fun clean(s: String) = s.trim().lowercase()
    fun score(s: String) = s.length * 2
    return score(clean(input))
}

// Extension functions — add to types you don't own
fun String.wordCount(): Int = trim().split(Regex("\\s+")).size
"the quick brown fox".wordCount()            // 4

// Infix — for single-parameter functions that read as an operation
infix fun Int.to(other: String): String = "$this=$other"
1 to "one"

// Operator overloading via conventions
data class Money(val cents: Long) {
    operator fun plus(o: Money) = Money(cents + o.cents)
    operator fun get(i: Int) = if (i == 0) cents else 0
}
Money(100) + Money(50)   // Money(150)

val user: User? = findUser()

// let — NULL CHECK + transform; return is the lambda result; receiver = it
val greeting = user?.let { "hi ${it.name}" }        // String?
user?.let { log.info("found ${it.name}") }

// with — group operations on one object; receiver = this; returns result
val text = with(StringBuilder()) {
    append("line1")
    append("line2")
    toString()
}

// apply — CONFIGURE a fresh object; receiver = this; returns the object
val request = Request().apply {
    method = "POST"
    url = "/users"
    header("X-Trace", "abc")
}                                                    // returns request

// also — SIDE EFFECT that doesn't change the flow; receiver = it; returns object
val users = mutableListOf<User>()
    .also { log.debug("created, size=${it.size}") }
    .apply { add(User("Ada")) }

// run — set up + compute; combines apply's receiver with let's return
val ports = run {
    val s = Socket()
    s.bind()
    s.localPort
}

import kotlin.contracts.*

fun <T> ensureNotNull(value: T?): T {
    contract {
        returns() implies (value != null)   // declare the effect
    }
    return requireNotNull(value)
}

fun handle(raw: String?) {
    val v = ensureNotNull(raw)
    println(v.length)    // ✅ smart cast — compiler trusts the contract
}

// Without the contract: "Smart cast to 'String' is impossible,
// because 'raw' is a function parameter that could change."

import kotlinx.coroutines.*

suspend fun fetchUser(id: String): User {
    delay(200)                       // suspends, does NOT block the thread
    return User(id, "Ada")
}

fun main() = runBlocking {           // bridges sync world → coroutine world
    println("before")

    val job = launch {               // fire and forget — returns Job
        val u = fetchUser("u1")
        println("got ${u.name}")
    }

    val deferred: Deferred<String> = async {   // returns a value
        fetchUser("u2").name
    }

    job.join()                       // wait for that one
    println("name=${deferred.await()}")        // get that one
    println("after")
}

import kotlinx.coroutines.*

suspend fun loadDashboard(): Dashboard = coroutineScope {
    // Concurrent — total time = slowest child, not the sum
    val user    = async { fetchUser("u1") }
    val posts   = async { fetchPosts("u1") }
    val alerts  = async { fetchAlerts("u1") }

    // If ANY child throws, the scope cancels the rest and rethrows.
    Dashboard(user.await(), posts.await(), alerts.await())
}

// Lifecycle scopes in an app
class ViewModel : CoroutineScope {
    private val job = SupervisorJob()
    override val coroutineContext = Dispatchers.Main + job

    fun refresh() = launch {
        val data = withContext(Dispatchers.IO) {   // hop to a blocking-friendly pool
            repository.load()
        }
        ui.render(data)                            // back on Main
    }

    fun onCleared() { job.cancel() }               // cancels every child
}

suspend fun work(items: Flow<Item>) = coroutineScope {
    launch {
        try {
            items.collect { process(it) }
        } catch (e: CancellationException) {
            throw e                       // ✅ always rethrow — it means "stop"
        } catch (e: Exception) {
            report(e)                     // real failure — handle it
        }
    }
}

suspend fun riskyLoop() {
    while (true) {
        ensureActive()                    // ❌ without this: cancellation ignored
        step()
    }
}

// Supervisor: children don't take each other down
val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
scope.launch { fetchUser("a") }   // if this fails…
scope.launch { fetchPosts("b") }  // …this keeps running

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

// Building a flow — suspending, one value at a time
fun numbers(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(100)                  // suspends — not blocking
        emit(i)                     // hand a value to the collector
    }
}

suspend fun main() = runBlocking {
    // Nothing happens until collect
    numbers().collect { value -> print("$value ") }   // 1 2 3 4 5

    // Transform operators — same shape as sequences
    numbers()
        .filter { it % 2 == 1 }
        .map { it * it }
        .take(2)
        .collect { println(it) }     // 1, 9

    // Terminal with a result
    val sum = numbers().reduce { a, b -> a + b }
    val first = numbers().first()
    val list  = numbers().toList()
}

data class Tick(val seq: Long, val price: Double)

fun ticks(): Flow<Tick> = /* socket feed */ emptyFlow()

suspend fun main() = runBlocking {

    // Intermediate — lazy, runs per value
    ticks()
        .filter { it.price > 100.0 }
        .distinctUntilChanged()          // suppress repeats — essential for signals
        .debounce(250)                   // wait for a pause in a bursty stream
        .onEach { audit.log(it) }        // side effect without changing values
        .collect { println(it) }

    // Combining and flattening
    val a: Flow<Int> = flowOf(1, 2, 3)
    val b: Flow<String> = flowOf("x", "y")

    a.zip(b) { n, s -> "$n$s" }.collect { print("$it ") }   // 1x 2y
    a.combine(b) { n, s -> "$n$s" }                          // emits on either

    // Merging concurrent sources
    merge(flowOf(1, 3), flowOf(2, 4)).collect { print(it) }  // interleaved

    // Flattening a flow of flows — flatMapConcat vs Latest vs Merge
    a.flatMapConcat { n -> flowOf(n, n) }.toList()   // sequential, in order
    a.flatMapLatest { n -> flowOf(n) }.toList()      // newest wins, old cancelled
}

import kotlinx.coroutines.flow.*

class SearchViewModel : CoroutineScope {

    // StateFlow: always has a value, new collectors get it immediately
    private val _query = MutableStateFlow("")          // write side
    val query: StateFlow<String> = _query.asStateFlow() // read-only exposure

    // SharedFlow: multi-subscriber events, no replay by default
    private val _events = MutableSharedFlow<UiEvent>()
    val events: SharedFlow<UiEvent> = _events.asSharedFlow()

    val results: StateFlow<List<Item>> = _query
        .debounce(300)
        .distinctUntilChanged()
        .flatMapLatest { q ->
            if (q.isBlank()) flowOf(emptyList()) else search(q)
        }
        .stateIn(
            scope = this,
            started = SharingStarted.WhileSubscribed(5_000),  // stop 5s after last UI
            initialValue = emptyList()
        )

    fun onQueryChanged(s: String) { _query.value = s }
}

@file:JvmName("Strings")          // Java: Strings.wordCount(...) instead of StringsKt

package com.acme.util

fun wordCount(s: String): Int = s.trim().split(Regex("\\s+")).size

class Greeter {
    companion object {
        @JvmStatic fun hello(who: String) = "hi $who"   // Greeter.hello(...)
        fun build(who: String = "world") = "hi $who"    // needs @JvmOverloads
        @JvmStatic @JvmOverloads
        fun shout(who: String = "world") = "HI $who"    // ✅ full Java ergonomics
    }

    @JvmOverloads
    constructor(prefix: String = "> ")

    @JvmField var label: String = "k"   // Java: g.label (no getter)
}

// From Java:
// Strings.wordCount("a b c");
// Greeter.hello("Ada");
// new Greeter();                    // thanks to @JvmOverloads
// g.label = "x";                    // thanks to @JvmField

import com.acme.util.Strings;      // file-level @JvmName
import com.acme.model.User;
import com.acme.net.Api;
import kotlin.Unit;

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

        // Top-level Kotlin function → static on the facade
        int n = Strings.wordCount("one two three");

        // Kotlin object with @JvmStatic → plain static
        String hi = Greeter.hello("Ada");

        // Lambda → SAM conversion (Kotlin fun interfaces are SAM-friendly)
        Runnable r = Greeter::helloRunnable;   // or a KotlinInterface { ... }

        // Suspending Kotlin function — the awkward one
        try {
            User u = Api.blockingFetch("u1");  // wrapped in runBlocking in Kotlin
            System.out.println(u.getName());
        } catch (Exception e) {
            System.out.println("failed: " + e.getMessage());
        }
    }
}

plugins {
    kotlin("multiplatform") version "2.0.21"
}

kotlin {
    jvm()                      // server, desktop, Android (as a library)
    iosArm64()                 // real device
    iosSimulatorArm64()        // simulator on Apple Silicon
    js(IR) { browser() }       // web
    linuxX64()                 // native server / CLI

    sourceSets {
        commonMain.dependencies {        // shared code sees this
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
            implementation("io.ktor:ktor-client-core:3.0.1")
        }
        jvmMain.dependencies {           // only the JVM target
            implementation("io.ktor:ktor-client-cio:3.0.1")
        }
        iosMain.dependencies {           // Apple targets
            implementation("io.ktor:ktor-client-darwin:3.0.1")
        }
    }
}

// commonMain — declares WHAT, not HOW
expect class Platform() {
    val name: String
    fun timestamp(): Long
}

expect fun  runBlockingCompat(block: suspend () -> T): T

// commonMain — real, shared business logic
class Greeting(private val repo: Repo) {
    suspend fun welcome(): String =
        "Hello from ${platformName()} at ${now()}"
}

// jvmMain/actual
actual class Platform actual constructor() {
    actual val name: String = "JVM ${System.getProperty("java.version")}"
    actual fun timestamp(): Long = System.currentTimeMillis()
}

// iosMain/actual
actual class Platform actual constructor() {
    actual val name: String = NSProcessInfo.processInfo.operatingSystemVersionString
    actual fun timestamp(): Long = (NSDate().timeIntervalSince1970 * 1000).toLong()
}

// ❌ "incompatible types: int cannot be converted to String"
String s = 42;
// ✅ decide what you meant:
String s = String.valueOf(42);        // display
int    i = Integer.parseInt(s);       // parse

// ❌ "unreported exception IOException"
static void copy(Path a, Path b) { Files.copy(a, b); }
// ✅
static void copy(Path a, Path b) throws IOException { Files.copy(a, b); }

// ❌ "local variables referenced from an inner class must be final or effectively final"
String tag = "x";
Runnable r = () -> System.out.println(tag);
tag = "y";              // ❌ breaks the lambda above
// ✅ capture a fixed copy before mutating:
String frozen = tag;

val name: String? = user?.name
println(name.length)     // ❌ safe-call required

// ✅ three legitimate answers to "what if null":
println(name?.length)            // pass the nullability along
println(name?.length ?: 0)       // choose a default
if (name != null) println(name.length)   // narrow first (smart cast)

// ❌ smart cast impossible — open/custom getter
class C { var x: String? = null }
fun f(c: C) { if (c.x != null) c.x.length }   // property may change

// ✅ local copy — now immutable, so the compiler trusts it
fun f(c: C) { val v = c.x; if (v != null) v.length }