TypeScript, C# and Turbo Pascal with Anders Hejlsberg

Key takeaways

Building programming languages and tools is a long-term endeavor, often taking a decade for maturity, emphasizing patience and persistence.
Small, focused teams with rigorous critique and iteration can produce highly influential programming languages.
The entire development cycle—including IDE, compiler, and tooling—is the product that developers love, not just the language itself.
Open sourcing tools like TypeScript significantly accelerates their adoption and evolution, transforming both the product and the community around it.
AI is becoming integrated into software development workflows, primarily aiding in review, testing, and code generation, but developer oversight remains essential.
Type systems and code locality are crucial for AI-assisted programming, enabling better semantic understanding and efficient processing.
Future software craftsmanship will evolve towards higher-level design, code review, and architecture, as AI reduces the need for manual coding.
Fundamental principles of programming, like data structures and algorithms, continue to be vital, even as tools and languages evolve.

Summary

Anders Hejlsberg’s Career and Beginnings in Programming

This section traces Anders Hejlsberg’s early fascination with programming, beginning with access to the first computers in Danish high schools and the allure of understanding hardware and writing simple games. He discusses his first compiler written for a subset of Pascal, which laid the foundation for Turbo Pascal. His initial projects involved building compilations for early microcomputers, leading into founding a computer store and experimenting with various languages and tools such as BASIC, Assembler, and Pascal.

Development of Major Programming Languages and Tools

Anders elaborates on creating Turbo Pascal, which became famous for its speed and integrated environment, making programming accessible and enjoyable. He describes the evolution to Delphi, focusing on rapid application development for Windows, and discusses the frequent cycles of language development—roughly ten years from initial version to maturity. His insights reveal the importance of small teams, critical evaluation of ideas, and comprehensive tooling in successful language and IDE design.

Work at Microsoft and the Creation of C# and TypeScript

The discussion covers Anders’ entry into Microsoft, where he contributed to the development of Java support, C++, and ultimately the design of C# in response to the needs for a modern, managed, object-oriented language for the .NET platform. He also discusses the motivations for creating TypeScript, emphasized by the rise of JavaScript and the need for a typed superset to improve tooling and development experience. The process of open-sourcing TypeScript and its subsequent rise in popularity are also detailed.

Technical Deep Dive: How C# and TypeScript Were Built

Anders provides an overview of compiler architecture, highlighting the stages from tokenization, parsing, binding, type checking, to code emission. He explains how TypeScript’s compiler is optimized for interactivity within IDEs, and how crucial features like async/await have transformed programming practices. The conversation covers the importance of small, skilled teams working iteratively, and the transition from separate language service implementations to a unified Roslyn compiler infrastructure.

Impact of AI on Programming and Language Development

The episode explores how AI is increasingly used in code review, bug fixing, and even in building compilers. Anders discusses the potential for AI to influence language design, emphasizing the importance of types and locality in code to facilitate efficient AI-assisted development. He also reflects on how AI might shift the craft of software engineering from writing code to overseeing, reviewing, and architecting code, and the need for tools that support this transition.

Thoughts on Future of Programming and Developer Tools

Anders predicts that developers will spend more time reviewing and orchestrating AI-generated code. He advocates for maintaining deep understanding of code semantics, emphasizing that responsibility still ultimately lies with human developers. He touches on the importance of comprehensive tooling, IDEs, and semantic search in managing large codebases and enabling AI integration. The discussion concludes with reflections on the long-term cycle of language development and the enduring importance of core programming principles.

Show notes

Brought to You By:

• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.

• WorkOS – Everything you need to make your app enterprise ready.

• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.

—

Anders Hejlsberg is a living legend and one of the most influential programming language designers of all time. He created Turbo Pascal, Delphi, C#, and also TypeScript. As well as that, he spent nearly a decade at the pioneering dev tools company, Borland, and is now in his 30th year of working at Microsoft, where he’s a Technical Fellow.

In this episode, we discuss what it takes to build programming languages that developers love to use, and trace his career from writing his first compiler to creating Turbo Pascal and Delphi, and helping to pioneer modern software development through C# and TypeScript.

Anders details how C# was designed by a small group of experienced language designers who met a few hours each week, and he explains why tooling was just as important as the language for TypeScript’s success, and what he has learned from building languages which stay relevant for decades.

We also look into how Anders uses AI today, which language features suit AI-assisted development, and what he thinks is changing in the craft of software engineering as developers move further away from writing code line by line.

—

Timestamps

(00:00) Intro

(02:48) How Anders got into programming

(05:40) Building his first compiler

(07:44) Turbo Pascal

(12:25) Delphi

(14:53) Joining Microsoft

(19:41) Building C#

(29:11) Async/await

(34:01) The rise of JavaScript

(37:52) Building TypeScript

(42:58) How the TypeScript compiler works

(48:30) JavaScript’s strengths and weaknesses

(52:18) How Anders uses AI

(56:03) What language features work well with AI

(1:02:49) How software craftsmanship is changing

(1:07:49) Performance and efficiency

(1:09:29) Anders’ tool stack

(1:11:30) A 30-year career at Microsoft

(1:13:40) Book recommendation

—

The Pragmatic Engineer deepdives relevant for this episode:

• Microsoft’s developer tools roots

• 50 Years of Microsoft and developer tools with Scott Guthrie

• How Linux is built with Greg Kroah-Hartman

• How will AI change operating systems? Part 1: Ubuntu and Linux

• How Uber uses AI for development: inside look

—

Production and marketing by ⁠⁠⁠⁠⁠⁠⁠⁠https://penname.co/⁠⁠⁠⁠⁠⁠⁠⁠. For inquiries about sponsoring the podcast, email podcast@pragmaticengineer.com.

Get full access to The Pragmatic Engineer at newsletter.pragmaticengineer.com/subscribe