Speakers and Sessions

20 awesome speakers that will blow your mind!

Pete Hunt i

Be predictable, not correct.

Functional programming is a great way of managing complexity in user interfaces. User interfaces are very difficult to build due to the difficulty in determining if they’re “correct” or not. In this talk I’ll go into some ways that functional programming techniques like referential transparency and immutability can lead to easier-to-build user interfaces.

Jafar Husain i

Asynchronous JavaScript at Netflix

What’s does a mouse drag event have in common with an Array of numbers?

The answer to this question may surprise you: they are both collections. This key insight holds the key to dramatically simplifying asynchronous programming in Javascript. In this talk you will learn how you can use the familiar Javascript Array methods to create surprisingly expressive asynchronous programs. Using just a few functions, you will learn how to do the following:

  • Declaratively build complex events out of simple events (ex. drag n’ drop)
  • Coordinate and sequence multiple Ajax requests
  • Reactively update UI’s in response to data changes
  • Eliminate memory leaks caused by neglecting to unsubscribe from events
  • Gracefully propagate and handle asynchronous exceptions

In this talk we’ll be exploring the open-source Reactive Extensions (Rx) library (https://rx.codeplex.com/) which allows us to treat events as collections. You’ll learn about how Netflix uses Rx on the client and the server, allowing us to build end-to-end reactive systems. We’ll also contrast Rx with Promises, another popular approach to building asynchronous programs in Javascript.

Josh Robertson i

HTML5 Canvas Animation with Javascript

Have you ever wondered how to make awesome canvas animations? This is where you can come learn about: Briefly talk about the Drawing API Basic Trigonometry for animation Basic motion (Velocity & Acceleration) Learn about radians & degrees. Just basically explain them and how to convert them. Learn about sine waves and how to animate using sine waves. The fun part will be motion. I will explain velocity, acceleration and show tons of code and demos. This talk will be more fun to you if you have a laptop and pull up my slides. I have a couple of demos that are interactive with the keypad. Do you want to animate awesome stuff? Then see you there!

James Long i

Unshackling JavaScript with Macros

JavaScript is thriving, but the language itself is shackled to the long process of ECMA standardization and implementation in all engines. We have to wait many years for a simple feature like variable destructuring.

Macros allow you to extend a language with new syntax and semantics, just like you would build new APIs on top of native ones. There’s no reason the language itself shouldn’t be extensible, which allows it to grow naturally.

sweet.js is a project that implements robust hygienic macros for JavaScript. I will explain how this works and why it’s such an exciting idea. I will show how you can already have ES6 variable destructuring, classes, fat arrow syntax, and more just with a few macros. In addition, you can use things like function tracing, native pattern matching, better assertions (logs contain the original expression), and much more. sweet.js macros track the original source location and generates sourcemaps, so debug away like normal! Let’s unshackle ourselves from the the mire of standardization, and take control of the language we love!

Eric Schoffstall i

gulp: The next generation build system

Build systems play a crucial role in every developers life. Why do we settle for subpar processes when we can have it all? I’ll talk about grunt, gulp, and a little about the philosophy of builds.

Jeremy Kahn i

60 FPS or Bust: Bleeding Edge Web Animation

This talk will cover everything about animation on the modern web: Terminology and concepts, APIs, performance considerations, and the tools that are available to get the job done.

JavaScript allows us to define complex behavior as well as respond to events. Modern browsers give us JavaScript APIs that are optimized for animation timing, but we still only get 16 milliseconds to render. Alternatively, CSS handles the heavy lifting of timing and rendering for us. However, it is often not as flexible as JavaScript and therefore has different use cases. How do we know what language is best for the job?

In addition to APIs, high-quality animation requires effective workflows and tooling. With animation being such a visual craft, text-based workflows will only get us so far. In this session, we will explore some of the visual tools to help us build better animations more easily than ever before.

Jamison Dance i

Hardware Hacking for JS Developers

Building things that interact with the physical world can be profoundly satisfying. However, if you work high up the abstraction ladder hardware hacking can seem a scary place full of scary things like assembly, microcontrollers, C, solder fumes, and the risk of death by electrocution. Fear not! None of those things are actually scary. Okay, death is scary, but highly unlikely!

We’ll learn how JavaScript makes it super easy to get started hacking on hardware, including Arduinos, drones, and a few other gadgets. We’ll also show off some live demos of some working projects, and the code that powers them. Hardware hacking is fun, and you can do it.

Guy Bedford i

Browser Package Management

We still don’t have a sensible package management workflow for the browser. Instead we have various pieces of package management tooling that may or may not play well together. The main reason for this is the lack of agreement on a module system and module loader for the browser.

With the ES6 module specification getting very close to completion, we now have a module format and dynamic loader that are specified natively for the browser. The hope is that this will provide the stability we need to move us closer towards agreement on methods allowing module management in the browser to be as easy as using npm on the server.

The ES6 Module Loader polyfill enables these ES6 module loading methods in browsers today, and with builds the polyfill is suitable for production use. The loader can also be customized to support dynamically loading AMD, CommonJS and global scripts directly in the browser, providing an upgrade path for legacy modules.

jspm is a package management system for JavaScript that is built on top of these principles of ES6 modules and the ES6 dynamic loader from the core. It also provides a CDN and CLI for working with flat dependency-managed modules of any module format directly from GitHub or npm.

This talk will provide an overview of ES6 modules and the module loader, as well as providing examples of these techniques in action.

Alex Navasardyan i

And benchmarks for all!

If you’re a framework maintainer it is really hard to measure performance of your library and it can be a real pain in the butt. This talk will show you how to write different kinds of benchmarks (certainly, not micro benchmarks), including the ones that will profile DOM interactions and JavaScript execution. Ember.js will be taken as a playground for showing different benchmarks’ demos

And benchmarks for all!

Dejan Dimic i

Apple's iOS 7 native JavaScript a bridge to new future

With new Apple’s iOS 7 native JavaScript bridge the new way of development is bringing a fresh breath of creativity to this platform.

I will try to demonstrate full development circle using this new functionality on iOS device using common and new iOS 7 features.

JavaScript Bridges are powerful, because they give developer communities access and the opportunity for code reuse.

It will be demonstrated how easy is to get started, and how well it composites with Objective-C language apps.

Apple’s iOS7 is the first iOS operating system to officially support JavaScript as a mobile development language in Apples XCode tool chain as a new light on horizon.

Kassandra Perch i

You should be using Twitter's Flight framework.

Twitter’s Flight framework is unobtrusive, powerful, and allows you to structure your client-side javascript more efficiently and makes it more manageable and testable. It gives you tools such as a modular system, event-based architecture, and functional mixins- all with tiny overhead. It even integrates easily with non-flight code, allowing for a piecemeal conversion of old code to a Flight-based system. This talk will go over Flight and how you can start using it, today, to create great javascript applications.

Glen Maddern i

A GIF Odyssey

This talk is about pursuing a dumb idea to its extremes. In this case, the dumb idea was to scrape GIFs off Tumblr, play them back fullscreen, and beat-match them to music from Rdio. An instant GIF party, if you will. It’s been my hobby project for over a year, and covers a huge range of web technologies.

We’ll explore some of the things I’ve learned along the way. Such as:

  • How inflexible, inefficient the GIF format is, but how ubiquitous and beautiful GIFs themselves are
  • Writing a binary GIF parser in JS vs using Emscripten to compile existing C code
  • Different ways of detecting a GIFs pacing, rhythm and mood
  • Repurposing CloudFront to circumvent same-origin policy problems and proxy someone else’s CDN
  • Synchronising audio, metadata, GIFs and resources from 3 external APIs within a requestAnimationFrame loop
  • The incredible depth of audio analysis information available from the EchoNest API
  • Using Heroku and a few lines of NodeJS to refactor an external API
  • The potential of using a computer’s microphone to do ambient beat detection of music playing elsewhere in the room

I hope you learn something along the way too.

Andy Pliszka i

Test-Driven Development of Ember.js Applications

Ember.js is JavaScript framework for building feature rich and very responsive applications. This session will provide an overview of Ember.js and demonstrate test-driven development of single-page web applications.

In this session, I will present a walkthrough of Ember.js core features. I will showcase a test-driven development of Ember.js application using Jasmine. I will also explain Ember.js’ data bindings that allow for creation of views that update automatically in response to model changes. I will demo ease of Ember.js and Rails integration. Finally, I will utilize Ember.js components to create reusable UI elements.

In summary, Ember.js is a great framework for creating complex single-page applications. Attendees will leave the talk with a solid understanding of Ember.js test-driven development process.

Ryan Florence i

Bringing the Web Back to the Blind

Its the ’90s and you’re blind. The internet shows up, and as it has for everybody else, the world has at once gotten much bigger and closer to you. The content is inspiring and the interfaces simple.

A few years later some sites start to act a bit funny so you avoid them. Then a few years after that, many sites are completely unusable. The web begins to slowly disappear one bad JavaScript interface at a time. The world begins to shrink and get farther from you.

It’s 2014 and you’re a web developer. You add alt tags to images and order your headings but have never heard of aria-labelledby or closed your eyes and used a screenreader. It is time for you to level up and bring the web back to the blind.

Join me and my screenreader in a dark room as we talk about fundamental accessibility strategies and learning resources.

Ryan Anklam i

Adding Even More Fun to Functional Programming With RXJS

With the rise in popularity of functional programming lately new ways of writing concise and expressive code have emerged. Reactive JavaScript (RXJS) is one of these and takes functional programming a step further by turning events and asynchronous calls into compostable data streams.

Focusing on how we use RXJS at Netflix, this session will show attendees how to use the 5 pillars of Functional programming: map, mergeAll, filter, reduce, and zip and how they are superior to their imperative counterparts. Attendees will then learn how to use Observable objects to put the “reactive” into their functional code to write code that will react to asynchronous calls and events using the RXJS library.

Brandon Hays i

Using TDD to Tame the Big Ball o' Mud

You have it in your codebase. You’ve tried to clean it up. Heck, you may have written it. It’s the Ball of Mud.

It didn’t start out that way. You just wanted to add some nice interactive functionality to your website. But then one jQuery plugin turns to three, you add a dash of statefulness, some AJAX error handling, and here you are, unable to sleep at night.

But your client-side ball of mud can be tamed! We’ll walk through test-driving a refactor until the code is understandable, usable, and extensible.

We’ll use Ember Components, though the pattern holds for the framework (or no framework) of your choice. It’s time to get excited, not exasperated, when asked to add advanced client-side interactions to your website.

Liz Abinante i

JavaScript: A Gateway Language, or, Why You Should Teach Your Kids JavaScript

When we talk about JavaScript, we’re not really talking about JavaScript: we’re talking about JavaScript and its various libraries, frameworks, and compilers. JavaScript is a gateway language for new technologists, providing a large amount of functionality spread across numerous libraries, growing in complexity with the students’ skill. Prepare your children for Skynet: teach them JavaScript.

Jeff Whelpley i

JavaScript SEO (the "right" way)

In the future, search engines may be smart enough to understand how to index JavaScript single page applications (SPAs). That is not the case today, however. Solutions based on PhantomJS do exist to help get your SPA indexed, but there is a big difference between simply getting indexed and actually ranking high in Google’s organic search rankings.

The “right way” to do SEO for SPAs requires building a complimentary server side application that renders content for search engines and pre-renders initial page loads for users. This talk will provide an overview of the challenges of SEO with single page applications, an explanation of why many common solutions out there are not sufficient and details of how you can implement a full stack JavaScript solution that rocks.

Todd Gardner i

Traces of Errors: Getting Better JavaScript Stacktraces

The web is full of broken JavaScript: broken forms, browser fragmentation, interaction race conditions, and malfunctioning API’s. The lack of quality is approaching crisis: we’re losing users, losing customers, and losing credibility.

Let’s write better JavaScript. Let’s find and debug our errors. The first step is to understand them. We’ll discuss JavaScript Error object in detail: How to use errors, how to catch them, and how to understand them. The asynchronous capabilities of JavaScript pose challenges to error handling that confuse many developers, so let’s talk about some techniques to deal with errors across asynchronous boundaries. I’ll also share some tips to improve the maintenance of your JavaScript applications.

Let’s fix our bugs!

Jamund Ferguson i

Error Handling in Node.js

At PayPal I’m working with a lot of people who are new to node.js. A big issue my team has run into is how to sanely handle errors in node./express. I want to talk about some common (and maybe some less common) ways to handle errors across the stack. We’ll look at patterns for dealing with synchronous and asynchronous errors and talk about when and where they’re appropriate. Mostly this will be about JavaScript, but we’ll touch a bit on logging and other aspects of error handling as well.

Lots of code. Lots of real life examples. Should be useful to anyone working with a large team on a large node code base.