How One Engineer’s Pragmatism Built Four Blockbuster Languages Over 40 Years

In 1983 a Danish team released Turbo Pascal at a price of $49.95 – a tenth of the typical $500 compiler price – and introduced a revolutionary “Run” button that compiled code directly in memory, eliminating the edit‑compile‑run cycle. This reduced a workflow that previously took minutes to seconds, turning a professional tool into a mass‑market product.

Turbo Pascal: Removing the "wait" from programming

Hejlsberg identified the real moat as the time developers spent waiting for compilation. By integrating editor and compiler and performing in‑memory compilation, Turbo Pascal turned a multi‑minute loop into a near‑instant feedback cycle, dramatically increasing developer productivity.

Delphi to C#: Competing on the platform, not on language features

After Turbo Pascal, Hejlsberg led Delphi, which combined visual rapid development with native compilation performance. When he moved to Microsoft, he rejected Java’s "write once, run anywhere" promise, arguing that developers on Windows needed the best native experience. This led to C# and .NET, which blended Visual Basic’s ease of use with C++’s power, targeting the platform developers already chose.

TypeScript: Fixing the language developers already use

Faced with teams using Script# to translate C# to JavaScript, Hejlsberg realized that adding a type system to JavaScript (TypeScript) offered zero migration cost, unlike creating a new language. TypeScript’s strategy was to inherit JavaScript’s ecosystem while providing static typing, allowing seamless adoption and massive developer uptake.

function greet(name) { return "Hello, " + name; }
function greet(name: string): string { return "Hello, " + name; }

He emphasized that a language’s success hinges on minimizing the effort required for developers to gain benefits.

Go Migration: Choosing a cheap, compatible path

In 2024 the TypeScript team needed a 10× performance boost. Porting the compiler to native code yielded a ten‑fold speedup, but the team debated rewriting in Rust versus porting to Go. Rust’s ownership model would have required a full rewrite, while Go’s garbage‑collected, simple object model allowed a line‑by‑line functional port, preserving behavior and enabling automated testing.

The decision favored Go because the migration cost was linear, verification could be automated per function, and compatibility with existing TypeScript projects was retained.

AI Era: Language network effects

Hejlsberg argued that AI models are "regurgitators" that excel at languages they have seen most. New languages therefore face a disadvantage because AI‑assisted coding favors established languages like JavaScript and Python, reinforcing existing ecosystem lock‑in.

He suggested using AI to generate deterministic migration tools rather than relying on AI‑generated code directly, keeping core logic auditable while leveraging AI for peripheral tasks.

The Common Formula

Across Turbo Pascal, C#, TypeScript, and the Go migration, the consistent principle was reducing developer friction: faster compile cycles, platform‑specific excellence, zero migration cost, and performance gains without changing the developer’s workflow.

Hejlsberg’s pragmatic approach demonstrates that language superiority alone does not win; the decisive factor is delivering the greatest output for the smallest developer effort.