HTML5 Developer Conference header

Sessions

Get the HTML5 Developer Conference App by:

Joyvent logo
Get it on Google Play Get it on the App Store

"How fast are we going now?"

Speaker: Steve Souders - Google

Front end developers have had visibility into web performance since the release of Firebug and YSlow back in 2006-2007. The momentum behind web performance has grown, steadily marked by many high points including the publication of High Performance Web Sites (cough), the growth of the Velocity conference, the formation of the W3C Web Performance Working Group, numerous browser optimizations, and the rise of an entire industry around Web Performance Optimization. So, is the Web any faster now than when we started? The answer is probably "no". Join Steve Souders as he looks at trends in web performance, and debates the merits of this sisyphean task.

Slides Video

"Setting disruptors to stun!"

Speaker: Christian Heilmann - Mozilla

When the web came around it shook the foundation of IT at that time. World wide distribution independent of platform and environment? People allowed to write code without having a degree, a beard or suspenders? Unthinkable! Now we are the mainstream and the pendulum swings the other way - we are the disruption target and we lose our users to closed, specialised environments. Or do we? There is nothing stopping you from dazzling audiences with web technologies - all you need to do is to get back some of the excitement we felt when we fought the machine. In this keynote Chris Heilmann will show how you can get your web mojo back and reach a market of millions of new users that will be available to you this year. All you need to do is to give your web apps more love and stop trying to copy what you cannot deliver.

"WebKit Rendering: Overview for HTML5 Developers"

Speaker: Ariya Hidayat - Sencha

WebKit is an open-source rendering engine for many popular desktop browsers, application run-times, and mobile devices. Do you ever wonder how WebKit pulls the bits off the server and converts them into visible pixels on the screen? Do you want to know how WebKit takes advantage of modern graphics system for hardware-accelerated animation and other effects? This session will show you a different take on WebKit and give you an insight on how to leverage WebKit to assist your HTML5 application development and performance workflow.

Slides Video

"Making The Web Rock: The Web Audio API"

Speaker: Chris Wilson - Google

In this session, Chris will talk about the audio in the web platform, and demo the exciting future of music and gaming audio on the web.

"Let Grunt do the work, focus on the fun"

Speaker: Dirk Ginader - Google

Slides Video

"Fun and Flair with CSS3 Animations"

Speaker: Alexis Goldstein - Aut Faciam

CSS3 provides a number of ways--from simple transitions to complex keyframe animations--to add a bit of flair and pop. From animating movement and rotation of existing site elements on user actions, to a complete cartoon-style animation, the new CSS3 animation techniques are a great way to use web standards to add a bit of fun to existing sites. This talk will review several examples of how to enhance an existing site with simple but lively animations that will work in modern browsers, but not take away from the experience in older browsers that do not support the newest features.

"Building Web Applications with Ember.js"

Speaker: Yehuda Katz - Tilde, Inc.

You know that Ember.js is a framework for building interactive front-end applications using JavaScript. But what does it mean to build a web application using Ember? In this talk, Yehuda will talk about how Ember helps you build applications that are fast and responsive, but also fit right in on the web platform.

"Three keys to successful Single Page Web Applications"

Speaker: Josh Powell

Single Page Web Applications are the next step in the evolution of the web, where hyperlinks join information to information, instead of page to page. The entire page, including the navigation and supporting framework, loads one time and subsequent requests for data are cached in the client and the client becomes responsible for the business logic of the application while the server's role is focused on authentication, validation, and data persistency.

In this talk, you'll discover techniques for developing single page web applications that are applicable to every framework and learn 3 important keys to developing an SPA that are different from traditional web development. You will also learn four unique challenges that have derailed otherwise successful single page web applications and how you can be your team's hero by avoiding them. While the talk will delve into some technical details, expertise in web programming is not required.

"microformats2 & HTML5: The Next Evolutionary Step For Web Data"

Speaker: Tantek Çelik - Mozilla

New HTML5 elements and microformats give us a simple way to represent web data without additional URLs, file formats, or callbacks. Microformats2 and HTML5 improvements bring better accessibility, simpler markup, improved semantics, and a direct mapping to JSON APIs for data consumers.

Millions of web sites use microformats to make their data available. Other approaches have emerged as well (e.g. RDFa, microdata, OGP, schema, Twitter Cards). Tantek will discuss which microformats to use for search engines and for public APIs.

"Performance Checklist for the Mobile Web"

Speaker: Colt McAnlis - Google

What's fast on desktop won't be fast on mobile. This talk provides the programmer's check-list of performance problem that your HTML5 apps will see when moving into the mobile ecosystem. We'll tackle popular problems with Tooling, Networking, Computation, and Rendering performance, and give developers actionable items to improve their app performance immediately.

"You Can't Build a Movement Alone"

Speaker: Diane Bisgeier - Mozilla

Why mozilla is positioned to help build a movement out of HTML5 for mobile.

Slides Blog

"HTML5 vs. Native When using a Backend as a Service"

Speaker: Bryan Klimt - Parse

There is a lot of chatter these days about whether to make a native app or HTML5 frontend when creating an application. While HTML5 can be easier to launch quickly across multiple platforms, native apps can provide greater control over your end user experience. With the rise of backend as a service in the developer world, one challenge is deciding whether HTML5 or native is right for your app. This talk will discuss the benefits and drawbacks of both native apps and HTML5 apps and present solutions for every tier of developer based on our extensive experience as a leading BaaS provider.

"Extending Boomerang"

Speaker: Philip Tellis - SOASTA

When we built boomerang at Yahoo!, we planned on it being a generic beaconing system with different payloads attached by plugins. We published an API, and wrote plugins to measure page roundtrip time, network throughput and latency. We received other plugins from Yahoo! to measure IPv6 and DNS latency, and then nothing happened...

Until one day, a certain Mr. Brewer submitted a NavTiming plugin. As it turns out, people were using boomerang in-house, and creating their own plugins that were never published.

In this talk, we’ll go over the basics of writing a boomerang plugin to measure anything you need, some best practices involved with writing plugins, and examples of third party plugins that others have written.

"Rapid HTML5 Prototypying"

Speaker: Garth Braithwaite - AdobeXD on Brackets

Visual comps lie and interaction details slip through the cracks. Instead of relying solely on static designs the Brackets team has been making use of html interactive prototypes to communicate design.

In this session we'll look at how to best go about utilizing html as a design tool.

Build interactive prototypes to make friends and then bend them to your will.

"Making Sense of the Flood: Data Visualization in the Browser"

Speaker: Rob Larsen

We're awash in data. Making sense of that flood of information is impossible without the aid of visualizations to simplify the information, amplify the important points and educate at a glance. The web has two main technologies for working with interactive visualizations: SVG and Canvas. This presentation will outline the optimal use cases for each, will talk about the current state of each technology and will show detailed examples of each in action.

"Video in the Open Web Platform"

Speaker: Philippe Le Hegaret - W3C

HTML5 adds support for video by introducing a dedicated element, the video tag, as well as at various methods to manipulate its playback. As such, it makes video a first-class citizen of the Web, completely integrated within HTML and its adjacent technologies, such as CSS or SVG, while enabling proper accessibility capabilities. This initial support is now being extended to accommodate more use cases, such as live streaming or video conferencing. Starting with the basics of HTML5 video, this presentation will look at the ongoing work happening in the video in the Web space including real time, captioning and protected content.

"pushState to the future: How to speed up without slowing down"

Speaker: Todd Kloots - Twitter

Managing state on the client has been a pain point for developers since the early days of AJAX-driven applications. pushState (part of the HTML 5 History API) provides a near-complete set of built-in tools for managing state in the browser. And the browser support for pushState makes it easier than ever to speed up in-site navigation using Progressive AJAX (PJAX) without having to redesign your frontend architecture around client-side rendering. Of course, like all DOM APIs, the History API is also imperfect. But then, what's a talk about DOM APIs without mentioning shortcomings and workarounds?

Slides

"Browser Versions Are Dead"

Speaker: Kyle Simpson - Getify Solutions

As a web developer you're surely familiar with the "IE6 Must Die" mentality of blaming old browsers (and their users) for what's holding back our industry.

But are they really to blame? Maybe not. I think what's mostly to blame is a series of lies about how browsers and sites and users interact, that we've now come to believe. We need to take a step back and rethink how we approach browsers and versions and how we develop sites/applications for them.

It's time to admit our obsession with browser versions so we can move past it. It's time we stop looking 10 years in the rear-view mirror. It's time to admit that we ourselves hold some blame for holding back our industry. It's time we start to retrain our bosses, clients, and marketing/sales departments on how our web platform really works.

When we do, we'll fully unleash our potential on the latest and greatest our platform can deliver!

Slides

"Hey underscore, you're doing it wrong!"

Speaker: Brian Lonsdorf - Looprecur

Underscore offers many tools from the functional paradigm including map, filter, reduce, take, drop, compose, and many more.
Except that in underscore, these functions are unnecessarily verbose, less generic, and don't compose well.
I aim to convince you of that contention and offer some solutions. I'll review all the FP basics for newcomers, but also try to touch on some heavier theoretical concepts as time allows.
Come join me if you dare to test the murky waters of the functional world.
Slides

"Moving Standards Forward, Faster"

Speaker: Bear Travis - Adobe

As HTML, CSS and JavaScript have each advanced to provide a richer development environment, the standards on which they are based have grown increasingly complex. This talk examines how standards are evolving, balancing the desire to define a cohesive, comprehensive toolset with the need to match the frenetic pace of progress on the web.

"Using Node.js to Build Great Streaming Services"

Speaker: Tom Hughes-Croucher - Change.org

Slides

"Intro to scaling your web app on the cloud with AWS"

Speaker: Mauvis Ledford - Pathbrite Inc.

In this talk we distill 1.5 years of building and scaling web applications on the biggest and oldest cloud provider: Amazon Web Services. We discuss the various moving parts of AWS and how they're beneficial, some open-source counterparts that you can mix and match with, and how to set things up the right way from the start so that you won't end up with a big mess a year down the road. Though we will touch upon advanced topics such as Autoscale and Elastic Load Balancer, this talk is geared toward front-end developers who want a better understanding of what cloud environments actually are and how to properly harness them.

Slides

"Built to Last: Modular JavaScript Design Patterns"

Speaker: Dan Lynch

Design on a scalable, state-based, front-end application architecture to manage business logic and control flow. We'll synthesize a number of programming patterns to help you decouple not only views and data, but also navigation paradigms and transitions between states to keep your product agile and moving forward without having to refactor.
Slides

"Client Side Package Management"

Speaker: Domenic Denicola - Lab49

One of Node.js's most important features is its package manager, npm. It's widely lauded for its successful model of local dependencies, small and focused packages, and the ecosystem it has encouraged. But what about the browser? What about HTML5 “packages”?

There have been a number of ill-fated attempts to solve this problem over the years, but none have reached critical mass. Browser package registries sputter along at a hundred, maybe a thousand packages, mostly written by a small cadre of authors invested in that particular packaging solution. But recently, the obvious solution has become hard to ignore: just use npm itself!

Given Node.js's focus on small packages, it's no wonder that many packages in npm work equally well in the browser. And a growing number of authors are publishing their client-side components to npm as well. This talk discusses how npm's standardized format, with a package.json and CommonJS modules, is actually perfect for browser use, and how I and others have used it successfully on several large enterprise-scale projects.This has impressive implications for code reuse between projects, as well: once client-side package management becomes as simple as that of Node.js, it becomes much easier to decouple your application into separate reusable packages that can be shared among projects or even open-sourced.
Slides Demo (GitHub)

"Holistic UX - Interaction patterns for the Web of Apps"

Speaker: Brett Van Zuiden - Filepicker.io

Given the plethora of apps and services that your users work with on a daily basis, best of breed applications will need to take into account not only the user experience inside their app, but also how their app interacts with the rest of their user's digital world. We'll examine what holistic UX looks like, identify best practices, and important questions to consider when designing your application.

"Get off my Internets - writing for the offline web"

Speaker: Parashuram Narasimhan - Microsoft

Web applications have gone where no site has been before - they are on tablets and mobile phone and even as apps on operating systems. These are places where internet connectivity is not guaranteed. Join Parashuram in this session where he tries to convince you to write web applications that work without the web, look at some libraries to make your life easy and look at performance comparisons of various offline operations. At the end of this session, you should be able to take your existing web application, unplug and gracefully fallback for an offline experience.
Slides

"Surviving Robots and Old Browsers by Server-side Backbone"

Speaker: Lauri Svan - SC5 Online

Writing single page applications that respect all web browsers and crawlers should be easy. Still, many end up rewriting their single page application with a server-side templating language, too and get trapped to maintaining two codebases.

With the emergence of server-side JavaScript, the “holy grail” of running the same app code on both ends seems attainable. Frameworks like Meteor, Derby and Yahoo Mojito have done it, and the efforts of AirBnB and Backbone LayoutManager bring it closer to Backbone developers, too. Still, the current approaches make such assumptions on the backend or enforce such constraints on the programming model that an old-fashioned Backbone.js developer cannot take them in use.

This talk compares the approaches for the “holy grail”, particularly from a Backbone application developer’s perspective. In addition, it presents a programming model by which pretty ordinary Backbone applications can run on both ends. The presented approach works for web crawlers and could have limited use for dumb browsers, too.

The talk is technical, with the primary audience being single page app developers planning to move their app server-side. The audience will benefit from previous knowledge of Backbone.js.

Slides

"Javascript - The Real Bad Parts"

Speaker: John K. Paul - Avagen Ventures

Douglas Crockford’s book “Javascript: The Good Parts,” is one of the best selling javascript books of all time and is only 176 pages long. For most developers, there’s an tacit belief that the rest of Javascript falls under “bad,” especially when comparing that to the 900 pages of “Javascript: The Definitive Guide” There are websites dedicated to these list of language mis-features and anti-patterns, and dozens of blog posts about how to avoid the “bad” in your own code.

I don’t think that these most of these things are actually “bad”. In their day to day, developers don’t need to worry about all of these smaller issues. Chances are, a javascript developer has encountered these difficult issues, learned the solution, and then immediately absorbed the concepts.

I’m going to explain to you, the real “bad” parts of the language. These are at least three javascript language features that are the most likely to trip up a javascript developer. Once you innately understand these three issues, you will become significantly more productive in javascript, and will be a lot less confused when reading through large javascript code bases.

I’ll be walking you through at least three concepts within javascript language semantics:
1) What on earth does “this” mean, and in what context does its meaning change?
2) How does prototypal inheritance work?
3) What is hosting? Why do I care what a function expression or function declaration is?

"WebGL For Game Development"

Speaker: Tony Parisi

This session with Web3D pioneer and 3D expert Tony Parisi will introduce WebGL game development concepts. Attendees will learn how to build a full, working WebGL application by creating a simple online game. Topics covered include graphics, animation, interactivity, 2D/3D integration, production tools, lean development methodologies, and practical deployment issues.
Slides

Bridging the Gap from Web App to Mobile App

Speaker: Paul Fischer - Intel

While HTML5 is very useful as a cross-platform application development tool, the process required to move from a “web app” that is served up to browsers by your web site to a “native device app” (aka “hybrid app”) that can be installed from an app store and run directly on a phone or tablet is something that many HTML5 developers struggle with. Paul will explore what is required to get from a “web app” to a “device app” and some of the ways to make that happen using Apache Cordova libraries (aka PhoneGap).

"Integrating (the upcoming) Modernizr 3 Into Your Workflow"

Speaker: Alex Sexton - Bazaarvoice

Modernizr is growing up. Many devs rely on the "official" tests as well as a slew of "community" tests to get their jobs done. In the next version of Modernizr, we're trying to tackle performance, integration, and comprehensive test coverage. This talk will go over why you might want to use Modernizr in your app, how to best integrate with it, as well as show off the "behind the scenes" in the upcoming new version.

"Web apps help ship faster but watch out for these gotchas"

Speaker: Liyan David Chang - Filepicker.io

The power of web and mobile web apps is that you can ship fast and iterate rapidly. While the ability to ship faster is a blessing, developers need to watch for constraints that will negate this benefit. The talk will touch on specific examples of some of these constraints and possible solutions:
  • Dealing with cross browser compatibility
  • Traffic shaping
  • Building libraries and language specific bindings that need to be maintained and supported
  • Managing the support organization
  • Prioritization process for features
Slides

"Sane Async Patterns: PubSub, Promises, and AMD"

Speaker: Trevor Burnham - HubSpot

From user interactions to resource loading, modern JavaScript apps are loaded with async processes. Managing those processes without losing your sanity can be a challenge. This talk is about best practices for dealing with async tasks. We'll go through several common problems in rich JavaScript applications and find out how to solve them with minimal boilerplate code, a responsive UI, and solid error handling.

Slides

"SVG Filters: A Guide for the Perplexed"

Speaker: Michael Mullany - Sencha

SVG image filters are now available for the first time in edge browsers on both desktop and mobile! What's in them and how do you use them? This talk will walk through the SVG filter toolbox with detailed code samples. I'll demonstrate color manipulation, image sharpening and blend noise effects and textures into your images and SVG content. We'll cap it all by reproducing some popular Instagram filters and Photoshop effects using pure SVG.
Slides

"Stronger, Faster, Cheaper: Building HTML5 Apps with a BaaS"

Speaker: Tim Anglade - Apigee

Backends-as-a-Service like Parse, Stackmob, Kinvey or baas.io are the new hot thing. By packaging data storage, user management, file storage and other advanced features (social, geolocation, etc.), they can drastically reduce the time it takes HTML5 developers to build their mobile and web apps, and minimize the costs they’ll incur maintaining a server infrastructure. In this talk, Tim will cover how this class of tools came to be and how they work, explain how to structure your HTML and JavaScript code to maximize their usefulness; detail common problems & security issues you may encounter with a BaaS; and give specific examples of how real-world apps are using them, from Silicon Valley to Seoul.

Slides

"Augmented Reality in JavaScript"

Speaker: Zeno Rocha - Liferay

Discover how to integrate virtual information with real world visualizations by using getUserMedia API to work with augmented reality apps on the Web.

Slides

"Canvas Only: Creative Coding with HTML5"

Speaker: James Stone

Are you interested in creating cool games or interactions for web or mobile? Are you new to graphics programming and want to jump in and experiment. For many years artists and technologists have created amazing installations such as "Flight Patterns" by Aaron Koblin by using Processing (both a pre-processed language and api that sits on top of Java). Today the power and simplicity in syntax has been ported to the HTML5 Canvas in Processing.js.

Explore creating 2d and 3d graphics, data visualization, algorithmic art and image generation/alteration. Topics covered include: Processing.js, Paper.js, Three.js, Box2DJS and toxiclibs.js. Examples will be shown in Processing, JavaScript and CoffeeScript and benefits and drawbacks of each approach will be given. Creating User Interfaces in the Canvas with Zebra.js will be explained as well as strategies for coding for a game style loop.

"Pro JavaScript Debugging"

Speaker: Ashutosh Sharma - Adobe

There are several tools and some not so well-known methods to debug JavaScript today. In this talk, I'll discuss modern techniques for debugging JavaScript. These include Source Maps, MutationObservers, DOM Breakpoints, Event Listener Breakpoints, Object.observe and Remote Debugging. In addition to providing useful tips and tricks for debugging JavaScript efficiently, I'll also discuss the Console API, lesser-known features of Chrome DevTools and its command line API, as well as browser tools to debug HTML5 features.

Slides Demo

"WebSockets: The Current State of the Most Valuable HTML5 API"

Speaker: Viktor Gamov - Farata Systems

If I had to vote for the most important HTML5 API, I'd select WebSockets. Shaving off hundreds of bytes of HTTP overhead and reducing the latency makes WebSocket worthwhile considering for any application. WebSockets is a new protocol that allows a bi-directional full-duplex communication as opposed to request-response HTTP model.

This session starts with a brief overview of WebSocket protocol, followed by the discussion of various AJAX alternatives for exchanging data with the server. We’ll talk about specifics of deploying WebSockets-enabled applications.

You’ll see some practical use cases and you’ll see for which types of application WebSockets is suitable. Finally I would like to cover how to integrate of a WebSockets-based module into the existing HTTP-based Web site.

"Realigning & Refactoring"

Speaker: Jina Bolton - Do

Often designers and developers see Markup and CSS Refactoring as a dreaded, monolithic task. Organization, architecture, clean up, optimization, documentation all seem tedious and overwhelming. However, if you're armed with the right tools and a solid foundation, you may find refactoring to be actually quite fun. Learn some Sass, markup, and documentation tips & tricks from a product designer's perspective. Start making refactoring a regular part of your design process and development workflows.

Slides

"Planning for the Horizontal - Scaling Node.js"

Speaker: Brandon Cannaday - Modulus

Node.js, being single-threaded and self-contained, lends itself very well to horizontal scaling, which is running several instances of the same application on one or more servers. Multiple instances provides a nearly endless amount of scalability, but requires up-front design considerations in order to be effective.

This talk covers how to design a Node.js application to easily scale to meet any amount of demand. We’ll take a quick look at the Node.js cluster module and how it can be used to maximize the resources of a single computer. Then we’ll look into multiple instances and how to properly load balance between them while maintaining session affinity, and what happens when you have to load balance the load balancers? Lastly we’ll see how to use Redis to store session and other data that can be shared between instances.

The ideas presented in this talk will apply to almost any environment Node is run under. This could be on your own hardware, cloud infrastructure services like EC2, or platform service providers like Heroku.
Video Slides

"HTML5 Goes Native"

Speaker: Jeffrey Burtoft - Microsoft

To this point in history “Native Apps” has been the domain of developers who use managed programing languages like objective C, C++ and C#, but that is all about to change. HTML5 and JavaScript have matured into a platform that extends beyond the web, into the realm of “Apps”.

From the pitfalls of developing in iOS and Android “webviews” to the pros and cons of delivering through PhoneGap, this session will survey the landscape of HTML5 development environments with a special focus on Windows 8, where HTML5/JavaScript apps live side by side with native apps, as a first class experience.

"Twig, and the new theme layer in Drupal 8"

Speaker: Jen Lampton - Jeneration Web Development

In order to overcome some of the shortfalls we encountered with our previous theme engine, we solved problems by creating a Drupal-specific combination of PHPTemplate and giant renderable "Arrays of Doom". Though the current solution is infinitely flexible for those who understand it - we've inadvertently produced a theme layer that is painfully frustrating to use, and very slow to learn.

Twig provides several huge advantages over PHPtemplate, including: Security, Performance (probably), and Ease of Use.

In this session I'll point out some of the specific problems we faced with PHPTemplate & Renderables, and show how these issues are being addressed through the move to Twig.There's still a lot to do, and some things we still haven't decided on yet, but we're definitely making progress. Come see what template files will look like in Drupal 8, and learn how you can get involved in making a better tomorrow for your favorite CMS: Drupal.
Slides

"Javascript Test-Driven Development that Feels Great"

Speaker: Toby Ho - Independent

While Test Driven Development (TDD) has gained acceptance as best practice in various programming communities, it is still just starting to gain traction in Javascript. One reason for this is the tediousness of manually opening and refreshing the browser; another is the sheer number of browsers we have to support - not only the handful of mainstream desktop browsers, but also the infinitely fragmented mobile landscape. Testem is a tool that exists to make TDD for Javascript a breeze, so much so that you will actually *want* to write tests. It not only streamlines your TDD workflow during development, but it also make it easy to run your tests in various browsers during continous integration.

Slides

"Modular applications with Montage Components"

Speaker: Benoit Marchant - montagejs.org

There is a growing demand to build increasingly complex mobile applications with HTML5, in part due to its cross-platform nature. However delivering these applications is still very challenging. The Montage framework was designed from the ground up to build complex HTML5 applications. This talk will explain how Montage’s reusable and encapsulated Components provides a natural and effective way to write modular, robust, applications by allowing team members to work on different part at the same time.

Slides

"Redemption from Callback Hell"

Speaker: Michael Jackson - HUM

Welcome to Callback Hell. Don't know how you got here? Neither do most of us. They told us we could just write asynchronous JavaScript APIs using callbacks. Forget about return and throw statements! Everything is async now, so just put your errors and return values in the callback! Just sweet, happy little callbacks calling callbacks all the way down the stack.

Ok, sure. But then it started getting complicated. We had an error that we needed to deal with somewhere further up the stack. Or maybe we needed to call several asynchronous functions in parallel and aggregate the results (that's something async API's should be good at, right?). And that's when we realized it: we were stuck in some god-forsaken callback. And so another callback goes on the stack...

But it doesn't need to be like this. You can learn to build fully asynchronous APIs in JavaScript that do not rely on callbacks. Instead, you can get back to using functions as arguments when you actually need them, like in a map or filter. It's going to take a little bit of rethinking the problem, and probably refactoring some of your existing code, but we'll get there!

Slides

Prototyping Data Visualizations with d3.js

Speaker: Ian Johnson - Lever

In this talk I will take you through the creation of a data visualization using d3.js and html5 web standard technologies including SVG and CSS. I will focus on the process of using these technologies to communicate a story found within a dataset. By the end of the talk I wish for you to have an appreciation of what data visualization can do and how you can do it with the technologies available to you.

"HTML5 Cross-Platform Game Development: The Future Is Today"

Speaker: Iker Jamardo - Ludei

HTML5 is finally ready for cross-platform game development. We'll explain best practices for HTML5 game development, case studies and how to overcome issues to make HTML5 games work.
Slides

"CSS Art! Styling a Stylesheet with Style"

Speaker: Bernard De Luna - Estante Virtua

It's no secret that CSS is really easy to code.

Each day we have more features and charms. Also, new techniques to get the best out of this friendly styling language.

See how to develop style sheets, enjoying full advantages of browsers, always focusing on modularization and magic.

All with great style.

"Introducing Rendr: Run your Backbone.js apps on the client and server"

Speaker: Spike Brehm - Airbnb

Have you ever ever had that sneaky feeling that the way we build webapps today is broken? Either build a snappy JavaScript app, or serve SEO-friendly HTML. Either optimize for initial page load performance, or rich user interactions. Write currency and date formatting twice, in two different languages. Render some of the page in Rails, and then tape it together with JavaScript.

Spike is here to tell you it doesn't have to be that way. He'll introduce Rendr, Airbnb's open source library for running Backbone.js apps seamlessly in both the browser and in Node.js. With Rendr, you write your entire application in JavaScript: views, models, collections, controllers, templates, routes. In the client, your app re-renders in response to pushState events, changing the URL as the user navigates. But hit refresh, and an Express server uses the same code to generate the exact same page. Now, you too can use Rendr for fun and profit.
Slides

"I can smell your CMS"

Speaker: Phil Hawksworth - R/GA

The word is getting out. Great web site experiences require careful development and crafty execution in the front end. Squeezing every drop of performance out of your user's browser is tough, but Steve Souders and friends have mobilized an army, and we are all having a bloody good go.

But there is a common threat to doing great work in the front-end. It lurks in the back-end and clients love it. It's the content management system, and more often than not, it stinks.

We'll look at examples of the damaging traces CMSs leave behind in the front-end and at how we might work to reduce them. We'll find ways to fight for what matters in a CMS, and ways to avoid the smell of your CMS wafting over to the user and sacrificing the craftsmanship of good front-end engineering.

"Web Motion: Leap Motion in a Web App"

Speaker: Bill Fisher - Hot Studio

Bill Fisher will present his experimental work with the Leap Motion Controller, and show how to achieve motion capture interactivity in a web application. Further, after providing a brief overview of the current competitive landscape of motion capture controllers, Bill will also discuss the current state of browser UI events, ranging from click to mouse to touch to pointer, and discuss how our post-touch future of motion capture controllers might best integrate with web standards.

#webmotion
Slides GitHub

"Making Peace with Twitter Bootstrap"

Speaker: Melanie Archer

You were persuaded of the advantages of this popular CSS framework--until you used it on a project. Find out why your expectations for Twitter Bootstrap didn't match your experience with it. Learn how to adapt to styles you didn't develop yourself. Sign a truce with Twitter Bootstrap and other CSS frameworks.
Slides

"Design at Scale: Techniques for great UX development across large organizations"

Speaker: Dan Harrelson - General Electric

It is hard to build good software, really hard. Doing so at scale is even more challenging. Add in the requirement that apps be well designed with a consistent UX and most organizations find failure. In this session you will get a rare glimpse into the platforms, frameworks, processes and techniques that GE uses to build software. Take a deep dive into our technical architecture, based on modern web development frameworks. Learn about the techniques used to support a community of 14,000 global developers. Learn about the challenges in running apps both on the cloud and embedded into devices.

Slides

"Using components to build native-quality HTML5 apps"

Speaker: Gray Norton - Enyo

HTML5 is a great way to develop cross-platform apps, but if you're aiming for native-quality polish and performance, you can't build apps the same way you build websites. In this talk, we'll explain why it takes more than HTML templates and UI plugins to deliver a native-quality user experience. Walking through examples from a simple Slider to a smooth-scrolling virtualized List, we'll show how a component model like the one in the Enyo framework not only delivers better-performing apps, but also makes it easier to maintain and reuse your application code.
Slides

"Beyond Bootstrap"

Speaker: Jason Wilkens | Josh Carver - Bizo

Bootstrap provides a clean, sleek front-end framework for design. But now we’re faced with a clone army of sites, all using the same buttons, toolbars and boring gray boxes. Learn to fight the dark-side by going beyond Bootstrap. Targeted at developers looking to improve their design and/or front-end skills, this talk will show you how to use Bootstrap as a starting point for your projects rather than a final design. Topics covered include: applying layouts, typography, custom components and more.

"Using SVG in Production"

Speaker: Jamund Ferguson - oDesk

SVG seems like a great solution to all of our retina woes, but it turns out that it presents its own set of problems and annoyances.

I'll share with you some of my experiences in ditching PNGs in favor of SVGs at odesk.com and all of the hoops you'll need to jump through and tools you'll want to use to make that work on your own site.

By the end of this talk you'll know all about Mime Types, EMs, data-uris, spriting, and falling back to PNG in a pinch!

"Single Page Applications - Hard-Won Lessons For Development At Scale"

Speaker: Michael S. Mikowski

My presentation builds on the speech I gave at the October HTML5Dev Conference. In that speech, I detailed how JavaScript is implemented in popular browsers, dispelled many misconceptions, and provided techniques we found necessary for successful development of SPAs. This prior presentation will be made available to the audience for off-line reading. (As an alternative, I also could also present that speech if you wish).

The techniques are presented as a quality initiative, with each step considered in turn. Highlights include:
  • What "development at scale" means
  • Adding structure where there is none - JS Code standard for large teams
  • A proven architecture refined over 5 large-scale commercial SPA's
  • Module namespacing and parallel CSS and HTML namespacing
  • Exception handling strategies
  • Unified checking of named arguments
  • Unified logging
  • The Publish / Subscribe component of asynchronous models to avoid nested-function-hell
  • Sophisticated URI management
  • Regression testing using node.js and js-test-driver
Many of the techniques are detailed in my book, and the presentation should be an excellent introduction and complement to that text.

"Standardized Realtime Events with EventSource"

Speaker: Burak Yiǧit Kaya - Disqus

Let’s say you’re developing a realtime application. Your first instinct? You’ll probably look at WebSockets, which after years of competing implementations and specification changes, has emerged as the standard technology for realtime communication in the browser. But what many developers may not understand is that WebSockets presents a complicated protocol that transmits unstructured data without any guidelines. And for most realtime applications, it’s total overkill.

Introducing server-sent events (EventSource), a new HTML5 browser feature that provides a JS API for consuming push events that are transmitted from a real-time source. Implementing SSE is incredibly easy. SSE sources are simple, long-lived HTTP connections. And listening to those sources is as simple as calling addEventListener.

In this talk I will walk the audience through the problem and demonstrate the shortcomings of WebSockets, and why it’s overkill for most realtime applications. Then I will introduce the EventSource object, perform a live demo, and show how much people can do more with less code. I will also introduce a polyfill for EventSource to work on older browsers (IE9 and below).

"Creating the interfaces of the future with the APIs of today"

Speaker: Luz Caballero

Recently we've seen some very powerful new APIs bring exciting capabilities to the web. In this talk I'll show two demos in which some of these new APIs are used to create some futuristic interfaces, a head tracker and a Wii-like remote that control two 3D models. We'll go step by step through the code, and talk about the tips and tricks you'll need to know to use these APIs in real life applications: browser and hardware support, polyfills, fallbacks, etc. APIs we'll cover: getUserMedia, device orientation, WebGL and web sockets. Libraries we'll cover: Three.js and headtrackr.js.
Slides Demo Code

"A Baseline for Web Performance with PhantomJS"

Speaker: Wesley Hales - Apigee

HTTP requests, heavy/unminified resources, reflow, and UI thread blocking should be on the mind of every front-end developer. These are just a few issues that can cause serious bottlenecks in page load times. Having a faster load time equals better search engine rankings, higher conversion rates, and an overall reduction in bandwidth costs.

How do we measure all the aforementioned performance killers? How can we bring these measurements into our automated build process to ensure that our site is getting better, and not worse?

PhantomJS, a headless WebKit with JavaScript API, gives us the ability to create lightweight performance measurement tools with JavaScript (and so much more). In this talk we’ll review how PhantomJS was put into the automated build for CNN.com and steps that were taken to immediately improve performance of a top ranking site. We’ll look at how other open source projects such as WebPageTest.org measure up to this approach and see when one might be better over the other.

"Building a 3D Physics Engine in JS that can control DOM at 60FPS on Mobile Devices"

Speaker: Steve Newcomb - Famo.us

Last year Steve walked us through the amazing "lessons learned" journey his team went through. His small team of engineers decided to ditch their original startup idea to dedicate themselves to solving performance for HTML5. He showed a demo of a 3D JS rendering engine capable of 60FPS on mobile devices without the use of any plugins, WebGL, Canvas or even CSS3 transition primitives. This year, Steve takes it to the next level and walks us through what it took for his team to build a 3D HTML5 physics engine. What makes this special? We've all seen physics with WebGL or with Canvas and we've all seen these demos on computers - but Steve will be demoing everything rendering to DOM and everything will be done on a mobile device. As always, Steve brings a lot of energy, lots of lessons learned and does it all by engaging the audience with demos you can try on your own devices.
Slides

"Using HTML5 on top of an existing business architecture. Tips and Tricks"

Speaker: Gregory Menvielle - Intel

Startups have it good; They do not have to worry about legacy systems, existing code, and business drivers when launching their apps. If you are using HTML5 for new initiatives in an existing business you know the rules of the game are different. We will go over some of the key elements you need to put in place to successfully use HTML5 with your existing systems without having to start everything from scratch.

"Data & Applications Across the Void :: Distributing Systems"

Speaker: Adron Hall

Today distributing applications is relatively easy, until you get to the data side of things. This is where the complexity in most applications comes into focus, where does the data go? How do I replicate or synchronize the data? How do or where do I cache data? What are the geographic issues with data in one place and applications in another? How does the gravity of the data affect my application?

This talk will hone in on key details around implementing a true distributed system across geographically dispersed areas and how to provide the end user a solid synchronized experience while using the application. Examples will be provided with hybrid computing solutions and distributed software solutions including Riak, PaaS Deployment packaging and other key technologies."

"Maintainable JavaScript"

Speaker: Nicholas Zakas

Maintainable JavaScript tackles the difficult problem of writing code as part of a large team. When you’re writing code that only you will change, there aren’t any issues. As soon as you’re writing code that someone else is going to also be changing, you need to think harder about the decisions you make. Will another developer be able to understand what you did? Did you organize your code in such a way that it’s easy to adapt and extend? Long after you’re gone, will others be able to continue using the same code, or will it need to be rewritten because no one understands it? This session shows the best practices used by teams to ensure their JavaScript is as maintainable as possible.

"Multi-platform HTML5 mobile games - Lessons learned"

Speaker: Jiri Kupiainen

Lessons learned from building and shipping HTML5-based mobile games on multiple platforms. What to do, what *not* to do, and what lies ahead.

"1996 Called; It Wants Those Audio and Video Tags Back"

Speaker: Kent Brewster - Pinterest

Part design, part code, and part black magic, the art of including subtle yet interesting sound and animation on Web pages hasn't advanced all that much since 1996. (It sucks, and we skip past it or turn it off as soon as we possibly can.) In this talk I'll show how I made the non-annoying sound, animation, and bonus video Easter egg for Pinterest's holiday microsite, 30 Days of Pinspiration. Technologies discussed: audio, video, animation, data URIs, keyframes, gradients, media queries, and dealing with ancient browsers.

"Getting Started with Responsive Web Design and Edge Reflow"

Speaker: Brian Rinaldi - Adobe

Everyone seems to be talking about Responsive Web Design lately, with popular sites such as Mashable have declaring 2013 the year of responsive web design even though RWD is relatively new, being only a few years old. In this session, we'll cover what RWD is and the problems it is trying to solve. We'll look at some templates and frameworks intended to make it easier to get started. Finally, we'll look at Edge Reflow, a new tool released as a preview by Adobe that helps you build responsive designs visually.

"Your Code Sucks: Best Practices for Enterprise JavaScript Applications"

Speaker: Arthur Kay - Sencha

JavaScript is the cornerstone of most HTML5 web and mobile applications, and yet few developers truly understand how to architect their code for performance, stability and scalability. In this session we'll cover advanced JavaScript topics: 1) improving application performance, 2) increasing code stability, 3) scaling the application for the enterprise. We will also: - showcase development tools everyone should use, - offer advice on implementation techniques, - make you a better JavaScript developer. Think your code doesn't suck? Think again.

"Architecting and Visualizing an Enterprise Risk Management: Solution Technologies, Tools and Visualization Mechanics"

Speaker: Senthil M. Kumar - RMS

Architecting a World Class Enterprise application over the cloud that deals with Big Data and intense computational analytics presents a multitude of interesting technical challenges. Hop on to this session to discover how we are solving it using modern web technologies, the visual metaphors we are developing, collective intelligence, multiple devices support and the structural choreography that chains this all.

"The Front End Revolution"

Speaker: Hampton Catlin - Moovweb

I've spent my career empowering front end developers (e.g. Sass, HAML) and I'm not even close to done yet. The front end is different than the backend and I am here to propose an entirely new approach to the problems we face on the front end, which are distinct from the traditional back end solutions you are used to. Traditionally minded programmers welcome, but this talk is a siren song for those whose main weapons are HTML, CSS and maybe a touch of Javascript. The only way to do this right is to break convention and go with what just simply works. Let's start a front end revolution!

"Remedies For Back Pain: Scaling Backbone.js at SoundCloud"

Speaker: Darrell Stephenson - SoundCloud

Over the past year and a half SoundCloud went full-steam ahead re-imagining our entire site as a single page Javascript application based on Backbone.js. This new version launched in December and is currently being used daily by millions of users around the world. Given the amount of competing frameworks, libraries, and approaches to single-page apps this approach shows no signs of slowing down. However, before going forward we should recap what we've learned so far. What kind of things have we had to invent / re-invent? Where do the basic abstractions leak? Where does HTML5 fall short? What are the performance advantages / disadvantages at scale? This talk will show the bruises and badges we've collected and ultimately answer the biggest question: would we do it again?

"Cross-Platform SVG and keyframe animation, give up those nasty spritesheets"

Speaker: Ben Savage - Spaceport.io

When it comes to rendering game assets on mobile devices, developers don't have many choices. Either use Bitmaps for everything or 3D models. There is another option though, scalable vector graphics.

Up until now this hasn't been a very legitimate option. Performance has been terrible, and there isn't a good set of mobile libraries for working with SVG. Ben Savage and the team at spaceport.io Inc. have spent years perfecting a system for rendering GPU accelerated SVG and keyframe animations on mobile devices. By converting assets created with popular tools like Illustrator and Flash Professional to 2D triangle meshes, they have unlocked the ability to use one set of assets for all screen sizes and resolutions. From tiny download size, to ease of creation, SVG is the ideal choice for 2D mobile games.

Ben's session will discuss the technical details of how Spaceport converts SVG files to vertex buffer objects (VBOs), and the challenges they faced creating the system.

"Building Killer HTML5 Apps with The Parse JavaScript SDK"

Speaker: Mattieu Gamache-Asselin - Parse

This presentation will walk the audience through creating a simple Parse-powered HTML5 app using the JavaScript SDK. The Parse JavaScript SDK is based on the popular Backbone.js framework and is compatible with existing Backbone applications with minimal changes on your part. Our goal is to minimize configuration and let you quickly start building your JavaScript and HTML5 apps on Parse.

"HTML5 Game Development - Myth vs. Reality"

Speaker: Joe Monastiero - Ludei

In this presentation, I will attempt to explain clearly the current state of the industry regarding the reality of using HTML5 to build compelling, monetizable games. 2012 offered a lot of noise, both positive and negative about HTML5 development, but not a lot of actual products. Will 2013 be the year that HTML5 gaming breaks through?

"Carrier App Stores Impacting the Mobile Ecosystem"

Speaker: Scott Teger - Playphone

This session tells you how to solve the discovery and monetization hurdles for your HTML5 game apps. You’ll learn why major global carriers with 100s of millions of players want your HTML5 game app; how their upcoming app stores are poised to rock the mobile ecosystem; how one-click carrier payments deliver up to 5x existing conversion rates and how target-right games delivered automatically to handsets overcomes discovery hurdles. You won’t want to miss this red hot session on the biggest disrupter to hit traditional appstores this year.

"Using HTML5 and SVG to Render Documents on the Web"

Speaker: Peter Lai - Crocodoc

As web the continues to takeover application development, more and more software is being being rewritten using JavaScript and HTML. Document viewers are the latest applications to become optimized for the web. Come learn how Crocodoc uses HTML5 and SVG to render documents for use in browsers and on mobile devices.

"Modern Styleguides for a Better Tomorrow"

Speaker: Shay Howe - The Starter League

Times are changing and so must the process in which we design and build websites. The days of designing static compositions in Photoshop are a thing of the past, instead, responsive design within the browser is the future. This new world is not without its own risks, but if we focus on maintainability, organization, and modularity we can achieve a better tomorrow.

In this talk Shay will outline styleguides, living documentation on the design and development of a website, and their role within web design and development process. Looking at a few modern practices and standards, this talk will cover the benefits of stylesguides, the strategy behind creating one, and how to best utilize one within your project.

"WebSocket Perspectives and Vision for the Future"

Speaker: Frank Greco - Kaazing

WebSocket is an integral part of the HTML5 family. The initial reaction to WebSocket is that it's a replacement for HTTP workarounds that mimic a persistent connection. But it's more than that. Along with other new connectivity enhancements in HTML5, it represents a foundational network stack for the new Web with living, dynamic, always-connected applications. We'll hear from a panel of experts who are using WebSocket beyond simplistic Comet-style applications.

"Creating Web Experiences with Users in Mind"

Speaker: Divya Manian - Adobe

Good web design is not just about aesthetics — it's also about the whole experience the user has while on your site, including how fast the page appears, how easy it is to interact with, and how frustration-free the experience is across multiple devices.

"Distributing Your Apps"

Speaker: David Schwartz - Wix

Apps have become common in recent years, but only a few developers are actually making money on them. In order to do so, apps should be marketed properly, placed inside the right markets and have the right pricing and business models (such as free trial/ freemium, rev share, etc).

"Tesla Go Electric"

Speaker: Doug Lawrence - Cibo Studios

Provide a detailed case study with lessons learned and best practices on how Cibo developed the innovative, advanced UX for their Go Electric site using advanced HTML5 & CSS 3: http://www.teslamotors.com/goelectric

We can provide details on the JavaScript MVC architecture, usage of LESS stylesheet management, advanced HTML5/CSS3 features, JavaScript custom interactive controls (e.g. scroll wheel listener), content optimization to improve performance, HighCharts integration, as well as approach for iPad compatibility, and dealing with browser compatibility for older Internet Explorer browsers.

"Module-Driven Development"

Speaker: James Halliday - Browserling

Tiny modules that do just one thing well will keep your application lean and maintainable. Tiny modules make it easier to test, reuse, and share but mostly they are just a lot of fun!

Tools like browserify, testling-ci, and npm can help you to leverage and release well-tested building blocks to make impressive applications in a very small amount of code!

http://substack.net/projects/voxel-demo/

"Better Performing Apps with a Component Model"

Speaker: Kevin Schaaf - Enyo

HTML5 is a great way to develop cross-platform apps — but if you're aiming for native-quality polish and performance, you can't build apps the same way you build websites. In this talk, we'll explain how a component model like the one in the Enyo framework not only delivers better-performing apps, but also makes it easier to maintain and reuse your application code.

"Building a Web Apps Platform"

Speaker: Yoav Abrahami - Wix

In the past year, Wix has introduced an SDK for building applications to the Wix platform. We will dig into the reasons to build such an SDK, what makes a good Web App SDK and API, how we designed the Apps Platform and what we have learned during this process.

"Continuous Integration Testing in All Browsers"

Speaker: Kevin Nilson - just.me

Would you love to test your HTML5 app in all browsers? The biggest challenge in writing HTML5 applications is that your application must run on many platforms, ranging from old desktop browsers to cutting-edge mobile browsers. Each browser behaves nearly the same, but inconsistencies can lead to major bugs. In this session, JavaOne Rockstar and Java Champion Kevin Nilson shows how you can leverage open source tools to test your HTML5 application in all browsers. The presentation shows examples of using tools such as TestSwarm, QUnit, jQuery, Jenkins to test your HTML5 application in all browsers.

"Exploring the Enyo Component Model"

Speaker: Roy Sutton - Enyo

Enyo is a JavaScript framework designed to make native-quality apps on both the desktop and mobile devices. One of its strengths is its component model. In this talk you will learn the ins and outs of Enyo components, including how their events, properties and inheritance model make it easy to create well-structured, maintainable apps. You will be introduced to the components that are included in the base Enyo library as well as the optional components from the Onyx widget set and the Layout library. A good time will be had by all.

"Radically faster web development -- Meteor after one year"

Speaker: Matt DeBergalis - Meteor

Meteor is a new development platform that makes it dramatically faster to write rich web applications in pure JavaScript. It provides you the same APIs on both the client and server, synchronizes data automatically across browsers, lets you push hot code updates without disturbing your active users, and automatically redraws just the right parts of the screen when the data they depend on changes. And now Meteor includes NPM integration, so you can incorporate your favorite Node.js modules into a Meteor package.

First released in April 2012, Meteor comes as a distribution of modular, open-source packages that solve each of these problems in a principled way; and a bundler tool that gathers up your code and the packages it depends on into a running app. I'll talk about the challenges of building client-side apps and how Meteor's packages work together to create an exceptional development experience.

"Choosing Your HTML5 Game Engine"

Speaker: Nate Altschul - Nickelodeon

A deep dive into the current state of the leading HTML5 game engines. This presentation draws from real-world experiences building professional games with each of the following HTML5 game engines--PlayN, CreateJS, ImpactJS, Construct 2, Cocos2d HTML5, Spaceport.io, and Haxe. The discussion will include specific recommendations for each technology based on distribution goals, company DNA, and content strategy.

"Remix the Web with Moovweb’s Mobile Web Hackathon"

Speaker: Ishan Anand, Michael Catlin, Naseem Makiya

We’re kicking off an online hackathon and want you to join us in transforming the web! Imagine you could build a fully functional mobile or tablet version of any website without worrying about the backend plumbing. This is exactly what the Moovweb platform enables. In this session we’ll cover the hackathon and perform a live demo using the Moovweb platform. Not only will you learn how to win $5000 in prizes, but you’ll be able to walk into your next meeting with a working site instead of just mockups.

"Go mobile today: Hands on with the Moovweb SDK"

Speaker: Michael Catlin & Naseem Makiya

If you've never tried our mobile web SDK or are considering entering our online hackathon, feel free to drop by. Moovweb engineers will help you take the Moovweb SDK for a spin, answer your questions, and provide hands on assistance with your project.

"The Inevitable Rewrite"

Speaker: Chris Chen

How the code choices you make were based on features and decisions from years before. When do you decide to rewrite or migrate to new libraries or frameworks? How do you avoid haphazard decisions and choose wisely with a large scale application?

"TouchDevelop: A touch-first IDE for your phone built with TypeScript"

Speaker: Matt Harrington - Microsoft

The first computing device for millions of people is a touch-enabled smartphone or tablet. Can a useful development environment be created on such devices? That’s the question Microsoft Research set out to answer, and the result is http://TouchDevelop.com. From your iPhone, Android phone, Windows Phone or associated tablets, you can write remarkably advanced programs using only touch. Access your phone’s gyroscope and accelerometer to build a position-aware game complete with a physics engine. Use your phone’s GPS, a map service, and your favorite API to create a mashup. Hit a web service, pull down JSON, and do something useful with it. Easily share your typesafe code with the rest of the world no matter what device they’re on. Recapture the fun you had writing your very first programs. Do all of this in the palm of your hand while you’re bored on MUNI.

"Web Design for Developers"

Speaker: Paul Trani - Adobe

Design. Why does it matter? What's up with colors, fonts, layout and aesthetic and why should I care? You might be asking yourself these very same questions and this session will answer them. Learn everything you need to know that you can quickly apply to any web project when it comes to color, fonts, layout and aesthetic. Learn the design secrets designers might not want you to know. The tips and tricks that can take a standard interface or web/mobile site and impress even the most skeptical. Real world. This session will be real world, with no "touchy, feely" words. Just good web design techniques to help you with your projects.

"Shareable staging environments with Docker"

Speaker: Thatcher Peskens - dotCloud

An introduction of how you can use Docker to setup light, portable and sharable staging environments for your server-side application.

"Preventing XSS with Content-Security Policy"

Speaker: Ben Vinegar - Disqus

For years, the best method for preventing Cross-Site Scripting (XSS) has also been the only method – careful sanitization of user input. Unfortunately, sanitization is still largely a manual process. And despite better tools and better developer know-how, all it takes is one haphazard mistake to introduce an XSS vulnerability to your application. If history is any indication, it’s not a matter of “if” you’ll make such a mistake, but “when”.

Thankfully, HTML5 introduces a new feature, Content-Security Policy (CSP), that prevents web clients from executing untrusted JavaScript in an affected document. Already supported in modern web browsers, CSP makes it impossible to execute injected JavaScript code, effectively eliminating the XSS threat.

In this talk, you’ll first learn about common client-side programming mistakes that lead to XSS vulnerabilities – mistakes even the pros have made. Then you’ll learn about HTML5’s Content-Security Policy, how it prevents execution of injected code, and how to implement it in your web application. We’ll cover how to whitelist script files to only trusted sources, making your code CSP friendly, browser compatibility, and using CSP's reporting feature to notify your application of infractions as they occur.

"New way of making apps using OOP in Coffeescript"

Speaker: Sinan Yasar - Koding

 

"What Web Developers Need to Know to Develop Windows 8 Apps"

Speaker: Doris Chen - Microsoft

You already have a Web app on the Internet and want to reach customers with a new, targeted experience on Windows 8. Come get practical guidance and best practices on how to reuse your Web assets. Come dive into the specifics of this exciting platform and see how you can use your Web skills to build deeply-integrated Windows apps.

  • You’ll discover how this mirrors or differs from traditional Web programming and how to harness the rich capabilities of Windows 8 through JavaScript and the Windows Runtime.
  • You'll learn practical techniques on how to access a web service, how to work with camera, and how to make live tiles, etc.
  • Expect a lot of code and demo.

This session will jump start you with everything you need to know to start building Windows 8 apps with the skills you already have.

Slides Blog

"Javascript Release Management for Open Hybrid-Cloud Environments"

Speaker: Ryan Jarvinen - Red Hat

Throwing uncompressed Javascript source on a server is easy work. But, as any coffeescript developer can tell you: Configuring an application build process can provide substantial performance gains, while helping you catch bugs, typos, and syntax-errors early on. Learn how to automate builds, deployment work, and automate application scaling, as we build development, test, staging, and production environments using OpenShift - RedHat's Open Source hybrid-cloud Platform-as-a-Service.

"Developing HTML5 Apps With Node.js"

Speaker: Mike Cantelon

I'll talk about how HTML5 applications can be developed using Node.js as a back-end, with an emphasis on local web applications (web apps running on a workstation intended for local, rather than remote, use).

"Brackets: An Open Source Code Editor For The Web"

Speaker: Adam Lehman - Adobe

Brackets is a new open source project started by Adobe to push tooling on the web forward. Based on the principle that the best developers to build tools for web developers are in fact web developers, Brackets is built in JavaScript, HTML and CSS. MIT-licensed and hosted on github, Brackets is a code editor that challenges the status quo with innovations like inline Quick Editing and live browser connectivity.

This session will provide an overview of Brackets and demonstrate how to hack on the project so you can customize and extend it to meet your needs.You can build a better editor.

http://github.com/adobe/brackets

"The Making of Fastbook: An HTML5 Love Story"

Speaker: Jacky Nguyen - Sencha

At Sencha, we believe that modern application development requires only a browser, a smart developer, and a great set of frameworks and tools. So, when we heard "HTML5 isn't ready," we took offense. Like you, we know HTML5 is ready, and we're here to prove it. Join Sencha lead developer, Jacky Nguyen, as he discusses the building of Fastbook, the pure HTML5 app that showed Facebook how it could be done. Jacky will demonstrate how HTML5 can be used to handle the toughest challenges in today's most popular native apps.

"Mobile HTML5 Use Cases"

Speaker: Tomomi Imura - Nokia Corp.

Showcasing the capabilities of the Web platform and more specifically of the subset of features that mobile platforms can take advantage of, by using an open source mobile app called Coremob Camera, using HTML5 to explain the real-life use cases of HTML5 in mobile. The technology behind the app is purely in HTML, CSS and JavaScript.

The HTML5 APIs covered in this talk includes HTML Media Capture, FileReader API, Canvas, IndexedDB, and XHR2/CORS.

"Chocolate and Peanut Butter: Dart and Web Components"

Speaker: Timothy Armstrong - Google

Building reusable, encapsulated, extensible web interfaces is hard. Don't worry, Dart's Web UI framework can help you write web applications quickly and effectively. Web UI combines ideas from web components and model-driven-views and adopts a concise, declarative syntax. This session will teach you how to get started with Web UI and demonstrate how show you how you can be highly productive while writing very little code.

No prior knowledge of Dart is required.

"Intro to PhoneGap and PhoneGap Build"

Speaker: Lorin Beer - Adobe

PhoneGap is an open-source framework that allows you to create cross-platform mobile apps using the web technologies you know and love: HTML, CSS, and JavaScript. Learn how PhoneGap works and how it will enable you to start building mobile apps with web standards. You will also get an introduction to PhoneGap Build which allows you to package mobile apps in the cloud.

Slaying the Dragon: How to Refactor CSS for Maintainability

Speaker: Alicia Liu - Lift

CSS is notoriously hard to refactor. It seems to just grow and grow, with no one being able to say for sure where each class is used, how it's used, or if it's still being used at all. Instead of re-using existing styles and keeping things DRY, developers often default to adding new classes, for fear of unintentionally disturbing existing styles. This talk covers CSS organization, modularization, naming, tools and best practices to make your existing CSS maintainable.

Mastering WebStorm

Speaker: John Lindquist - JetBrains

John will demonstrate Power User tips and tricks to speed up your Web development workflow with WebStorm. He'll also demo some of the latest and greatest features just recently released with WebStorm 6.

"Conquering Mobile & Desktop with Responsive Design"

Speaker: Lance Thibodeau - Trial Pay

Iframes, scrolling, orientation changes, speed. Support for html5 across devices can be quirky. We'll give you examples of issues we had and how we dealt with them in a rapidly changing environment. We'll also discuss tips and tricks to make a more user friendly product.

"NodeJS at LinkedIn"

Speaker: Ganesh Srinivasan

25% percent of all site traffic for LinkedIn now goes through NodeJS servers. LinkedIn mobile moved to NodeJS couple of years ago. In this talk we will go over why we chose NodeJS and how well it has performed/scaled at LinkedIn.

Getting Down and Dirty with the Parse Javascript SDK

Speaker: Hector Ramos, Solutions Architect & Mattieu Gamache-Asselin, Software Engineer

This will be a great office hour like environment, with Parse engineers to help anyone get started with the Parse JS SDK, as well as present basic features of the Parse JavaScript SDK.

Go Top
Sponsors
Newsletter Signup
Signup for our newsletter today!