dotconferences
Live coding with Ryan Dahl: Deno and OpenTelemetry - dotJS 2025
updated
It's a delight to discover new language features that enhance your Swift programming experience. Many of Swift's features adopt a style that "reads" as if they're native constructs but are actually created and maintained by third parties. Erica shows you Swift 5's new property wrappers (added in Swift 5.2), how they fit into this paradigm and why they're an exciting avenue for developers looking to create reusable property enhancements.
The animation capabilities of SwiftUI are simply great. Pavel briefly covers the basics of animations in SwiftUI and then discusses several techniques of animation tweaks that can either ease animation creation or take your eye candies to the next level. He talks about GeometryEffect and AnimatableModifier and adds the explanation of AnimatableData.
SwiftUI has become a topic of great interest this year. It really is fantastic. Unfortunately, it’s incomplete at the moment. Ishmael discusses the process of either starting with a new SwiftUI project and adding UIKit to fill in the gaps or starting with an existing UIKit project and augmenting it with SwiftUI.
Writing networking code is a common task among many projects, but it poses several challenges. Functional programming can help us deal with them, leading to code that is easier to compose and test.
This talk from Thomas aimed to be an eye-opener on how easily you can use the Redux architecture with SwiftUI.
Denis explains how conforming most of your entities to simple protocols can turn out to be really useful. Especially those protocols that require no more work than just stating your given entity conforms to it. Hashable, Identifiable I am looking at you. Once most of your entities do conform to those protocols, you can now enjoy the full power of mixins and other protocol extensions.
Tobias shares a full story on how to build a prototype for a custom UI that visualizes instantaneous sound level as well as sound level over time. The talk is highly interactive and covers how Swift and SwiftUI are perfect for making prototypes, particularly when building custom UI.
In this session, Cory discusses the tools for using cryptography in Swift, and introduces a new Apple open source project for working with cryptography on all platforms, Swift Crypto.
Kaya explains two unique techniques to help make your tests easier to read, write and understand. The first technique is using Swift enums to abstract XCUIElementQuery calls and to isolate UI element into cases with each enum representing one screen. The second technique uses function builders to allow you to group multiple calls to XCTAssertTrue() and XCTAssertFalse().
App architecture has been a topic of many discussions in the iOS development community. Many developers and companies propose novel architecture options to supposedly improve the development of iOS apps, while Apple keeps supporting the MVC architecture. Guilherme shows what causes people to have problems with that architecture, how to avoid the common pitfalls and why adopting a shiny new architecture might not be the best solution.
Swift is a great language. But we’ve all met situations where a certain feature was missing, and we wished were part of it.
Since programs are basically functions, and functions are first-class citizen in Swift, Vincent shows how we can implement “pseudo-keywords” at a short cost and to great value.
Many modern apps need to make 10s or even 100s or network calls just to populate the home screen. And they'll likely be calling multiple different APIs, all requiring different authentication methods, JSON parsing and aggregation. Not only does this increase battery drain and frustration for users on slow and unreliable networks, it places a huge burden on the developer that isn't easy to update or iterate on quickly.
Tim looks at the Backend for Frontend pattern and how we can leverage Swift in both our iOS applications and server applications to share code and make development faster. He shows clear examples of how BFFs can dramatically simplify your networking code and how a BFF in Swift can help you develop iOS applications quicker by reducing context switching and being able to share code.
Combine is Apple's own Functional Reactive Programming framework. Donny explains three of the main pillars that Combine is built on. By re-implementing Combine's sink subscriber we explore every aspect Combine's subscription stream.
Learn about Sign In with Apple, the new identity provider announced at Apple WWDC 2019.
This authentication option, which Apple has stated will be mandatory for all App Store apps soon, may present some challenges to application developers, but aims to provide a better user experience for those in the Apple ecosystem through enhanced privacy and seamless login across the web and native applications.
Dates and times are one of the most common problems programmers encounter - so why is it that we so often get this space wrong?
Maggie discusses where our current Date goes bad, better ways to model the date and time space in our code, and how the Temporal proposal making its way through TC39 helps us write correct code for every person in every time zone.
We’ve learned to rely on sophisticated frameworks and fast engines so much that we’re slowly forgetting how computers work. With modern development tools, it’s easy to locate the exact code that’s slowing down your application, but what do you do next? Why exactly is it slow, and how do you make it fast? Time to regain the lost art of algorithmic performance optimization!
Software performance is all about recognizing and eliminating unnecessary work. You can learn to do this intuitively, and eventually you’ll be able to write code that’s fast from the start, by default. Vladimir shows you how — on practical, real-world cases of optimizing popular open-source libraries, PR by PR.
A decade after Node.js was first announced, JavaScript and the web platform have evolved, and TypeScript has changed the way JS applications are developed. Deno is a new JavaScript/TypeScript runtime that was designed with all those new capabilities in mind.
Jana covers how to bring multi-dimensional computing power to the browser using Web Workers. She focuses on one particular dimensionality reduction algorithm—UMAP—used more and more frequently these days to visualize high-dimensional datasets. She deep dives into the specific features of Web Workers that aid in making it possible to perform tasks typically reserved for cloud computing jobs in the browser, albeit on smaller samples from data sets.
These features include transferable objects, which allow for efficient, zero-copy passing of computed results back to the browser from the Worker and OffscreenCanvas, a bleeding edge browser feature that can let us even perform the visual rendering of the UMAP result in a non-blocking Worker.
Adam reviews the design and architecture that went into creating a component compiler which generates framework agnostic components. First, he goes over "why" a compiler, then dives into how we're able to take advantage of TypeScript and Rollup to generate web-standard components, while also focused on developer experience.
Ziad shares some guidelines for using TypeScript types as precisely as possible.
It’s 3019, how has writing stylesheets changed? Ire covers topics such as progressive enhancement, accessibility, internationalization, and performance as it relates to writing CSS in 3019 (and, of course, today).
We used to avoid inline styles, considering them a “bad practice”. But what if most of the known pitfalls could be avoided by using modern CSS features like custom properties?
Roman shows how we can use CSS variables to recreate a utility-first approach by using them as an API from our HTML style attributes.
Daniel presents the TC39, the committee working on evolving the JavaScript language standard. Because JavaScript is both programmed by a diverse set of people and deployed in diverse settings, it is essential that its development be governed in a way that is inclusive to these various requirements. We are not there yet, but the TC39 is working on it, and this can be seen in the development of various new language features that are coming to JavaScript. The TC39 needs your help in bringing JavaScript to the next level, and Daniel explains how you can get involved.
What do CRDTs and frontends have to do with each other? James talks about how CRDTs finally deliver on the promise of local-first apps, which provide superior user experience, and explains how simple CRDTs can be and how to leverage them to create robust local-first apps.
Before being a web developer, we are all users of the internet which is a jungle of UX patterns, some bad, some good and some terrible. Sara explores the complex paths of this jungle to understand together how we can plan and develop ways to make our applications be a more enjoyable experience for both our users and us.
While everyone is talking about CSS in JS, what if we look at how to do JS in CSS? Because yes it is possible! Is that a good idea? Jean-François is not sure about that, but why not come and relax on this technical and fun session.
The WebAssembly Community Group is actively working on improving the interoperability, allowing a seamless integration in our JavaScript projects!
Sven talks about how WebAssembly looks like from a JavaScript developer perceptive.
Every code line can be tested, even CSS.
Fabien shows you how to test SASS functions and master SCSS update impact on generated CSS.
When developing applications with states which require some effort to make them consistent, we can either accept that and write many unit tests to make sure things are consistent, or we can model domains in a better way, leveraging the type system to eliminate as many inconsistencies as possible.
Testing native JavaScript web components can be tricky. Andrew walks through the basics needed to test native JS web components without a browser.
When we develop a Single Page Application, we have to use a Router. It's a common use case, yet every single framework has its own router, React even has multiple ones you can choose from. And even though each framework is different and every router takes a different approach, they all share quite a few principles. Understanding those helps us handle routing in our SPA because behind all those simple, different APIs provided by framework-specific routers, a more complex architecture is hidden from us.
Eduardo dives into the architecture of a Router and some of its implantation details.
More info & upcoming conferences: dotconferences.com
Using CSS with SVG is a great adventure full of magic, friendship and sometimes… creepy villains! Jump in and discover why you should tell the world that CSS and SVG are forever best friends.
Stefan covers regular expression features like non-capturing groups, named capture groups, the dotall flag, and Unicode property escapes.
Aurélien shows how CSS can be wonderful or dreadful for accessibility depending on how you use it and how small details can open doors to everyone or destroy all your efforts to do it.
In the past few years, UI libraries have taken the web development world by storm, however, this shift in how web applications are built has also increased the complexity of tooling needed to be productive.
In reality, it has gotten easier as new a new segment of tooling was created to aid in creating scalable and performant web applications. These “Web Frameworks” focus on providing great end-user experience while also making developers more productive.
Tim explores what web frameworks are, why they exist, and how you can immediately improve your end-user experience and developer experience by applying low-level concepts from web frameworks in your application.
Testing the front end shouldn't be that hard! There are ways to achieve a healthy testing strategy for our front-end applications.
Adrià discusses, explores, and showcases some of the best practices around what to test, and also how to test it.
Modern developments in CSS make it easier than ever to create robust, scalable, elegant typographic systems on the web. Add variable fonts and the design, technical, and performance benefits are really exciting. Jason looks at how to combine them with other CSS capabilities like custom properties, calculations, and grid to create a whole new way to think about design and development. He also shows how they work together by using some variable fonts in layouts that work across screen dimensions, accessibility needs, design requirements, and even network speeds—better than you thought possible.
Even though we don’t really think about it, sound is a very rich source of information.
Leveraging the properties of sound with machine learning, we can gain insights about an environment or an activity performed.
Acoustic activity recognition has the potential to create new interactions and better smart systems, and in this talk, Charlie explores how to experiment with this technology in JavaScript, using the Web audio API and Tensorflow.js.
As web apps and user interfaces become increasingly more dynamic and complex, structuring stylesheets for every possible state can be a challenge. David explores innovative ways of organizing our styles, adding complex interactivity and meaningful transitions, and comprehensively test UIs through a decades-old concept – finite state machines. With ARIA, data-attributes, and CSS variables, state machines can bring a new level of maintainability, testability, and interactivity to your styles.
Data centers produce about 3% of the world's greenhouse gases and this is set to treble in the next 10 years. When building apps, we focus on minimizing costs, time to market, bugs, bundle size, application speed, SEO, but we spend almost no effort trying to minimize the damage our applications are making to the environment.
Asim discusses how to build a green sustainable web application with NestJS and Serverless.
Svelte is a new generation of web framework, it compiles your code to vanilla JS and CSS instead of evaluating it at runtime. This new approach opens new possibilities, especially for writing reactive web app.
Bertrand explains how Svelte changed his mind on frameworks.
Writing CSS that scales is hard, even when you're great at it. It often starts well, but soon, unforeseen requests start coming in, the layout is being moved around, and you have to undo most of what you've done. Soon, you realize that your component-based architecture isn't as resilient as you thought, and it feels like the best thing you can do is to start over.
There's one methodology made for change. Instead of being tied to your project, it's tied to your style guide. This is called utility-first CSS.
Kas discuss the MIDI communications protocol, how we can create and augment music with JavaScript, and will hopefully make you think about how your apps communicate with each other.
We are obsessed with coding and creating automated workflows and optimizations. And yet our final products aren't making it easy for people to use them. Somewhere, we lost empathy for our end-users and other developers. Maybe it is time to change that. Here are some ideas.
Hakim tries to give people tools for finding unexpected ways to improve UI elements. He talks about how reinventing the wheel is a great way to learn and improve as a front-end developer. The talk covers three specific UI improvements that he’s deep-dived into, complete with hands-on examples of how to implement them.
Authoring performant, scalable & accessible CSS is difficult and requires specialist knowledge. Emily covers why design systems can help enable organizations to ship well-written CSS. She also covers what design systems are, the history of design systems at GitHub, and why we decided to abstract styles into reusable React components.
You will walk away with a deeper knowledge of how to design a public API for components, how theming works, and common pitfalls one might come across when trying to scale a design system across an organization.
It's been 25 years since the first people proposed a language to style the web. Since the late nineties, CSS lived through years of platform evolution. The cascade, specificity and the enormous choice in values and units set the language up for success. But not everyone liked to use these features everywhere. Some began to adapt the language to meet their needs.
In this Darwin-themed talk, you'll learn how CSS came to be, and how the language's simplicity and flexibility still make it stand out today.
WebAssembly, the new low-level bytecode format for the Web, could seem like a complicated topic to some. Vlad provides you with required WebAssembly knowledge, so you can use the power of WebAssembly to optimize your own JavaScript web applications. He also takes a glance at the future of WASM and how it can improve the speed and security of the software we write on a daily basis.
For a period of time, most of the mainstream frontend frameworks have converged on a class-or-semi-class-based model for declaring components. However, in the past year, we are seeing some new ideas emerging regarding how stateful logic inside components are declared, managed and composed.
Evan examines three different approaches: React Hooks, Vue Composition API, and Svelte 3. They share a common departure from the class-based models, but also have fundamental differences due to the trade-offs in their respective designs, which he discusses in this talk.


