Skip to content

TypeScript 7 and What Comes Next

Software Engineering Daily

57m
Transcript

Original podcast

Where to listen

Summary

Written by a model from the transcript; not yet reviewed.

This episode explores the major architectural shift in TypeScript 7, featuring Daniel Rosenwasser, principal product manager of TypeScript at Microsoft, in conversation with host Josh Goldberg. They discuss the complete rewrite of the compiler into native Go code to leverage multi-core processors, achieving up to a tenfold speedup for large codebases. The discussion also covers the history of TypeScript's integration with open source and the JavaScript standardization process, the technical challenges of designing a new API and inter-process communication boundary for version 7.1, and how large language models and type system features might shape the future of developer tools.

  • Developers can start using TypeScript 7 today for massive speedups on large codebases. 30:45
  • TypeScript implements new JavaScript features as soon as they reach stage three in the ECMAScript standardization process. 27:13
  • The upcoming TypeScript 7.1 release will introduce a new API and inter-process communication boundary for external tool integrators. 35:13
  • Fostering rescue cats is a rewarding experience that directly helps animals find permanent homes. 54:43

Chapters

  1. 0:00
    Introduction to TypeScript and Episode Overview

    Josh Goldberg introduces the episode, Daniel Rosenwasser, and outlines the main topics of TypeScript 7 and future plans.

  2. 2:12
    Daniel’s Early Tech Journey

    Daniel recounts how his curiosity about video games and early internet forums sparked his interest in programming.

  3. 4:58
    From Hobbyist to Microsoft Engineer

    Daniel explains his transition from tinkering with LAMP stacks to joining Microsoft as a TypeScript engineer.

  4. 8:32
    Empathy‑Driven Development Culture

    Daniel discusses the TypeScript team’s focus on developer empathy and how it shapes feature decisions.

  5. 13:19
    Early Challenges with JavaScript Standards

    The conversation covers TypeScript’s early interactions with TC39 and the complexities of aligning with evolving JavaScript features.

  6. 21:11
    Decorators and Angular Collaboration

    Daniel details the history of decorators, the partnership with Angular, and the evolving semantics of the feature.

  7. 30:45
    TypeScript 7: Go Rewrite and Performance Gains

    Daniel explains the rewrite of the TypeScript compiler into Go, the resulting 10× speed improvements, and the challenges of porting.

  8. 35:06
    API and IPC Boundary for Tooling

    The team discusses the new API design, inter‑process communication, and how it supports multiple tooling clients efficiently.

  9. 41:57
    Future Roadmap: 7.1, 7.2, and Beyond

    Daniel outlines upcoming features, the role of the API, and how the ecosystem may evolve with LLMs and new language features.

  10. 46:28
    Performance Trade‑offs and New Type Features

    The discussion turns to potential new type system features, performance considerations, and the balance between expressiveness and speed.

  11. 50:19
    Evaluating TypeScript Feature Complexity

    Discussion on whether adding new type features is worthwhile versus focusing on LLM integrations.

  12. 51:49
    Practical Advice for Using TypeScript 7

    Guidance on installing and integrating TypeScript 7, including editor support and API compatibility.

Highlights

  • 2:12

    Starting Out in Techstory

    Daniel Rosenwasser explains how early internet forums, HTML on GeoCities, and learning QBasic from Beginning Programming for Dummies sparked his path into software development.

  • 21:33

    The Role of Decoratorsinsight

    Decorators enable meta-programming over classes and methods, allowing developers to intercept execution, register members, and implement dependency injection.

  • 27:13

    Stage Three Policystrategy

    The TypeScript team adopts JavaScript features into the type checker as soon as proposals reach stage three in the ECMAScript standardization process.

  • 31:01

    Rewriting in Godata

    TypeScript 7 was rewritten in Go to leverage shared memory, parallelism, and multi-core processors, resulting in a tenfold speedup for large codebases.

  • 36:55

    The IPC Boundary Challengestrategy

    Because TypeScript 7 runs in Go, an inter-process communication boundary was designed to let JavaScript and Rust tooling safely consume compiler data without exhausting memory.

  • 48:02

    Negated Types Discussioninsight

    The guest discusses why features like negated types present complex user experience and mathematical reasoning challenges within the type system.

Quotes

  • “TypeScript is a programming language that builds on JavaScript by adding a system of types.”
    Unnamed speaker · 0:00
  • “I think that there was always just a natural curiosity about how every part of the computer that I was using worked, right?”
    Unnamed speaker · 5:05
  • “It's so much faster and it's more ready than you think it is.”
    Unnamed speaker · 53:44
  • “We have explicit documentation on how to do that on our blog post and you should go, go check it out.”
    Unnamed speaker · 52:49
  • “I think over 12 cats now.”
    Unnamed speaker · 55:01
  • “I mean, it's, it's a lot of fun.”
    Unnamed speaker · 55:23
  • BitDrift 19:22–19:36
  • XWeather 19:45–20:25
  • Tiger Data 20:27–21:12

About this episode

TypeScript is a programming language that builds on JavaScript by adding a system of types. Those types let developers describe the shape of their data and catch mistakes before code ever runs, while also powering the autocompletion and editor tooling that many developers now rely on every day. It was first released in 2012, and has since become one of the most widely used tools in web development. TypeScript recently underwent one of the most significant changes in its history with the release of version 7. Daniel Rosenwasser https://x.com/drosenwasser is the Principal Product Manager of TypeScript at Microsoft https://www.microsoft.com/, where he began as an engineer on the team just weeks after the TypeScript 1.0 release. In this episode, Daniel joins Josh Goldberg to talk about the features of TypeScript 7. They discuss the TypeScript team’s approach to tooling, TypeScript’s relationship with the TC39 standards process behind JavaScript, the new API and IPC boundary, how LLMs could reshape type checking and linting, and more. Sponsorship inquiries: sponsor@softwareengineeringdaily.com mailto:sponsor@softwareengineeringdaily.com The post TypeScript 7 and What Comes Next https://softwareengineeringdaily.com/podcasts/typescript-7-and-what-comes-next/ appeared first on Software Engineering Daily https://softwareengineeringdaily.com.

Transcript

0:00
57:15

10,271 words · 4 speakers

Topics

  • TypeScript
  • JavaScript
  • Go
  • Microsoft
  • TypeScript 7
  • TC39
  • ECMAScript
  • Visual Studio
  • TypeScript 6.0
  • TypeScript 7.1

Page updated · transcript and summary are machine-generated