It's not just about jQuery anymore. jQuery Conference is about bringing together experts from across the field of front-end development to bring you up to speed on the latest open-web technologies. Get the latest on jQuery and related projects, code architecture and organization, design and implementation practices, tooling and workflow improvements, and emerging browser technologies.
It gets even better. We've partnered with Roost, a two-day training event operated by the folks at Bocoup to create our most significant conference experience to date. While you can attend either event, we've put them back-to-back in the same venue to create an immersive and thorough training and conference experience like no other.
jQuery continues to evolve to meet the needs of web developers. House cleaning in jQuery Core 1.9 and 2.0 has whittled away the fat and cruft from the API, plus the ability to create custom builds means you don't need to load what you don't use. When performance problems arise, however, it's important to understand how your use of jQuery can affect performance. We'll bust a few myths about what makes web pages slow and use some readily available tools to identify the real performance killers.
chat.meatspac.es is a chat app that mixes Websockets, webRTC, animated GIFs.
Creator Edna Piranha will talk about how it came together, the months-long beta test, the app's sudden popularity, as well as expanding to support third-party APIs and the growing Meatspace ecosystem.
These days, publishing a project without a comprehensive test suite is frowned upon. However, the tests themselves do not always tell the full story. We need to level up and provide a more confident level of dynamic code testing. In this talk, two types of such analysis will be covered: code coverage and run-time complexity profiling. Code coverage is instrumental in deciding the quality of the existing sets of unit tests. An important aspect of coverage testing, branch coverage, plays an important role in discovering possible latent bugs due to untested code flow. In addition to code coverage, complexity profiling permits selective instrumentation of a particular code block for the purpose of performance analysis. More than just measuring elapsed time, run-time profiling also needs to reveal the algorithmic complexity which can be tracked via this empirical approach.
You're putting your application together, but now you're getting some sort of weird errors, and you're not exactly sure where the heck to start looking. Did you mess something up, or are you bringing in some plugin that might be broken in a weird way that only you've hit?
Having spent the last few years debugging code that he didn't write, Brian will show you how to dig into code using the latest developer tools in today's browsers in order to find and fix (or at least isolate) what's broken. We'll be using the console along with DOM inspection and source viewing to find all the bugs!"
jQuery gained notoriety largely because of how seamless it made writing code that worked everywhere. But times have changed, and the browser landscape is radically different - and far more standards compliant - than it was in 2006. We can now select elements with querySelectorAll, animate elements with CSS, and even attach event handlers without forking our code.
This standards proliferation has led many to conclude that jQuery's job is done; we can map $ to querySelectorAll and get on with our development lives. They argue that reimplementing these native features adds unnecessary bloat and weight, especially in the context of limited mobile browsers and networks.
In this talk we'll debunk these myths of irrelevance and bloat. We'll see that even in a browser utopia - a mystical land where all features are implemented, all bugs are fixed, and unicorns roam free - jQuery is not only still relevant, but it remains a foundation for any web development stack.
Most people have a driver's license, but very few are race car drivers. Every web developer knows jQuery, but very few make use of all its potential.
This talk will cover some basics from a new perspective, to make more effective use of the finely tuned library we all seem to know so well. For example, how to structure your markup, CSS and JS for them to work well together while promoting maintainability of all three; how to use CSS3 transitions with fallbacks; how to deal with bad APIs with Deferreds; and more.
Recently the jQuery UI and jQuery Mobile teams have commenced unifying some of the widgets that comprise the UI framework and implementing this in jQuery Mobile. This allows for a shared API across desktop and mobile devices and reduces the amount of time required to maintain the code base. This talk will not only take a look at how the jQuery Mobile and jQuery UI teams are sharing their widgets, but will also demonstrate how to build a $.widget from scratch that will work with jQuery UI on the desktop and jQuery Mobile.
Writing web applications is fun. Getting hacked is not fun. This talk will walk through several different ways that websites, especially front-end heavy ones, are being hacked. It will cover cross site scripting, and resource forgery as well as introduce some protective measures for writing secure web apps.
Performance is a major concern on mobile platforms. jQuery Mobile 1.4 adds a number of performance related options and features to help you speed up your mobile site along with a new theme designed to make your site render as fast as possible. Learn Tips and tricks to make your site as fast as it can. Covered in this talk will be not only framework optimizations but server side tricks to minimize transfer and page initialization times.
Developing responsive websites has become a core service for web design agencies, but presents a challenge in delivering nimble, lean websites that are beautiful, usable and functional at every screen size. Through client case studies, learn real-world jQuery solutions we use at Happy Cog to solve the most common responsive design challenges.
Firefox OS is a new mobile operating system from Mozilla and with it comes a mix of excitement, fear, and apathy from the mobile community. In this session we will talk about what Firefox OS is, how you can develop apps for it, and most importantly - why it is a relevant platform. With easy to understand code examples and down to earth talk we will navigate the murky waters together and come to understand why this new mobile OS is worth looking into.
REST web services are everywhere! It seems like everything you want is available via a web service, but getting started with one of these web services can be overwhelming – and debugging the interactions bewilders some of the smartest developers I know. In this talk, I will talk about HTTP, how it works, and how to watch and understand the traffic between your system and the server. From there I’ll proceed to REST – how REST web services layer on top of HTTP and how you can expect a REST web service to behave. We’ll go over how to monitor and understand requests and responses for these services. Once we’ve covered that, I’ll talk about how OAuth is used for authentication in the framework of a REST application. I will cover http monitoring tools for multiple OS’s. When you’re done with this talk you’ll understand enough about REST web services to be able to get started confidently, and debug many of the common issues you may encounter.
Create hands-free interfaces using new HTML5 speech API's. We will look inside two examples. TalkShow is an exercise in ambient computing, using the Web Speech API and Named Entity Recognition -- it eavesdrops on your conversations and shows images of things you mention. The Translating Telephone is a web app for multilingual conference calls, combining the Web Speech API and Web Real Time Communicaton (WebRTC) with text-to-speech and online translation services.
For 5 weeks, I worked with a small team of developers to refactor the front-end of a moderately trafficked website for a ubiquitous international brand. The project’s initial launch deadlines were tight, and sacrifices were made to get the site out the door. Months down the road as features were added and changed, performance began taking a major hit, with page load times reaching 15 seconds. Some of this was attributed to poor front-end practices. Implementing new features became a somewhat of a nightmare, and morale on the team dropped. Given the opportunity to refactor and rework a portion of the site, we planned and worked for several weeks. In the end, we shaved 75% off page load times, eliminated a ton of technical debt, and set future work up for success by modularizing our code. This talk will cover some of that process. What worked for us, what didn't, how schedules and priorities between developers and clients can conflict, and how to make that better. We’ll also cover several things you can do right now to clean up your front-end code and optimize for performance.
But now your users are trying to type in your Very Important Form, and nothing is showing up; you loaded Backbone into your app *right there on line 1*, but `window.Backbone` is nowhere to be found; that widget that's supposed to end up in a certain div is showing up somewhere completely different; calls to jQuery's `.css()` are doing absolutely nothing; and, rarely but not never, your app just doesn't load at all.
Join Scott Hanselman as he explores the relationship between the Cloud and the Browser, many Languages and one Language, how it might all fit together and what comes next.
Making a website or application accessible can be an overwhelming task for a lot of developers, especially if you’re not already an expert. Looking at all the complex regulations, specs, and articles on the topic, where should we begin?
In this talk, I’ll walk through some of the challenges I faced when working through accessibility requirements for the first time. I’ll cover basic considerations, how design and content fit in, testing advice, and introduce Aria practices. Attendees will leave knowing some of the practical constraints and tools that can make a big difference for users, and will have a starting point of how to make their next project more accessible. By thinking about accessibility as we would any other feature, it becomes less of a scary unknown requirement, and instead something we can plan for and implement to create a more open web for all.
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.
Unit testing is never easy, but it is a necessary evil in software development. Unit testing an AMD code base is even more difficult. A few questions that quickly arise are – How do I mock dependencies? How do I ensure my paths have been configured? How do I generate coverage reports? This talk will answer all these questions and much more.
Internationalization is the process that provides users with a localized experience that matches their own cultural and linguistic expectations. Learn how jQuery is improving its Globalize project to leverage the official CLDR JSON data, allow users to load as much or as little data as they need, avoid duplicating data if using multiple i18n libraries that leverage CLDR, and that run in browsers or node.js.
Keeping frontend code cleanly decoupled is challenging at the best of times. Rich user interfaces often depend on complex interactions between program state, control values, and AJAX requests, which makes it hard to write correct and testable code.
One technique for handling this complexity that is gaining favor in some circles is Functional Reactive Programming, which provides powerful tools for manipulating and composing streams of events and values that change over time.
Using the working example of a simple Flight mobile web app, this talk will introduce the fundamentals of functional reactive programming and show how it can greatly simplify complicated UI logic.
Embereños! Ember.js is hot and so are you – but just because it's hot doesn't mean you start sharing a toothbrush on the first date. We'll take a brief look at the ever evolving landscape of client-side MVC and speak generally about which tools are best suited for different types of apps. Then we'll take a look at the basics of Ember.js and top it off with some tips for supporting Ember.js in production. Afterwards, we'll all get matching Tomster tattoos.
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 component framework from the ground-up this talk will give an excellent outline of what to look for in 3rd party components.
What do web components look like outside of Google and conference presentations? How do they fit into frameworks like Angular? In this session we'll go over some real world use cases and the headaches web components cure and present, where they should be used and where they shouldn't, and why you should consider using web components today.
In this talk we'll take a look at just how messed up the world wide web can be, ranging from broken web browsers to broken web servers and everything in between. We'll also look at how jQuery (and jQuery Mobile) APIs, often working around these various busted components, have helped to shape the future of a more compatible web. Come prepared to hear some battle tales and learn some low-level details about the web stack works, despite being so broken.
I'll cover some of the different possibilities to capture user information from the browser, from cookies to timing attacks but mainly i'll show and focus on mutations observers as a new and cool way to efficient way to really capture a user interaction on a live page and make a movie of it using phantomJS.
In the process, I'll cover WeakMaps (to weakly store user nodes), Mutation Observer(to actually capture the session), NodeJS(as a backend), RequireJS(As a build system) and PhantomJS(to create a movie of the session).
Expect an awesome and mind blowing demo!
At Ally, we used Node.js along with Grunt, Yo and Bower to develop a custom developer toolset for Ally's front-end development teams. The toolset had to be crafted in a way that allowed us to take a forward approach while still supporting the use of some legacy code and not-so legacy code. In the end, we created a toolset that separated new and on-going development tasks, gave living documentation and usage examples, and also allowed us to focus on maintainable and testable code. In this talk, you will get an overview about problems we tackled as well as solutions we found and approaches to creating a more maintainable codebase.
Are you interested in obtaining amazing power over HTML5 features for animating, sound, preloading and more? CreateJS is a suite of module libraries that work great independently or can be combined to enable rich interactive mobile or web content to open technologies through HTML5. In this session, you will learn how CreateJS will give you this power and more including cleaner code that requires less effort to maintain. It will illustrate how you can use the libraries independently or together.
In this session, Teresa Light and Josh Smith will provide an overview of Create JS before going through a real example of creating an interactive map. Attendees will leave his session inspired to create amazing interactive content.
We showcase the technical hurdles we overcame, how we did it, and present the open source frameworks we released as a result of it.
While the prospect of returning to Boston in February (30°F anyone?) was quite alluring, we thought San Diego might be a tad more comfortable. Town and Country Resort & Convention Center will provide a wonderful place to stay, same-location conference and lodging and have plenty of amenities if you so desire.