“TypeScript is JavaScript that scales.”
The Story
Anders Hejlsberg has built four major programming languages or platforms, each one a response to the dominant failure mode of its era. His career is a forty-year arc through the evolution of software development, and each stop left tools that millions of developers still use daily.
Turbo Pascal (1983): Hejlsberg wrote the Turbo Pascal compiler at Borland. It compiled Pascal nearly instantly on an IBM PC, included an integrated editor, and sold for $49.95. Before Turbo Pascal, compiled-language development on personal computers was slow, expensive, and painful. Hejlsberg made it fast, cheap, and accessible. The compiler was so efficient that it could compile itself in under a minute on hardware that would make a modern smartwatch look powerful. Turbo Pascal didn't just sell well — it proved that a single developer could build a world-class compiler, and that developer experience (fast feedback loops, integrated tooling) was a feature, not a luxury.
Delphi (1995): As Borland's chief architect, Hejlsberg created Delphi — Object Pascal with a visual component framework for building Windows applications. Delphi was the tool that powered the enterprise desktop era. Drag a button onto a form, double-click it, write the event handler. Applications that would take months in C++ took weeks in Delphi. Banks, hospitals, logistics companies, government agencies — Delphi was everywhere. The applications built in Delphi during the late 1990s and early 2000s are, in many cases, still running. Some are documented in TechnicalDepth's exhibits, including the Greedy Initializer, where Delphi's rapid development capabilities sometimes led to architectural shortcuts that calcified into permanent technical debt.
C# (2000): Microsoft hired Hejlsberg away from Borland to build their answer to Java. C# launched with .NET in 2002 — a managed language with garbage collection, strong typing, and a runtime (the CLR) designed for cross-language interoperability. Where Java was cautious and verbose, C# was willing to evolve: generics, LINQ, async/await, pattern matching. Hejlsberg pushed C# to absorb good ideas from functional programming while remaining accessible to the enterprise developers who were its core audience. Today, C# powers everything from Unity game development to Azure cloud services.
TypeScript (2012): JavaScript had won the browser. Then it won the server (Node.js). Then it won mobile (React Native). But JavaScript's dynamic type system meant that bugs that a compiler could catch were instead caught by users in production — or not caught at all. Hejlsberg's response was TypeScript: a strict syntactic superset of JavaScript that adds optional static typing. The key word is optional. TypeScript doesn't force you to type everything — it meets you where you are, letting you add types gradually. This pragmatic approach to type safety drove adoption: by 2025, the majority of new JavaScript projects started with TypeScript.
Why They're in the Hall
Hejlsberg is a Builder of unusual range. Most language designers create one language and spend a career refining it. Hejlsberg has created four, each addressing a different problem, each successful, each still in active use.
His career arc traces the same evolution that TechnicalDepth's Exhibits wing documents. The desktop era (Turbo Pascal, Delphi) gave way to the managed-runtime era (C#, Java) which gave way to the web era (JavaScript, TypeScript). Each transition created new categories of bugs and new categories of exhibits. Delphi's rapid application development produced the initialization patterns documented in the Greedy Initializer. Java and C#'s garbage collection traded manual memory bugs for a new class of performance problems. JavaScript's dynamic typing created the type-confusion bugs that TypeScript was built to prevent.
Hejlsberg has been present at each of these transitions, not as an observer but as a builder of the tools that defined them. He has watched the same categories of bugs recur across decades and platforms, and each of his languages is an attempt to make one category of mistake structurally impossible.
The Turbo Pascal-to-TypeScript arc also demonstrates something about the nature of type systems and data integrity. Turbo Pascal enforced types strictly — every variable had a declared type, and the compiler rejected mismatches. JavaScript abandoned types entirely — everything is a number or a string or an object, and the runtime will silently coerce between them. TypeScript brought types back, but optionally, gradually, pragmatically. This journey — from strict types, through no types, back to types — mirrors the industry's slow realization that type safety isn't a bureaucratic constraint imposed by fussy compilers. It's a defense mechanism. Every type error caught at compile time is a bug that never reaches production, never appears in an incident report, never becomes an exhibit.
Hejlsberg understood this in 1983. The industry took forty years to agree with him.