An all things JavaScript conference

In ancient times, knowledge was passed down through word of mouth, like an endless game of telephone where details changed with each retelling. Without a written record, information was often distorted or lost. This talk draws a parallel to software teams that work without documentation. Just like etymology traces the origins of words, documentation preserves history, accuracy, and meaning in code, ensuring that everyone shares a common understanding.

When setting up an app there are things that are nice-to-have and some things that you can’t ship without. In this day and age, protecting your users data and making it harder for others to attack them is a must. Let’s have a look on nice defaults that can set you and your app up for success. What are the best heuristics, practices, and measures to make sure you can scale your app on the safe-side and without headaches!

A new addition to CSS are “Scroll-Driven Animations”. With it, you can link animations to the scroll offset of a scroll container using only CSS — no JavaScript needed! In this demo-heavy presentation, we’ll dig into what this spec has to offer and dissect some of its demos (such as a working Cover Flow implementation) + use-cases.

How can we expect LLM products to impact software engineering? Join Chelsea Troy for an examination of how LLM products are built, what they tend to do well with, and where they tend to struggle. Then, take a tour with Chelsea through current research elucidating the impact of LLM use on developer productivity, and dig into what that means for us as practitioners in an LLM-enabled world.

A major shift is taking place in frontend programming that is mostly going unnoticed: the comeback of RPC (Remote Procedure Call). Leading frameworks, such as React, Qwik and Solid are embracing RPC as the preferred mechanism for accessing backend services and sending data from the frontend in the form of server components, server actions, and server functions. This is surprising because RPC used to be big in the 90s but fell out of favor when the Web took off, replaced by protocols such as REST and GraphQL. Now RPC is back and replacing these protocols instead. What’s driving this resurgence? Why is it happening now? What’s its impact on the way we implement frontends? In this talk I will answer these questions and explain how to achieve the benefits of RPC, avoid its limitations and make the most from this technological comeback.

We have all dealt with Technical Debt in one way or another throughout our careers. We’ve tried to prevent it, manage it, or mitigate its impact—and if we’re honest, we’ve probably introduced some ourselves. But is technical debt always something to be avoided at all costs?

Let’s use Martin Fowler’s Technical Debt Quadrant to explore the ideas of Reckless and Prudent Debt, while distinguishing between deliberate and inadvertent cases. Drawing on real-world examples from various web application projects that migrated to React and TypeScript, we’ll break down these types of debt and uncover four key lessons and strategies for effectively managing technical debt in a sustainable and practical way.

The compiler is your friend.

Even when you think it’s out to get you, chances are it’s just misunderstood. Before exploring TypeScript’s inner workings, I used to spend more time than I care to admit cluelessly reading an error and wondering: “Why won’t it just leave me alone?”

In this talk, I’ll explain why the compiler sometimes seems spiteful. We’ll discuss the type system’s power, its limitations, and the historical reasons behind its design.

By sharing some insights from TypeScript’s deep end, I hope to leave you with a better understanding of the language and more compassion for your loyal friend, the compiler.

From React.createClass to PureComponent to hooks – React has changed a lot. Each of these changes was driven by a desire for better architecture. But under the hood, each of these changes also pushed us to write faster apps – often, without us even noticing that.

In this talk, let’s look at how React’s invisible hand has been making our apps faster over the past 10 years:

• useEffect, and how it’s faster than componentDidMount
• Batching, and how it improved from version 0.4 to 0.12 to 18
• <Suspense>, and some of the less obvious effects of using it
• and possibly more

The Node.js world celebrated its 15 years this year, with the Express Framework turning the same age next January. Strong of more than a decade of experience, the Express ecosystem is one of the bigger of the JavaScript world, with close to 55 billions downloads a year.

With the now released released Express 5.0, we plan to bring significant performance and security improvements while also signaling back to the community the next steps of the modernization of the framework. Let’s see all the current work being done to achieve version 5.0, including Express CITGM in Node.js, the change of governance and how the project was revivified during the year.

With a new technical committee, captains, triagers and goal, this talk will focus on the work that was done, but most importantly the next steps leading to Express 6.0 and 7.0, paving the way for a more sustainable and efficient Express.js ecosystem.

Used by everyone, but maintained only by a small number of people, let’s dive into the news around the new Express.js version 5 - the first major released since 2014. Performance, security but also sustainability are core topics for this new version.

A lot has been happening with the Angular framework lately. Let’s talk about all the new features from signals to server side rendering to incremental hydration. Get all the details on what’s new and what’s coming.

TypeScript! ESLint! Biome! Oh my! So many tools exist that we can choose from as modern developers. Do you ever feel like you’re getting lost in a sea of GitHub README.mds and configuration file messes?

Let’s talk about the state of tooling for TypeScript developers in 2025. What are the tools that many developers are finding helpful? How are those tools changing over time to be more helpful (and less annoying to configure)? Why do we even care about tooling when we have TypeScript!?

All those questions and more will be answered. We’ll cover:

• The state of common tooling: linters, TypeScript, their integrations together (hello, Rust!)
• Some of the great benefits of aggressive static analysis (hello, plugins!)
• Miscellaneous other tools such as Knip and TypeChat (hello, AI!)
• High-level trends for tooling

After this talk, you’ll be prepared not just to configure your linter and type checker, but you’ll understand why so many developers are excited for that task in the first place.

Refactoring code without tests is risky, but writing tests often requires refactoring first. How do you solve this paradox? I’ll show strategies to reduce risks, even without tests, and demonstrate key refactorings for legacy codebases—moves you might know, but not fully master yet.

Forms can become a pain to maintain, with a lot of duplication between the server and the client: Duplicated data structures, validations, sync deploys, etc… Come learn how JSON Schemas can become the SSoT (single-source of truth) to manage your Forms at scale and fill the gap between any server and the browser, without compromising the final User Experience.

“Wait… I don’t have to write all this code and my users still get the best experience possible? … It’s like my code is auto-optimizing itself!”

That’s exactly how I felt when I first learned about “JavaScript Streaming” - a new way to build for the web that feels almost like magic.

It also helped me answer a big question: “What’s next for web development, and where should I invest my time to prepare for the future?”

In this session (or should I say, magic show?), I’ll take you on a journey through my decision to join the innovative Qwik framework, how it’s philosophy is going to change our lives as web developers forever, and show it in action.

Get ready to learn, laugh, and get inspired about what’s next for the web!

It seems like there’s always a hot new library or framework promising great things. But people often forget about the pain and effort required to move from an old technology to a new one. How long will it take? If you finish, will it be worth it? And if you don’t, could it leave you in a worse place than where you started?

Drawing from my experience of the Typescript migration we recently completed at Monzo I’ll take you through some of the different outcomes of technical migrations and the things we learned along the way.