We are currently in the process of adding sessions. Thank you for all of the wonderful submissions. You will see current sessions for spring soon, and we will be adding more over the coming weeks.
Click the session titles below for more details.
Viewports are hard. Don't let anyone tell you they aren't. Although desktop browsers have only one, and it works pretty intuitively, mobile and tablet browsers have three. And sometimes they don't work intuitively - or at all.
What are the three viewports? (Spoiler: layout, visual, and ideal.) Why do we need all three? Why does responsive design work? (Not how. Why.) What happens when you set the meta viewport? How do browsers go wrong? (Spoiler: in plenty of innovative ways.)
And what about resolution, or DPR? (Spoiler: it is not what you think it is.)
In this session PPK, who spent more time on the mobile viewport than anyone not working for a browser vendor, answers these questions and more.
I bet you've heard that "callback hell" is about function nesting and levels of indentation. Nope.
I bet you've heard that Promises take away the nightmares of callbacks. Not so much.
I bet you think the event loop is *the* model for concurrency in JS. Meh.
Finally, we'll reveal generators for synchronous-looking async, and even how we can create cooperative concurrency with coroutines.
Yield those confused async notions and control your flow. I promise we'll get your thoughts in order.
Ember.js is a framework for creating "ambitious" web applications; the kind that aim to be as good or better than their native counterparts. It's a lofty goal, and Ember borrows heavily from some of the most successful and productive programming paradigms including Cocoa and Smalltalk, so it's off to a solid start. But it's still early days for the framework and many best practices have yet to be defined.
In this talk we'll dive deep into the code base a real-world, ambitious web application built with Ember. We'll steer clear of contrived examples or shallow, useless code samples. Instead, we'll cover many of Ember's core concepts including routing, data modeling and binding, controllers, views, and templates, and how all the various pieces work together in the context of a working application. We'll identify common patterns inherent in Ember's architecture and we'll discuss advanced concepts like animation and building custom components as well.
In the process we'll see many of the powerful features that make Ember a solid foundation for building an ambitious web application.
As more and more people start using CSS libraries like Bootstrap, our CSS files are full of unused rules. Not only they take away unnecessary bandwidth (which matters a lot on mobile), they also slow down the browser since it has to parse all the rules and test to see if they apply to the current page.
Through this talk, I'll show how you can use node-uncss and grunt-uncss to automate the process of removing CSS rules that are not used in your pages.
With a solid understanding of UI patterns, and best-practices for reusable code, rolling your own UI components is awesome and enjoyable. And for those who don't have to time to write a widget framework from the ground-up this talk will give an excellent outline of what to look for in 3rd party components.
This talk is based on a blog post that can be found here: http://tybenz.com/post/widgetize-all-the-things/
More importantly we'll talk about how to catch exceptions reliably, and in a way that doesn't pollute the rest of your code or crash your app.
On top of all these, emory leakage is also a problem, because the application will most probably be a single page fat-client app, that will not be switched off for hours, or even days. Dealing with cache manifests and offline browsing is also an important thing to consider.
Some of the techniques that I offer might seem arguable, and open to discussion. And I won't be talking about "the only way" that works; per contra I will be discussing "a way that works all the time."
Web Security is usually an afterthought but is an important part of building a production-ready app. In the last few years, Single Page Apps (SPAs) have become very popular in the web community. Unfortunately, there are plenty of bad patterns with security vulnerabilities being spread across the web. Single Page Apps are a new and different kind of architecture but you need to do even more than the "classic web" to secure your app. The good news is there are a lot of great modules and frameworks to use to help protect you against XSS, Clickjacking, CSRF, etc.
In this talk, I plan to identify some anti-patterns and show best practices for securing your apps (focusing on node and SPA libraries like backbone). I'll show actual security holes found in common SPA patterns, too!
I hope to inspire others to care about security and take the extra step to secure their app and their users. Thanks!
Techniques and approach involved to build Google Racer, a multi-device web based mobile game.
The ability deploy code should be predictable. Running your build should take no time when theres nothing to do. You should be able to split your code base up into as many components as possible to optimize reuse. With npm and grunt it is possible to achieve those goals, but not without lots of effort!
This talk will go through how Eventbrite:
What does a mouse drag event have in common with an Array of numbers?
There’s lots to love about three.js: ease of use, massive developer community, and some of the coolest demo projects out there. But let’s be clear, three.js is not a game engine, and it’s not fair to compare the core rendering library to purpose built engines like Unity or even Babylon.js.
In this talk, Ross will talk about the architecture of three.js, the good, bad and ugly of using the WebGL renderer for building games. He’ll also talk about what is missing, and how his team at Verold is closing the gap with new components and tools.
We’ll do some live coding to showcase bringing a component entity model system and uber-shaders to three.js. Then give an overview of how to deliver gaming-relevant topics like custom controllers, particle systems, physics, and cross-platform considerations and optimizations.
This talk will focus on the rationales behind the design of the API, show code examples, and present demos.
After the talk, you’ll know how to:
In fact, the core Angular team would rather that developers build framework-agnostic code, then wire it in to Angular.
At least basic HTML5 understanding is needed. Very little AngularJS experience would be needed since it will be used more as a framework to wire things together rather than a platform on which to build applications.
The main questions that will be discussed:
Data analysts must navigate increasingly large data sets, sometimes with billions or more records. I present methods for interactive visualization of big data, following the idea that perceptual and interactive scalability should be limited by the chosen resolution of the information, not the scale of the data.
I first describe methods for interactive querying using binned plots through a combination of multivariate data tiles and parallel query processing.
I then present a design space of scalable visual summaries that use data reduction methods (such as binned aggregation or sampling) to visualize a variety of data types.
When shipping web applications, developers usually worry about backend performance and scaling. With tools like YUI and Page speed, front end performance engineering was brought into spotlight.
However, event today, developers have to look at render/paint timelines and the confusing about:tracing tabs to see if their sites are smooth and jank-free. Developers look at these graphs and try to identify known patterns that slow down a site.
Can this all be automated? Even better, can it be made a part of a continuous integration system so that a developer just pushes code, and knows if something is wrong?
During this talk, I would like to discuss my experiments with porting the Chromium telemetry smoothness and loading benchmarks into Node, how the data can be collected and how it can be integrated into a continuous system. I would be exploring the new set of tools that developers can create to ensure that no website is janky again.
Rendering performance on the mobile web -- it's hard. This talk will provide an overview of the challenges for building a snappy, interactive, touch-based application, including both best practices and a few of the latest changes to Chrome to make it shinier.
This topic provides developers with the opportunity to discover three core tools that the Yeoman workflow has to offer but also gives them an insight into its advanced features.
The topic will focus on what kind of applications can be built using Yeoman and what kind of frameworks that can be used easily with it.
In order to demonstrate how it can speed up development time, we'll build a application from scratch, integrating with the AngularJS framework with as many functionalities as needed by any modern web application.