See you in 2024!

Web accessibility communities and tools keep evolving with time: if in 2009 we would refer to accessibility being tied to the HTML and some of the good practices widely known, in 2023 the picture is broader.

Accessibility in 2023 touches many aspects: copywriting, content creation, UX testing and interviews with people with disabilities, accessibility-first design systems and specs are being created by design teams. Developers are required to be involved not only in keeping up to date with best practices in modern frameworks, but also be ready for a11y testing (end-to-end, unit, and manual with assistive technology), performance, security. More clients and project managers are aware of accessibility and demand high standards. At the same time, it has never been easier to get accessibility training and establish bullet-proof practices in teams.

In the mid-1980s, Larry Tesler stated that “every application has an inherent amount of complexity that must be dealt with, either in product development or in user interaction”.

This adagio is also known as the WaterBed theory and is mostly referenced in product design. However, I believe that it equally applies to any type of “interface” between an author and its consumers, such as UI components, functions, API endpoints, you name it.

In this talk, we’ll explore different methods for tackling software complexity, by understanding our users and deciding where to place the effort: in the implementation, or in the consumer.

Have you ever wondered how far you could take the JamStack? This architecture can be used to build lots of different types of web applications, but did you know you could use it to get real-time data from passing airplanes? Using the WebUSB API and a Software-Defined Radio dongle, you can turn your browser into a live flight tracker using only front-end technologies! Fasten your seatbelt, and join me on this journey to learn how to get data from the sky, using JavaScript.

There are two kinds of state management libraries: easy and simple. Direct and indirect. Quick and maintainable. When you’re quickly prototyping apps or writing robust app logic, which do you choose? Is there a right answer? In this talk, we’ll traverse the evolution of state management, from mutation to statecharts and signals and take a walk through the state-of-the-art state libraries. From state mutation to statecharts, we’ll explore the various ways developers manage state and learn how we can choose the best strategy for efficient, robust, testable state management that satisfies all kinds of use-cases (and edge-cases, too).

It’s time to play your tests wright. Let’s take a look at how to write good tests and cover some of the best practices for testing, choosing the right locators and more. Let’s make testing easy and fun by generating tests on user actions. Then lets explore some cool tips and tricks to help you write better tests.

Too many tabs open? Can’t focus at work? Is something wrong with me?

It’s not uncommon for people who spend a lot of time around computers to wonder if they have ADHD. Why is that and how can we manage it?

This talk will go over how ADHD brains are affected by technology, and how to deal with the struggles those with ADHD in tech might face. Regardless of if you’re diagnosed, learning about ADHD will help us understand how we’re ALL affected by the digital world we’ve created.

The history of the JavaScript ecosystem can be described as a move from a simple ecosystem with no tooling (just write the code and F5!) in the 90s, towards the current wave of massive tooling which nobody understands but which helps us mitigate the deficiencies in browsers and the internet.

Are we stuck there? Writing code for a dynamic language that needs no compiling, and yet surrounding ourselves with extremely complex tooling that we must have to develop significant software? I believe we don’t.

I aim to bring a vision that returns full circle to an ecosystem with little to no tooling. It shows that with modern technologies like import maps, web bundles, the type annotations proposal, 103 Early Hints, and others, we can bring back the simplicity of the early ecosystem, while not sacrificing the advantages of the current one.

This talk presents this vision, and describes the technologies and techniques that enable this return to simplicity.

As web engineers, we build user interfaces that make using our products simple, understandable and delightful. Over the years, we’ve built a toolkit of frameworks, patterns and practices to do so.

In the next few years, more and more products will be built on top of Artificial Intelligence technologies, such as generative models like OpenAI’s GPT-3. In this world, which of our tools will remain helpful, and which problems will require new solutions?

In this talk, I’ll explore some of the challenges our existing frameworks and mental models have in the age of generative AI. I’ll also introduce novel ways of thinking about user interfaces that we’ve discovered while designing and building an AI-powered web application for serious writers.

Our jobs are increasingly stressful, the growing complexity of what is being asked is a heavy burden, the dream of democratized access to the web is being challenged, our coworkers are being laid off and we need to find a way to do more with less— and for some reason, our website is slower than it used to be. So, what do we do?

The best we can.

Let’s look at some common pitfalls facing engineers today focusing specifically on web performance and discuss how engineering leaders can find where to concentrate to get through these challenges, and how they can influence others to adapt along with them. We’ll find some quick wins and ways to make sure that, out of all that’s on your plate, this is one less thing to worry about.

Memory management can be an overwhelming topic to navigate. This talk is the result of my journey down the rabbit hole to better understand it myself. By drawing on my research and experience, I’ve put together a comprehensive guide that covers everything from hardware implementation to the inner workings of V8.

We’ll cover the basics of memory implementation in the computer and operating system. Then we’ll talk about the challenges of managing memory in a dynamically-typed language like JavaScript, and explore how references and memory addresses work with practical examples. Finally, we’ll take a deep dive into the intricacies of V8 implementation, including heap organization and garbage collection.

These days of cyber warfare and targeted supply chain attacks on open source packages we developers are more attentive to security vulnerabilities. Yet writing secure code to avoid security vulnerabilities is an entirely different paradigm that needs to be mastered. One such vulnerability is Path Traversal, and while it may sound harmless, it is in fact ubiquitous and presents a significant risk. My session will teach you how path traversal vulnerabilities manifest in everything from code in your own applications to code in dependencies to core modules in the Node.js runtime. Additionally, path traversal vulnerabilities may endanger your local development setup and lead to insecure Node.js applications risking your production environment. Join me to gain a new secure coding skill and learn how to mitigate this set of security vulnerabilities.

Modular, componentized frameworks and libraries are more popular than ever, but currently screen size is the only dimensional constraint to which a web design can adapt to. Luckily for us, great things are a foot.

Container Queries, which allow you to style elements based on their ancestors dimensions, a feature requested by many since the advent of component-based front-end architectures met the principles of responsive webdesign, is finally in active development.

In this talk, Maarten will explain what Container Queries are and show you how each component can adapt its design to the dimensions of its container. Join us on our journey towards a more modular CSS!

Over the last decade, Google Docs dethroned Microsoft Word, Figma overtook Sketch, and Slack has nearly replaced email within teams. What makes these all-star experiences stand out? Real-time and offline capability. In this talk, we’ll deconstruct and understand the state-of-the-art technology powering many of these experiences: CRDTs.

As we always want to push the envelope and manage more and more on the front-end, our UI code code grew in complexity in the last few years. All of our modern application deal with three big challenges: optionality (is my data there or not?), fallibility (did my operation succeed?) and asynchronicity (when do I have my data?). Inspired by how typed functional languages treat those, we’ll see how we can leverage TypeScript to deal with them and make a whole category of issues disappear, so that we can focus on the essential parts: making great, accessible interfaces.

For decades, JavaScript developers have relied on a multitude of module systems to organize and share code. But in 2015, ECMAScript finally introduced built-in standard semantics for modules, providing a long-awaited solution for the language. While ECMAScript modules have quickly become a popular format for writing code, most published code is still compiled to a single bundle or to a legacy module system.

The TC39 committee, which designs the ECMAScript language, is actively exploring this design space: are there any missing functionalities compared to previous systems? Do JavaScript developers need any capabilities that the language does not currently provide? What problems do ECMAScript modules currently cause?

This talk will walk you through the answers to those questions and show you current developments, giving a sneak peek at possible future modules features!

In this talk, Siddharth shares the challenges his team faced with optimising runtime css in js (styled-components) for performance. At GitHub, there are more than 4000 React components that contain styles, Siddharth dives into the reasons for considering the change, the challenges of scale and the path forward.

Reactivity is one of the core building blocks of web frameworks. And it has a direct impact on how we build apps and overall developer experience. In this talk we’ll explore different approaches to expressing the propagation of change in web frameworks and their consequences.

For over a decade, a vibrant testing ecosystem evolved naturally in the Node.js ecosystem. Many unique, yet wildly useful tools were built to help us ensure our code does exactly what we expect it to. More recently, as JavaScript has seen the front-end explode with an even more vibrant array of tools, we’ve seen a distinct break in the ability of popular front-end testing tooling to integrate nicely with Node.js. Further, we’ve seen an explosion of growth in the runtime ecosystem, with new pressures for unique DX additions - including built-in test libraries. This newfound, multi-faceted pressure resulted in an experiment to add a testing module to Node.js directly - node:test. We’re going to explore this new, built-in library, resulting in you understanding how you can and why you should use it today.

There has been no shortage of both fair and unfair criticism toward Web Components from a wide range of folks that build for the web, including but not limited to JavaScript Framework authors in supposed competition with the platform. In this talk I’ll show you how to navigate and simplify the multifaceted landscape of web components, satisfying common criticisms and showing how you can Use the Platform most effectively today.