jQuery is so easy to use and thankfully abstracts many of the cross-browser concerns we used to labor over years ago. As with any library, however, there are a common set of bugs that tend to crop up as you start and continue to use it more and more. This session aims to help equip developers with the appropriate knowledge and tools to exterminate a subset of these common issues.

For each topic that is covered we will start with an example piece of code that contains a jQuery bug, then expose what the bug is, explain why it is happening, proceed to explore various techniques to exterminate the bug, and in some cases provide extra insight surrounding the problem.

These solutions range from simple to advanced concepts. By exterminating bugs in multiple ways it will help expo

Deferreds are a relatively new addition to jQuery, but what can they be used for beyond ajax resolutions and chaining? This talk shows 7 interesting and useful ways to make safe asynchronous JavaScript apps leveraging that mysterious object, Deferred.

In the bad old days of JavaScript, our days were spent fighting through a thicket of DOM differences. These days, we've pretty much conquered those challenges thanks to tools such as jQuery, but our new challenge is figuring out how to adapt as more and more of our application logic moves from the server to the client. We have great tools like Backbone, Ember, Knockout, and more, but in order to use them effectively, we need to do more than learn their APIs -- we need to learn to think about our code beyond the DOM-centric ways of the past. In this talk, I'll look at useful patterns for thinking about client-side appplication development that will help you avoid creating a tangled mess of code.

Building a jQuery Mobile application is easy, but making it stand out from the pack takes work. This session will take an in-depth look at the inner workings of jQuery Mobile and show you how to get started with creating custom theming, custom icons, and even custom plugins.

An overview of how to build a dynamic mobile application using the rendering features of jQuery Mobile. An end to end analysis of how to receive form meta data from a web service called through the jQuery ajax api. Store that data on the client in order to render it both in an online and offline manner. Render forms by adding controls to the jQuery Mobile container and then enhancing the forms. Finally saving information from the dynamic forms via a web service. Presentation will be from the standpoint of a programmer and will get in depth with JavaScript, jQuery Mobile and HTML5.

Our team has learned great lessons while developing Fashion Tale, a hidden object game entirely in HTML5. The process taught us several tricks, pitfalls, and successful workarounds. This talk covers using hardware accelerated graphics, responding effectively to touch events and gestures, and creating actionable feeds and message centers using jQuery.data().

There are 1 thing(s) that you have probably noticed about l10n and I18n in your JavaScript App(s). The sentences, even in english, are as ridiculous as the first one in this paragraph. Sure, you may be used to it, but it's a crappy user experience. There's lots you can do to make your data driven sentences valid, even expressive, in your language, and then expand that to any language. This talk will round up a set of tools and techniques to help prepare you to write apps that don't sound like Borat.

Performance. A word programmers use so often it's almost a buzzword. But in our world of web apps written in HTML, CSS and JavaScript it can mean many different, sometimes contradictory things.

In this presentation I will talk about the most common targets of web app performance, the techniques used to optimize them and how they influence each other. Additionally, I will discuss several performance targets that are mostly overlooked even though they arguably matter most.

A few months ago, the jQuery Foundation announced its participation in the W3C and ECMA standards bodies. Why did we do this, and how are we doing?

In this talk, Yehuda will give a rough overview of the standardization process, some examples of ways that web developers have helped the process, and talk about how the jQuery project is making a difference.

The thick client is back! Pushing entire applications down to the client has become a lot more popular in recent times, and is especially interesting for mobile devices.

Building a really solid and polished single-page applications means that we need to replicate a lot of native browser behavior, and when we don’t we’ll annoy or even scare away our users. This talk will cover both pitfalls and opportunities of single-page applications, with a focus on native behavior that your app needs to provide in order to behave like an actual web site, while fixing a lot of the usability issues that web sites usually have.

Topics covered include dealing with proper URLs without breaking back and forward buttons and using the (still somewhat new) HTML5 history.pushState API. We’ll look at existing (and still missing) frameworks that help implement these behaviors.

Once you break the habit of initializing everything on DOM ready, you need to be able to predict what users are about to do next so you can ensure it is setup and ready to go. This session dives into a techniques for setting up portions of your page right as (or right before) a user interacts with it. The techniques learned in this session can leveraged to speed up page load, reduce bandwidth and speed up the overall user experience of your website or web application. Though this is the third session in the Contextual jQuery series of talks, you do not need to have seen the previous talks to understand and start using this material.

The process of getting involved with jQuery, or indeed, any open source project, is unique for every contributor. Listen to how a group a number of jQuery team members came to be involved with the project, and learn how you can find your own niche and give back to the community.

During this talk, Ben Alman will demonstrate how you can use grunt, the task-based JavaScript build tool, to improve your development process through automation. Maybe you want to more easily employ popular, best-practice approaches to JavaScript and jQuery development like linting your code, writing and running unit tests, and concatenating or minifying files, but haven't quite figured out how to incorporate them into your application. Perhaps you just want to write a jQuery plugin, and don't want to spend a lot of time setting up project scaffolding. Either way, by the end of this talk, you'll have a much better grasp on what this tool can help you do!

Have you ever had to exclude an element from a collection so you could run a plugin method with two different sets of arguments? Have you ever had to modify someone else's (or maybe your own) plugin for a specific use case and felt dirty for doing so? When dealing with plugins, do you frequently think to yourself there's got to be a better way to develop plugins? You're not alone. Shane Riley, the front-end development lead at Hashrocket, is tired of modifying plugins to suit a particular need and fearing the modified plugin will be overwritten by future Shane when he realizes there is a new version out. To that end, he set out to change the way he, and hopefully others, develop plugins to eliminate this worry and hassle and returned with a solution that's not only super-extensible at the plugin level, it's also completely customizable at the element level once the plugin has been initialized. Intended for those who have experience writing and/or modifying plugins, Shane will walk through the process he now uses in his own plugin development to ensure that if the plugin doesn't exactly suit your use case, you can make it easily and without having to change the core code of the plugin.

For many front end developers, including me, a jQuery plugin was their first repository on GitHub. Reading that code again, I found many bugs and I am very grateful that no one ever used it in production. At the time, I was completely confident about my code working as I intended it to, but I never stopped to think twice about why I felt that way. Since then, the most significant tool that I have picked up is unit testing and the biggest hindrance in learning how to unit test has consistently been the event loop. For example, how do I ensure that particular code paths are followed when an element is clicked, double clicked, or if the window has scrolled into a particular state.

Most unit testing examples focus on very straightforward imperative tests. I have seen many explanations of JavaScript unit testing that describe how to verify the logic behind a calculator or a form validation library, but not how to test a more complex, event-triggered interaction. In this talk, I will address how to begin unit testing jQuery plugins, and how to avoid common pitfalls when dealing with asynchronous, or event handling code. Most importantly, I will explain how to deal with verifying that code is executed when native browser events fire.

Interacting with iframes is a JavaScript rite of passage. There will be hurdles: the Same Origin Policy, postMessage, and browser history will each rear their ugly heads. Fear not, for others have tread this path.

Learn the techniques and challenges required to create a live preview interface and how WordPress used jQuery's utilities to create a lightweight data-binding library to synchronize data and UI across multiple frames. Then, pull the whole experience together with seamless full page refreshes and an extensible API.

Math: It's certainly not something you expect to see at a conference about JavaScript, but even this far from its ivory towers it has an important role to play. Together we'll build two categories, see how satisfying the Functor laws shines light on a simple optimization for our jQuery method chains, and derive a plugin/method standard that will allow us to easily use this optimization in our applications.

Don't worry, you don't need to know any Math to understand and enjoy the talk, just some curiosity and a desire to make your jQuery based JavaScript faster!

Spacecraft Operators require extremely reliable, accurate, and real time software to optimize the efficiency of spacecraft operations and to ensure proper commands are issued to take pictures of the Earth. Any loss of contact or data misreading due to software error can be mission ending.

Come learn how our team developed a lightweight JavaScript real-time event-driven platform utilizing WebSockets and proven open source technology such as jQuery to enable a cross platform mission operations center. Prototypes and testing tools were created to verify the data stability and limits of several different real time technologies, from Comet to WebSockets, while constant performance testing was done to keep the memory footprint low in the browser while maintaining high data volume. This platform has supported day in the life testing of SkySat-1, our first imaging satellite.