TS Congress is an online event for web developers on all things TypesScript. Learn from industry professionals and community members, exchange ideas, interact, and collaborate in the form of a modern tech event. September 21 & 22, 2023.

TS Congress

TypeScript Congress 2022

Maintaining widely-used JS libraries is already complicated, and TypeScript adds an additional set of challenges. Join Redux maintainer Mark Erikson for a look at some of the unique problems TS library maintainers face, and how the Redux team has handled those problems. We'll cover: - Tradeoffs of different ways to define TS types for a library - How to target different versions of TS, and considerations for determining the supported version range - Migrating existing JS libraries to TS - Differences between writing "app" types and "library" types - Managing and versioning public types APIs - Tips and tricks used by types from the Redux libraries - TS limitations and possible language-level improvements

Lessons from Maintaining TypeScript Libraries

Mark Erikson

'TypeChat' Panel Discussion

John Reilly

Titian-Cornel Cernicova-Dragomir

Nathan Shively-Sanders

Gabriela Araujo Britto

Fireside Chat with Orta Therox

Josh Goldberg

Orta Therox

Adding a new feature to an unfamiliar codebase can be painfully slow. What if you could lean on TypeScript to guide you? At Snyk plugin architecture is a common pattern to extend language support across different products and codebases. Adding TypeScript to the mix has allowed us to add new features quickly and it can be as simple as painting by numbers when it comes to extending the code. Join me as we create a simple library using plugin architecture and follow the trail of TypeScript hints to add a new feature.

Plug-in architecture: how TypeScript let us paint-by-numbers

Lili Kastilio

Using real-life open-source examples, we'll explore the power of TypeScript to improve your users' experience. We'll cover best practices for library authors, as well as tips and tricks for how to take a library to the next level. This talk will cover:  - how to leverage the type inference to provide help to your users; - using types to reduce the need and complexity of your documentation - for example, using function overloads, string literal types, and helper (no-op) functions; - setting up testing to ensure your library works (and your types do too!) with tools like tsd and expect-type; - treating types as an API and reducing breaking changes whilst shipping enhancements; - I'd draw on my experience with libraries like nuxt3, sanity-typed-queries and typed-vuex and show what we managed to do and what I'd do differently in future.

TypeScript for Library Authors: Harnessing the Power of TypeScript for DX

Daniel Roe

The talk will introduce the concept of variance as in pertains to generic types. It will then show how this concept applies to TypeScript. While showing TypeScript example, I will try to help the audience form an intuition about variance. Finally we will look at what some of the design decisions in TypeScript mean for the soundness of the code we write, and what are some blind spots the compiler has.

Understanding types as sets

This talk will walk you through writing a module in TypeScript that can be consumed by users of Deno, Node, and browsers. I will walk through how to set up formatting, linting, and testing in Deno, and then how to publish your module to deno.land/x and npm. I will also start out with a quick introduction on what Deno is.

Writing universal modules for Deno, Node, and the browser

Luca Casonato

Your team has just hired a React Developer to work on your Typescript codebase. Both your team and the new engineer are eager to start building features, but they only have experience writing Javascript. How can you quickly onboard the engineer to Typescript while still providing them with time and space needed to learn the language effectively? In this talk, we’ll discuss why Typescript fundamentals, like function types, interfaces, and generics, can be intimidating for learners. Then, we’ll walk through successful, practical approaches for teaching each of these concepts and relating them back to React. By the end of this talk, you’ll have the building blocks for creating a fruitful onboarding session for your engineers.

Onboarding React Developers to Typescript

Sylvana Santos

We all love writing types in TypeScript, but we often find ourselves having to write types in another language as well: SQL. This talk will present the choose-your-own-adventure story that you face when combining TypeScript and SQL and will walk you through the tradeoffs between the various options. Combined poorly, TypeScript and SQL can be duplicative and a source of headaches, but done well they can complement one another by addressing each other's weaknesses.

TypeScript and the Database: Who Owns the Types?

Dan Vanderkam

If you're using a headless CMS for storing content, you also work with URL slugs, the last parts of any URL. The problem is, content editors are able to freely change the slugs which can cause 404 errors, lost page ranks, broken links, and in the end confused visitors on your site. In this talk, I will present a solution for keeping a history of URL slugs in the CMS and explain how to implement a proper redirect mechanism (using TypeScript!) for dynamically generated pages on a Next.js website. Add to the talk notes: https://github.com/ondrabus/kontent-boilerplate-next-js-ts-congress-2022

How to properly handle URL slug changes in Next.js

Ondrej Polesny

Learn how running your TS in Temporal's runtime gets you extreme reliability

How to build distributed systems in TypeScript

Loren Sands-Ramshaw

While TypeScript is currently the most popular static type checker for JavaScript, there are alternatives. In this talk, we'll look at Flow.js and Hegel, and review the similarities and differences among the three. Doing this will put TypeScript in perspective, and maybe help explain why the TS team made certain design decisions.

Alternatives to TypeScript

Ashley Claymore

We all know, that TypeScript helps us in many ways. The compiler guides us during our work, ensuring, that every piece of data falls into a given place. But there are some limitations. TypeScript was meant to help us during development time. After the compilation step, we still cannot be 100% sure what can happen during runtime... Unless we do something about that and defend ourselves against unwanted runtime errors! This talk serves as an introduction to the problem and explains how we can face it to make our applications more error-proof.

Type Safety at Runtime in Typescript

Kajetan Świątek

In this workshop, I’ll first show you how to create a new project in a headless CMS, fill it with data, and use the content in your project. Then, we’ll spend the rest of time in code, we will:- Generate strongly typed models and structure for the fetched content.- Use the content in components- Resolve content from rich text fields into React components- Touch on deployment pipelines and possibilities for discovering content-related issues before hitting production

Crash Course into TypeScript for content from headless CMS

If you're looking to get the most out of TypeScript, this workshop is for you! In this interactive workshop, we will explore the use of advanced types to improve the safety and predictability of your TypeScript code. You will learn when to use types like unknown or never. We will explore the use of type predicates, guards and exhaustive checking to make your TypeScript code more reliable both at compile and run-time. You will learn about the built-in mapped types as well as how to create your own new type map utilities. And we will start programming in the TypeScript type system using conditional types and type inferring. Are you familiar with the basics of TypeScript and want to dive deeper? Then please join me with your laptop in this advanced and interactive workshop to learn all these topics and more. You can find the slides, with links, here: <a href="http://theproblemsolver.nl/docs/ts-advanced-workshop.pdf">http://theproblemsolver.nl/docs/ts-advanced-workshop.pdf</a> And the repository we will be using is here: <a href="https://github.com/mauricedb/ts-advanced">https://github.com/mauricedb/ts-advanced</a>

The Type of Conference Developers Need