TypeScript 7

Original Article ↗ Hacker News Discussion ↗

Go Port and Performance Gains

  • Main story: TypeScript 7’s Go-based compiler delivers huge type-checking speedups (often ~8–12x) with lower memory, especially on large codebases (e.g., VS Code, Sentry).
  • Many are surprised there were fewer HN complaints about tsc slowness than about rustc, despite tsc often feeling worse in practice.
  • Some argue Rust might be marginally faster than Go, but gains from the Go port are already “good enough,” and a Rust rewrite would take longer and be structurally harder (circular data structures, borrow checker).
  • Others highlight Go’s benefits for quick development, stable performance evolution, and easier 1:1 translation from JS/TS.

Compiler Architecture, APIs, and WASM

  • Port was intentionally a bug‑for‑bug, file‑for‑file translation, not a redesign, to preserve behavior.
  • Lack of a stable compiler API in 7.0 is a big pain point; many tools (frameworks, ESLint, ts-jest, etc.) are stuck on TS 6 until 7.1 and later APIs land.
  • WASM builds are planned but not fully clarified; different groups want:
    • LSP/Monaco in the browser
    • Compiler API in the browser
    • CLI binaries targeting WASM-only platforms

Ecosystem Impact and Tooling

  • Some already see big practical wins (fast pre-commit checks, snappier editors), others “only” 3–4x speedups but still happy.
  • Environments like Deno and various build/test tools need to integrate TS7 carefully because they plug into the compiler in non-trivial ways.
  • Linting/tooling (especially ESLint) remains a bottleneck for upgrading.

Static Typing Debate

  • Large subthread revisits static vs dynamic typing:
    • Pro-TS: types are crucial for maintainability, refactoring, onboarding, IDE support, and AI agents; TS helped normalize sophisticated type systems in JS land.
    • Skeptical/anti-TS: dynamic or gradually typed languages (Python, Ruby, JS + JSDoc/Zod) plus tests can be sufficient, especially for small teams, prototypes, or “vibe coding.”
    • Some argue earlier static type systems (Java/C-style) were clumsy; modern ones with inference, unions/sum types, and pattern matching change the tradeoffs.
    • Disagreement persists on whether untyped or dynamically typed approaches are “serious” for large systems.

Language Choices and AI / “Agentic” Era

  • Some see Go as a good fit for AI/agentic tooling; others argue strong static typing (e.g., TS, Rust) is even more valuable when code is machine-generated.
  • There’s tension between richer type-level programming (HKTs, complex type tricks) and the performance budget; faster compilers tempt developers to use more expensive type patterns.