Ember, Angular, React, Polymer, and Backbone. Following in jQuery's footsteps, these projects (and others) are helping to drive some future APIs in the browser.
While they all get lumped into the category "Frontend MVC", an intimate look at each reveals they are quite different. These stark and subtle differences matter when choosing one for your project.
In this session, you'll see each project's sweet spot, and where each struggles. You'll get a healthy dose of code as we explore the primary APIs. You will walk away with a better understanding of the goals and intended use-cases for each project.
Comparing Angular, Backbone, Ember, Polymer and React.
We're all building a client-side framework. And they're all different implementations of the same stuff. I want to compare the approaches that popular frameworks take to solving these patterns. If they even try to solve them at all. I also want to include info about the custom framework that Yammer uses. It'll be illustrative to see how all of these have different approaches to the same set of patterns.
Ember.js is arguably the most thought-out of the bunch. One of its key principles is Convention over Configuration which might sound familiar to some of you ;) Most rich-client apps still need a server-side component, though, to fetch data from and store data to, and we all know Rails also shines when it comes to building an API.
In my talk, I'm going to go through the steps of building a real web application with Emberjs on the client side and Rails on the backend. Rest assured I'll also point to all the code we're not writing ;)
As ember is being used for the foundation of even more ambitious web applications, the appeal of leveraging less code to do more has grown. Keeping composability in mind will allow teams to effectively build their own layers of “boilerplate” on top of the framework, and build apps high quality and velocity.
In this talk, we’ll dive into composable components, computed property macros and tests to explore how investment in generic code can pay off in terms of high degrees of maintainability, testability and extensibility.
We love Ember, but wouldn't it be great if the components we want or create were host framework agnostic? W3C Web Components aims to do this, but it’s missing a large part of the story. Graffiti fills in these gaps using HTMLBars, ES6/7++ syntax to let you experience the future, now. Kumbaya, all the frameworks can now hold hands.
After upgrading Ember we might have times where we start to receive warnings about things that we should update in our code because of deprecations.
We can write scripts with tools like sed or Perl to fix our code but, when we are working with multiple teams and projects, we can see that those scripts start to fail or are not easy to maintain.
In this talk we’ll cover a different approach to update our code through direct operations on its abstract syntax tree (AST) using recast and how to distribute our solutions as addons so they can be used by other teams.
Specifically we’ll see how AST transform are used for scenarios like:
- Route generation in ember-cli
- Update QUnit tests via ember-watson
- Upgrade Ember-Data deprecations
Ember.js describes itself as a framework for creating ambitious web applications. But “ambitious” doesn’t have to stop at the boundaries of the web world.
Projects such as NW.js have shown that it was possible to write cross-platform desktop applications using web technologies. NW.js goes even further, letting you interact with Node modules directly in the browser. But here’s the catch: without proper guards and good code organization, issues can arise quickly, leaving you fighting your way through an environment where Node and browser contexts don’t always play well together.
In this talk, we will explore some of the challenges you may face, and how you can overcome them with simple tools and techniques. You don’t have to look very far for answers. Ember and Ember CLI provide just the right hooks to make desktop applications a breeze to develop and test.
You’ll leave this talk with a few techniques you can bring to your applications tomorrow and hopefully a new approach to thinking about building web applications.
Millions of web apps are silently suffering and you can help. These web apps are dying because they don’t have the means to work offline. You can end the suffering today. Your Ember apps can have a brighter future by using features like Application Cache, offline storage and Service Workers.
In this session we will explore what it takes to build an offline-first Ember app by examining an open source Ember project built to run in locations lacking stable Internet like parts of Africa and Southeast Asia.
As an ember developer, we have a large collection of tools at our disposal. Sometimes it is tricky to know what the best tool is for a given task.
Likely one of the most problematic ambiguities comes from the pair computed properties and observers. Existing ember docs and guides treat these concepts as equal pairs. It is even common for established ember developers to have details of the two confused.
This talk aims to clear up the confusion and demonstrate the blissful joy of an (nearly) observer free world.