The Web Platform
March 7–8, 2016: Training
March 8–10, 2016: Conference
San Francisco, CA

Speaker slides & video

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.)

Kyle Simpson (Getify)
Kyle Simpson offers observations from seven years of conference talks.
Brad Green (Google)
The Angular team has been investing in building techniques that enable large teams to build robust applications that span desktop and mobile. Brad Green covers the new specs for zones and decorators and explains how new techniques make it easy to use advanced browser features like web workers, HTTP/2, and service workers for building robust apps.
Jeremy Wilken (VMware)
Angular 2 comes with new paradigms and features that make it a powerful tool for today's Web. Jeremy Wilken explains how to structure and build an Angular 2 app using TypeScript and ES6+. You'll get practical training on Angular 2 architecture as you learn how TypeScript can improve your applications and how ES6+ makes Angular 2 more approachable and easier to work with.
Ryan Baxter (IBM)
MQTT is a standards-based, lightweight pub/sub messaging protocol ideal for Internet of Things use cases. With implementations in a number of different languages, using MQTT in your applications is simple and straightforward. Ryan Baxter shows how to build an application that connects to an MQTT broker and can receive data from—and issue commands to—a number of different IoT devices.
Sarah Drasner (self-employed)
Scalable vector graphics (SVGs) are now extremely well supported. In the age of multiple screen resolutions, SVGs offer the potential for clarity, reduced byte size, and a navigable DOM. What does this mean in terms of animation? Sarah Drasner covers advanced, performant SVG-animation techniques that offer cross-browser stability.
Sarah Drasner (self-employed)
Sarah Drasner demonstrates how to use GreenSock (GSAP) to create seamless, engaging, complex SVG animations with ease.
Elijah Manor (LeanKit)
Elijah Manor brings backend or junior devs up to speed on CSS by explaining foundational concepts, such as the box model, specificity, position, cascading, and sizing, and introducing newer concepts, including Flexbox, Sass, BEM, Autoprefixer, and CSS modules. You'll walk away with a set of tips and techniques that make CSS easier to organize, understand, and maintain.
Brian Belhumeur (craigslist)
Progressively enhanced sites are awesome, but testing all their permutations across browsers is not. Using Nightwatch.js, Brian Belhumeur demonstrates some techniques you can use to write end-to-end tests that will adapt to the capabilities of the targeted browser so you can spend less time maintaining your test matrix and more time making it more adaptable and future-proof.
Josh Simmons (Salesforce | Open Source Initiative)
Failure is inevitable—even praised in startups and technology—so why aren't we better prepared for it? Josh Simmons has failed in freelancing, small businesses, agencies, and startups. Let him be your cautionary tale. Josh outlines the top 10 ways to fail and explains the 3 major components of failing well.
Jamund Ferguson (PayPal)
Jamund Ferguson offers an overview of Paypal's transition from AMD to CommonJS, a very beneficial move. Moving from RequireJS to webpack meant Paypal could use any module in npm on its frontend and has made it easier to explore new technologies like Flux and React. Jamund summarizes Paypal's experiences to demonstrate how you too can move to webpack with ease.
Ariya Hidayat (Shape Security)
After you've built an application, written some unit tests, integrated a linter, and hooked up a CI system, what should you do next? Level up, as Ariya Hidayat explains how to track code coverage, leverage Docker for a consistent development platform, and implement cross-browser testing.
Pete Hodgson (Independent)
Functional reactive programming (FRP) brings the same unifying abstraction to both async network calls and event-based UI code. Pete Hodgson explains the core concepts of FRP and shows practical applications in JavaScript for both client-side UI development and server-side networking code. Say goodbye to manually managing state in your programs and start seeing the world as streams of values.
Steven Atkin (IBM)
Developers want to rapidly build cloud applications and make them available to as many users as possible, as fast as possible. However, translating applications has not changed very much. Steve Atkin explores IBM's new Bluemix service, Globalization Pipeline, which seamlessly integrates real-time machine translation and persistent human postediting capabilities.
Nicolas Bevacqua (Independant)
Nicolas Bevacqua explores the past, present, and future of web performance. Nicolas quickly covers what you're already doing—minifying, bundling, and using progressive enhancement—before moving on to what you should be doing—optimizing TCP, inlining the important stuff, and deferring the rest so that you don't block the rendering path. Nicolas also explores what HTTP/2 has in store for the future.
Laurie Voss (npm Inc)
Laurie Voss tells the story of how npm made the journey from a monolithic, single-process registry to a distributed system made up of separate measurable, testable, and manageable microservices. Laurie highlights the process and philosophy behind this immense behind-the-scenes change.
Tammy Everts (SpeedCurve)
There are compelling arguments why companies need to care about serving faster pages to their users. Countless studies have found an irrefutable connection between load times and key performance indicators, ranging from page views to revenue. Tammy Everts outlines research-based reasons why you need to care about web performance and what you can do to make your pages faster.
Ragnar Lonn (Load Impact)
The new HTTP/2 protocol is mostly focused on web performance, but what kind of performance improvement can you expect by switching to HTTP/2? Ragnar Lönn explains the key improvements within HTTP/2 and demos a new application developers can use to see how their applications will function on the new protocol.
Jonathan Beebe (Ramsey Solutions)
Typography pervades most facets of our modern lives. We can learn a lot from typography's rich, colorful history as well as from the modern trends that affect every aspect of the design and development of digital products. Jonathan Beebe demonstrates the most effective uses of typography to influence users and explores the current set of problems designers must grapple with.
Christopher Pitt (SilverStripe)
Programming is hard; making compilers is harder. Or so people think. The truth is that making a compiler is just a series of small steps using regular language constructs. It's so easy, we'll make one in this talk.
Yao Morin (Intuit)
Even though each of us is only 1 of 7 billion, we all want to feel special. Product personalization is transforming the Internet experience to be all about me (and you too!). Yao Morin explores how to create customer-centric experiences through data science and software engineering, using Intuit TurboTax as a case study.
Andrew Chalkley (Treehouse)
So you've mastered JavaScript in the browser or on the server side, and you have an itch to get into hardware? In recent years, a plethora of low-cost devices that can run JavaScript code have come to market. But which ones are best for what situations? Andrew Chalkley gives you a tour of the current landscape to get you started on your JavaScript hardware adventure.
Shane Russell (United States Digital Service)
A "living" style guide uses an actual library of frontend assets instead of existing as a static PDF. Living style guides can bring consistency, agility, and many other benefits to an organization's web apps, but there are potential pitfalls. Shane Russell melds dev-community wisdom with a firsthand account of implementing a living style guide across a suite of web apps at a health provider.
Rachel Andrew (
Flexbox and Grid offer powerful layout methods for the Web. However, to make best use of them, you must familiarize yourself with some new core concepts. Rachel Andrew demystifies the new CSS layout methods so you can fully benefit from their power.
Bradley Holt (IBM)
Web and mobile apps shouldn't stop working when there's no network connection. PouchDB is an open source syncing JavaScript database that runs within a web browser. Offline-first apps built using PouchDB can provide a better, faster user experience—both on- and offline. Bradley Holt demonstrates how to use PouchDB and CouchDB to build offline-enabled web and mobile apps.
Alex Russell (Google)
Web apps have long been considered underpowered compared to native mobile apps, but what's really at the root of this perception? Alex Russell describes a new way to build that combines emerging browser features into something that just might answer the question.
Laura Palmaro (Google)
The state of web accessibility is rapidly improving. This rising tide lifts all boats by driving quality frontend development. Laura Palmaro explains how we can continue this upward trajectory using the rich array of tools and learning resources now available.
Cory House (Pluralsight | Cox Automotive)
Cory House gets participants started in React and Flux by helping them build a real-world application from the ground up, using react-router, Node.js, Browserify, and ESLint to help make it happen. You’ll be amazed how quickly you can build a responsive single-page application in this modern stack.
Dina Goldshtein (Riverbed)
Dina Goldshtein demonstrates how to use the Canvas API to draw a very large number of shapes in the browser, animate them, and apply various transformations. Dina also shares some best practices for wrapping the Canvas API with custom JavaScript classes.
Corinna Cohn (Fusion Alliance)
Is your AngularJS application becoming too difficult to maintain? Corinna Cohn explains how to take an overburdened application and make it maintainable by separating concerns of retrieving models, creating components, and isolating business logic. You will learn techniques for making your own code cleaner and more maintainable by writing small, testable modules instead of tangled monoliths.
Ryan Jarvinen (Red Hat)
Building Docker images is easy; that’s why there are over 45,000 public images on Docker Hub today (albeit only 100 of them "official" images). Creating reproducible, secure images from source that are easily maintained and updated takes a bit more planning and automation. Ryan Jarvinen illustrates what it takes to create a successful (and secure) build strategy.
Oliver Friedmann (Ziggeo)
Oliver Friedmann introduces Ziggeo's open source framework for video recording and playback, which features responsive HTML5-enabled components with Flash fallbacks for older browsers. It is customizable and extendable via the components' state machines and their dynamic templating system and works across all platforms, including mobile browsers.
Paul Draper (Lucid Software)
Web apps are complex and comprised of many technologies. It can be difficult to simultaneously scale large server and client codebases. Scala is an expressive, performant language that can now run in your browser as well as on the JVM. Paul Draper explains how Scala's presence on the two most ubiquitous runtimes greatly assists web developers.
Volkan Ozcelik (Cisco Systems)
It's one thing to create a sample RESTful API using Node.js, but it's quite another to horizontally scale your architecture to hundreds of thousands of concurrent connections while trying to ensure redundancy and high availability. Volkan Özçelik shows what it takes to create real-life, scalable, highly available, and highly responsive Node.js applications.
Tracy Osborn (Hello Web Books)
If you work with web technology, at some point you'll work on something people will see. What's the quickest way to better interfaces? Tracy Osborn explores the two most important principles to get you started on the path to being a better designer.
Kent C. Dodds (PayPal)
“Feel free to submit a pull request.” For some, this is a welcome invitation, but for many developers, pull requests are intimidating, discouraging them from contributing to the community. Kent Dodds demonstrates how easy and fun it is to create a pull request as a first timer. And if you’re a project maintainer, Kent will show what you can do to make contributing easier and more inviting.
Alicia Sedlock (Society of Grownups)
From unit testing to visual-regression testing to even testing accessibility, the list of frameworks that help you test your code—already quite a large landscape—continues to grow over time. Alicia Sedlock gives an overview of the state of frontend testing and explains how you should go about choosing which tests work best for your product.
Jeremy Fairbank (Test Double)
As JavaScript has evolved over the past several years, so have the patterns for handling its asynchronous nature. Through callbacks, Promises, and now async functions, JavaScript has made asynchronous control flow easier to tackle. Jeremy Fairbank dives into the new async functions landing in ES7 and investigates various use cases and “gotchas” along the way.
The Web has grown to become a hugely important medium, but it has also become horrendously complex, which extends development schedules and promotes bug formation. Douglas Crockford introduces Seif, an open source project started at PayPal with the goal of transitioning the Web into an application delivery system that will be safer, easier to use, and easier to develop for.
Philip Tellis (Akamai)
If you've always wanted to play around with D3 or Julia, Philip Tellis will bring you up to speed very quickly. Philip explores both Julia and D3 to demonstrate how to extract meaningful information from web-performance data and guides participants through some fun visualizations that are possible only when using these tools together.
Thibaud Hottelier (Graphistry)
The ability to visualize millions of data points opens up a world of applications. But it’s hard to quickly render that much data, let alone compute anything with it. Thibaud Hottelier shares the GPU technology—a hybrid client/server GPU engine using Node-OpenCL and a new library, CL.js—that Graphistry used to break the million datapoint barrier for fast, interactive visualizations.
Charles Engelke (Google, LLC), Laurie White (Google, LLC)
The Internet's security depends on cryptography. People use "secure" websites to take advantage of current cryptography methods. But what if users can't (or don't want to) trust the web server with their secrets? Web-page authors can use the Web Cryptography API to give their users end-to-end secrecy and authentication through web servers, not just to them. Charles and Laurie will show you how.
Tony Parisi (Wevr)
Tony Parisi explores the latest developments in web graphics using WebGL 2. Tony covers the new version of the 3D standard, as well as related technologies such as glTF for 3D data transmission and WebVR for web-based virtual reality.