April 4 - 5, 2024
Node Congress
Online

Node Congress 2024

The biggest event on JavaScript backends

A two-day conference on all things Node.js, DevOps, Edge-native workers (Cloudflare & others), Serverless, Deno & other JavaScript backend runtimes, gathering Back-end and Full-stack engineers across the globe.

This edition of the event has finished, the latest updates of this JavaScript Conference are available on the Brand Website.
CloudflareSentryFocusReactiveHygraph
Deep TypeScript Tips & Tricks
83 min
Deep TypeScript Tips & Tricks
Top Content
Workshop
Josh Goldberg
Josh Goldberg
TypeScript has a powerful type system with all sorts of fancy features for representing wild and wacky JavaScript states. But the syntax to do so isn't always straightforward, and the error messages aren't always precise in telling you what's wrong. Let's dive into how many of TypeScript's more powerful features really work, what kinds of real-world problems they solve, and how to wrestle the type system into submission so you can write truly excellent TypeScript code.
Build Modern Applications Using GraphQL and Javascript
152 min
Build Modern Applications Using GraphQL and Javascript
Workshop
Emanuel Scirlet
Miguel Henriques
2 authors
Come and learn how you can supercharge your modern and secure applications using GraphQL and Javascript. In this workshop we will build a GraphQL API and we will demonstrate the benefits of the query language for APIs and what use cases that are fit for it. Basic Javascript knowledge required.
AWS Lambda Performance Tuning
25 min
AWS Lambda Performance Tuning
This Talk covers various optimization techniques for Lambda functions, including parameter fetching, code minification and bundling, observability with Power Tools and X-Ray, baseline testing with load testing tools, caching with Elastic Cache and Redis, and optimizing code size and memory usage. The importance of library choices, power tuning for cost and performance, leveraging subprocesses and sandboxes, and adjusting concurrency limits are also discussed. Overall, these techniques can significantly improve Lambda function performance.
Deep Dive into Undici
24 min
Deep Dive into Undici
Undici is a modern HTTP client for Node.js that offers improved performance and advanced features. It supports HTTP 1.1 and recently added HTTP 2.0 support. Undici provides impressive performance, especially with Undici.Stream. It also supports HTTP 1.1 pipelining, which can significantly cut response time. Undici offers flexible connection management and dispatchers, as well as interceptors for customization. Undici v7 is coming with improved APIs and platformatic runtime for running multiple microservices in the same process.
Parsing Millions of URLs per Second
14 min
Parsing Millions of URLs per Second
Today's talk explores the performance of URL parsing in Node.js and introduces the ADA URL parser, which can parse 6 million URLs per second. The ADA URL parser includes optimizations such as perfect hashing, memoization tables, and vectorization. It is available in multiple languages and has bindings for popular programming languages. Reach out to Ada URL and Daniel Lemire's blog for more information.
Understanding Package Resolution in Node.js
11 min
Understanding Package Resolution in Node.js
In this Talk, the speaker discusses package resolution in Node.js, covering topics such as CommonJS, ES modules, package.json structure, and package.json loader. The Talk also touches on conditional loading and file extension resolution, module import and export, module type determination based on file extensions and package.json, module resolution strategies in Node.js, and tips for improving loading time in ESM applications.
Mastering Node.js Test Runner
117 min
Mastering Node.js Test Runner
Workshop
Marco Ippolito
Marco Ippolito
Node.js test runner is modern, fast, and doesn't require additional libraries, but understanding and using it well can be tricky.You will learn how to use Node.js test runner to its full potential.We'll show you how it compares to other tools, how to set it up, and how to run your tests effectively. During the workshop, we'll do exercises to help you get comfortable with filtering, using native assertions, running tests in parallel, using CLI, and more. We'll also talk about working with TypeScript, making custom reports, and code coverage.
Biome, Toolchain of the Web
19 min
Biome, Toolchain of the Web
Biome is a toolchain for web projects that provides formatting and analysis. It offers high-quality diagnostics and is compatible with Prettier. Biome's analyzer includes over 200 unique lint roles and provides informative error messages. Pion, a part of Biome, aims to be fast and efficient, outperforming other tools. Biome is exploring type inference and plug-in support, and has plans to revamp its configuration in version two.
Making My Node.js API Super Fast
34 min
Making My Node.js API Super Fast
This talk focuses on improving performance in Node.js API development. It covers various areas such as optimizing database work, connection pool, JSON parsing, logging, and web framework selection. Key highlights include the use of Native Mongo Driver for better database performance, optimizing connection pool for improved throughput, replacing Express serializer for faster serialization and deserialization, and choosing Festify as an efficient web framework. Caching and authentication's impact on performance is discussed, along with recommendations for caching types. The talk also emphasizes considering environmental factors and human impact on performance. Fastify is highlighted as a recommended tool for Node.js performance optimization.
Managing Large-Scale Node.js Projects with Monorepos
19 min
Managing Large-Scale Node.js Projects with Monorepos
Monorepos are a development strategy that allows you to store multiple projects in one repository, facilitating code sharing and simplifying dependency management. They provide simplified dependency management, improve code reusability, and enable a consistent build, test, and deployment process across projects. Tooling support like Nix, Yarn Workspaces, and NPM Workspaces streamline monorepo development. Code organization and scalability strategies involve fine-grained models, consistent directory structure, and selective dependency installation. Streamlining build processes can reduce build time, and optimizing performance and collaboration involves profiling tools and effective code review processes.
The Need for Speed: How AWS New JS Runtime is Redefining Serverless Latency
25 min
The Need for Speed: How AWS New JS Runtime is Redefining Serverless Latency
Serverless services like AWS Lambda allow developers to build modern applications without provisioning servers or additional infrastructure. LLRT is a low latency runtime designed specifically for serverless environments and JavaScript applications. LLRT uses a lightweight JavaScript engine called Quick.js, achieving fast execution and performance with minimal memory consumption. LLRT is ideal for latency-critical applications, high-volume functions, and integration with AWS services. It significantly improves performance, reducing cold starts and providing consistent warm start times. Users are encouraged to test LLRT and contribute to its development.
Creating an HTTP Server from Scratch with Node-addon-api, Libuv, and Milo
18 min
Creating an HTTP Server from Scratch with Node-addon-api, Libuv, and Milo
Today's Talk focuses on creating an HTTP server from scratch using Node.js and native add-ons. The process involves implementing a TCP socket using LibuV for data exchange between the server and client. The Talk also covers invoking callbacks, creating a high-level abstraction for the HTTP server, and parsing HTTP data using an experimental HTTP parser called Milo. The project serves as a proof of concept, showcasing the ease of creating add-ons and interacting with low-level APIs in Node.js.
Breaking REST Chains: A Fastify & Mercurius Pathway to GraphQL Glory
23 min
Breaking REST Chains: A Fastify & Mercurius Pathway to GraphQL Glory
GraphQL is a versatile query language that allows for the creation of a single server and API that can serve different types of devices. Mercurius is a high-performance GraphQL adapter built on Fastify, offering features such as caching, just-in-time compilation, and support for subscriptions and federation. The Talk demonstrates how to build a GraphQL server using Mercurius Fastify and TypeScript, including the setup of the server, schema, resolvers, and loaders. It highlights the benefits of using GraphQL with TypeScript and how loaders can optimize queries by reducing the number of database calls. The conclusion emphasizes the benefits of building a GraphQL server with Mercurius and provides additional resources for further exploration.
The Full-stack Framework of the Future is a DSL
21 min
The Full-stack Framework of the Future is a DSL
The future of web frameworks will be a DSL, simplifying development and allowing for clear instructions for AI collaboration. DSLs like SQL and JSX have value in building better web apps. Wasp is a powerful full-stack web app framework that eliminates the need for writing backend code. It offers features like cron jobs, type safety, and email sending. Wasp also has projects like OpenSaaS and Mage that provide production-ready templates and AI-generated prototypes.
Building Reliable Backends with Durable Execution
21 min
Building Reliable Backends with Durable Execution
This Talk explores the paradigm of message queues for reliable backend execution. It highlights the benefits of message queues, such as guaranteed delivery and offloading of long-running processes. The drawbacks of using queues are discussed, including the complexity of managing infrastructure and applications. The solution of using a reliability layer called Ingest is presented, which allows for non-blocking background tasks and provides a dashboard for monitoring and managing jobs. The Talk also emphasizes the importance of reliability in building software systems and introduces the expanding scope and functionality of Ingest.
Understanding Async Context
29 min
Understanding Async Context
Async local storage is an API that has been around in Node for quite some time and is gaining popularity in other frameworks and runtimes. It allows for easier logging by eliminating the need to pass values through multiple functions. The storage frame in async local storage acts as a map, storing key-value pairs. Tasks and promise continuations are used to perform the next steps in a promise chain. Async Context is a TC39 proposal that adds async local storage to the JavaScript language.
Milo, a New HTTP Parser for Node.js
23 min
Milo, a New HTTP Parser for Node.js
Hello and welcome to Node Congress 2024. NearForm focuses on delivering modern and elegant solutions. Milo is a new HTTP parser written in Rust, designed to address the complexity and vulnerabilities of the current Node HTTP parser. Milo allows developers to opt-in for copying data being parsed for improved developer experience. It follows the latest RFCs for HTTP strictly and provides a common interface across different languages. Milo is being explored for C++ and WebAssembly integration, and future steps include performance improvements and regression testing.
Optimizing Microservice Architecture for High Performance and Resilience
24 min
Optimizing Microservice Architecture for High Performance and Resilience
Today's Talk discusses microservices optimization strategies for distributed systems, specifically focusing on implementing casual consistency to ensure data synchronization. Vector clocks are commonly used to track the casual relationship between write events in distributed systems. Casual consistency allows for concurrent and independent operations without synchronization, maximizing parallelism and system resource utilization. It enables effective scalability, better latency, and fault tolerance in distributed systems through coordination, resilience, reconfiguration, recovery, and data replication.
Testing Alternative Runtimes with Node and Vitest
25 min
Testing Alternative Runtimes with Node and Vitest
Welcome to my talk on testing alternative runtimes with Node and VTest. VTest is a popular testing framework that allows dynamic code evaluation and runs inside Cloudflare workers. Durable objects provide distributed JavaScript class instances with unique IDs and persistent storage for improved developer experience. The testing framework in Cloudflare workers automatically undoes writes to storage and supports seeding data. Mocking outbound fetch requests is also possible in Cloudflare workers.
What's New on Node.js Test Runner and Why it's Game-changing
17 min
What's New on Node.js Test Runner and Why it's Game-changing
The Node.js Test Runner is presented as a better alternative to Jest, offering more flexibility and improved performance. It supports TypeScript out of the box and provides comprehensive test suite visualization. The test runner has native support for code coverage and upcoming features include module mocking and improved filtering. Shifting to the test runner is simple and helps the community grow.
Mastering Web Scraping with Scrapoxy: Unleash Your Data Extraction Wizardry!
21 min
Mastering Web Scraping with Scrapoxy: Unleash Your Data Extraction Wizardry!
Fabien Vauchel is a software developer passionate about web scraping and the creator of Scrapoxy, a proxy aggregator. Isabella, a student, used web scraping to gather data for her trip tool. The talk discusses various techniques for web scraping, including using language models and proxies to bypass website protections. The speaker also introduces ScrapOxy, a super proxy aggregator, and explains how to integrate it into web scraping projects. The use of Playwright, a headless browser, is highlighted for handling fingerprint errors. Ultimately, the talk emphasizes the importance of adjusting time zones to successfully complete web scraping requests.
The Dark Side of Open Source
37 min
The Dark Side of Open Source
The talk explores the dark side of open source, focusing on supply chain attacks and the need for improved security measures. It highlights the dangers of loading external code and the importance of mitigating supply chain risks. The talk also discusses the use of AI and LLMs in code analysis to enhance security. It emphasizes the challenges of sustaining IC maintained open source projects and the future of supply chain security. Lastly, it touches on the variations in open source definitions and the empowerment of the open source community.
Peace, Love and JavaScript
17 min
Peace, Love and JavaScript
The OpenJS Foundation supports the entire JavaScript ecosystem and thousands of open source projects. They follow a neutral nonprofit organization with separate business and technical governance to minimize drama. Rebooting governance and addressing intellectual property can also help reduce conflicts. OpenJS provides collaboration spaces and support in various areas for open source projects. They foster a collaborative environment and invite participation in their projects.
Observability Matters: Enhancing Performance of our Node Application with OpenTelemetry
7 min
Observability Matters: Enhancing Performance of our Node Application with OpenTelemetry
Yash Rajavarma introduces observability and explains its importance for developers. He discusses how OpenTelemetry can empower Node.js applications by providing easy instrumentation and management of telemetry data. OpenTelemetry simplifies the implementation of observability and is designed to benefit developers.
Bun or Deno will Replace Node.js?
Recording pending
Bun or Deno will Replace Node.js?
Tamar Twena-Stern
Richard Davey
Jonas Peeck
Lucas Santos
4 authors
How not(!) to Build Real-time Apps
10 min
How not(!) to Build Real-time Apps
Today's Talk discusses different approaches for implementing real-time updates in server-side applications, including application-level updates and polling. The drawbacks of polling include inefficiency and complexity at scale. Adding extra infrastructure, like messaging systems, can ensure scalability but introduces operational overhead. Prisma Pulse is a system that simplifies change data capture, providing an easy setup for subscribing to database changes and solving scalability issues.
CommonJS vs ESM, the Fight is on?
Recording pending
CommonJS vs ESM, the Fight is on?
Emanuele Stoppa
Jonas Peeck
 Yagiz Nizipli
Richard Davison
4 authors
Open Source Software: Open Governance or for-profit Startups?
Recording pending
Open Source Software: Open Governance or for-profit Startups?
James Snell
Marco Ippolito
Sylwia Vargas
Jonas Peeck
 Yagiz Nizipli
Robin Ginn
Fortune Ikechi
Cyrus Roshan
8 authors
Building a Network Stack for our Browser Extension
19 min
Building a Network Stack for our Browser Extension
The Talk discusses the development of the Jam browser extension, which is a bug reporting tool. It explores the challenges of messaging between different execution environments within a browser and the need for message chunking to overcome size constraints. The Talk also explains how the development team rebuilt the system using a TCP/IP network stack approach, which allowed them to solve messaging difficulties similar to networking problems. The benefits of this approach include a smoother rollout, simpler debugging, and a focus on feature development without worrying about messaging constraints.
The State of Node Compatibility in Deno
23 min
The State of Node Compatibility in Deno
David Sherret
Kevin Whinnery
2 authors
Today's Talk introduces Deno, a next-generation JavaScript runtime with native TypeScript support and improved server-side development features. Deno offers granular permissions for sensitive APIs and includes built-in tools like a test framework and linter. The Talk demonstrates how to use Deno with an existing Node.js project, showcasing compatibility and import features. It also discusses upcoming features like bringing Node modules to Deno and handling file extensions. Overall, Deno provides a seamless transition for Node developers and offers a range of powerful tools and features.