On October 1, 2012, Microsoft publicly released TypeScript 0.8 — a typed superset of JavaScript that compiled to plain JavaScript. The technical lead and principal designer was Anders Hejlsberg, a 52-year-old Danish software engineer who had already created three commercially successful programming languages over the previous three decades: Turbo Pascal, Delphi, and C#. TypeScript was his fourth. Within a decade, it would become one of the most adopted programming languages in history — the 2024 Stack Overflow Developer Survey found that TypeScript was used by 38.5% of all developers, making it the fourth most popular language overall, and 73% of TypeScript users said they wanted to continue using it (the highest satisfaction rate among mainstream languages). By 2026, TypeScript has become the default for serious JavaScript development. Angular, adopted it from inception. React’s ecosystem overwhelmingly uses it. Vue 3 was rewritten in it. Deno runs it natively. The language that Hejlsberg built did not replace JavaScript — it enhanced it, adding a type system that catches bugs at compile time while maintaining perfect compatibility with the existing JavaScript ecosystem of billions of lines of code.
Early Life and Path to Technology
Anders Hejlsberg was born on December 2, 1960, in Copenhagen, Denmark. He became interested in programming as a teenager and largely taught himself through experimentation. While attending the Technical University of Denmark in the early 1980s, Hejlsberg wrote a Pascal compiler for the Nascom microcomputer that ran in just 8 kilobytes of RAM. This compiler caught the attention of Philippe Kahn, the founder of Borland International, a software company in Scotts Valley, California.
Borland licensed Hejlsberg’s compiler and released it as Turbo Pascal 1.0 on November 20, 1983, at a price of $49.95 — dramatically undercutting competing Pascal compilers that cost several hundred dollars. Turbo Pascal included an integrated development environment (IDE) — one of the first commercial IDEs — that combined a text editor, compiler, and debugger in a single program. The compiler was blazingly fast, compiling programs in seconds on hardware that typically took minutes, because Hejlsberg had optimized it to perform single-pass compilation entirely in memory. Turbo Pascal became a massive commercial success, selling over a million copies and making Borland a major force in the software tools market. Hejlsberg moved to California to work at Borland full-time, becoming Chief Architect.
The Breakthrough: Turbo Pascal, Delphi, C#, and TypeScript
The Technical Innovation
Hejlsberg’s career represents a unique arc in computing: four distinct language projects, each addressing the dominant challenge of its era.
Turbo Pascal (1983) solved the problem of personal computer programming. In the early 1980s, compilers for the IBM PC were expensive, slow, and disconnected from the editing and debugging process. Hejlsberg’s single-pass compiler, integrated with an editor and debugger, made programming accessible and productive on affordable hardware. Turbo Pascal taught a generation of programmers — particularly in Europe and Latin America — how to code.
Delphi (1995) solved the problem of Windows GUI development. By the early 1990s, Windows had become the dominant desktop platform, and creating Windows applications required either the Windows SDK (complex C code) or Visual Basic (limited in performance and capability). Hejlsberg led the design of Delphi at Borland — an Object Pascal language with a visual form designer, a component architecture (VCL — Visual Component Library), and native code compilation. Delphi let developers build sophisticated Windows applications by dragging components onto a form and writing event handlers. It compiled to native code (unlike Visual Basic, which was interpreted), making Delphi applications fast and distributable as standalone executables. Delphi was enormously successful in the enterprise market and is still used today, particularly in Eastern Europe and Latin America.
C# (2000) solved the problem of managed-code application development. In 1996, Microsoft recruited Hejlsberg away from Borland (a move that triggered a lawsuit). At Microsoft, Hejlsberg became the lead architect of C# and a key designer of the .NET Framework. C# drew heavily from Java (classes, interfaces, garbage collection, single inheritance) and C++ (operator overloading, value types), but added significant innovations: properties (getter/setter syntax), delegates (type-safe function pointers), events, attributes (metadata), and later LINQ (Language Integrated Query), async/await, and pattern matching. C# was released in 2000 alongside .NET and has evolved through 13 major versions, each adding substantial features while maintaining backward compatibility.
TypeScript (2012) solved the problem of large-scale JavaScript development. By 2010, JavaScript had grown from a browser scripting language into the foundation of both frontend and backend web development (via Node.js). But JavaScript’s dynamic type system made it difficult to maintain large codebases — a renamed function would not produce an error until that code path was executed at runtime, and IDE support (autocomplete, refactoring) was limited because the types of variables were unknown. Hejlsberg’s solution was to add optional static types to JavaScript in a way that was completely backward-compatible:
// TypeScript adds types to JavaScript without changing its semantics
interface User {
id: number;
name: string;
email: string;
role: 'admin' | 'editor' | 'viewer'; // Union type: only these values allowed
}
function getDisplayName(user: User): string {
return `${user.name} (${user.role})`;
}
// The compiler catches errors before runtime
const user: User = {
id: 1,
name: "Anders",
email: "anders@example.com",
role: "admin"
};
console.log(getDisplayName(user)); // Works fine
// console.log(getDisplayName({ name: "Test" }));
// ERROR at compile time: missing required properties 'id', 'email', 'role'TypeScript’s type system is structurally typed (not nominally typed like Java or C#), meaning that types are compatible if their structures match, regardless of their declared names. This design decision was crucial because it allowed TypeScript to type-check existing JavaScript patterns that rely on duck typing. TypeScript could describe virtually any JavaScript API using its type system — including complex patterns like function overloading, generic types, mapped types, conditional types, and template literal types:
// TypeScript's advanced type system can model complex patterns
type ApiResponse<T> =
| { status: 'success'; data: T; timestamp: number }
| { status: 'error'; message: string; code: number };
async function fetchUser(id: number): Promise<ApiResponse<User>> {
try {
const response = await fetch(`/api/users/${id}`);
const data = await response.json();
return { status: 'success', data, timestamp: Date.now() };
} catch (error) {
return { status: 'error', message: String(error), code: 500 };
}
}
// The compiler knows exactly which properties are available
const result = await fetchUser(1);
if (result.status === 'success') {
console.log(result.data.name); // OK: data is typed as User
console.log(result.timestamp); // OK: timestamp exists on success
} else {
console.log(result.message); // OK: message exists on error
// console.log(result.data); // ERROR: data doesn't exist on error
}Why It Mattered
TypeScript’s brilliance was in its strategy of gradual adoption. Every valid JavaScript program is also a valid TypeScript program — you can rename a .js file to .ts and it will compile. This meant that teams could adopt TypeScript incrementally, adding type annotations to existing code file by file, rather than rewriting their entire codebase. This zero-barrier-to-entry approach was critical for adoption in an ecosystem with billions of lines of existing JavaScript code.
The DefinitelyTyped repository (now containing type definitions for over 8,000 npm packages) provided type information for existing JavaScript libraries, so TypeScript developers could get type checking even when using libraries written in plain JavaScript. The TypeScript compiler itself provided IDE services — autocomplete, go-to-definition, rename refactoring, error highlighting — that dramatically improved the JavaScript development experience in editors like VS Code.
TypeScript’s success also validated a broader insight about programming language adoption: it is often easier to improve an existing language than to replace it. JavaScript’s position as the web’s runtime language was unassailable. Rather than fighting that reality (as CoffeeScript, Dart, and Elm attempted), TypeScript embraced it, providing a better experience while maintaining complete JavaScript compatibility.
TypeScript’s Type System Innovation
TypeScript’s type system is one of the most sophisticated in any mainstream programming language — not because it is theoretically pure, but because it was designed to model the real-world patterns of JavaScript code. Unlike the type systems of Java or C#, which TypeScript’s own creator also designed, TypeScript’s type system is structural rather than nominal. This means types are compatible based on their shape (what properties and methods they have) rather than their name or declaration hierarchy.
Mapped types allow creating new types by transforming the properties of existing types. Conditional types enable type-level logic — choosing one type or another based on a condition evaluated at compile time. Template literal types (added in TypeScript 4.1) can manipulate string types at the type level, enabling type-safe routing, event handling, and API definitions. The combination of these features makes TypeScript’s type system Turing-complete — it can theoretically compute any computable function — which has led to creative (and sometimes absurd) demonstrations like implementing a chess engine or a SQL parser entirely within the type system.
The practical impact of these features is profound. Libraries like Prisma (a database ORM) generate TypeScript types from database schemas, ensuring that every query is type-checked against the actual database structure. tRPC creates end-to-end type-safe APIs where the types flow from the server implementation through to the client code without any code generation step. Zod provides runtime validation with automatic TypeScript type inference. These tools would be impossible without TypeScript’s advanced type system, and they represent a new approach to software development where the type system serves as a single source of truth that is automatically propagated throughout the application stack.
Beyond Languages: Other Contributions
Hejlsberg’s influence extends beyond the specific languages he designed. At Microsoft, he was a key designer of the .NET Common Language Runtime (CLR) and the .NET type system — infrastructure used by C#, F#, Visual Basic .NET, and dozens of other languages targeting the .NET platform. The CLR’s generics implementation (co-designed with Don Syme, who later created F#) was notable for preserving full type information at runtime (reified generics), unlike Java’s type-erased generics.
He also championed Language Integrated Query (LINQ), which added query syntax (filtering, sorting, grouping, joining) directly into C#. LINQ influenced similar features in Ruby‘s Enumerable, Python’s list comprehensions, Kotlin’s collection operations, and Swift’s sequence and collection APIs. The async/await pattern, which Hejlsberg helped bring to C# 5.0 (2012), was subsequently adopted by JavaScript (ES2017), Python 3.5, Rust, Kotlin, Swift, and Dart — becoming the standard approach to asynchronous programming across the industry.
Throughout his career, Hejlsberg has received numerous awards: the Dr. Dobb’s Excellence in Programming Award (2001), election to the Microsoft Technical Fellows program, and the TC39 committee recognition for TypeScript’s contribution to the JavaScript ecosystem. He was named a Technical Fellow at Microsoft, the company’s highest technical designation.
Philosophy and Engineering Approach
Key Principles
Hejlsberg’s design philosophy centers on pragmatic type safety. Across all four of his languages, he has sought to provide the maximum benefit of static typing while minimizing the burden it places on programmers. Turbo Pascal used a simpler, more accessible Pascal than the formal standard. Delphi added properties and events to make type-safe GUI development natural. C# introduced type inference with var and later pattern matching to reduce boilerplate. TypeScript made its entire type system optional, allowing programmers to use as much or as little typing as they needed.
He also values compiler performance. From Turbo Pascal’s single-pass compilation in 8KB of RAM to TypeScript’s incremental compilation and language server protocol, Hejlsberg has consistently prioritized fast feedback loops. He understands that developers will not adopt a language whose tools slow them down, no matter how theoretically superior it might be. TypeScript’s language server — which provides real-time error checking, autocomplete, and refactoring in IDEs — was designed to be responsive even on million-line codebases.
Hejlsberg is pragmatic about backward compatibility. TypeScript maintains compatibility with all valid JavaScript. C# maintains backward compatibility across versions. This commitment sometimes requires compromises — TypeScript cannot fix JavaScript’s quirks, and C# carries legacy features from early versions — but Hejlsberg considers the ability to adopt new tools incrementally more valuable than theoretical purity. This philosophy connects to a tradition in successful language design: Stroustrup’s insistence on C compatibility for C++, or Go’s commitment to backward compatibility from version 1.0 onward.
Legacy and Modern Relevance
In 2026, Hejlsberg’s fingerprints are on much of the software industry. TypeScript has become the standard for frontend development — the major frameworks (React, Vue, Angular, Svelte) all have first-class TypeScript support, and new projects increasingly default to TypeScript over JavaScript. TypeScript 5.x releases continue to add features: decorators (5.0), const type parameters (5.0), improved narrowing (5.3), and ongoing performance improvements.
C# remains a top-10 programming language worldwide. .NET 8 (November 2023) delivered significant performance improvements, native AOT compilation, and continued the framework’s transformation from a Windows-only platform to a cross-platform powerhouse running on Linux, macOS, and in containers. C# 12 added primary constructors, collection expressions, and alias any type. The Unity game engine, used to create roughly half of all mobile games, uses C# as its scripting language — meaning Hejlsberg’s language design decisions directly affect millions of game developers.
The four languages Hejlsberg created or led — Turbo Pascal, Delphi, C#, and TypeScript — span the entire history of personal computing, from the IBM PC era through Windows desktop dominance through the managed-code revolution through the web application era. Each solved the central development challenge of its time. No other living language designer has produced four commercially successful languages across four distinct computing eras. That consistency of output, over four decades, makes Anders Hejlsberg one of the most productive and influential figures in programming language history.
Key Facts
- Born: December 2, 1960, Copenhagen, Denmark
- Known for: Creating Turbo Pascal, Delphi, C#, and TypeScript
- Key projects: Turbo Pascal (1983), Delphi (1995), C# and .NET (2000), TypeScript (2012)
- Awards: Dr. Dobb’s Excellence in Programming Award (2001), Microsoft Technical Fellow
- Current role: Technical Fellow at Microsoft (as of 2024)
Frequently Asked Questions
Who is Anders Hejlsberg?
Anders Hejlsberg is a Danish software engineer who has created four commercially successful programming languages over four decades: Turbo Pascal (1983), Delphi (1995), C# (2000), and TypeScript (2012). He is a Technical Fellow at Microsoft and one of the most prolific programming language designers in history, with each of his languages becoming widely adopted in its respective era.
What did Anders Hejlsberg create?
Hejlsberg created Turbo Pascal (a fast, affordable Pascal compiler with an integrated IDE), Delphi (a visual development environment for Windows using Object Pascal), C# (Microsoft’s modern, managed programming language for the .NET platform), and TypeScript (a typed superset of JavaScript for large-scale web development). He also played a key role in designing the .NET Common Language Runtime and pioneered features like LINQ and async/await that were widely adopted across the industry.
Why is Anders Hejlsberg important?
Hejlsberg has had a unique impact because he solved the dominant programming challenge of four different computing eras. Turbo Pascal made programming accessible on personal computers. Delphi made Windows GUI development productive. C# provided a modern, safe language for enterprise development. TypeScript tamed JavaScript for large-scale web applications. His innovation of adding optional static types to JavaScript through TypeScript — achieving safety without sacrificing compatibility — has become the dominant approach to JavaScript development and influenced how the industry thinks about gradually introducing type systems into dynamic languages.
