Podpower Episode AtlasIn this episode of The Pragmatic Engineer, host Gergely Orosz sits down with legendary programmer Anders Hejlsberg, the mind behind iconic languages like Turbo Pascal, C#, and TypeScript. Hejlsberg shares his journey from programming on an HP 2100 with 32K of core memory in the 70s to leading language design at Microsoft, offering unique insights into the philosophy and engineering challenges behind creating widely adopted programming languages.
The conversation delves into the origins of Turbo Pascal, emphasizing the importance of integrated development environments (IDEs) from the outset, and the unexpected success of Delphi in the Windows development landscape. Hejlsberg recounts the pivotal moment at Microsoft when the Sun vs. Microsoft Java lawsuit spurred the creation of C# and the .NET runtime, highlighting the design goals that blended the power of C++ with the ease of Visual Basic.
The discussion then shifts to TypeScript, exploring its genesis as a solution to JavaScript's tooling limitations and the internal struggle to open-source it at Microsoft. Hejlsberg explains the compiler pipeline, the concept of gradual typing, and the critical role of interactive tooling in developer productivity. Finally, they tackle the burgeoning influence of AI on programming, discussing how AI agents are changing code generation, the importance of language characteristics like locality for AI, and the evolving craft of software engineering in an AI-assisted world.
Hejlsberg explains that modern compilers, especially for IDEs, must function as interactive services, performing minimal work within milliseconds to provide real-time feedback, unlike traditional command-line compilers.
Why careThis shift from batch compilation to interactive services is crucial for modern developer productivity and the responsiveness of tools like VS Code.
A design pattern that allows developers to write asynchronous, non-blocking code in a sequential, readable style by having the compiler transform it into a state machine, managing continuations and heap allocations.
Why careThis pattern, pioneered in C#, solved the complexity of cooperative multitasking and callback-heavy programming, influencing many other languages.
TypeScript's approach of adding a type system that is primarily for development-time checking and then 'erased' during compilation to plain JavaScript, allowing for gradual adoption and dynamic runtime behavior.
Why careThis enables superior tooling and developer productivity without imposing strict runtime type enforcement, making it highly adaptable for JavaScript projects.
The concept of a compiler providing interactive services to an IDE, such as statement completion, refactoring, and semantic analysis, which is now standardized by the Language Server Protocol (LSP).
Why careLanguage services are fundamental to modern IDEs, offering real-time assistance and significantly enhancing the developer experience.
The ability to introduce types incrementally into a codebase, allowing for a mix of typed and untyped code, which is a core feature of TypeScript.
Why careThis flexibility allows developers to adopt TypeScript at their own pace and leverage its benefits without a complete rewrite, making it highly accessible.
The idea that programming languages with clear module boundaries and explicit imports (good locality) are more suitable for AI agents because they reduce the context window needed for analysis.
Why careAs AI generates more code, languages that facilitate localized understanding will be easier for AI to process and reason about, improving its efficiency and accuracy.
"We were totally right there that adding an erasable type system and then using that to enable great tooling is where the productivity boost is realized."
"You can't compile all of those in 200 milliseconds. So, you got to be super super deferred and interactive. And so you got to do minimal amounts of work."
"The problem with threads is that they come with preemptiveness and the OS has the ability to preempt you at any point in time and that's not necessarily what you want."
"The world started opening its eyes to that and and started building larger and larger applications in JavaScript. And we saw that externally but also internally."
"But getting that off the ground inside Microsoft, it took some uh some pulling. Um, and we paid some taxes. We we did eventually get the okay to do open source."
"I mean, you could argue that we we're already past peak truth on the on the on the internet, right? And now there's there's just more and more garbage every every day."