Ember Training at Ticketfly

In this intense training, designed for those already familiar with the framework, we'll work with Fastboot, engines, and the progressive web app technologies that will help you take your apps to the next level.

Ember Training at Ticketfly

Advanced Training

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!

    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.

  • Advanced TrainingEXERCISE: Broccoli Plugin

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

  • 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.

  • Advanced TrainingLunch

    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-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.

  • 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.

Community Favorites

Learn the things that the community has voted that they're most excited about!

New Topics

In this event, we'll tackle the hottest freshest developments in the Ember ecosystem.

Big Picture

As always, all of our exercises build up to some big-picture realizations, that will change the way you think about building apps!