Building a Better Web
June 19–20, 2017: Training
June 20–22, 2017: Tutorials & Conference
San Jose, CA

Speaker slides

Presentation slides will be made available after the session has concluded and the speaker has given us the files. Check back if you don't see the file you're looking for—it might be available later! (However, please note some speakers choose not to share their presentations.)

Bryan Braun (Sparkbox)
There are more options than ever for animating things on the web. Bryan Braun leads a tour of the web animations ecosystem, comparing animation approaches in detail and exploring the principles that transcend them all. To do this, Bryan uses lessons learned from building and maintaining Bouncy Ball, a project that compares web animation approaches (think, a TodoMVC for web animation).
David Eisenberg (Evergreen Valley College)
J. David Eisenberg offers a whirlwind tour of ClojureScript, a functional language that compiles to JavaScript, covering everything from basic syntax, variables, and function definitions to lists, vectors, and the map and reduce functions.
Alexis Menard (Intel)
Alexis Menard offers an overview of the new W3C Generic Sensor API, which enables you to use hardware sensors in your website or web app. Join in to learn how you can implement it today and catch a glimpse of future plans.
Wayne Elgin (Cantina Consulting)
Between race conditions, object references, and async stack traces, JavaScript can be hard to sift through. Modern browsers offer many tools for debugging, so why not use them? And now that Node works out of the box with DevTools, you can step through your Node stack too. Wayne Elgin illustrates the latest ways to masterfully march up and down your stack and solve your code’s greatest mysteries.
Islam Sharabash (Superhuman)
Offline web applications with native performance are no longer a myth. Islam Sharabash explains how to architect an application that loads offline, persists data to disk, and even resolves conflicts in data and shares the challenges he encountered, including managing optimistic updates, syncing, and performance on a single thread, and the solutions that worked best.
Nicole Chung (TWG)
From callbacks to promises to generators to async/await, JavaScript has a myriad of ways to handle out-of-order events and processes—some of which are more readable than others and some of which are more testable than others. Nicole Chung explores the readability and testability of each approach in detail.
Atomic design is well suited for migrating web applications. Because you build complexity out of simple components, you can start small and slowly carve out your application. Harrison Harnisch shares how Buffer is migrating six years of development with atomic design.
Marcy Sutton (Deque Systems)
Marcy Sutton discusses open source web development tools and testing practices that can help your team develop a pragmatic and sustainable approach to accessible software, benefiting many people with disabilities.
Cory House (Pluralsight | Cox Automotive)
Starting a new JavaScript project from scratch is overwhelming. Cory House provides a playbook outlining the key decisions you need to make to build a robust development environment that handles bundling, linting, transpiling, testing, and much more.
Ruthie Nachmany (Warby Parker)
Warby Parker recently built an electronic health record system for its optometrists to use to conduct and store their eye exams. The company used this project as an opportunity to explore building a serverless web application on AWS. Ruthie Nachmany shares details of the system's implementation, challenges faced, and lessons learned along the way.
Creating a lasting style guide that the product team will actually use and adopt is challenging. Archana Sankaranarayanan demonstrates how to build a style guide instantly with an Atomic CSS-based starter that ensures accessibility, performance, and engineering and design efficiency and shares some PostCSS tools to help grow the style guide, maintain it, and ease its adoption.
Chris Griffith (Nortek Security & Control)
Chris Griffith offers an introduction to the Ionic framework. Built atop Angular and Apache Cordova, this framework gives developers an incredibly powerful set of mobile components to create app store-ready or progressive web apps.
Tracy Lee (This Dot)
Native or hybrid? React Native apps are easier than you think. You can get started building apps in just a few minutes—even as a beginner. The React Native CLI makes the building experience as easy as typing a few commands. Tracy Lee explains how to get started and build an native app easily in less than 30 minutes.
Sean Regan (Atlassian)
While most conversations around DevOps revolve around tool X or tool Y or the automation of X and Y, the reality is that DevOps requires high-performing people and teams. Sean Regan runs a brief DevOps Health Monitor live on stage and shares the other 26 team playbooks that emerged from Atlassian's Agile, DevOps, and microservices journey.
Yoav Weiss (Akamai)
Caching ensures content gets to users as fast as possible and provides a great experience to repeat visitors. But getting network and browser caching right can be difficult, which explains why most web content today is not properly cached. Yoav Weiss explores HTTP cache semantics, strategies, browser internal caches, and service workers and explains how to serve your content fast and fresh.
Simon MacDonald (Adobe)
Progressive web apps (PWAs) are the new hotness, and Google is pressing hard to make them the de facto choice for building mobile applications. But what about iOS, where many of the key APIs are not supported? Cordova/PhoneGap offers a solution, polyfilling the missing functionality. Simon MacDonald demonstrates how to create a PWA that runs on the web, Android, and iOS from a single code base.
Ilya Nesterov (Shape Security)
Content Security Policy (CSP) is a powerful and complex standard that allows you to bring an additional level of security to your web applications. Ilya Nesterov outlines the not-so-obvious things that lead to weak CSP, illustrates typical mistakes in CSP, based on the Alexa top 1 million sites, and explains how you can build strict CSP in your own projects.
Estelle Weyl (Instart Logic)
If you think outside the box, you can solve almost anything with CSS. Join Estelle Weyl to learn the power of CSS, as she covers several CSS WTFs. Depending on your perspective, that can mean "wonderfully terrific feature" or, very often, "what the @#$%!."
Leo Vasiliou (Catchpoint Systems)
Join Leo Vasiliou for a quick walk-through of the evolution of analytics, setting the stage for a deeper dive in a later sponsored session.
Tim Kadlec (Independent), Patrick Meenan (Facebook)
Tim Kadlec and Patrick Meenan explain how the construction of websites and applications impacts performance as well as how to quickly debug and resolve performance issues. Tim and Patrick dive into how browsers work, how web pages are delivered, backend and frontend issues, optimizations, and techniques to get the best performance and provide hands-on experience for working on web performance.
Jonathan Creamer (Lonely Planet)
As a beginner, heck even as a veteran, trying to understand all of the different lifecycle events in a React component can be a bit daunting. You'll often find yourself googling which one to use even after spending months working with React because each method has different uses. Jonathan Creamer goes through each lifecycle method, giving some examples of how and when to use them.
Neil Manvar (Sauce Labs)
Neil Manvar shares best practices for leveraging modern technologies to develop and test maintainable, quality code within CI/CD workflows.
Rachel Andrew (
Rachel Andrew shares a modern roadmap for browser support that enables you to create sites that can enhance themselves as the platform improves—without leaving people stuck on older browsers in the cold.
Tim Kadlec (Independent)
We work and live in a bubble. Our limited perspective of what it means to use technology influences the way we build, the tools we use, and the tasks we prioritize. In the process, we risk losing the most powerful thing about the internet: its ubiquity.
If you've used Git for any amount of time, you've probably gotten yourself into some confusing, frustrating, or downright terrifying situations. You are not alone. Katie Sylor-Miller explains how to avoid getting into Git messes in the first place and how to leverage Git's powerful features to save yourself when everything seems to go wrong.
Anjana Vakil (Mapbox)
Functional programming—programming without side effects or mutability—has great advantages, especially for JavaScript developers, but never mutating data can lead to efficiency problems. Anjana Vakil explains how immutable data structures provide an elegant solution and explores two libraries that make it easy to use these remarkable data structures in your own JavaScript projects.
Marcy Sutton (Deque Systems)
Building a better web means removing barriers for users and helping them live more productive lives. Marcy Sutton explores how the work we do with technology can have a monumental impact on the lives of people with disabilities by providing independence, privacy, and growth opportunities. But making a positive impact depends on our willingness to do the work.
Mike North (LinkedIn)
Your users are almost certainly vulnerable in one way or another. Mike North explores a series of common web app security pitfalls, first demonstrating how to exploit the vulnerability and then recommending a pragmatic and effective defense against the attack. Buckle up, because Mike's about to take some things you love and depend on and smash them to bits.
K Vignos (Twitter)
Constant change—caused by high attrition, frequent reorganization, shifting priorities, and management turnover, among other reasons—is the new normal. It takes months to onboard a new team member and get them adding value. Kathleen Vignos offers tips, shortcuts, and stories for stabilizing a team and finding a path to productivity amid the chaos.
Shane Russell (United States Digital Service)
The US Digital Service is building a suite of tools to replace a large legacy application at the Department of Veteran Affairs. Knowing the complexity of the end state and enamored with microservices, the team was much too aggressive in breaking up the product. Shane Russell reflects on this experience, sharing advice and lessons learned on how and when to break up your web app.
Eli Fitch (Social Tables)
Perceived performance, in the end, is the only performance that truly matters. If what we make doesn't feel fast, then no amount of optimization counts. Eli Fitch breaks down the psychology of how users perceive time and how we can combine that knowledge with clever use of animation, unconventional event listeners, and predictive design to make our experiences seem faster than they actually are.
Addy Osmani (Google)
Addy Osmani explains why progressive web apps (PWAs) are becoming the new normal for fast, reengaging mobile web experiences for large brands such as Twitter, Lyft, and Forbes. Addy also explores how PWA support has massively improved in modern frameworks like React, Preact, Polymer, and Vue, lowering the barriers for developers and businesses to explore them.
Shubhie Panicker (Google), Nic Jansma (Akamai)
Responsiveness to user interaction is crucial for users of web apps, but bad user experiences abound. Shubhie Panicker and Nic Jansma share new web performance APIs that enable developers to reliably measure responsiveness and correctly identify first- and third-party culprits for bad experiences. They then compare these measurements to business metrics using real-world data.
David Fox (LookZook)
Despite spending countless hours optimizing our own sites, many of us still look at sites like Amazon's or the Guardian's in awe, wondering how they are still so much more performant. What are they doing differently? David Fox reverse engineers these sites, shedding light on the various tricks and optimizations they have and we don't.
Danielle Man (Meteor Development Group)
GraphQL improves both your API's performance and the performance of your team in general. Schema-first GraphQL development forces front- and backend teams to agree on a strict contract up front, enabling them to work quickly and efficiently while staying on spec. Danielle Man discusses the benefits of schema-driven development and shares lessons learned using GraphQL in production.
Jeremy Fairbank (Test Double)
Elm is a functional programming language that compiles to JavaScript and allows building robust and safe web apps. Jeremy Fairbank dives into Elm's syntax and its Model-View-Update architecture, explaining the advantages Elm offers for developing frontend apps and how to structure a simple app with pure functions, and shares steps to getting started with Elm.
Addy Osmani (Google)
Venture deep into the belly of the browser to uncover the secret to instantly loading anything—backed by data. Addy Osmani explains how to use preload, prefetch, preconnect, HTTP/2 server push, service workers, and more and how to ship JavaScript bundles on mobile that don't break the bank as he shares data-driven techniques and performance patterns for efficiently loading content instantly.
Addy Osmani (Google)
Venture deep into the belly of the browser to uncover the secret to instantly loading anything—backed by data. Addy Osmani explains how to use preload, prefetch, preconnect, HTTP/2 server push, service workers, and more and how to ship JavaScript bundles on mobile that don't break the bank as he shares data-driven techniques and performance patterns for efficiently loading content instantly.
John Allsopp (Web Directions)
The era of so-called "personal" computing (as we've known it for 40 years) is coming to a close. John Allsopp explores the ways in which personal computing has become deeply impersonal and how the modern age of apps, screens, and devices that bring personal computing to us on the go is evolving and impacting human interaction.
3596b02f b4b12d54 (MeasureWorks)
Third parties offer many benefits, but they also break sites, open security holes, and are often bad for performance. Kristian Skoeld shares proven methods and techniques on how to manage third parties and break through IT and business silos. You'll leave with a list of tools, checklists, and approaches to help you end emotionally loaded discussions and make data-driven decisions.
Gareth Hughes (Akamai), Michael Gooding (Akamai)
Keeping up to date with the latest web performance trends, features, and techniques can be time consuming and hard. Gareth Hughes and Michael Gooding guide you through the top five performance techniques for today's modern browsers and provide the tools and knowledge you need to implement them today.
Joao Fernandes (Docker)
Getting early adopters is hard, but bringing your product to the rest of the world is harder. Known as crossing the chasm, this is a make-or-break moment. Joao Fernandes explains how good docs can help you cross the chasm and ensure you won't need to spend your days holding users' hands and shares the processes and tools Docker uses to deliver docs in a continuous way.
Elijah Manor (LeanKit)
Elijah Manor explains how to use npm scripts to handle your various build needs, covering running scripts in series or parallel, using lifecycle hooks, passing arguments, piping data, using environment variables, running scripts on file change or when Git hooks are triggered, and organizing our scripts in external files—as well as how to modify your scripts to run across Mac, Linux, and Windows.
laura carvajal (The Financial Times)
Laura Carvajal explains how her team introduced accessibility to the Financial Times website,, and shares lessons learned along the way as well as practical solutions you can implement in your project today, regardless of available time, resources, or support.