In this special event, we've spun together an exciting combination of topics that'll help you supercharge your day-to-day development work, and those that'll get you invigorated about what's coming in the future of ember.
Advanced TrainingWelcome & Kick Off
We'll cover our special agenda, and ensure that everyone's set up properly
Advanced TrainingBuilding & Booting - On the Client
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.
Advanced TrainingEXERCISE: Initializers & Registration API
We'll use an initializer to get a user's geolocation data, and store it in the container for later, using the registration API.
Advanced TrainingModule Management
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?
Advanced TrainingEXERCISE: ES6 Math
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).
Advanced TrainingBroccoli Basics
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!
Advanced TrainingEXERCISE: Broccoli Plugin
Build your own broccoli plugin to add copyright comments with a date stamp to the top of production
Advanced TrainingBlasting off with Fastboot
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
Advanced TrainingWhere does the State Belong?
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.
Advanced TrainingEXERCISE: State Management
We'll put our newfound state management expertise into practice, and add several features to our project!
Advanced TrainingTemplates: Logic Heavy or Logic Light
We have a few choices when it comes to implementing basic UI logic: we can use libraries like
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.
Advanced TrainingEXERCISE: Logic Heavy or Logic Light
We'll add two new features to our project. One by way of logic in templates, and another using composable computed property macros.
Advanced TrainingModular Architecture
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.
Advanced TrainingEXERCISE: Modular Architecture
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.
Advanced TrainingRecap & Wrap Up
We'll recap how far we've come today, and provide some guidance for further learning on these topics.