Working with databases in Node.js can be painful! The open-source Prisma ORM provides a new approach that makes it fun, easy, and intuitive for developers to work with databases.

This talk will outline the difficulties of working with databases in Node.js and give an overview of the landscape of database libraries and ORMs in the ecosystem. It then introduces Prisma as a novel approach to working with databases.

In recent years, our applications have been increasingly transforming into distributed systems, such as microservices, serverless, and edge computing.

This migration brings many benefits, but it also presents challenges in terms of monitoring, tracing, and logging, sometimes turning what used to be straightforward into an absolute nightmare.

In this talk, we will see a practical example of how to instrument an application using OpenTelemetry, adding span metrics and logging, and how to collect and analyze them.

Try telling a fairy tale using only the four verbs Create, Read, Update, and Delete. The result will - guaranteed! - rather scare than fascinate.

But if CRUD is completely unsuitable even for simple stories like fairy tales, why do we try to tell far more complex (business) stories with these four verbs every day? Why do we limit ourselves? Why don't we rely much more on a technical, semantically rich and diverse language? Quite simply: Because in the end we have to do CRUD again, certainly in the database. At least that's what we believe.

But what if there was an alternative? What if you could develop applications in such a way that they not only adequately reflect the underlying domain but also tell a much more expressive and comprehensible story, from UI to persistence? In short: If you could simply write better software? And guess what, you can: with event-sourcing. In this talk, you'll learn how.

The current revision of the JavaScript Source Maps specification is over 12 years old.

Throughout this time, the entire ecosystem has evolved immensely, but for some reason, we have done nothing to improve the debugging experience and are still stuck at version 3 of the specification. Can we do better?

How many ways do you know to do iteration with JavaScript and Node.js? While, for loop, for…in, for..of, .map(), .forEach(), streams, iterators, etc! Yes, there are a lot of ways! But did you know that JavaScript has iteration protocols to standardise synchronous and even asynchronous iteration? In this workshop we will learn about these protocols and discover how to build iterators and iterable objects, both synchronous and asynchronous. We will learn about some common use cases for these protocols, explore generators and async generators (great tools for iteration) and finally discuss some hot tips, common pitfalls, and some (more or less successful) wild ideas!

In 2012, this tiny community group "WEBdeBS" run the first conference ever on Node.js. I was there in the room, watching great speakers present a future in technology that was so innovative that blew my mind. No one would have thought that the bumblebee could fly, but now Node.js is installed on every developer machine - yours too! In this talk, we are going to go through the story of Node.js, what were the key moments in Node.js history, and what's the state of the project today. We will also cover all the key features we shipped between 2012 and now, and why developing Node.js applications in 2023 can be so much better!

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.

In the newest versions of V8, there are architectural changes that make V8 extremely fast. When V8 parses code, part of it is interpreted and part of it compiles. V8 memory management has improved a lot and now presents sophisticated algorithms, as well as many interesting optimizations. In this talk, Tamar will get into the internals of V8 in the new versions, from the code interpreters and compilers to the memory management: What was changed? Which layers were added? How does it make Node.js applications much faster and in which cases/patterns?

The talk will include demos of patterns in the code that you can optimize to get better performance for your application.

Modern users expect apps that are natively built to support team collaboration and communication - it’s not a coincidence that Figma, Miro, Canva, Notion, etc. are top-performing apps. Not to mention that multiplayer products are virality machines for businesses.

Implementing real-time collaborative tech in your Node.JS app is easier than you think...provided that you know which approach would suit best your use case.

This talk will walk you through how to leverage a lean and OSS-focused tech stack to make your apps multiplayer.