Why we use Ember

Ember powers several of our mission-critical apps at Zesty. In this post I'll explain why we think Ember is a great choice for companies.

Why use a JavaScript framework?

Before digging into Ember, it's important to point out why we use single-page apps at all. We have a lot of internal tools at Zesty and we use Rails views for simpler tools. Some of our apps, however, have a lot of dynamic and interactive elements. For example:

  • Our operations app integrates with Firebase to provide real-time context about what's happening with our lunchtime delivery fleet. It is a critical part of how our support team is able to resolve issues so quickly.
  • Our scheduling app provides us a visual interface for interactively assigning drivers to tasks and for resolving conflicts when tasks change.
  • Our sales calculator app allows our sales team to ensure that they are making good deals while tuning various parameters.

These are complex interfaces and we've found that Rails is not the right tool for the job in these cases.

Why Ember?

In short, Ember provides all the tools you need to develop, deploy and maintain ambitious single-page applications.

We first tried Ember out back in early 2014. At that time, our engineering team was two people and our business looked very different to the way it looks today. Our stack was a single Rails app and an iOS app that customers used to order healthy food for takeout or delivery.

At the time, we wanted to build this out into a web app. In a twist of fate, we stumbled on Ember: we liked that Ember shared Rails' philosophy of convention over configuration and had a reliable core team backing it. We didn't have time to exhaustively compare all our options, so we dived in and tried it out.

Ember grows with us

Today, we have nine Ember apps in production with more in the pipeline. Our engineering team has grown to fifteen.

We've seen first hand how quickly an experienced engineer can get started with Ember (usually under a day). We attribute this to the strong conventions and excellent documentation in the guides and API docs. Our engineers have no trouble jumping between different Ember projects when they need to and they feel confident making changes because of Ember's robust testing tools.

Charmander is taking his career into his own hands

May burn opponent.

Ember CLI

Since we started using Ember, we've seen the tooling develop at a rapid pace. Ember now comes with a powerful command line interface that lets you start a development server, run tests, deploy, generate files, and more.

Using the Ember CLI is a core part of the Ember experience and one of the things we miss most when working with other front-end frameworks.

Ember CLI can be extended through the use of Ember addons, which are generally created and maintained by community members. There are addons for almost everything. Here's a taste of some of the addons we use at Zesty:

  • ember-cli-deploy: to manage our continuous deployment
  • ember-simple-auth: to manage client-side user sessions
  • ember-data: to communicate with our api
  • ember-metrics: to integrate with Google Analytics
  • emberfire: to integrate our real-time apps with Firebase
  • ember-bootstrap: to integrate with the Bootstrap CSS framework and its built-in components.

We use Ember Observer to find more addons that we can use in our apps. Ember Observer organizes addons by category and also rates the addon based on how popular and well tested it is.

Ember addons have been a huge productivity booster for our team.

Move fast and don't break things

Single page apps tend to have a lot of asynchronous behaviors that can be tricky to test. Fortunately, Ember has an excellent testing infrastructure that lets you write expressive tests with very little code. Here's an example acceptance test for adding a todo in a hypothetical todo app:

test('simple test', async function(assert) {  
  await visit('/todos/new');

  assert.equal(currentURL(), '/todos/new');

  await fillIn('input.todo-message', 'Pickup some eggs');
  await click('button.todo-submit');

  assert.equal(currentURL(), '/todos');
  assert.equal(find('ul.todos li:first').text(), 'Pickup some eggs');
});

Ember takes advantage of async/await and Promises so that you can write your asynchronous code in a procedural, easy-to-read way.

If you dig into the test above, you'll notice something interesting happens when we await the click helper. Not only does it click the button, but it also waits on all the asynchronous side-effects that the button click may have triggered (e.g. persisting the todo to a remote server, redirecting to the todos index route and reloading the list of todos, etc.).

Writing your tests this way makes them concise and more robust to internal refactoring, allowing us to build quickly without breaking our apps.

Embracing the modern web

Together, Ember and Ember CLI give you easy access to many modern web technologies. Ember CLI uses Babel to provide support for modern JavaScript features like modules, arrow functions, and the async functions discussed above. Ember was an early adopter of promises which are heavily used in the routing layer and in Ember Data.

Ember's renderer, Glimmer, uses a diffing strategy, originally made popular by React, for efficient DOM updates. Using the ember-cli-fastboot addon, you can use Ember to render and serve static pages on the server. With the ember-engines addon you'll soon be able to lazily load parts of your app on demand rather than loading everything up front.

We feel comfort in knowing that Ember will help us keep our apps at the forefront of web technologies.

Even Charmander uses Ember in production

It's super effective!

Stability

The Ember framework is released in four stability tracks: canary, beta, stable and the newly introduced LTS. A new stable version is released every 6 weeks, allowing you to make small incremental steps without having to go through massive upgrade procedures.

The quick release cycle also means that you quickly get access to new features the moment they are completed, but if you want, you can test drive new Ember features that are being developed by using the canary track.

The LTS (long-term support) track is even stabler than the stable track. This track provides a slower release cadence for addon authors so that they know what versions of Ember they should target. You can read more about it on the Ember blog.

Ember follows semantic versioning. This removes any of the guesswork of upgrading. The deprecation guides help you to migrate away from deprecated Ember patterns so that upgrading to the next major version becomes painless. Over the last few months, we've upgraded almost all of our apps to the latest 2.x versions.

Ember's commitment to stability is very important to us because our apps will be used and maintained for a long time.

The Ember community

Ember has a large, vibrant community. There are meetups around the world and a yearly conference. There's a community Slack channel where you can ask questions at any time of the day. Ember is used by independent contractors, consultancies, and companies small and large.

The Ember core team itself is also composed of members from several different companies. This gives us the confidence that changes to Ember reflect the needs of the the greater Ember community.

Give Ember a shot

We believe Ember is a great investment if you're building ambitious applications. We're very happy users and pleased that we stumbled upon choosing to use it when we did. We would not have been able to build our apps as quickly and with the same quality without Ember.

If you want to work on interesting Ember apps, we're hiring! https://www.zesty.com/jobs