Name: Node Congress 2023
Start: 2023-04-14T07:00:00.000Z
End: 2023-04-17T19:00:00.000Z

Deno 2.0 está a punto de llegar y trae consigo grandes cambios para el entorno de ejecución de JavaScript. En esta charla, presentaremos las nuevas características, incluyendo mapas de importación, auto-descubrimiento de package.json y especificadores desnudos. Discutiremos cómo estas mejoras ayudarán a abordar problemas como las dependencias duplicadas y las dependencias que desaparecen. Además, profundizaremos en el soporte incorporado para los especificadores de deno en el registro deno.land/x y su papel en proporcionar un camino recomendado para la publicación. Ven a aprender cómo estas actualizaciones darán forma al futuro del ecosistema de JavaScript y mejorarán la compatibilidad con las aplicaciones Node.

Deno 2.0

The Talk discusses forced optimization with Node and Deno, with Deno aiming to pursue the same goals in a more expansive and modern way. Deno has built-in support for NPM and enforces security constraints. It also has a key-value database called Deno KV, which will be a core part of the Deno 2 API. Deno Deploy is a serverless Edge Functions platform powered by FoundationDB, optimized for fast reading and ideal for building eCommerce sites or application servers at the edge. Deno 2.0 is coming soon with more features under development.

Deno 2.0 is imminent and it's bringing some big changes to the JavaScript runtime. In this talk, we'll introduce the new features including import maps, package.json auto-discovery, and bare specifiers. We'll discuss how these improvements will help address issues like duplicate dependencies and disappearing dependencies. Additionally, we'll delve into the built-in support for deno: specifiers on the deno.land/x registry and its role in providing a recommended path for publishing. Come learn about how these updates will shape the future of the JavaScript ecosystem and improve backwards compatibility with Node applications.

Ryan Dahl

En esta charla explico cómo funciona el servicio AWS Lambda, explicando la arquitectura, cómo escala y cómo un desarrollador debería pensar cuando diseñan su software utilizando funciones Lambda

AWS Lambda bajo el capó

In this Talk, key characteristics of AWS Lambda functions are covered, including service architecture, composition, and optimization of Node.js code. The two operational models of Lambda, asynchronous and synchronous invocation, are explained, highlighting the scalability and availability of the service. The features of Lambda functions, such as retries and event source mapping, are discussed, along with the micro VM lifecycle and the three stages of a Lambda function. Code optimization techniques, including reducing bundle size and using caching options, are explained, and tools like webpack and Lambda Power Tuning are recommended for optimization. Overall, Lambda is a powerful service for handling scalability and traffic spikes while enabling developers to focus on business logic.

In this talk I explain how the AWS Lambda service works explaining the architecture, how it scales and how a developer should think about when they design their software using Lambda functions

AWS Lambda under the hood

Luca Mezzalira

En mi viaje por Nodeland, vi a la mayoría de los equipos luchando con la naturaleza libre de desarrollo de Node.js: no hay barreras para la máxima flexibilidad. Sin embargo, no todos los caminos ofrecen un viaje suave. ¿Cómo construir aplicaciones que estén bien organizadas, sean probables y extensibles? ¿Cómo podríamos construir un código que resistiera la prueba del tiempo? En esta charla, exploraremos cómo evitar la trampa de los Singletons para crear aplicaciones robustas de Node.js a través del uso de plugins de Fastify: ¡construiremos un monolito modular!

Construyendo un monolito modular con Fastify

Fastify is a powerful tool for building web applications and APIs in Node.js, with millions of downloads per month. It promotes encapsulation and structuring through plugins and decorators, allowing for code and data segmentation. The talk emphasizes the importance of modularizing applications by domains and features, and showcases a demo of a typical Fastify application. The speaker also discusses the benefits of using Platformattic for refactoring and launching Fastify applications in the cloud. The Q&A section covers topics such as dependency injection and debugging, while also highlighting the importance of separating business logic from API contracts.

In my journey through Nodeland, I saw most teams struggling with the free-form nature of Node.js development: there are no guardrails for maximum flexibility. Yet, not all paths offer a smooth ride. How to build applications that are well-organized, testable, and extendable? How could we build a codebase that would stand the test of time? In this talk, we will explore how to avoid the trap of Singletons to create robust Node.js applications through the use of Fastify plugins: we will build a modular monolith!

Building a modular monolith with Fastify

Matteo Collina

Varias apis y varios equipos en el mismo repositorio pueden causar muchos dolores de cabeza, pero Nx te tiene cubierto. Aprende a compartir código, mantener archivos de configuración y coordinar cambios en un monorepo que puede escalar tanto como tu organización. Nx te permite dar estructura a un repositorio con cientos de colaboradores y elimina las desaceleraciones de CI que normalmente ocurren a medida que crece la base de código. Índice de contenidos:- Laboratorio 1 - Generar un espacio de trabajo vacío- Laboratorio 2 - Generar una api de node- Laboratorio 3 - Ejecutores- Laboratorio 4 - Migraciones- Laboratorio 5 - Generar una biblioteca de autenticación- Laboratorio 6 - Generar una biblioteca de base de datos- Laboratorio 7 - Añadir un cli de node- Laboratorio 8 - Limites de módulo- Laboratorio 9 - Plugins y Generadores - Introducción- Laboratorio 10 - Plugins y Generadores - Modificación de archivos- Laboratorio 11 - Configuración de CI- Laboratorio 12 - Caché distribuida

Monorepos de Node con Nx

This workshop explores Node Monorepos with NX, highlighting the benefits of monorepos and NX in managing complexity, code sharing, and dependency management. It covers creating and using libraries, setting up module boundaries, linting, and CI/CD integration. The workshop also introduces NX Cloud, which offers distributed caching and task execution for improved performance. Overall, the workshop provides practical insights and tools for efficient software development and engineering in a monorepo environment.

Multiple apis and multiple teams all in the same repository can cause a lot of headaches, but Nx has you covered. Learn to share code, maintain configuration files and coordinate changes in a monorepo that can scale as large as your organisation does. Nx allows you to bring structure to a repository with hundreds of contributors and eliminates the CI slowdowns that typically occur as the codebase grows. Table of contents:- Lab 1 - Generate an empty workspace- Lab 2 - Generate a node api- Lab 3 - Executors- Lab 4 - Migrations- Lab 5 - Generate an auth library- Lab 6 - Generate a database library- Lab 7 - Add a node cli- Lab 8 - Module boundaries- Lab 9 - Plugins and Generators - Intro- Lab 10 - Plugins and Generators - Modifying files- Lab 11 - Setting up CI- Lab 12 - Distributed caching

Node Monorepos with Nx

Isaac Mann

Los Durable Objects, parte de la plataforma Cloudflare Workers, son la solución para un almacenamiento y coordinación fuertemente consistentes en el borde. En esta charla, aprenderás sobre los Durable Objects, por qué son adecuados para casos de uso colaborativos y cómo construir aplicaciones multijugador con ellos!

Construyendo Aplicaciones Multijugador con Cloudflare Workers y Durable Objects

Durable Objects are a part of CloudFlare's long-term goal to expand application possibilities on workers, allowing for the building of scalable collaborative applications. Durable Objects provide a way to store global state and coordinate multi-client applications. They can be created as close to the user as possible and have unique IDs for routing requests. Durable Objects have a persistent storage API with strongly consistent semantics and IO gates to prevent correctness errors. They are well-suited for collaborative applications and can be used with WebSockets. Performance impact and read replicas are considerations for accessing Durable Objects globally.

Durable Objects, part of the Cloudflare Workers platform, are the solution for strongly consistent storage and coordination on the edge. In this talk, you will learn about Durable Objects, why they are suited for collaborative use-cases, and how to build multiplayer applications with them!

Building Multiplayer Applications with Cloudflare Workers & Durable Objects

Matt Alonso

Un vistazo temprano al uso de componentes de servidor a través del nuevo empaquetador de Bun, con y sin React.

Componentes de Servidor con Bun

Bun is a modern JavaScript runtime environment that combines a bundler, transpiler, package manager, and runtime. It offers faster installation of NPM packages and execution of package.json scripts. Bun introduces a new JavaScript and TypeScript bundler with built-in support for server components, enabling easy RPC with the client. This allows for code splitting and running code that streamingly renders React or any other library from the server and mixes it with client code, resulting in less JavaScript sent to the client.

An early look at using server components via Bun’s new bundler, with and without React.

Server Components with Bun

Jarred Sumner

Durante los últimos meses, desarrollé Lyra, un motor de búsqueda de texto completo increíblemente rápido escrito íntegramente en TypeScript. Me sorprendió ver cómo podía competir con soluciones escritas en Rust, Java y Golang, todos idiomas conocidos por ser típicamente "más rápidos que JavaScript"... ¿pero es eso cierto? En esta masterclass, compartiré algunas lecciones que aprendí mientras desarrollaba aplicaciones complejas y críticas para el rendimiento en JavaScript.

Cosas que aprendí mientras escribía aplicaciones de JavaScript de alto rendimiento

This talk explores the creation of a full-text search engine in JavaScript, highlighting the challenges with existing search engines like Algolia and the advantages of using JavaScript. The speaker emphasizes the importance of code optimization and performance enhancement techniques in JavaScript. The talk also discusses the evolution of the Lyra search engine into the open-source project Orama, which offers a feature-rich and highly performant full-text search engine for JavaScript. The speaker addresses questions about language choice, scalability, and deployment, and showcases the benefits of deploying an immutable database to a CDN.

During the past months, I developed Lyra, an incredibly fast full-text search engine entirely written in TypeScript. It was surprising to me to see how it could compete with solutions written in Rust, Java, and Golang, all languages known for being typically "faster than JavaScript"... but is that even true? In this talk, I will share some lessons I learned while developing complex, performance-critical applications in JavaScript.

Things I learned while writing high-performance JavaScript applications

Michele Riva

¿Alguna vez has tenido dificultades para diseñar y estructurar tus aplicaciones Node.js? Construir aplicaciones que estén bien organizadas, sean probables y extensibles no siempre es fácil. A menudo puede resultar ser mucho más complicado de lo que esperas. En este evento en vivo, Matteo te mostrará cómo construye aplicaciones Node.js desde cero. Aprenderás cómo aborda el diseño de aplicaciones y las filosofías que aplica para crear aplicaciones modulares, mantenibles y efectivas. Nivel: intermedio

Masterclass de Node.js

Welcome to the NojectCants backend masterclass! In this workshop, we will cover key aspects of building robust and flexible Node.js applications, including test-driven development, avoiding global state, and splitting business logic across multiple modules. We will also discuss the importance of project structure and how most tutorials can lead to unmaintainable code. Additionally, the workshop covers topics such as choosing the right testing framework for Node.js, mocking and global state, module singletons and avoiding global state, structuring applications and implementing caches, and implementing graceful shutdown for servers.

Have you ever struggled with designing and structuring your Node.js applications? Building applications that are well organised, testable and extendable is not always easy. It can often turn out to be a lot more complicated than you expect it to be. In this live event Matteo will show you how he builds Node.js applications from scratch. You’ll learn how he approaches application design, and the philosophies that he applies to create modular, maintainable and effective applications. Level: intermediate

Node.js Masterclass

V8 proporciona la capacidad de capturar una instantánea de un montón inicializado y rehidratar un montón a partir de la instantánea en lugar de inicializarlo desde cero. Uno de los casos de uso más importantes de esta característica es mejorar el rendimiento de inicio de una aplicación construida sobre V8. En esta charla vamos a echar un vistazo a la integración de las instantáneas de inicio de V8 en Node.js, cómo se han utilizado las instantáneas para acelerar el inicio del núcleo de Node.js, y cómo las instantáneas de inicio del usuario pueden ser utilizadas para acelerar el inicio de las aplicaciones de los usuarios.

Instantáneas de inicio de Node.js

The Talk discusses the Startup Snapshot initiative in Node, which aims to improve startup performance by adding new features and optimizing initialization costs. Startup snapshots, serialized binary blobs, are used to speed up startup and can be generated for both the core and user applications. Custom snapshots allow deserializing a heap from a specified snapshot, skipping parsing and compilation. The Talk also addresses misconceptions and limitations of startup snapshots, and highlights the different use cases for heap snapshots and startup snapshots.

V8 provides the ability to capture a snapshot out of an initialized heap and rehydrate a heap from the snapshot instead of initializing it from scratch. One of the most important use cases of this feature is to improve the startup performance of an application built on top of V8. In this talk we are going to take a look at the integration of the V8 startup snapshots in Node.js, how the snapshots have been used to speed up the startup of Node.js core, and how user-land startup snapshots can be used to speed up the startup of user applications.

Node.js startup snapshots

Joyee Cheung

La API AsyncLocalStorage es sin duda una de las adiciones más importantes y relativamente recientes a Node.js. Hoy en día estamos viendo implementaciones que se agregan a otras ejecuciones como workerd, deno y bun. Y hay un esfuerzo en marcha en TC-39 para introducir una nueva API de AsyncContext al lenguaje. Esta charla presentará el seguimiento del contexto asíncrono con AsyncLocalStorage y AsyncContext y discutirá cómo el modelo está evolucionando a medida que se implementa en múltiples plataformas.

El camino hacia el contexto asíncrono

This Talk discusses the implementation and performance improvements of the async local storage API in Node and Cloudflare Workers. It explores the concept of continuations and execution contexts and how async local storage allows for passing contextual data through async flows. The talk also highlights the challenges in implementing async local storage in Node and the need for a standardized API. The introduction of async context as a replacement for async local storage is discussed, along with its benefits and the ongoing development of the async context API.

The AsyncLocalStorage API is arguably one of the most important relatively recent additions to Node.js. Today we are seeing implementations being added to other runs such as workerd, deno, and bun. And there is an effort underway in TC-39 to introduce a new AsyncContext API to the language. This talk will introduce async context tracking with AsyncLocalStorage and AsyncContext and discuss how the model is evolving as it is being implemented across multiple platforms.

The Road to Async Context

James Snell

Fresh es un marco de trabajo web basado en Deno y en estándares web construido para funcionar en el borde

Fresh: un nuevo marco de trabajo web de pila completa para Deno

Today's Talk introduces Fresh, a full-stack web framework for Deno, and covers its features, such as static files, routes, and data-fetching. It also discusses middleware, error pages, and styling options. The Talk explains the Islands architecture used by Fresh to enable client interactivity. The demo showcases the use of hybrid routes and islands components, and resources for Fresh, Deno, Preact, TypeScript, and web standards are provided.

Fresh is a web framework based on Deno and Web standards built to run on the edge

Fresh: a new full stack web framework for Deno

Nick Taylor

Bun, Deno y muchos otros tiempos de ejecución de JavaScript han sido elogiados, pero ¿sabes por qué? ¿Es tan fácil crear un tiempo de ejecución desde cero? He estado investigando el secreto detrás del poder de Node.js y por qué hay tantos nuevos tiempos de ejecución de JavaScript surgiendo. Desglosando cada componente clave utilizado en Node.js, he llegado a conclusiones interesantes que muchas personas solían decir, pero en la práctica funciona de manera un poco diferente. En esta charla, los asistentes aprenderán los conceptos utilizados para crear un nuevo tiempo de ejecución de JavaScript. Pasarán por un ejemplo de cómo hacer un tiempo de ejecución de JavaScript siguiendo lo que está detrás de escena en el proyecto Node.js utilizando C++. Aprenderán la relación entre V8 de Chrome y Libuv y qué hace que un tiempo de ejecución de JavaScript sea mejor que otros. Esta charla cubrirá los siguientes temas: - ¿Qué es un motor de JavaScript - V8 - ¿Por qué Node.js utiliza Libuv - Cómo crear un tiempo de ejecución de JS desde cero

Bun, Deno, Node.js? Recreando un tiempo de ejecución de JavaScript desde cero - Comprende la magia detrás de Node.js

The Talk explores the magic behind Node.js and delves into its components, including V8, libuv, and the C++ bridge. It discusses the workflow and execution process, the use of NodeMod, and the understanding of console functions. The Talk also covers Node.js functions and scheduling, the introduction of runtimes, and the collaboration between JavaScript runtimes. It concludes with insights on content production, the choice of Node.js, and the inspiration behind it.

Bun, Deno, and many other JavaScript runtimes have been hyped, but do you know why? Is it that easy to make a runtime from scratch? I've been researching the secret behind Node.js' power and why there are so many new JavaScript runtimes coming up. Breaking down each key component used on Node.js I've come to interesting conclusions that many people used to say whereas in practice it works a bit differently. In this talk, attendees will learn the concepts used to create a new JavaScript runtime. They're going to go through an example of how to make a JavaScript runtime by following what's behind the scenes on the Node.js project using C++. They'll learn the relationship between Chrome's V8 and Libuv and what makes one JavaScript runtime better than others. This talk will cover the following topics: - What's a JavaScript Engine - V8 - Why Node.js uses Libuv - How to create a JS Runtime from scratch

Bun, Deno, Node.js? Recreating a JavaScript runtime from Scratch - Understand magic behind  Node.js

Erick Wendel

El masterclass se centra en conceptos, algoritmos y prácticas para descomponer una aplicación monolítica en microservicios GRPC. Presenta una visión general de los principios de arquitectura, patrones de diseño y tecnologías utilizadas para construir microservicios. Cubre la teoría del marco de trabajo GRPC y el mecanismo de protocol buffers, así como técnicas y especificidades de la construcción de servicios TypeScript aislados en el stack de Node.js. El masterclass incluye una demostración en vivo de un caso de uso de descomposición de una aplicación API en un conjunto de microservicios. Es adecuado para arquitectos, líderes técnicos y desarrolladores que deseen aprender patrones de microservicios. Nivel: AvanzadoPatrones: DDD, MicroserviciosTecnologías: GRPC, Protocol Buffers, Node.js, TypeScript, NestJS, Express.js, PostgreSQL, TurborepoEstructura de ejemplo: configuración de monorepo, configuración de paquetes, utilidades comunes, servicio de demostraciónEjercicio práctico: refactorizar la aplicación monolítica

Descomponiendo Monolito NestJS API en Microservicios GRPC

The workshop focused on decomposing a monolithic API into microservices using NestJS and gRPC. The speaker discussed the benefits and drawbacks of monoliths and microservices, as well as principles and architecture patterns for microservices. The process of decomposing the monolith involved refactoring the code, introducing gRPC for communication, and gradually moving parts of the monolith to separate services. The workshop also highlighted the importance of testing, CI/CD pipelines, and database decomposition. Overall, the workshop emphasized the need for careful planning and testing when decomposing a monolith into microservices.

The workshop focuses on concepts, algorithms, and practices to decompose a monolithic application into GRPC microservices. It overviews architecture principles, design patterns, and technologies used to build microservices. It covers the theory of the GRPC framework and protocol buffers mechanism, as well as techniques and specifics of building isolated TypeScript services in the Node.js stack. The workshop includes a live use case demo of decomposing an API application into a set of microservices. It fits the best architects, tech leads, and developers who want to learn microservices patterns. Level: AdvancedPatterns: DDD, MicroservicesTechnologies: GRPC, Protocol Buffers, Node.js, TypeScript, NestJS, Express.js, PostgreSQL, TurborepoExample structure: monorepo configuration, packages configuration, common utilities, demo servicePractical exercise: refactor monolith app

Decomposing Monolith NestJS API into GRPC Microservices

Alex Korzhikov

La autenticación sin contraseña puede parecer compleja, pero es fácil de agregar a cualquier aplicación utilizando la herramienta adecuada. Mejoraremos una aplicación JS de pila completa (backend de Node.JS + frontend de React) para autenticar usuarios con OAuth (inicio de sesión social) y contraseñas de un solo uso (correo electrónico), incluyendo:- Autenticación de usuario - Administrar interacciones de usuario, devolver JWT de sesión / actualización- Gestión y validación de sesiones - Almacenar la sesión para solicitudes de cliente posteriores, validar / actualizar sesiones Al final del masterclass, también tocaremos otro enfoque para la autenticación de código utilizando Flujos Descope en el frontend (flujos de arrastrar y soltar), manteniendo solo la validación de sesión en el backend. Con esto, también mostraremos lo fácil que es habilitar la biometría y otros métodos de autenticación sin contraseña. Tabla de contenidos- Una breve introducción a los conceptos básicos de autenticación- Codificación- Por qué importa la autenticación sin contraseña Requisitos previos- IDE de tu elección- Node 18 o superior

0 a Auth en una Hora Usando NodeJS SDK

This Workshop focuses on adding passwordless authentication to a node application, covering basic authentication concepts and the importance of authentication for application security. It explores session management using server-side sessions and client-side tokens like JWTs. The Workshop demonstrates the implementation of various authentication methods, including one-time password and OAuth. It also discusses the validation and refreshing of session tokens, as well as the customization of authentication methods and the storage of public keys for multiple instances.

Passwordless authentication may seem complex, but it is simple to add it to any app using the right tool. We will enhance a full-stack JS application (Node.JS backend + React frontend) to authenticate users with OAuth (social login) and One Time Passwords (email), including:- User authentication - Managing user interactions, returning session / refresh JWTs- Session management and validation - Storing the session for subsequent client requests, validating / refreshing sessions At the end of the workshop, we will also touch on another approach to code authentication using frontend Descope Flows (drag-and-drop workflows), while keeping only session validation in the backend. With this, we will also show how easy it is to enable biometrics and other passwordless authentication methods. Table of contents- A quick intro to core authentication concepts- Coding- Why passwordless matters Prerequisites- IDE for your choice- Node 18 or higher

0 to Auth in an Hour Using NodeJS SDK

Asaf Shen

Los productos de trazado modernos funcionan combinando diagnostics_channel con AsyncLocalStorage. Construyamos juntos un trazador para ver cómo funciona y qué puedes hacer para hacer que tus aplicaciones sean más observables.

Observabilidad con diagnostics_channel y AsyncLocalStorage

Observability with Diagnostics Channel and async local storage allows for high-performance event tracking and propagation of values through calls, callbacks, and promise continuations. Tracing involves five events and separate channels for each event, capturing errors and return values. The span object in async local storage stores data about the current execution and is reported to the tracer when the end is triggered.

Modern tracing products work by combining diagnostics_channel with AsyncLocalStorage. Let's build a tracer together to see how it works and what you can do to make your apps more observable.

Observability with diagnostics_channel and AsyncLocalStorage

Stephen Belanger

ChatGPT está revolucionando Internet. En enero de 2023, ChatGPT alcanzó más de 100 millones de usuarios, convirtiéndose en la aplicación de consumo de más rápido crecimiento hasta la fecha. No te pierdas esta charla y aprende cómo usar ChatGPT en una aplicación Node.js. Utilizaremos la API de OpenAI para interactuar con el modelo ChatGPT, obtendremos una clave de API de OpenAI y luego utilizaremos una biblioteca de cliente de API para realizar solicitudes a la API desde tu código Node.js. ¡Aprende trucos sobre cómo optimizar tu productividad con ChatGPT y diviértete con la inteligencia artificial!

Cómo usar ChatGPT con Node.js

Today's Talk introduces Chat GPT and its integration with Node.js, highlighting its exceptional performance and natural language capabilities. The speaker demonstrates how to interact with ChatGPT using Node.js and showcases examples such as selecting avatars and getting jokes. The Talk also discusses the use of ChargePT for extracting important information and interacting with databases. Important considerations when using ChatGPT, the potential of GPT-4, and the impact of AI on jobs are also covered. Security concerns and the use of extensions like Runme in Visual Code are mentioned as well.

ChatGPT is revolutionizing the internet. In January 2023, ChatGPT reached over 100 million users, making it the fastest-growing consumer application to date. Don't miss this talk and learn how to To use ChatGPT in a Node.js application, we will use: OpenAI API to interact with the ChatGPT model, we will get an API key from OpenAI, and then use an API client library to make requests to the API from your Node.js code. Learn hacks on how to optimize your productivity with ChatGPT and have fun with artificial intelligence!

How to use ChatGPT with Node.js

Lizz Parody

<div>La mayoría de las aplicaciones JavaScript utilizan JSON.parse para crear cualquier objeto primero, y luego validar y estrechar el tipo de datos al esperado. Este enfoque tiene problemas de rendimiento y seguridad, ya que incluso si los datos no son válidos, toda la cadena JSON debe ser analizada primero antes de que los datos sean validados, en lugar de fallar en la etapa de análisis JSON (por ejemplo, si se pasa un número en lugar de una cadena en alguna propiedad).</div><div> </div><div>Muchos lenguajes admiten el análisis de cadenas JSON directamente en los tipos esperados, pero no es compatible de forma nativa en JavaScript o TypeScript.</div>En esta charla mostraremos cómo se pueden utilizar las capacidades de TypeScript combinadas con la nueva especificación JSON Type Definition (RFC 8927) y la biblioteca Ajv para analizar sus datos directamente en el tipo definido por la aplicación más rápido que JSON.parse, y también cómo serializar datos de un tipo conocido aproximadamente 10 veces más rápido que JSON.serialize.

Analizar, no validar

Hello. We're going to talk today about JavaScript and how to ensure data correctness. JSON can be wasteful and has security issues, but Fastify tackles these challenges. JTD is better than JSON Schema for most API use cases, as it has a more strict structure and avoids debugging issues. Jason demonstrates how to validate data with JTD and TypeScript, ensuring data validity and improving performance. The approach of parsing JSON directly to the application type and serializing a specific type improves security and reliability.

<div>Most JavaScript applications use JSON.parse to create any object first, and then validate and narrow the data type to the expected one. This approach has performance and security problems, as even if the data is invalid, the whole JSON string needs to be parsed first before the data is validated, instead of failing at JSON parsing stage (e.g., if number is passed instead of string in some property).</div><div> </div><div>Many languages support parsing of JSON strings directly into the expected types, but it is not natively supported in JavaScript or TypeScript.</div>In this talk we will show how the powers of TypeScript combined with the new specification JSON Type Definition (RFC 8927) and Ajv library can be used to parse your data directly into the expected application-defined type faster than JSON.parse, and also how to serialize data of a known type approximately 10 times faster than JSON.serialize.

Parse, Don’t Validate

Evgeny Poberezkin

Jason Green

En este masterclass, veremos cómo adoptar Orama, un potente motor de búsqueda de texto completo escrito completamente en JavaScript, para hacer que la búsqueda esté disponible donde sea que se ejecute JavaScript. Aprenderemos cuándo, cómo y por qué sería una gran idea implementarlo en una función sin servidor, y cuándo sería mejor mantenerlo directamente en el navegador. Olvídate de las APIs, configuraciones complejas, etc.: Orama facilitará la integración de la búsqueda en proyectos de cualquier escala.

Búsqueda de texto completo basada en JavaScript con Orama en todas partes

Orama Search Workshop is a learn-as-you-type workshop that introduces Orama, an open-source full-text search engine written in TypeScript. The workshop covers topics such as ES Modules, project structure, using pnpm for monorepos, creating a new Orama schema, importing and inserting data, performing searches, and filtering search results. Orama is recommended for those needing a full-text search engine that can easily scale and run on CDNs. The workshop also discusses future plans, deploying strategies, and community support through Slack.

In this workshop, we will see how to adopt Orama, a powerful full-text search engine written entirely in JavaScript, to make search available wherever JavaScript runs. We will learn when, how, and why deploying it on a serverless function could be a great idea, and when it would be better to keep it directly on the browser. Forget APIs, complex configurations, etc: Orama will make it easy to integrate search on projects of any scale.

JavaScript-based full-text search with Orama everywhere

Desplegar aplicaciones desacopladas y de microservicios no es solo un problema que se resuelve el día de la migración. Avanzar con estas arquitecturas depende completamente de cómo será la experiencia del flujo de trabajo de su equipo día a día después de la migración. La parte más difícil de esto a menudo es la cantidad de proveedores involucrados. Algunos objetivos son más adecuados para frameworks frontend específicos, mientras que otros son más adecuados para CMS y APIs personalizadas. Desafortunadamente, sus suposiciones, flujos de trabajo, APIs y conceptos de seguridad pueden ser bastante diferentes. Si bien hay ciertas ventajas en confiar en un contrato estricto entre aplicaciones, donde el trabajo del equipo backend y frontend se limita a un solo proveedor, esto no siempre es realista. Esto podría ser porque aún están experimentando, o simplemente porque el tamaño de su organización aún no permite este tipo de especialización. En este masterclass, tendrás la oportunidad de explorar un enfoque diferente y de un solo proveedor para microservicios utilizando Strapi y Next.js como ejemplo. Desplegarás cada aplicación individualmente, estableciendo un flujo de trabajo desde el principio que simplifica la personalización, introduce nuevas características, investiga problemas de rendimiento e incluso permite la intercambiabilidad de frameworks desde el principio. Estructura:- Comenzando- Descripción general de Strapi- Descripción general del flujo de trabajo de Platform.sh- Desplegar el proyecto- Cambiar servicios- Agregar el frontend Requisitos previos:- <a href="https://auth.api.platform.sh/register?trial_type=general&amp;_utm_medium=node-congress&amp;_utm_campaign=2023-Node-Congress&amp;_utm_source=node-congress" target="_blank">Crear una cuenta de prueba en Platform.sh</a>- <a href="https://docs.platform.sh/administration/cli.html" target="_blank">Instalar la CLI de Platform.sh</a>

Desacoplamiento en Práctica

Platform.SH is a platform as a service provider that supports various frameworks and runtimes. In this workshop, a two application project called food adviser is deployed using Next.js as the front end and Strapi as the back end. The process involves creating a Strapi application, managing content collections, building the Strapi API, setting up the database and admin panel, deploying the project to Platform.SH, integrating with GitHub, configuring routes, and deploying the backend. The workshop also covers deploying the frontend, configuring the frontend and backend, and additional topics such as email settings in Strapi.

Deploying decoupled and microservice applications isn't just a problem to be solved on migration day. Moving forward with these architectures depends completely on what your team's workflow experience will look like day-to-day post-migration. The hardest part of this can often be the number of vendors involved. Some targets are best suited for specific frontend frameworks, while others are more so for CMSs and custom APIs. Unfortunately their assumptions, workflows, APIs, and notions of security can be quite different. While there are certain advantages to relying on a strict contract between apps – where backend and frontend teams work is limited to a single vendor – this isn't always realistic. This could be because you're still experimenting, or simply the size of your organization doesn't allow for this kind of specialization just yet. In this workshop, you'll have a chance to explore a different, single vendor approach to microservices using Strapi and Next.js as an example. You'll deploy each app individually, establishing a workflow from the start that simplifies customization, introducing new features, investigating performance issues, and even framework interchangeability from the start. Structure:- Getting started- Overview of Strapi- Overview of Platform.sh workflow- Deploying the project- Switching services- Adding the frontend Prerequisites:- <a href="https://auth.api.platform.sh/register?trial_type=general&amp;_utm_medium=node-congress&amp;_utm_campaign=2023-Node-Congress&amp;_utm_source=node-congress" target="_blank">A Platform.sh trial account created</a>- <a href="https://docs.platform.sh/administration/cli.html" target="_blank">The Platform.sh CLI installed</a>

Decoupling in Practice

Chad Carlson

La base de datos puede ser una de las partes más difíciles de escalar en una aplicación web. Muchos proyectos terminan utilizando sistemas de caché ad-hoc que son complejos, propensos a errores y costosos de construir. ¿Qué pasaría si pudieras implementar un sistema de caché listo para usar para mejorar el rendimiento y la optimización de consultas sin necesidad de realizar cambios en el código de tu aplicación? Únete a los desarrolladores Aspen Smith y Nick Marino para ver cómo puedes cambiar una línea de configuración en tu aplicación y utilizar ReadySet para escalar el rendimiento de tus consultas en órdenes de magnitud hoy mismo.

Escalando tu base de datos con ReadySet

ReadySet is a plug and play caching solution that improves database performance and query optimization. It supports scaling out to multiple nodes without additional load on the database and ensures real-time cache updates. ReadySet significantly speeds up queries and reduces query time, making it a game-changer for web applications. It is not designed for write-heavy applications but works best for read-heavy loads. Community feedback is encouraged, and a cloud version of ReadySet is available for production use.

The database can be one of the hardest parts of a web app to scale. Many projects end up using ad-hoc caching systems that are complex, error-prone, and expensive to build. What if you could drop in a ready-built caching system to enable better throughput and latency with no code changes to your application? Join developers Aspen Smith and Nick Marino to see how you can change one line of config in your app and use ReadySet to scale up your query performance by orders of magnitude today.

Scaling up Your Database With ReadySet

Aspen Smith

Nick Marino 

En 2018, se publicó un nuevo vector de ataque contra los códigos JavaScript: la Contaminación de Prototipos. A primera vista, parecía bastante limitado en su impacto: básicamente sería una buena forma de hacer que algunos códigos se bloqueen. Sin embargo, se han producido múltiples casos de Ejecuciones de Código Remoto basados en este vector. En esta charla, aclararemos qué son las contaminaciones de prototipos, su impacto real y cómo evitar que ocurran en su código.

Contaminación de Prototipos en JavaScript

This Talk discusses prototype production in JavaScript and focuses on the concept of prototype pollution. It explains the impact of prototype pollution and ways to avoid it. The Talk also highlights real-world examples of prototype pollution vulnerabilities in Kibana and MongoDB. It provides recommendations for preventing and mitigating prototype pollution, such as filtering out merge functions and using defensive objects. The Talk concludes with a discussion on tools like Semgrep for static analysis and the importance of sanitization and validation in preventing outside attacks.

In 2018, a new attack vector against JavaScript codebases has been published: Prototype Pollution. At first glance, it seemed pretty limited in impact: it would basically be a good way to crash some code. However, multiple cases of Remote Code Executions have happened based on this vector. In this talk, we will clarify what are prototype pollutions, their real impact and of to prevent them from happening in your codebase.

Prototype Pollution in JavaScript

Vladimir de Turckheim

En esta charla, hablaré sobre los beneficios de usar GraphQL y mostraré una pequeña demostración de un punto final creado con Fastify Mercurius y Prisma.

GraphQL con Mercurius y Prisma, amor a primera vista

The Talk discusses the use of Prisma and Mercurius in moving from REST API to GraphQL. Prisma improves the developer experience and allows for easy data modeling and type-safe queries. Mercurius is easy to learn if you already know Fastify and offers a performant GraphQL server. Fastify is preferred over Express for its active community and good performance. The ideal stack for Node.js includes Fastify for REST API and GraphQL, Prisma for the database, and the default provider like MongoDB.

In this speech, I'll talk about the benefit of using GraphQL and show a small demo of an endpoint created with Fastify Mercurius and Prisma.

GraphQL with Mercurius and Prisma, love at first sight

Luca Del Puppo

En el panorama actual de desarrollo de software rápido, es esencial contar con herramientas que nos permitan construir, probar y desplegar nuestras aplicaciones de manera rápida y eficiente. Poder enviar características rápidamente implica tener una base de código saludable y mantenible, lo cual puede ser complicado y desafiante, especialmente a largo plazo.En esta charla, exploraremos estrategias para construir backends de Node mantenibles aprovechando las herramientas que proporciona Nx. Esto incluye cómo modularizar una base de código, utilizar generadores de código para mantener la consistencia, establecer límites de código y cómo mantener la integración continua rápida a medida que crece la base de código.

Arquitectura de código de próxima generación para construir aplicaciones de Node mantenibles

Today's Talk focused on code architecture, modularization, and scaling in software development. The speaker discussed the benefits of separating code by domain and using tools like NX to improve productivity and enforce modular architecture. They also highlighted the importance of automating library creation and configuration. Additionally, the Talk covered code scaling and deployment strategies, including caching and automated code migrations. The speaker emphasized the flexibility and scalability of Fastify and the advantages of using a monorepo for front-end and back-end development.

In today's fast-paced software development landscape, it's essential to have tools that allow us to build, test, and deploy our applications quickly and efficiently. Being able to ship features fast implies having a healthy and maintainable codebase, which can be tricky and daunting, especially in the long-run.In this talk, we'll explore strategies for building maintainable Node backends by leveraging tooling that Nx provides. This includes how to modularize a codebase, using code generators for consistency, establish code boundaries, and how to keep CI fast as your codebase grows.

Next Generation Code Architecture for Building Maintainable Node Applications

Juri Strumpflohner

Las aplicaciones web son comúnmente vulnerables a varios ataques de Denegación de Servicio Distribuido, a veces de formas inesperadas. Un ejemplo es el ataque SlowLoris, una explotación que provoca interrupción del servicio simplemente enviando los datos al servidor lo más lento posible. En esta charla contaré la historia de cómo tomó casi 13 años proteger por completo a Node del ataque SlowLoris. También mostraré que a veces, priorizar el rendimiento puede llevar a soluciones incorrectas que resultan en una falsa sensación de protección.

La historia de cómo evitar un ataque DDOS basado en el tiempo en Node.js

Web applications face constant threats from DDoS attacks, including the new Zoloris attack that can bring down a server with minimal bandwidth. Node.js has had vulnerabilities in its timeout handling, but recent versions like Node 18 provide better protection. NGINX is recommended for protection against slow loris attacks due to its superior timeout handling. Mitigating slow loris attacks for WebSockets involves enforcing higher timeouts and shutting down idle clients. It is important to prioritize security over performance and use common sense in software development.

Web applications are commonly vulnerable to several Distributed Denial of Service attacks, sometimes in unexpected ways. An example is the SlowLoris attack, an exploit that leads to service interruption by simply sending the data to the server as slowest as possible.  In this talk I will tell the tale of how it took almost 13 years for Node to be completely protected by SlowLoris attack. I will also show that sometimes prioritizing performance can lead to incorrect fixes that can result in a false sense of protection.

The tale of avoiding a time-based DDOS attack in Node.js

Paolo Insogna

En esta charla, me encantaría informar e inspirar a la comunidad para superar las limitaciones del desarrollo web ejecutando Node.js dentro del navegador. Cubriré cómo y por qué desarrollamos WebContainers, cuáles fueron y son nuestros obstáculos y limitaciones, cómo hemos trabajado con la comunidad para mejorar la tecnología y qué se ha habilitado y construido con WebContainers.

Lleva Node.js a tu navegador con WebContainers

This Talk discusses bringing Node.js into the browser using web containers. It covers the history of Node.js and the internet in the early 2000s, the possibilities of Node.js in the browser, and approaches to achieving this. It also explores Stackbits' journey and growth, innovation in web container design, and the functionality of web containers. The Talk emphasizes the importance of open source and collaboration in improving the web ecosystem.

In this talk, I'd love to inform and inspire the community to push the limitations of web development running Node.js inside the browser. I will cover how and why we developed WebContainers, what our roadblocks and limitations were and are, how we've worked with the community to make the technology better and what has already been enabled and built with WebContainers.

Bring Node.js into your browser with WebContainers

Sylwia Vargas

Esta charla trata sobre SecureEcmaScript y Compartments, que son propuestas de TC39, y estoy trabajando en herramientas para hacer que estos conceptos sean utilizables con las personas que defienden esas propuestas. Esta es una cuenta de primera mano sobre el futuro de la seguridad de JavaScript. SES + herramientas (LavaMoat o Endo) están haciendo posible limitar el acceso a la red, fs, módulos principales o globales por paquete. Quiero mostrar cómo funcionan, qué posibilidades abren y cómo hacer que ese futuro suceda hoy con un poco de esfuerzo. Para mí, este es el paso final para asegurar la cadena de suministro de npm: incluso si un paquete es tomado por actores maliciosos, no podrá hacerme daño.

Evaluar todas las cadenas! - JavaScript endurecido

NPM packages can be potentially dangerous, so it's important to be proactive in managing them. Lava Mode allows you to detect and investigate suspicious packages before deploying your app. Lavamote prevents unauthorized access to sensitive resources by isolating dependencies and using hardened JavaScript. Lava Mode makes it easier to analyze obfuscated files and understand their actions.

This talk is about SecureEcmaScript and Compartments which are TC39 proposals, and I'm working on tooling to make these concepts usable with people championing those proposals. This is a first-hand account of the future of JavaScript security. SES + tooling (LavaMoat or Endo) is making limiting access to network, fs, core modules or globals possible on a per-package basis. I want to show how they work, what possibilities they open and how to make that future happen today with some effort. To me this is the final step in securing npm supply chain - even if a package gets taken over by bad actors, it won't be able to hurt me.

Eval all the strings! - Hardened JavaScript

Zbyszek Tenerowicz

Esta charla explorará cómo se puede integrar el aprendizaje automático en aplicaciones Node.js para hacerlas más rápidas, eficientes y poderosas. Discutiremos diferentes enfoques para agregar capacidades de aprendizaje automático, incluyendo APIs, bibliotecas y frameworks. También demostraremos cómo el aprendizaje automático puede resolver problemas complejos y crear nuevas oportunidades de desarrollo. Por último, esta charla proporcionará consejos y mejores prácticas para incorporar el aprendizaje automático en aplicaciones Node.js.

Cómo potenciar tu aplicación Node.js con Machine Learning

Welcome to our talk on incorporating machine learning to your Node.js applications. Learn how to take your Node.js application to the next level with machine learning. Implementing machine learning in Node.js can be daunting, but with the right framework and approach, it can be simplified. Start with a simple model, gradually add complexity, and ensure high-quality data. Monitor and evaluate your models using metrics and consider scalability and reusing pre-trained models.

This talk will explore how machine learning can be integrated into Node.js applications to make them faster, more efficient, and more powerful. We will discuss different approaches for adding machine learning capabilities, including APIs, libraries, and frameworks. We will also demonstrate how machine learning can solve complex problems and create new development opportunities. Finally, this talk will provide tips and best practices for incorporating machine learning into Node.js applications.

Using Machine Learning to Supercharge Your Node.js App

Marian Villa

Esta masterclass tiene como objetivo brindarte un módulo introductorio sobre los aspectos generales del código abierto. Sigue a Claudio Wunder de la Fundación OpenJS para que te guíe sobre cómo funciona el modelo de gobierno de Node.js, cómo se toman decisiones de alto nivel y cómo hacer tu primera contribución. Al final de la masterclass, tendrás una comprensión general de todos los tipos de trabajo que hace el proyecto Node.js (desde la clasificación de errores hasta decidir los próximos 10 años de Node.js) y cómo puedes formar parte del panorama más amplio del ecosistema JavaScript. Las siguientes tecnologías y habilidades suaves podrían ser necesarias: - Comprensión básica de Git e interfaz de GitHub - Conocimiento de inglés profesional/intermedio para la comunicación y para permitirte contribuir a la organización Node.js (ya que todas las contribuciones requieren comunicación dentro de los problemas y solicitudes de GitHub) - La masterclass requiere que tengas una computadora (de lo contrario, se vuelve difícil colaborar, pero las tabletas también están bien) con una configuración de IDE, y recomendamos <a href="https://code.visualstudio.com/download" target="_blank">VS Code</a> y recomendamos la extensión <a href="https://marketplace.visualstudio.com/items?itemName=GitHub.vscode-pull-request-github" target="_blank">GitHub Pull Requests &amp; Issues</a> para colaborar con problemas y solicitudes directamente desde el IDE. Se cubrirán los siguientes temas durante la masterclass: - Un repaso de algunas características de la interfaz de GitHub, como los proyectos de GitHub y los problemas de GitHub - Repasaremos los conceptos básicos del código abierto y seguiremos la Guía de código abierto - Repasaremos Markdown - Cubriremos el gobierno del código abierto y cómo funciona el proyecto Node.js y hablaremos sobre la Fundación OpenJS - Incluyendo todas las formas en que uno puede contribuir al proyecto Node.js y cómo se pueden valorar sus contribuciones - Durante esta masterclass, cubriremos problemas de nodejs/nodejs.dev, ya que la mayoría de ellos son de nivel básico y no requieren conocimientos profundos de C++ o de Node.js. - Dicho esto, aún recomendamos a los asistentes entusiastas que deseen desafiarse a sí mismos a los "Good First Issues" de nodejs/node (repositorio principal) si lo desean. - Permitiremos a cada asistente elegir un problema o trabajar junto con otros asistentes para abordar problemas juntos mediante la función de Pair Programming a través de la característica de VS Code Live Share - También podemos hacer salas de descanso en Zoom para las personas que deseen colaborar juntas - Claudio estará allí para brindar apoyo a todos los asistentes y, por supuesto, responder cualquier pregunta sobre problemas y desafíos técnicos que puedan enfrentar - Las tecnologías utilizadas en nodejs/nodejs.dev son React/JSX, Markdown, MDX y Gatsby. (No se necesita ningún conocimiento de Gatsby, ya que la mayoría de los problemas son agnósticos a la plataforma) - Al final de la masterclass, recopilaremos todos los colaboradores que hayan abierto con éxito una solicitud de extracción (incluso si es un borrador) y reconoceremos su participación en las redes sociales.

Node.js: Aterrizando tu primera contribución de código abierto y cómo funciona el proyecto Node.js

Today's workshop covers the Node.js project, governance model, collaboration, and contribution. The Node.js organization has important repositories and follows a governance model for proposing changes. Collaboration involves bug reporting, pull requests, and detailed contribution guides. Strategic initiatives aim to improve Node.js, and the website redesign initiative faced challenges. The workshop focuses on technologies like React, Next.js, Jest, and Storybook, and provides hands-on experience and collaboration. Participants can work on various issues, including component migration and testing, and contribute to the Node.js project.

This workshop aims to give you an introductory module on the general aspects of Open Source. Follow Claudio Wunder from the OpenJS Foundation to guide you on how the governance model of Node.js work, how high-level decisions are made, and how to land your very first contribution. At the end of the workshop, you'll have a general understanding of all the kinds of work that the Node.js project does (From Bug triage to deciding the Next-10 years of Node.js) and how you can be part of the bigger picture of the JavaScript ecosystem. The following technologies and soft skills might be needed):   - Basic understanding of Git &amp; GitHub interface   - Professional/Intermediate English knowledge for communication and for allowing you to contribute to the Node.js org (As all contributions require communication within GitHub Issues/PRs)   - The workshop requires you to have a computer (Otherwise, it becomes difficult to collaborate, but tablets are also OK) with an IDE setup, and we recommend <a href="https://code.visualstudio.com/download" target="_blank">VS Code</a> and we recommend the <a href="https://marketplace.visualstudio.com/items?itemName=GitHub.vscode-pull-request-github" target="_blank">GitHub Pull Requests &amp; Issues</a> Extension for collaborating with Issues and Pull Requests straight from the IDE. The following themes will be covered during the workshop: - A recap of some of GitHub UI features, such as GitHub projects and GitHub Issues - We will cover the basics of Open Source and go through Open Source Guide - We will recap Markdown - We will cover Open Source governance and how the Node.js project works and talk about the OpenJS Foundation   - Including all the ways one might contribute to the Node.js project and how their contributions can be valued - During this Workshop, we will cover Issues from the nodejs/nodejs.dev as most of them are entry-level and do not require C++ or deep technical knowledge of Node.js.   - Having that said, we still recommend enthusiast attendees that want to challenge themselves to "Good First Issues" from the nodejs/node (core repository) if they wish.   - We're going to allow each attendee to choose an issue or to sit together with other attendees and tackle issues together with Pair Programming through VS Code Live Share feature     - We can also do Zoom breakrooms for people that want to collaborate together   - Claudio will be there to give support to all attendees and, of course, answer any questions regarding Issues and technical challenges they might face   - The technologies used within nodejs/nodejs.dev are React/JSX, Markdown, MDX and Gatsby. (No need any knowledge of Gatsby, as most of the issues are platform agnostic) - By the end of the Workshop, we'll collect all (make a list) the contributors who successfully opened a Pull Request (even if it's a draft) and recognise their participation on Social media.

Node.js: Landing your first Open Source contribution & how the Node.js project works

 Claudio Wunder

Las codificaciones de caracteres pueden ser confusas para cualquier desarrollador, brindando dificultades incluso para los más experimentados, por lo que muchas veces queremos obtener algo que simplemente funcione sin una comprensión profunda de los conceptos involucrados. En esta charla, Anna dará una visión general de qué son, qué proporciona el lenguaje JavaScript para interactuar con ellas y cómo evitar los errores más comunes en Node.js y en la Web.

Codificación de caracteres en JS

Character encodings are important for converting characters into bytes. UTF-8 is the most commonly used encoding in JavaScript. JavaScript engines handle character encodings automatically. There are bugs in Node.js related to character encoding and string manipulation. It is important to be cautious when working with character encodings and to choose the appropriate method for string manipulation.

Character encodings can be confusing for every developer, providing pitfalls even for the most experienced ones, so a lot of the time we want to end up with something that “just works” without an in-depth understanding of the involved concepts. In this talk, Anna will give an overview over what they are, what the JavaScript language provides to interact with them, and how to avoid the most common mistakes in Node.js and the Web.

JS Character Encodings

Anna Henningsen

Cuando se monitoriza Node.js, se puede realizar un seguimiento del rendimiento y la disponibilidad de las aplicaciones mediante la identificación de cuellos de botella y la corrección de errores. Se pueden identificar problemas al analizar métricas como el uso de memoria del proceso, el tiempo de respuesta promedio, el uso de la CPU y más. Si se agrega la monitorización de los demás componentes de toda la pila, se obtendrá una visión integral de lo que podría estar afectando el rendimiento de la aplicación. En ese momento, se puede señalar el problema a nivel de código, lo que le permite localizar y solucionar esos problemas antes de que afecten negativamente la experiencia del usuario final. Esta charla se centrará en las herramientas disponibles en la base de datos de series temporales de código abierto InfluxDB. Se utilizará el complemento de código abierto node.js telegraf, para que pueda recopilar fácilmente métricas clave que le ayuden a obtener esa visión de su aplicación. Utilizaremos la Plantilla de Monitorización de Node.js, que está preconfigurada y equipada para monitorizar el rendimiento y la disponibilidad de las aplicaciones. Todos los ejemplos de código estarán en JavaScript, y también repasaremos la biblioteca de JavaScript para aquellos que trabajen en otros entornos de servidor JavaScript o que deseen exportar datos a sus herramientas de visualización preferidas.

Monitorización, Alertas y Visualización de la infraestructura del servidor Node.js con herramientas de código abierto

This Talk introduces monitoring, alerting, and visualizing Node.js server infrastructure with open source tools. It covers the use of time series databases for server monitoring and discusses the JavaScript client library. The InfluxDB platform offers features for data acquisition, visualization, and task scheduling. The Talk includes a live demo of a fake Express server and showcases the use of community templates and the Node.js dashboard. It also provides resources for further learning and discusses options for visualization with Grafana.

When monitoring Node.js, you can track your applications’ performance and availability by finding bottlenecks and fixing errors. You can identify issues by specifically looking at metrics like Process memory usage, Average response time, CPU usage, and more. If you add monitoring of the other components of your entire stack, you will gain a comprehensive view of what could be impacting application performance.  At that point, it can point out the problem at the code level — allowing you to track down and fix those issues before they negatively impact end user experience.  This talk will focus on the tools available from the Open Source time series database InfluxDB. It will be using the open source node.js telegraf plugin, so you can easily collect key metrics to help you get that view into your application. We will be using the Node.js Monitoring Template which is prebuilt and equipped to monitor an applications' performance and availability. All code examples will be in Javascript, and we will also go over the javascript library for those who are working in other javascript server environments, or who want to export data to their preferred visualization tools.

Monitoring, Alerting, And Visualizing your Node.JS server infrastructure with Open Source tools

Zoe Steinkamp

Cómo, por qué y cómo usar tRPC por su creador

tRPC - Mueve rápido y no rompas nada

TRPC is a tool that simplifies API development by allowing you to call functions in the backend and have the type data inferred into the frontend without code generation. It provides type safety and auto completion when querying databases using Prisma. TRPC can be used with various frontend frameworks and has features like automatic batching and middlewares. It can be shared between repositories using a monorepo or by publishing the types as an npm package. TRPC is easy to set up compared to gRPC and provides built-in input and output validation.

How, why and how to use tRPC by the creator of it

tRPC - Move Fast and Break Nothing

Alexander Johansson

Node.js, como plataforma, está en constante cambio y evolución. El núcleo de Node es una mezcla de características de nuestra propia comunidad, así como de dependencias como V8 y libuv. Esta charla cubrirá los últimos desarrollos en el núcleo de Node.

El Estado del Núcleo de Node.js

Today's Talk discussed the state of Node.js core, with increasing downloads and over 2 million packages on npm. Node.js has a LTS schedule, with Node 14 currently in maintenance mode. It was recommended to aim for Node 18, as Node 16 and its version of OpenSSL will soon be end of life. Node 18, known as Hydrogen, is stable and has new features. The Talk also covered CLI testing, core modules, new features, and upcoming enhancements.

Node.js, as a platform, is constantly changing and evolving. Node's core is a melting pot of features from our own community, as well as dependencies such as V8 and libuv. This talk will cover the latest developments in Node core.

The State of Node.js Core

Colin Ihrig

Esta charla te enseñará cómo escribir módulos de Node.js críticos para el rendimiento sin la carga de distribuir artefactos dependientes de la plataforma y usar la cadena de herramientas C/C++. Descubrirás cómo integrar sin problemas código Rust en tu aplicación Node.js + TypeScript utilizando WebAssembly. También aprenderás cómo evitar los problemas típicos de serialización de WebAssembly y entenderás cuándo otras alternativas como Neon o Napi.rs son preferibles. Juntos, cruzaremos el puente del lenguaje entre Rust y Node.js mientras preservamos la familiaridad de la experiencia de desarrollo que estás acostumbrado.

Enlaces seguros para Node.js con Rust y WebAssembly

This Talk explores TypeScript bindings for NodeJS with Rust and WebAssembly, providing an alternative approach for creating native NodeJS modules and automatically generating types. It delves into the use of WebAssembly and Rust for TypeScript modules, showcasing how Rust functions can be defined and imported using the wasm.bindgen library. The Talk also highlights the challenges of string conversion between Rust and JavaScript, the limitations of supporting Rust data types in JavaScript, and the seamless integration of Rust functions into TypeScript apps using tspy. It concludes with the recommendation of TSFI for type-safe bindings and showcases its usage in a TypeScript-based full-text search engine with WebAssembly support.

This talk will teach you how to write performance-critical Node.js modules without the burden of distributing platform-dependent artifacts and using the C/C++ toolchain. You will discover how to smoothly integrate Rust code into your Node.js + TypeScript application using WebAssembly. You will also learn how to avoid the typical WebAssembly serialization issues, and understand when other alternatives like Neon or Napi.rs are preferable. Together, we will cross the language bridge between Rust and Node.js while preserving the familiar DX you're used to.

Type-safe bindings for Node.js with Rust and WebAssembly

Alberto Schiabel

En esta charla, crearemos un pequeño tiempo de ejecución de JavaScript desde cero en Rust. Aprovecharemos el mismo ecosistema de componentes que utiliza Deno para mostrar que crear un tiempo de ejecución personalizado que se ajuste a tus necesidades es simple y divertido en 2023

Crea tu propio tiempo de ejecución de JavaScript

This Talk introduces Deno, a custom JavaScript runtime similar to Node.js, and discusses the benefits of using a custom runtime. It explores the process of building a custom runtime with Deno in Rust, including the integration with Cargo and the ability to mix and match crates and APIs. The Talk also covers the implementation of the setTimeout function in both Run.js and Runtime.js, and provides examples of how to fix errors and implement additional functions. Overall, the Talk highlights the flexibility and possibilities of creating custom runtimes with Deno.

In this talk, we’ll create a small JavaScript runtime from scratch in Rust. We’ll leverage the same ecosystem of components that Deno uses to show that rolling a bespoke runtime fitting your needs is simple and fun in 2023

Node Congress 2023

The biggest event on JavaScript backends