Dark Ways to Get a Decent Amount of Test Coverage Real Fast

We know that tests are important. We aspire to do test-driven development. We wish we had tests when it comes time for a big refactor. But, sometimes, reality (tight deadlines, legacy code bases, poor choices, and other good reasons) get in the way and we find us without the test coverage that we wish we have. In this talk, we'll take a tour of a bunch of ways to get a decent amount of test coverage with as little work as possible. We'll look at both unit tests as well as browser-based integration tests. Get ready to be a hero and everyone's favorite teammate.

Making Music with the Web Audio API

When you weren't looking, someone stuck a synthesizer into your favorite web browser. The Web Audio API is widely supported and makes it easy—and more importantly, fun—to create, process, and control audio in the browser. We can spin up oscillators, adjust gain, tweak frequencies, and slap on some funky delay. Additionally, we can also take existing sounds and manipulate them to our heart's content. We can grab input from cameras and microphones and use them as we see fit. But, the fun doesn't stop there—we still have the rest of the browser's media APIs at our disposal. We'll talk a little bit about the Web Audio API. We'll explore the browser as a vehicle for creative expression. We'll fire up some audio contexts and connect some nodes. We'll also leverage the getUserMedia Web API, WebSockets, and others to build unique musical instruments that could only be possible in the web browser. We'll not only talk about the API itself, but also some of the fundamental concepts for working with audio and making music.

Actually Understanding Asynchronous JavaScript

Reasoning about asynchronous code can be hard if you don’t understand the mechanics. It often trips up programmers with deep experience in other languages when they try their hand at client or server-side JavaScript. But, asynchronous JavaScript isn’t as hard as it seems once you learn a few simple rules about how it works. In this talk, we’ll dive into the mechanics of concepts that you might have had a chance to full grok.

Let’s dispel this confusion once and for all. We’ll explore some metaphors that illustrate the difference between how synchronous and asynchronous code execute. In a 30-minute tour de force, we’ll dive into essential concepts like the call stack and the event loop to build a solid conceptual understanding of how the asynchronous model is implemented. We’ll take a good hard look at a number of common patterns for writing asynchronous code in JavaScript. We’ll start with listening for events on XMLHttpRequest before abstracting that mess with callbacks and promises. Finally, we’ll pull back the curtain and see that async/await is really just a cocktail of promises and generators. (Spoiler alert.)

Demystifying React Performance

React is incredibly fast until it’s not. In this rapid-fire talk, we’ll take a look at some of the best practices for keeping your React applications fast as well as some techniques for diagnosing why they’re slow when they are slow. For all of the magic that React provides, it’s still written in JavaScript. If your JavaScript has performance problems, then your React application will as well. We’ll take a look at how to diagnose performance problems, using the developer tools.

React is optimized for performance, but it is possible to accidentally opt out by writing code that is incompatible with these optimizations. We’ll look at tools that have been custom-tailored for React to help suss out these issues and correct them. Finally, we’ll look at other common performance issues as well as have a discussion on when you should optimize for performance and when you shouldn’t. We’ll close our short time together the day by tweaking the build pipeline to pump out progressively more performant versions of our application from the exact same code.

This could also be a workshop!