An introduction to Ember, some resources, and the prerequisites for installation.

Installing ember-cli and creating your first application.

An indispensable tool for Ember development.

Learning how Ember router, routes, and controllers work.

Links that cover: APIs, RFCs, Discussions, Twiddles, Weekends; Also, an exercise to create a nested route.

The solution to last week's exercise and some readings to prepare for the upcoming work with Components and Models.

Building a custom component and passing a controller action to it.

Ember Data, explained a bit.

A rapid introduction to Ember's Models and JSON API support.

Links on: Serializers, route action helper, and a couple of interviews.; Also, an exercise to show a contact and add an address model.

The solution to last week's exercise, and readings to prepare for learning more about Routes and Components.

A basic introduction to routes, followed by a detailed walkthrough of their lifecycle hooks.

A look at getting data from the route to a component.

An introduction to the lifecycle hooks for components.

Links on: Accessibility, Dependency Injection, Fastboot and Phoenix, Ambition. Also, an exercise to create a component with internal state.

The solution to last week's exercise, and readings to prepare for Services, Initializers, and Dependency Injection

An introduction to Services. Load it lazy-like and let's throw in a Bower package.

Injecting a service from an initializer.

Modifying data on a service by way of an action which will call a method on the service.

Links that cover: Embedding Ember in an existing app; Ember Links; Singletons; Tests and Dependency Injection.

Expanding the current user and some reading about tests.

Using Ember's default QUnit testing to test-drive a component with unit and integration tests.

Learning about testing the whole Ember app with acceptance tests.

Using the Ember CLI Mirage client-side server along with Pretender to make our acceptance tests less fragile and create a nice development environment for data.

An exercise with model relationships and computed properties. Some reading covering testing, es6, and babel.

Solving relationship challenges and reading on component lifecycle hooks.

Using the component helper to add something akin to polymorphism to a template in an existing, relatively real-world application.

Building your app for development and production and a super basic deploy.

Adding JSON-API-compliant pagination to the School Directory application.

Exercise extending our pagination and some reading covering pagination, the component helper, meetup talks, and composable helpers.

Looking at how we extended our pagination in the exercise and a bunch of links about developing addons.

Creating an Addon - Part 1: Getting Started with our Components and Test-driving our Development.

Creating an Addon - Part 2: Testing our Addon and Linking it Locally.

Creating an Addon - Part 3: Creating a Service, Object Destructuring, and Promises.

Exercise to Complete the Data Fetching Portion of our Addon and Links covering DevOps, Actions, Tips, Authentication.

Creating an Addon - Part 4: Exercise Solution for Fetching Data for our Addon.

Finishing the addon, publishing it to npm, and setting up CI.

Going into More Detail with Ember Actions.

Learning about Serializers and Munging Through Irregular Payloads.

Links coving Serializers and Adapters, Mini Talks from Ember Camp London, Broccoli and RSVP, Testing addons, and Ember-ci. Exercise munging relationships out of our payload.

Here we go over our solution to dealing with an irregular payload in our serializer and there is a link to prep for creating, updating, and deleting records.

We are looking at updating records with Ember using Dockyard's Ember Changeset addon.

Adding validations while updating our records.

We look at deleting records then creating records in Ember.

Here we have an exercise to add validation to record creation. We also look at some links covering the Ember Let addon from The Frontside, a talk by Charles Lowell about immutability, typecasting, and the Yarn package manager.

Solution to the previous exercise adding validation to record creation and preparatory reading on the Ember Runloop.

Learning the basics of the Ember Runloop.

A little more on the Runloop.

The villain of our story: Observers.

Our exercise is to refactor some observers into computed properties and we look at links about the runloop, observers, and functional programing in Ember.

Solution to converting a few observers to computed properties and a few links about Fastboot and Deploys.

Here we look at prepping our Ember app to deploy and deploying it to Heroku.

What is Fastboot and how can we use it in our apps?

Talking about computed properties and watching the values of arrays, and using filter, filterBy, and map.

Here we look at a couple of exercises where we can use Ember's built in computed methods.

Here we go over the solutions to the computed exercise and get a few links about templates.

We are looking at using and creating helpers for your templates and utils for use in your JavaScript.

We go over Inline conditionals and other uses of `{{else}}`

Wrapping components can yield context to their wrapped items. We can also really customize a component's HTML element's attributes.

Wrapping up, some places for further learning and some resources to help you moving forward.