We'll cover our special agenda, and ensure that everyone's set up properly

To kick off our first topic, we'll take a trip through the glue that holds our apps together. First, we'll go on a trip through the application and registry objects, touching on the changes around the recently-added Ember.getOwner API. Then we'll explore initializers and instance initializers -- the most common place to make an adjustment to these kinds of objects. Attendees will be left with a methodical process for debugging container-related issues.

We'll use an initializer to get a user's geolocation data, and store it in the container for later, using the registration API.

Let's take a look at how Ember finds ES6 modules in particular places using the Resolver. If you get a module not found error, where can you look to see all registered modules in your app? How can we add a new ES6 module to our project? How can we ES6-ify a global or a named AMD module?

Let's make a wrapper around the Math global, so that we can consume it as an ES6 module. This technique will pay off when ember-cli supports tree shaking in the future, because it'll be clear which symbols are consumed from each library (the rest can be omitted from production builds).

Broccoli is the asset pipeline inside ember-cli, and its great at one thing: transforming files. Most of the magic happens in Broccoli plugins, but if you've never written one, they can seem like a black box. Let's change that!

Building a broccoli plugin is a little different from what you're used to, if you mostly work with client-side JavaScript. Broccoli plugins can be thought of as streams; lazily evaluated parts in a functional chain.

Build your own broccoli plugin to add copyright comments with a date stamp to the top of production .js files.

Fastboot is ember's server-side rendering technology, and compared to the React and Angular 2 counterparts, it's unbelievably easy to use. We'll explore the benefits of using Fastboot, and address some of the important requirements of preparing your app for running in Node.js.

I'll also outline the moving parts involved with an auto-scaling production-grade Fastboot cluster, using AWS services as a case study.

Break for Lunch

State management problems can haunt even the most meticulously-maintained apps. We'll discuss four categories of state, provide a framework of questions that will help you identify things that belong in that category, and describe and some best practices for state management.

We'll put our newfound state management expertise into practice, and add several features to our project!

We have a few choices when it comes to implementing basic UI logic: we can use libraries like ember-composable-helpers and ember-truth-helpers, or lean on the tried and tested concept of computed properties. We'll weigh the pros and cons of each approach, illustrating some clear cases as well as some grey areas.

We'll add two new features to our project. One by way of logic in templates, and another using composable computed property macros.

With components, addons, in-repo addons and now routed and non-routed engines, we have more tools than ever to design our app in a modular way. Lazy engines provide us with a means of gradually loading static assets on an as-needed basis.

We'll first explore the various tools at our disposal, and strategize about how to best apply them in the context of our project app.

With our newfound knowledge of in-repo addons and engines, we'll start to break our app apart into layers, with components and state shared between them.

We'll recap how far we've come today, and provide some guidance for further learning on these topics.