An all things JavaScript conference

I spent the last year bringing Mock Service Worker closer to the platform, and I learned a lot along the way. As a result of it, MSW 2.0 was created—the biggest and most impactful release in the project’s existence.

In this talk, I will share the story behind that change, why it was necessary, and how exactly web standards make API mocking better.

From basically every framework across the board to TC39, signals are all the rage nowadays. A lot has been said about the performance benefits, but that’s not all it is. Let’s talk about how signals provides a better mental model to render user interfaces, and how they make developing apps more predictable and, likely, error-free.

This talk explores the lessons learned I learned from Rust, a language renowned for its safety and performance, and how these lessons can be applied to improve TypeScript development. While Rust and TypeScript are different in many ways, the principles and best practices from Rust can significantly enhance the way developers approach TypeScript coding, leading to more robust, efficient, and maintainable applications.

This talk is not endorsed by my employer. All opinions are my own.

In 2023 we at Google shipped View Transitions for SPA in Chrome 111. This year we bring you something new: View Transitions for MPA, activated by a same-origin navigation. Simply click a link from one page to the other, and you can have a rich transition between both.

“Alright I’ll just upgrade Typescript, aaaaaand everything is broken now”

Building a complex JavaScript project can feel like a tangled mess of yarn. Fear not, fellow developer! This talk will provide you with the tools and techniques to gently untangle your dependencies and knit a well-structured, maintainable codebase. Our basket of tools include using npm why as our yarn needle, breaking down tasks into manageable stitches, strategically upgrading for progress, utilising branching techniques to keep your project from unraveling, and much more!

Join us as we unravel the secrets of dependency management, leaving you with a project that’s not only functional but beautifully maintainable, stitch by stitch.

If we follow Atwood’s Law, “Any application that can be written in JavaScript, will eventually be written in JavaScript”. As I started studying cybersecurity in my personal time, I noticed that the tools available to hackers are usually coded in C, C++ or Python but, as a front-end developer, I started wondering… Wouldn’t it be cool to rebuild some of these tools in JavaScript instead?! In this talk, I will show how I rebuilt a famous tool to hack wireless devices using only Web APIs so you can hack doorbells, garage doors and more right from the browser!

How do you get into the zone while coding? Why does taking a walk or taking a shower seem to help solve problems?

Everything we do is regulated by complex processes in the brain, and coding is no exception. Sometimes it can feel difficult to feel in control of our brains when coding, but to debug the problem we’ll first need to understand it.

This talk will dive into the basic neurological processes and psychological behaviors involved with learning and writing code. By understanding the physiological processes involved in the work we do, we can be more in touch with our bodies and more productive as a result.

We hope for our web applications to be as beautiful, performant, and accessible as possible; but sometimes… Things get in the way and the outcome is not as good as we hoped. In this talk I’ll walk you through a few of my failed attempts at developing accessible web applications. We’ll go through different accessibility assumptions and myths that I wrongly believed to be true and how to avoid them by properly testing for accessibility.

This talk aims to be a reminder about the fact that, more often than not, inaccessible applications are a result of lack of knowledge, not lack of caring. That it is ok to make mistakes, but it is also essential to avoid making the same mistake twice.

Some bugs just tend to hide when you look at them. We’ve all experienced a 3 hour bug-hunt that lead to nowhere and made us question our skills. In my talk, I would like to share some of the most annoying bugs and test flakes that I have encountered in my time as SDET and walk you through a process of how to make debugging faster and - believe it or not - fun. I’d like to share my tips on how to narrow down a bug, test flake and demonstrate how to use a time-machine debugger called Replay.io to identify the root cause.

How do you get into the zone while coding? Why does taking a walk or taking a shower seem to help solve problems?

Everything we do is regulated by complex processes in the brain, and coding is no exception. Sometimes it can feel difficult to feel in control of our brains when coding, but to debug the problem we’ll first need to understand it.

This talk will dive into the basic neurological processes and psychological behaviors involved with learning and writing code. By understanding the physiological processes involved in the work we do, we can be more in touch with our bodies and more productive as a result.

Most CSS developers today write visual styles in terms of what you literally see: exact color values, size numbers, and so on. But what if you could write styles as a function of how they fit into your design system? And what if you could get type safety in specifying and using those values, including in responsive props?

This talk will dive into some of the key features and flaws in many design system builders today such as Chakra UI and Tailwind. We’ll establish what the best next steps for design systems should be with type-safe TypeScript APIs and performance both for prebuilt pages and at runtime. The Vanilla Extract and Rainbow Sprinkles projects together are a great way to try this out now, and I’m hopeful for more efforts.

Attendees will leave the talk both with an appreciation for the systems of today and hope for the type-safe systems of the future.

console.log(”<— INTRO HOOK”);

Console.log: a JavaScript developer’s old friend. While it’s tried and true, it often feels like blindly probing at your running code.

console.log(”<— PROBLEM STATEMENT”);

Don’t you just wish you could skip it all and peer into your running application? Maybe you’ve used the debugger before, but what about in production? How can you find the source of a bug when it’s affecting your users?

console.log(”<— MEAT AND POTATOES”);

In this talk, we’ll give an overview on the landscape of debugging tools in the JS ecosystem used in both local development and production. We’ll dissect logging, tracing, instrumentation, and profilers, exploring how these tools can provide profound insights into your running code. You’ll see these tools in action, helping you understand their power and ease of use.

Modern JavaScript application are built on top of an immense stack of tools: transpilers, bundlers, minifiers… The code we write goes through multiple transforms before being sent to the browser. Yet, Source Maps let us debug our application and decode errors as if we were directly running our original source files.

How are they able to undo any transformation applied to your code? Can they actually do it, or is there something that they cannot represent? How do different tools decide what to encode to and decode from source maps?

We will explore together how the source maps format works and which data they encode, as well as a new standardization effort to align all tools and expand what source maps are capable of.

The web is constantly evolving, yet most content websites remain confined to the static layout of printed media. It’s time to move beyond this skeuomorphic phase, where digital content mimics physical forms, and start exploring the full potential of the web.

We’ll examine real-world examples where content is not just informative but also engaging, and how to make similar experiences yourself without leaving the simplicity and familiarity of Markdown.

Web layout is one of the most important aspects of web development, as it determines how the content is presented and perceived by the users. However, web layout is not a one-size-fits-all solution, as different languages and writing modes have different text directions and layout conventions. Using traditional CSS properties can lead to layout issues when the text direction changes.

To solve this problem, we can use CSS logical properties. In this presentation, we will explore CSS logical properties and how they differ from traditional CSS properties. We will see some practical examples of using CSS logical properties in real-world scenarios, that you can apply in your next project.

Twitter influencers would have you believe that if you just use the semantic html tag for elements instead of a div, your components will be accessible. but there’s a lot more that goes into it!

Sid works on the design systems team at GitHub, this talk looks at one complex highly-composable component and the many accessibility considerations that go into it!

The C programming language, a cornerstone of computing, originated in the early 1970s. Meanwhile, techno music with its roots in 1980s Detroit, has been with us as an always-evolving phenomenon ever since. These enduring artifacts of cultural creativity have not only survived but thrived over the decades.

On the other hand, WebAssembly and Audio Worklets represent some of the latest advancements of the web platform, only having been widely supported for a small handful of years.

In this session we’re going to smash the old together with the new to make some creative sparks appear. Equipped with nothing but a C to WASM compiler and a standard web browser, we’re going to conjure some minimal techno into being. We’ll see that you don’t necessarily need anything new or anything big to make something cool. There’s a lot of value in the minimal and the mature.

The devastating wildfires that ravaged Europe in 2023, burning an area the size of London, highlight the urgent need for improved fire detection and reporting systems at scale.

In this talk, we will explore how JavaScript and widely available electronics can be combined to create a low-cost, cheap and effective wireless fire detection system. We will deploy this system in a wild forest in Greece and utilize AI models to predict where the next blaze could be sparked.