Overview
Across four decades of language design, Anders Hejlsberg has repeatedly pursued the same goal: make powerful programming feel immediate, coherent, and productive. Turbo Pascal combined compiled performance with an inexpensive, interactive edit-run experience; Delphi adapted that philosophy to graphical and client-server applications; C# joined object orientation, managed execution, and modern component models; and TypeScript added erasable types to JavaScript primarily to unlock dependable tooling at scale. Hejlsberg explains that language development is a long-cycle discipline shaped by small expert teams, adversarial design review, real users, and repeated refinement. He also describes the architecture of interactive compilers, where parsing, binding, type checking, and emission must support incomplete programs and answer IDE queries within roughly 200 milliseconds through laziness and reuse. The discussion then turns to AI: agents already help with reviews, issue fixes, test generation, and migration work, but remain weak at understanding the deep architecture of a large compiler. Hejlsberg expects engineers to shift toward architecture, orchestration, and review while retaining responsibility for correctness. His central conclusion is that AI does not diminish the value of programming languages; deterministic code, explicit module boundaries, semantic language services, and thoughtful developer tools are precisely what make stochastic AI useful in reliable software systems.
Sections
Compiler and Language Architecture
Concrete implementation details behind C#, TypeScript, interactive tooling, and asynchronous execution.
- The TypeScript pipeline begins with a lexer that converts text into tokens, followed by a parser that validates grammar and creates abstract syntax trees.
- A binder discovers declarations, builds symbol tables, attaches symbols to relevant scopes, and constructs a control-flow graph before semantic type checking.
- The type checker is the largest compiler stage and validates type relationships, assignments, name resolution, and callable members.
- TypeScript's emitter primarily erases annotations and can emit JavaScript plus declaration files; historically it also downleveled newer ECMAScript constructs for older runtimes.
- For interactive performance, the compiler reuses syntax trees from unchanged files and lazily resolves only enough information to answer the current IDE query, targeting responses within roughly 200 milliseconds.
- Async/await lets the compiler transform apparently sequential code into a state machine, move state that survives suspension from the stack to heap-allocated storage, and resume execution when a promise completes.
- C# was designed around managed bytecode, garbage collection, exceptions, reflection, a unified object system, and first-class properties, methods, and events.
- TypeScript uses gradual typing: annotations improve development-time checking and tooling but are erased before JavaScript executes.
Four Decades of Language Development
Major milestones in Hejlsberg's progression from early microcomputers to AI-assisted TypeScript development.
- Hejlsberg encountered programming at a Copenhagen high school through an HP 2100 with 32K of ferrite-core memory, paper-tape bootstrapping, and an early hard drive.
- He began at the Danish Technical University, worked with Z80-based kit computers, learned assembly, and co-founded a Copenhagen computer retailer.
- He built a Pascal subset compiler that fit into a 12K ROM and replaced a machine's Microsoft ROM BASIC with an interactive Pascal environment.
- The first Turbo Pascal product shipped through a royalty arrangement with Borland and achieved adoption beyond the team's expectations.
- Delphi extended the Turbo Pascal philosophy into graphical Windows development and client-server enterprise applications.
- Hejlsberg joined Microsoft to lead Java development-tool architecture and worked on Visual J++ before the Sun-Microsoft lawsuit undermined its viability.
- C# and .NET development began, with internal framework teams becoming early users and beta copies reaching developers at the 2000 Professional Developers Conference.
- TypeScript moved from Microsoft's CodePlex repository to GitHub and adopted a genuinely open development workflow.
- The TypeScript team began a native-code port and later applied AI to reviews, issue fixes, test generation, and transferring accumulated pull requests.
Broader Implications
Patterns implied by Hejlsberg's experience across languages, tools, ecosystems, and AI.
- Type systems are evolving from human-facing correctness mechanisms into shared semantic infrastructure for IDEs and AI agents. Their future value may depend as much on exposing precise machine-consumable queries as on rejecting invalid programs.
- Open source licensing was necessary but insufficient for TypeScript; adoption accelerated when the project changed its operating model to open development. Transparency of workflow and community access can matter as much as source availability.
- AI increases the value of modularity because context is now a metered computational resource. Explicit imports, local reasoning, and compact public interfaces reduce both human cognitive load and agent token consumption.
- As code generation becomes cheap, verification, architectural coherence, and responsibility become scarcer. The bottleneck shifts from producing implementation text to establishing that the resulting system is understandable and correct.
- The best AI-oriented language may not be a new language at all. Existing languages with large training corpora, gradual types, strong inference, clear modules, and mature language services may offer a stronger practical foundation.
Lessons for Language and Tool Builders
Practical principles distilled from Hejlsberg's projects and career.
- Design the complete developer loop—editing, understanding, compiling, running, and debugging—not merely the language grammar.
- Use a small, deeply experienced design group that actively attempts to disprove new ideas before committing to them.
- Treat responsiveness as a feature of language architecture; interactive tools require incremental, lazy, and reusable computation from the beginning.
- Match optimization effort to the application: performance is essential for compilers, cloud inference, and latency-sensitive systems, but irrelevant where even a tenfold slowdown is imperceptible.
- Use AI to remove toil, but retain enough system knowledge to detect failure, repair deviations, and accept responsibility for the result.
- Plan foundational technologies on decade-long horizons; repeated versions and ecosystem adoption are part of the product, not post-launch cleanup.
- Prefer programs that compute verifiable answers over unstructured model responses when deterministic behavior is required.