Java
vs
The World

// Java 21
record Payment(String id, BigDecimal amount) {}

sealed interface Status permits Ok, Fail {}
record Ok() implements Status {}
record Fail(String why) implements Status {}

// C# equivalent — cleaner property syntax
record Payment(string Id, decimal Amount);

abstract record Status;
record Ok : Status;
record Fail(string Why) : Status;

// C# LINQ — Java Streams are the answer, but LINQ won first
var large = payments
    .Where(p => p.Amount > 1000m)
    .OrderBy(p => p.Amount)
    .Select(p => p.Id)
    .ToList();

// C# async/await — Java adopted CompletableFuture, then Loom
async Task<Payment> GetAsync(string id) {
    var data = await _db.FindAsync(id);
    return data ?? throw new KeyNotFoundException(id);
}

// C++20 — modern, but you own every byte
struct Payment {
    std::string id;
    double amount;
    
    // Rule of Zero — let compiler generate copy/move
    Payment(std::string id, double amt)
        : id{std::move(id)}, amount{amt} {}
};

// Templates — zero-cost compile-time polymorphism
template<typename T>
concept Processable = requires(T t) {
    { t.process() } -> std::same_as<void>;
};

// std::expected (C++23) — error handling without exceptions
std::expected<Payment, Error> find(std::string_view id) {
    if (auto it = db.find(id); it != db.end())
        return it->second;
    return std::unexpected(Error::NotFound);
}

// Java: no pointers, no manual memory, no undefined behavior
// The JVM is the "zero-cost abstraction" Java chose

{ Pascal/Delphi — verbose, unambiguous, pedagogically clear }
type
  TPayment = record
    Id: string;
    Amount: Currency;  { Pascal had Currency type! Java uses BigDecimal }
  end;

  TPaymentStatus = (psOk, psFailed, psPending);  { Typed enums 1970! }

procedure ProcessPayment(const P: TPayment);
begin
  { Delphi interfaces — inspired COM, which influenced JavaBeans }
  if P.Amount > 1000 then
    LogAudit(P.Id)
  else
    FastTrack(P.Id);
end;

{ Delphi VCL — visual component library, 1995
  Spring Framework didn't arrive until 2002
  Delphi was shipping IoC via components 7 years earlier }

// Java equivalent muscle memory:
public void processPayment(final Payment p) {
    if (p.amount().compareTo(BigDecimal.valueOf(1000)) > 0)
        logAudit(p.id());
    else fastTrack(p.id());
}

Understanding Pascal's lineage illuminates modern language design. Niklaus Wirth designed Pascal for teaching structured programming, then later designed Modula-2 and Oberon (direct predecessors of Go's simplicity philosophy). Anders Hejlsberg led Turbo Pascal, then Delphi, then C# (for Microsoft), then TypeScript. One person's design philosophy spans Pascal → C# → TypeScript — three languages you use or study in this curriculum. The clean type system, excellent IDE integration, and developer ergonomics are a continuous thread.

// Go: explicit, minimal, no magic
type Payment struct {
    ID     string
    Amount float64
}

// Interfaces satisfied implicitly — no "implements" keyword
type Processor interface {
    Process(Payment) error
}

// Multiple return values — error handling by convention
func FindPayment(id string) (Payment, error) {
    p, ok := db[id]
    if !ok {
        return Payment{}, fmt.Errorf("not found: %s", id)
    }
    return p, nil
}

// Goroutines + channels — CSP model
func ProcessBatch(payments []Payment) {
    results := make(chan error, len(payments))
    for _, p := range payments {
        go func(pay Payment) { results <- process(pay) }(p)
    }
}

// Java equivalent: virtual threads + StructuredTaskScope (Java 21)
// Go had this model since 2009 — 14-year head start

// Go CSP — channels are first-class values
func FanOut(ids []string) []Payment {
    ch := make(chan Payment)
    for _, id := range ids {
        go func(id string) { ch <- fetch(id) }(id)
    }
    results := make([]Payment, 0, len(ids))
    for range ids {
        results = append(results, <-ch)
    }
    return results
}

// Java 21 equivalent — virtual threads make this comparable:
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    var tasks = ids.stream().map(id -> scope.fork(() -> fetch(id)));
    scope.join().throwIfFailed();
    return tasks.map(Task::get).toList();
}

// Rust: the borrow checker enforces memory safety at compile time
struct Payment {
    id: String,
    amount: f64,
}

// Result<T,E> = Java's Optional + checked exception, unified
fn find_payment(id: &str) -> Result<Payment, AppError> {
    db.get(id)
      .ok_or(AppError::NotFound(id.to_string()))
      .cloned()
}

// Ownership — one owner, explicit borrowing, no GC needed
fn process(payment: Payment) {         // takes ownership
    audit(&payment.id);              // borrows immutably
    charge(&mut payment.amount);      // borrows mutably
}                                    // payment dropped here

// Pattern matching — more powerful than Java's switch
let msg = match status {
    Status::Ok           => "cleared",
    Status::Failed(why)  => &why,
    Status::Pending      => "awaiting",
};

// Java: GC handles this. Rust: compiler handles this.
// Different solutions to the same problem: safe memory management.

// Rust async with Tokio
async fn fetch_all(ids: Vec<String>) -> Vec<Payment> {
    let futures: Vec<_> = ids.iter()
        .map(|id| fetch_payment(id))
        .collect();
    futures::future::join_all(futures).await
}

// Zero stack allocation per task — stackless coroutines
// Java Virtual Threads: ~1KB stack per thread by default
// Rust async: 0 bytes until awaited — pure state machine
// For 1M concurrent tasks: Rust wins on memory.
// For developer ergonomics: Java virtual threads win.

# Python 3.12 — readable like pseudocode
from dataclasses import dataclass
from decimal import Decimal

@dataclass
class Payment:
    id: str
    amount: Decimal

# Type hints (optional but increasingly used)
def process_batch(payments: list[Payment]) -> list[str]:
    return [p.id for p in payments if p.amount > 1000]

# FastAPI — closest to Spring Boot, but 5x less ceremony
from fastapi import FastAPI
app = FastAPI()

@app.get("/payments/{id}")
async def get_payment(id: str) -> Payment:
    return await db.find(id)  # auto-serialized to JSON

# LangChain — this is your Python superpower for the new job
from langchain.agents import AgentExecutor
from langchain_anthropic import ChatAnthropic

agent = AgentExecutor(
    agent=create_tool_calling_agent(
        ChatAnthropic(model="claude-3-5-sonnet"),
        tools, prompt
    ),
    tools=tools
)

# Elixir — everything is a process, nothing shares state
defmodule Payment do
  defstruct [:id, :amount, :status]

  # Pattern matching is the primary control flow
  def process(%Payment{amount: amount} = payment)
      when amount > 1000 do
    payment |> audit() |> high_value_route()
  end

  def process(payment), do: fast_track(payment)
end

# GenServer — stateful process, OTP's workhorse
# Equivalent to a Spring @Service but with built-in
# supervision, restart strategies, and message queues
defmodule PaymentServer do
  use GenServer

  def init(state), do: {:ok, state}

  def handle_call({:process, payment}, _from, state) do
    result = Payment.process(payment)
    {:reply, result, state}
  end
end

# Supervisor tree — crashes are managed, not avoided
Supervisor.start_link([PaymentServer], strategy: :one_for_one)
# "Let it crash" — the opposite of Java's defensive programming

# Elixir's |> pipe operator
result = payment_id
  |> fetch_payment()
  |> validate_limits()
  |> apply_rules()
  |> route_to_processor()
  |> record_audit()

# Java equivalent — method chaining or Stream pipeline:
String result = Stream.of(paymentId)
    .map(this::fetchPayment)
    .map(this::validateLimits)
    .map(this::applyRules)
    .map(this::routeToProcessor)
    .peek(this::recordAudit)
    .findFirst().orElseThrow();

# The pipe influenced Clojure's threading macros,
# Java's Stream API, and functional thinking broadly.

-- Haskell: types encode business rules
data Payment = Payment
  { payId     :: PaymentId   -- newtype wrapper, not raw String
  , payAmount :: Positive Money -- amount > 0, enforced by type
  }

-- Functor/Monad -- Java's Optional and CompletableFuture
-- are watered-down versions of this concept
processPayment :: PaymentId -> IO (Either Error Receipt)
processPayment pid = do
  p   <- fetchPayment pid     -- IO action
  val <- validate p           -- pure function
  charge val                  -- effectful, but tracked in type

-- The type IO (Either Error Receipt) tells you:
-- this function touches the outside world (IO)
-- and can fail with Error OR succeed with Receipt
-- Java's checked exceptions tried this; Haskell perfected it

-- Typeclasses -- more powerful than Java interfaces
class Auditable a where
  auditTrail :: a -> [AuditEvent]

-- Instance derived automatically where possible
instance Auditable Payment where
  auditTrail p = [AuditEvent (payId p) "processed"]

// TypeScript — familiar structure, structural typing
interface Payment {
  readonly id: string;
  readonly amount: number;
  status: 'pending' | 'cleared' | 'failed'; // union type
}

// Generics — recognizable from Java
async function findById<T extends { id: string }>(
  id: string, repo: Repository<T>
): Promise<T | null> {
  return repo.findOne({ where: { id } });
}

// Discriminated unions -- sealed interfaces in Java
type Status =
  | { kind: 'ok'; clearedAt: Date }
  | { kind: 'failed'; reason: string }
  | { kind: 'pending' };

// NestJS — the Spring Boot of TypeScript
@Controller('/payments')
export class PaymentController {
  constructor(private svc: PaymentService) {}  // DI injection

  @Get('/:id')
  async get(@Param('id') id: string): Promise<Payment> {
    return this.svc.find(id);   // Same mental model as @GetMapping
  }
}