rgoussu.dev
rgoussu@goussu: ~/library/paths
❯ ~/library/paths cat language-craft.md

Language craft — mastery in depth

# Four languages held to the same bar — Java and TypeScript as the working pair, Go and Rust as the perspective pair — each proven by a flagship build, with concurrency as the through-line.

Pathsaved 2026-08-08 #path#java#typescript#go#rust#concurrency

Goal

A full-stack architect needs depth in the languages they ship (Java on the backend, TypeScript on the front) and perspective from languages with different opinions (Go's deliberate simplicity, Rust's ownership discipline). This path takes each beyond syntax — runtime, memory model, concurrency story, ecosystem — and proves each with the KB's flagship build for that language. The recurring lens is concurrency and parallelism: every language module answers "how does this one do many things at once, and what does it cost?"

Prerequisites

  • Foundations — especially the OS and network modules; every build here leans on them.

Modules

1. Java, to the metal

  • Read: Deep dive Java — JVM internals, GC, virtual threads, the modern language.
  • Do: One Billion Row Challenge.
  • Proof: the staged optimization ladder per the subject, each stage's speedup measured and explained — profiler evidence, not vibes.

2. TypeScript as a design tool

  • Read: TypeScript deep dive and Covariance & contravariance — the variance thread runs through all four languages here.
  • Do: the note's practice drills — type-level katas plus a strict-mode migration of a real project (the variance workout slots in here); the type discipline gets product-scale exercise in the full-stack path's capstone.
  • Proof: a domain modeled so invalid states don't compile, defended in review.

3. Go and the CSP worldview

  • Read: Deep dive Go.
  • Do: Protohackers ladder.
  • Proof: rungs 0–5 race-detector clean and green on the online checker; the mutex-vs-monitor-goroutine opinion from Budget Chat, written down.

4. Rust and the ownership discipline

  • Read: Deep dive Rust.
  • Do: Tokio mini-redis.
  • Proof: the build's staged acceptance, plus one Protohackers rung re-solved in Rust and a written comparison of the two concurrency models.

5. The cross-language synthesis

  • Read: the Concurrency and Parallelism group in full.
  • Do: a one-page comparison — threads vs goroutines vs async/await vs virtual threads, memory safety strategies, where each language would be your pick and why.
  • Proof: the page exists, cites the four builds above as evidence, and takes actual positions.

Related