Name: TypeScript Congress 2022
Start: 2022-04-29T12:00:00.000Z
End: 2022-04-29T20:00:00.000Z

Varun

Lera

Joanna Otmianowska

Andreas Roth

Nikolay Advolodkin

Oscar Pagani

Ricardo Machado

Bernie Green

João Portela

Žiga Šinko

Ian Sutherland

Alex Hayton

Lukas

Denis Radin

Norm Crandall

Sofia Markoglou

Simon Flack

Christian Guy

Andrea Martz

Rishi Narang

Antwan Sherif

Vitor Barbosa

Renata Dzherhalova

Paulo SILVA

Steve

Ricardo Del Rio Rubial

Mailing Delgado Medina

Martyna Skup

mickael

Andres Pineda

Carlo Straccialini

Mohamed Sibras

Kristian Bødker

Si estás utilizando un CMS sin cabeza para almacenar contenido, también trabajas con URL slugs, las últimas partes de cualquier URL. El problema es que los editores de contenido pueden cambiar libremente los slugs, lo que puede causar errores 404, pérdida de rangos de página, enlaces rotos y, al final, visitantes confundidos en tu sitio. En esta charla, presentaré una solución para mantener un historial de URL slugs en el CMS y explicaré cómo implementar un mecanismo de redirección adecuado (¡usando TypeScript!) para páginas generadas dinámicamente en un sitio web de Next.js. Añadir a las notas de la charla: https://github.com/ondrabus/kontent-boilerplate-next-js-ts-congress-2022

Cómo manejar correctamente los cambios de URL slug en Next.js

This Talk explains how to handle URL slug changes in Next.js by using the getStaticPaths and getStaticProps methods. It covers implementing redirects and provides a solution to eliminate the need for editors to perform additional steps. The approach involves tracking URL slug changes and issuing proper redirects. The speaker encourages the audience to reach out with any questions or experiences with handling URL slugs.

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

Todos amamos escribir tipos en TypeScript, pero a menudo nos encontramos teniendo que escribir tipos en otro lenguaje también: SQL. Esta charla presentará la historia de elige-tu-propia-aventura que enfrentas al combinar TypeScript y SQL y te guiará a través de los compromisos entre las diversas opciones. Combinados de manera deficiente, TypeScript y SQL pueden ser duplicativos y una fuente de dolores de cabeza, pero si se hacen bien, pueden complementarse entre sí al abordar las debilidades de cada uno.

TypeScript y la Base de Datos: ¿Quién Posee los Tipos?

The Talk discusses the use of TypeScript and SQL together in software development. It explores different approaches, such as using an ORM like TypeORM or a schema generator like pg2ts. Query builders like connects JS and tools like PGTyped are also discussed. The benefits and trade-offs of using TypeScript and SQL are highlighted, emphasizing the importance of finding a middle ground approach.

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

Mantener bibliotecas JS ampliamente utilizadas ya es complicado, y TypeScript añade un conjunto adicional de desafíos. Únete al mantenedor de Redux, Mark Erikson, para echar un vistazo a algunos de los problemas únicos que enfrentan los mantenedores de bibliotecas TS, y cómo el equipo de Redux ha manejado esos problemas. Cubriremos: - Compromisos de diferentes formas de definir tipos TS para una biblioteca - Cómo dirigirse a diferentes versiones de TS, y consideraciones para determinar el rango de versión soportado - Migración de bibliotecas JS existentes a TS - Diferencias entre escribir tipos de "aplicación" y tipos de "biblioteca" - Gestión y versionado de APIs de tipos públicos - Consejos y trucos utilizados por tipos de las bibliotecas Redux - Limitaciones de TS y posibles mejoras a nivel de lenguaje

Lecciones de Mantenimiento de Bibliotecas TypeScript

Mark Erickson, a Senior Frontend Engineer at Replay, discusses JavaScript libraries and their support for TypeScript, including migration, versioning, and debugging. He also explores the challenges of supporting multiple TypeScript versions and designing APIs for use with TypeScript. Additionally, he shares advanced Redux type tricks and insights into maintaining a TypeScript library. The poll results reveal the widespread usage of TypeScript among developers, with many gradually migrating their codebases. Lastly, he provides tips for upgrading TypeScript and verifying functionality.

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

Agregar una nueva funcionalidad a una base de código desconocida puede ser extremadamente lento. ¿Qué tal si pudieras confiar en TypeScript para guiarte? En Snyk, la arquitectura de complementos es un patrón común para extender el soporte de lenguaje en diferentes productos y bases de código. Agregar TypeScript a la mezcla nos ha permitido agregar nuevas funcionalidades rápidamente y puede ser tan simple como pintar por números cuando se trata de extender el código. Acompáñame mientras creamos una biblioteca simple utilizando la arquitectura de complementos y seguimos las pistas de TypeScript para agregar una nueva funcionalidad.

Arquitectura de complementos: cómo TypeScript nos permite pintar por números

When faced with challenges in supporting multiple package managers and keeping up with growth, implementing a plugin architecture can help. Extending a CLI for source control management systems like GitHub and GitLab can be done using TypeScript and Oclef CLI. TypeScript errors can be resolved by adding missing properties and implementing required functions for plugins. Supporting multiple repositories by following TypeScript errors and having the right setup can reduce time to production and onboarding. Plugin architecture with TypeScript can be a valuable tool for faster development and onboarding onto repositories.

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

Aprende cómo ejecutar tu código TypeScript en el tiempo de ejecución de Temporal para obtener una confiabilidad extrema

Cómo construir sistemas distribuidos en TypeScript

This Talk discusses building distributed systems in TypeScript, focusing on an e-commerce store and implementing a create order endpoint. It covers handling retry and error cases, saving order state, handling crashes and duplicate orders, and the process order function and architecture. The Talk also introduces Temporal, a durable code execution framework that simplifies fault-tolerant software development.

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

How to build distributed systems in TypeScript

Loren Sands-Ramshaw

Esta charla te guiará en la escritura de un módulo en TypeScript que puede ser utilizado por usuarios de Deno, Node y navegadores. Te mostraré cómo configurar el formato, el linting y las pruebas en Deno, y luego cómo publicar tu módulo en deno.land/x y npm. También comenzaré con una breve introducción sobre qué es Deno.

Escribiendo módulos universales para Deno, Node y el navegador

Deno is a modern runtime for TypeScript and JavaScript that runs out of the box and is secure by default. The Talk covers building a greeting message library with Deno, compiling Deno libraries for Node consumers, setting up the editor and writing code, writing tests and running them with dnotest, code formatting, linting, and publishing, publishing to NPM and running tests, and building and publishing the NPM package. The speaker emphasizes the ease of use and integration of Deno's tooling system.

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

Si estás buscando sacar el máximo provecho de TypeScript, este masterclass es para ti! En este masterclass interactivo, exploraremos el uso de tipos avanzados para mejorar la seguridad y previsibilidad de tu código TypeScript. Aprenderás cuándo usar tipos como unknown o never. Exploraremos el uso de predicados de tipo, guardias y verificación exhaustiva para hacer tu código TypeScript más confiable tanto en tiempo de compilación como en tiempo de ejecución. Aprenderás sobre los tipos mapeados incorporados, así como cómo crear tus propias utilidades de mapeo de tipos. Y comenzaremos a programar en el sistema de tipos de TypeScript utilizando tipos condicionales e inferencia de tipos. ¿Estás familiarizado con los conceptos básicos de TypeScript y quieres profundizar? Entonces únete a mí con tu computadora portátil en este masterclass avanzado e interactivo para aprender todos estos temas y más. Puedes encontrar las diapositivas, con enlaces, aquí: <a href="http://theproblemsolver.nl/docs/ts-advanced-workshop.pdf">http://theproblemsolver.nl/docs/ts-advanced-workshop.pdf</a> Y el repositorio que utilizaremos está aquí: <a href="https://github.com/mauricedb/ts-advanced">https://github.com/mauricedb/ts-advanced</a>

Tipos avanzados de TypeScript para diversión y confiabilidad

This workshop covers advanced TypeScript types and features such as strict mode, type validation, error handling, and type mappings. It explores techniques to improve code reliability and prevent errors. Topics include treating elements as never being null, deriving TypeScript type definitions from schemas, using read-only types to enforce immutability, and utilizing type mappings like omit and pick. The workshop also emphasizes the importance of type safety, type readability, and exhaustiveness testing. Overall, it provides practical insights to enhance the reliability and type safety of TypeScript code.

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>

Advanced TypeScript types for fun and reliability

Maurice de Beijer

Tu equipo acaba de contratar a un desarrollador de React para trabajar en tu base de código de TypeScript. Tanto tu equipo como el nuevo ingeniero están ansiosos por comenzar a construir características, pero solo tienen experiencia escribiendo JavaScript. ¿Cómo puedes integrar rápidamente al ingeniero a TypeScript sin dejar de brindarle el tiempo y el espacio necesarios para aprender el lenguaje de manera efectiva? En esta charla, discutiremos por qué los fundamentos de TypeScript, como los tipos de funciones, interfaces y genéricos, pueden ser intimidantes para los aprendices. Luego, recorreremos enfoques prácticos y exitosos para enseñar cada uno de estos conceptos y relacionarlos con React. Al final de esta charla, tendrás los elementos básicos para crear una sesión de integración fructífera para tus ingenieros.

Integración de desarrolladores de React a TypeScript

Today's Talk discusses best practices for onboarding React developers to TypeScript, including pain points faced by engineers, principles for effective onboarding, and a workshop format. The workshop covers function type expressions, annotating React functional components, and the return type of React functional components. The session emphasizes creating a safe space for hands-on practice and gradually exposing engineers to TypeScript concepts. Overall, the Talk aims to improve onboarding experiences for React developers learning TypeScript.

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

La charla presentará el concepto de variación en relación con los tipos genéricos. Luego mostrará cómo este concepto se aplica a TypeScript. Mientras se muestran ejemplos de TypeScript, trataré de ayudar a la audiencia a formar una intuición sobre la variación. Finalmente, analizaremos qué significan algunas de las decisiones de diseño en TypeScript para la solidez del código que escribimos y cuáles son algunos puntos ciegos que tiene el compilador.

Comprendiendo los tipos como conjuntos

This Talk explores the concept of types and their relationship to variables in TypeScript, including primitive types, special types, and literal types. It also delves into unions and intersections of types, their canonical form, and their effect on sets of values. The Talk discusses object types, their defined members, and the behavior of access property checks. It highlights how unions and intersections can be used with objects and how they are reduced to a canonical form. The importance of base types in TypeScript and how they allow variables to hold instances of any subtype is also emphasized.

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

Titian-Cornel Cernicova-Dragomir

Mientras TypeScript es actualmente el verificador de tipos estáticos más popular para JavaScript, existen alternativas. En esta charla, analizaremos Flow.js y Hegel, y revisaremos las similitudes y diferencias entre los tres. Haciendo esto, pondremos a TypeScript en perspectiva y tal vez ayudemos a explicar por qué el equipo de TS tomó ciertas decisiones de diseño.

Alternativas a TypeScript

This Talk explores alternatives to TypeScript such as Clojure, Flow, and Hagel, highlighting their unique features and syntax. Flow and Hagel make finer distinctions between types and prioritize safety. TypeScript offers quick fixes for inferring types. Hagel aims for fewer type annotations and increased safety. These alternatives can provide insights and understanding of TypeScript.

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

Usando ejemplos de código abierto de la vida real, exploraremos el poder de TypeScript para mejorar la experiencia de tus usuarios. Cubriremos las mejores prácticas para los autores de bibliotecas, así como consejos y trucos para llevar una biblioteca al siguiente nivel. Esta charla cubrirá: - cómo aprovechar la inferencia de tipos para brindar ayuda a tus usuarios;- usar tipos para reducir la necesidad y complejidad de tu documentación, por ejemplo, usando sobrecargas de funciones, tipos literales de cadena y funciones auxiliares (no-op);- configurar pruebas para asegurarte de que tu biblioteca funcione (¡y tus tipos también!) con herramientas como tsd y expect-type;- tratar los tipos como una API y reducir los cambios que rompen la compatibilidad al enviar mejoras;- me basaré en mi experiencia con bibliotecas como nuxt3, sanity-typed-queries y typed-vuex y mostraré lo que logramos hacer y lo que haría diferente en el futuro.

TypeScript para Autores de Bibliotecas: Aprovechando el Poder de TypeScript para DX

TypeScript for library authors offers benefits for both internal and external use, improving code quality and providing accurate understanding of libraries. Documentation and examples should be in code to provide up-to-date information. Testing types alongside unit tests ensures accurate typing. Managing changes and exposing types requires careful versioning. Deep integration of types improves usability. Using a map in TypeScript allows for simpler implementation and customization. Leveraging types in libraries can generate code based on user access. TypeScript integration with Nuxt provides support and type declarations.

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

Todos sabemos que TypeScript nos ayuda de muchas maneras. El compilador nos guía durante nuestro trabajo, asegurando que cada dato se coloque en su lugar correspondiente. Pero hay algunas limitaciones. TypeScript fue diseñado para ayudarnos durante el tiempo de desarrollo. Después del paso de compilación, aún no podemos estar seguros al 100% de lo que puede suceder durante la ejecución... ¡A menos que hagamos algo al respecto y nos defendamos contra errores no deseados en tiempo de ejecución! Esta charla sirve como una introducción al problema y explica cómo podemos enfrentarlo para hacer nuestras aplicaciones más a prueba de errores.

Seguridad de tipo en tiempo de ejecución en TypeScript

TypeScript does not have runtime type checking, but there are libraries available for runtime type validation. ZAD is a popular runtime type validation library in the React ecosystem, offering schema primitives for specific validations on primitive types and support for complex data like objects and arrays. ZAD also provides methods for parsing values and handling successful or failed parsing with error objects.

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

En este masterclass, primero te mostraré cómo crear un nuevo proyecto en un CMS sin cabeza, llenarlo con datos y usar el contenido en tu proyecto. Luego, pasaremos el resto del tiempo en código, haremos lo siguiente:- Generar modelos y estructuras de tipo fuertemente tipados para el contenido obtenido.- Usar el contenido en componentes- Resolver contenido de campos de texto enriquecido en componentes de React- Tocar los pipelines de implementación y las posibilidades de descubrir problemas relacionados con el contenido antes de llegar a producción

Curso Intensivo de TypeScript para contenido de CMS sin cabeza

This workshop provides an introduction to working with content in TypeScript using CMS. It covers topics such as generating TypeScript models, implementing Next.js, resolving rich text fields, and improving type safety and code maintainability. The workshop also discusses importing content packages, troubleshooting, and automatic model generation. It emphasizes the importance of generating strongly typed models for content and demonstrates how to resolve rich text elements into React components.

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

John Riley introduces TypeScript team members, including Nathan and Gabriella. Tishan discusses his transition from C Sharp to TypeScript and highlights regrets and improvements in TypeScript. The team discusses evolving views on enums, union types, and language features in TypeScript. They explore potential changes in TypeScript's evolution and the influence of Microsoft's philosophy. The conversation also covers enhancing user experience through improved TypeScript error messages.

'TypeChat' Panel Discussion

John Reilly

Nathan Shively-Sanders

Gabriela Araujo Britto

Fireside Chat with Orta Therox

Josh Goldberg

Orta Therox

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.

TypeScript Congress 2022

The Type of Conference Developers Need