Anders Hejlsberg has designed languages for more than four decades, but
his influence reaches beyond syntax. From Turbo
Pascal to TypeScript, he has worked on
the relationship among language, compiler, editor, libraries, and
runtime. The programming experience depends on that entire system.
The contexts differ sharply. Turbo Pascal had to fit 1980s
microcomputers and compile unusually fast. Delphi targeted visual
Windows development. C# accompanied .NET and had to remain coherent
as it evolved. TypeScript brought static analysis to
JavaScript without breaking its vast
ecosystem.
Hejlsberg has been a central architect, not a solitary inventor.
Borland’s teams, C#’s co-designers, the TypeScript team, and their
communities turned initial directions into widely used languages.
Programming on a microcomputer before modern environments
Born in Copenhagen in 1960, Hejlsberg studied engineering at the
Technical University of Denmark. Early microcomputers broadened access
to programming, but memory, processor speed, and storage severely
constrained their tools. Editing, compiling, correcting, and running
code were often separate, slow steps.
Hejlsberg developed Compass Pascal, later PolyPascal, in Denmark.
Borland acquired it and integrated it into a microcomputer product:
Turbo Pascal.
Turbo Pascal: the compiler as a complete experience
Released in 1983, Turbo Pascal combined an editor, compiler, build
commands, and execution in one affordable program. Near-immediate
compilation changed the working rhythm: users could test an idea and
correct it without losing their train of thought.
Hardware constraints encouraged a compact design with few layers and
careful memory use. Turbo Pascal built on Niklaus
Wirth’s language while adding libraries,
application features, and object extensions. Hejlsberg wrote the
original compiler; Borland’s engineering, documentation, compatibility
work, and distribution made it a platform.
Delphi: uniting language, components, and visual interfaces
Windows development required interfaces, events, libraries, and platform
conventions. Hejlsberg became lead architect of Delphi, released in
1995. It combined Object Pascal, a visual form designer, a component
library, and native compilation.
Visual controls were programmable objects, and graphical properties
belonged to the language model. This accelerated application development
without reducing programmers to an opaque generator, though projects
depended on Delphi’s components and commercial platform. Like Turbo
Pascal, it shortened the distance between intention and visible result.
Moving to Microsoft and the .NET context
Hejlsberg joined Microsoft in 1996 and initially worked on Visual J++
and Windows Foundation Classes. Java had made virtual machines, managed
memory, and portability central industry concerns.
Microsoft was preparing the Common Language Runtime, a multilingual
platform with managed memory, shared libraries, and controlled
interoperability. A new language could target this model directly while
remaining familiar to C, C++, and Java developers. The project that
became C# emerged as one part of that platform.
Hejlsberg is the lead designer of C#, while the specification also
names Scott Wiltamuth and Peter Golde as principal inventors. Many teams
built the compiler, CLR, .NET libraries, and Visual Studio tools.
C# appeared publicly in 2000 with familiar brace syntax and static
typing, plus managed memory, properties, events, delegates, metadata,
and platform-consistent exceptions. Explicit unsafe regions permit
pointer operations when necessary while keeping risk visible.
Ecma and ISO standardization distinguished the language definition from
Microsoft’s implementation. Although C# and Java share managed
execution, C# evolved closely with the CLR and developed LINQ, value
types, delegates, advanced properties, and functional features.
Evolving C# without losing coherence
A widely adopted language cannot be freely redesigned: each addition
must coexist with existing code, tools, libraries, and reading habits.
C# 2.0 added runtime-supported generics; C# 3.0 introduced lambdas,
extension methods, and LINQ for queries over collections, databases,
and documents.
Later versions added async/await, pattern matching, records, and
concise syntax. These features increased expressive power but also
learning cost and stylistic variety. The design challenge is to add
mechanisms that compose with the existing whole.
JavaScript at scale: the problem that led to TypeScript
By the early 2010s, teams were building large JavaScript applications
from many modules and libraries. Dynamic typing supported
experimentation but made renaming, navigation, completion, and early
error detection harder when editors could not infer object shapes.
A separate replacement language would lose access to browsers, Node.js,
packages, and established behavior. Any solution had to meet JavaScript
programs where they already were.
TypeScript: describing JavaScript rather than replacing it
Microsoft announced TypeScript in October 2012 with Hejlsberg as
lead architect. It adds annotations and a type system, then emits
standard JavaScript for existing runtimes.
Types are erasable: they support checking, navigation, and editing but
disappear from output. TypeScript is mainly structurally typed, so
compatibility depends on members rather than shared nominal
declarations. Optional properties, unions, overloads, narrowing,
generics, and conditional types describe JavaScript patterns instead of
turning the language into C#.
Declaration files and the value of a community
A JavaScript library can gain typed tooling through a .d.ts
declaration file without changing its runtime code. The community-run
DefinitelyTyped repository supplies declarations for many packages,
making gradual adoption possible.
Declarations can be incomplete or outdated, and dynamic behavior
sometimes resists static modeling. TypeScript therefore favors
usefulness over absolute safety. Configurable rules and any ease
migration but require teams to choose rigor and monitor escape hatches.
An open project that must follow JavaScript
TypeScript is open source and developed publicly. The team increasingly
avoids TypeScript-only runtime features, participates in ECMAScript
standardization, and later supports standard syntax. TypeScript remains
an analysis and tooling layer over a living language.
It cooperates with bundlers, frameworks, linters, and runtimes rather
than owning the whole toolchain. Its language services provide
completion, navigation, refactoring, and diagnostics—continuing Turbo
Pascal’s concern with a short feedback loop.
An architect’s work, not a succession of solitary inventions
Turbo Pascal became a product through Borland. Delphi required platform
and component teams. C# emerged with Wiltamuth, Golde, and .NET teams.
TypeScript evolves through engineers, contributors, and users.
Hejlsberg’s specific role appears in decisions about compilation speed,
coherence between language and environment, gradual adoption,
compatibility, and tools that understand programs. The projects answer
different problems and share a design method rather than forming a
straight line toward one final language.
Why Anders Hejlsberg still matters
Language history often emphasizes syntax and paradigms. Hejlsberg’s
career shows that compilation time, diagnostics, completion, libraries,
migration, and compatibility matter just as much.
TypeScript succeeded by analyzing real JavaScript practices while
preserving execution and enabling gradual adoption, accepting imperfect
safety. C# coordinates language, runtime, and libraries more deeply but
bears the growing weight of compatibility.
Together, these models frame a central question: how can expression and
guarantees improve without separating developers from the ecosystems
they already use?
Timeline
- 1960: Anders Hejlsberg is born in Copenhagen.
- Early 1980s: He develops Compass Pascal, later PolyPascal.
- 1983: Borland launches Turbo Pascal.
- 1980s–1990s: Turbo Pascal and its object model evolve.
- 1995: Delphi launches with Hejlsberg as lead architect.
- 1996: He joins Microsoft and works on Visual J++ and WFC.
- Late 1990s: The future C# is designed with .NET teams.
- 2000: C# is broadly introduced with .NET.
- 2002: Ecma standardizes the first C# version.
- 2007: C# 3.0 introduces LINQ and lambdas.
- 2012: TypeScript is announced; C# 5 expands
async/await.
- 2014: TypeScript 1.0 is released.
- 2010s–2020s: C# and TypeScript continue evolving openly.
Frequently asked questions
Did Anders Hejlsberg create Turbo Pascal?
He wrote the original Pascal compiler acquired by Borland and became
Turbo Pascal’s central architect. The commercial product, its
environment, and later versions were collective Borland work.
Is Anders Hejlsberg the sole creator of C#?
No. He is the lead designer, while the specification names Scott
Wiltamuth and Peter Golde among the principal inventors. Many teams
built the language, runtime, libraries, and tools.
Does TypeScript replace JavaScript?
No. It analyzes a typed extension of JavaScript and emits JavaScript for
existing browsers and engines. It improves tooling rather than creating
a competing runtime.
Why do TypeScript types disappear at runtime?
They support static checking and development tools. Erasure preserves
JavaScript behavior, avoids a type-specific runtime cost, and maintains
ecosystem compatibility.
What connects Turbo Pascal, C#, and TypeScript?
All shorten the loop between intention, diagnosis, and result by
integrating language and tools under different constraints: limited
hardware, a managed platform, or the existing JavaScript ecosystem.
