Little Opinions, Big Possibilities: The tools and patterns for building large scale Backbone AppsView slides
Little Opinions, Big Possibilities: The tools and patterns for building large scale Backbone Apps
Backbone has been used to build some of the greatest web apps in the world. Chances are, you have one running in your tabs. But the gap from first starting Backbone to building a large application is enormous. In this talk, Brian Mann will focus on closing that gap, and pave the way for creating powerful and highly scalable Backbone Apps.
One of the biggest pain points of Backbone is dealing with its boilerplate code. Let’s face it; Backbone is notorious for being small and un-opinionated. While an attractive feature, it unfortunately means automation and workflow falls on developer’s shoulders. This often results in bloated code bases, reinvented patterns, frustration, and wasted time.
Instead of building your application’s infrastructure from scratch, Brian will show you how to become a much happier Backbone developer by demonstrating how to build modular Backbone apps using Marionette JS.
As the popularity of web apps increases it becomes more and more important to test your code. Backbone makes it simple to make a dynamic web app, but how do you know it works when a change is made? There are a slew of tasks that you must do every time you update your application that you as a developer should automate; ensuring modules work in any situation, simulating network requests, cross-browser testing, and more. Using Grunt and other tools and libraries, we will run through how to write unit tests and discuss the importance of testing and testing as you code.
My talk will address what to do when you encounter these problems and how you can use techniques like dependency injection and modularity to write applications that can grow and scale over time. I'll draw from experience implementing Backbone applications in a variety of scenarios: working with an externally developed APIs, developing Backbone apps that progressively enhance server-rendered content and from my work helping teams plan and implement better applications.
Domain-Driven Web Applications Using BackboneView slides
Domain-Driven Web Applications Using Backbone
Domain Driven Design (DDD) is an architectural pattern that focuses on building an accurate model of the business logic of an application. While remaining separate from the other layers of the architecture, this conceptual model is closely tied to the software implementation of that model. The benefits of this approach include flexibility, maintainability, and an easing of communication between the technical and domain experts.
DDD is somewhat established on the server side, but has seen very little use in client-side applications. We will introduce Keel.js: a very light framework on top of Backbone.js, which allows us to easily build domain-driven applications. We will discuss both the benefits and challenges of this approach.
The Geologic Time Scale of Gilt.com's View LayerView slides
The Geologic Time Scale of Gilt.com's View Layer
Advanced Architectural Patterns with Backbone and cujoJS
Advanced Architectural Patterns with Backbone and cujoJS
There's more to client-side architecture than models, collections, and events.
In this talk, you'll see architecturally sound patterns that can scale your codebase linearly, facilitate cross-functional iterative development, and free your code from obsolescence and dependency lock-in. And because your modules are smaller, more understandable, and more testable, you'll sleep soundly at night, too.
Specifically, we'll discuss data binding, aspect oriented programming, function pipelines, dependency inversion, application composition, promises/futures, and DOM state manipulation using OOCSS and monads.
Becoming a Control Freak with Controllers and PromisesView slides
Becoming a Control Freak with Controllers and Promises
Learn how LinkedIn's mobile web app manages control flow and application structure with promises and page controller components. As is the case with many original applications, the code-base of LinkedIn's first mobile web app was a bit like the "wild west." It was, in some areas, ill-suited to support the requirements of a large mobile web application that was constantly evolving at the hands of several teams. This session will share the problems faced, lessons learned, and solutions found while developing and scaling the LinkedIn mobile web app. After giving a quick primer on promises and explaining what the heck controllers are for, the session will dive into the use of promises to manage control flow and page controllers to manage page cycle, data, and memory.
With Backbone, don’t leave your jQuery plugins shivering out in the cold production air. We can keep them warm and toasty in a coat of Backbone view goodness. Gone are the days when we just copy and paste plugin files and start hacking in our script tags. Now that we have the expressiveness and modularity of Backbone views to manage our application behavior we can build a reusable facade for jQuery plugins. I’m going to provide a guide to wrapping our jQuery plugins cozily in Backbone views.
I’ll be giving you an alternative to large spaghetti .render() methods that make every jQuery plugin initialization call. I’ll walk you through the key tactics in decomposing a plugin into it’s core functionality and explain how to flexibly build your backbone view. We will also discuss the best patterns and styles for wrapping different kinds of jQuery plugins. Most notably, I’ll be going through the process of wrapping jCarousel in a Backbone view that can be reused in many different situations.
If you're developing a Backbone app, you're likely also creating an interface with UI components that you want to re-use. The usual approach to UI components is jQuery plugins, but as it turns out, they're not the only way and not necessarily the best way.
At Coursera, we have been standardizing on an alternative approach to building libraries to better deal with the issues of addressing the scale of our team size, building flexibility into our libraries, and making it possible for designers to work with them in pure HTML. In this talk, I'll walk through our library design principles and show examples using it, like popups, modals, uploaders, a rich text editor, and A/B testing library.
The intersection of mobile and cloud computing is driving significant change in the enterprise environment. Innovation projects designed to meet the increasing mobile demands are acting as the thin edge of the wedge for cloud services.
At the heart of this intersection is the mobile web. Large companies with a fragmented device landscape want a universal solution to their mobile pains, and apps built with tools like Backbone, HTML5, and backend as a service are uniquely positioned to provide that solution.
This session will explore how to leverage these three technologies for the unique needs of an enterprise client. We'll cover topics like data security, offline usage, and integration with existing legacy data sources. In addition to technical topics, we'll also touch on the selling points for this approach: efficiency with cross platform solution, leveraging existing infrastructure investments, and future proofing via abstracting from data sources.
Disqus is the web's largest discussion community. We process millions of comments every day, across hundreds of thousands of websites, including CNN, IGN, Rolling Stone, MLB.com, and NPR – to name a few.
Early last year we re-wrote our embedded commenting application from the ground up using Backbone. Being a non-standard application (embedded in other people's websites), working with a not-quite-RESTful API, built on a set of terribly unpopular microlibraries (Ender), we've had to bend Backbone to do terrible – and sometimes neat – things.
In this talk, I'll walk through the architecture of the ""new"" Disqus application and our relationship with Backbone. I'll explain why and how we use iframes, and how it affects Backbone's development model. I'll also talk about some unique hacks we do with models, and how we communicate with our legacy-ish API.