Speaker Lineup

Check back in January for full details on the agenda :)

This talk is a technical deep dive into the implementation of Glimmer 2, and what it will enable going forward.

It will cover the basic architecture of Glimmer 2, how it integrates with Ember, and how it fits in with FastBoot, Progressive Web Apps, and Off Main Thread rendering.

Check back in January for full details on the agenda :)

There have been some amazing, audacious public projects. Chicago in the second half of the 19th century is up there at the top. There are a ton of lessons to be learned from 163 year old public works projects in building software today.

Think lightning talks, but better curated and better prepared. We've selected a handful of really great topics that are critical to get before the EmberConf audience, but not neccessarily needing a full 30 minutes.

Ember stands on the shoulders of hundreds of contributors. Some land a small bugfix, and others refactor entire APIs. Some write documentation or improve CI reliability, and yet other help with deployment and automation. All of them started small before making a larger contribution.

Join us for a loosely structured day of hacker hours and instruction that will include presentations on how to make a PR to Ember, tutorials on how to contribute to documentation, and everything you need to know about how to collaborate on RFCs.

This Workshop is sponsored by 201 Created, and the $29 registration fee will go toward conference scholarship programs.

Lunch will be served.

Though component and custom element patterns have become the standard for web application architecture, communicating from one solution to another remains fogged by guesswork and opinion.

How should you write a web component that needs to be compatible with Ember and other frameworks? Where are the tradeoffs between purity of design and ergonomics? In a talk touching on libraries and standards, come learn how to write component code useful across many environments.

This workshop is designed for both the intermediate and advanced Ember.js developer. Understanding of core Ember.js concepts is assumed, as we plan to cover more advanced topics.

As we know, Ember.js aims to enable developers by giving them leverage of an entire ecosystem. This workshop aims to build on that foundation by distilling advanced patterns used in real life ambitious applications into a series of lab like exercises, discussions and lessons.

In the real world, latency is variable, requests fail, the features are due Tuesday and users still expect a good experience. Attendees should come away from this training enabled, and confident to tackle advanced user interfaces, without succumbing to excess complexity.

As such, the general theme will revolve around building reliable state-full user interface, while keeping implementations idiomatic, maintainable and most importantly enjoyable.

High Level Topics

• TDD/Maintainability
• Ephemeral and Persistent State
• Asynchrony/Latency
• Rich user experiences
• Reliability in the face of failure
• Keeping complexity low and productivity high

Expectations

• Intermediate to advanced Ember.js knowledge
• Laptop with working installation of ember-cli (latest stable version) and npm
• Pair programming encouraged!

Ticket price of $299, class size limited to 30 students.

Coming Soon!

Service Workers are now available in browsers but why should we as Ember developers care about them?

In this talk we will examine some of the common use cases for Service Workers and patterns for implementing them in your Ember applications.

You may have heard the quote, "Good artists copy, great artists steal."

Ember's origins were inspired by Cocoa. Ember has taken many cues from Rails, the biggest coming in the form of strong framework conventions. In 1.13, Ember's rendering engine was rewritten based on concepts pioneered by React. Instead of writing their own cli from the ground up, Angular has embraced ember-cli.

Let's examine past and future benefits of sharing ideas, and what it means for our favorite framework and our industry as a whole.

What's in an Ember <select> element? For a long time, the answer was two-way data binding, observers, and an obscured DOM, along with the challenges and bugs that went with it.

Today, we can move beyond the {{view “select”}} helper and render this common UI element using native DOM and one-way data flow. Through the lens of the select element, both as standalone code and a re-usable component, we’ll learn how and why to use good Ember patterns like data-down, actions up (DDAU), plus some handy new Ember features like closure actions and the mut and {{get}} helpers.

We'll approach Ember as an illustrated fairy tale: drawing upon the power of story telling to describe the creation of an Ember application through its inciting incident, caste of characters (object model), and the conflicts that arise and how our heroine overcomes them through wit and cleverness.

You may have seen apps like Slack, Visual Studio Code, or Docker's Kitematic: desktop applications written using Node.js and Chromium. You might be hoping to build something similar.

Electron was originally built for the Atom editor, and enables developers to build beautiful cross-platform apps using the JavaScript we all love. When combined with Ember, you're looking at a fantastic desktop app development framework.

Ember and Electron are a match made in heaven, and this talk will teach you all you need to know to get started building desktop apps with Ember.

"I’ve always been a backend guy. I love Ruby. Keep things simple. Oh no, not another JavaScript framework..."

This was me a year ago. Now I don't feel like this anymore. Matter of fact, the other day I caught myself saying:

"I can do everything in Ember!"

In this talk, I will narrate the journey that turned a hardened Ruby Engineer into an Ember enthusiast. I will recount how I escaped from the "New to Ember" pits of despair, how I fought in the "Upgrade Wars" and ultimately how it changed my mind about all software development.

As I learned Ember, I learned to love Ember.

It is possible to create performant mobile applications with Ember and Cordova, and to achieve this with your existing Ember application. But most peoples first hybrid experience is seeing serious performance issues and stop ("It doesn’t feel native").

This talk will serve beginner and intermediate Ember developers looking to extend their application to mobile. It will touch on both the best tools in the Ember ecosystem, and best practices for optimization and performance.

Creating a living design system is essential to developing a cohesive experience for users over the lifetime of a product. Ember tooling and conventions make this easier than you might expect.

By organizing your application functionality into Ember components, you can easily build a living style guide to showcase key features, design patterns, and user interactions. This fashion of style guide driven development enables a rapid implementation and feedback cycle, a comprehensive overview of key features, and the blissful feeling of providing order in a chaotic world.

In low level languages, primitives exist for memory management. Despite the C-like syntax, JavaScript is garbage collected, causing many front end developers to feel it does a great job of memory management for us. But how does it actually work and does it work how we think it does?

This session will discuss memory management in JavaScript (compared to other languages) and what is really going on behind your browser. Using an Ember.js application, we will also discuss best practices to optimize our code, how JavaScript and Ember optimizes for us, and ways we can address common pain points.

Denial, anger, bargaining, depression, acceptance. But I don't mean the five stages of grief—I'm talking about the five stages of debugging your first Ember app!

Learning how to navigate the building blocks of Ember can be difficult, but the even trickier thing is knowing where to start debugging while you're still learning the framework. One approach that I use is to put myself into my code's shoes.

In this talk, we'll connect with our objects to understand what's going on under the hood. Let's jump over some common first-time Ember hurdles together by debugging our code—with empathy.

As the tooling ecosystem continues to evolve, developers nowadays can easily scaffold out a new Ember app and start being productive right away, without ever thinking of all the intricacies that go on behind a typical build command. But there comes a time when manipulating trees or nodes in Broccoli may be required to support a custom project architecture, or you may find yourself having to extend the build for specialized environments through addons.

Whether you face any one of those scenarios, or you simply want to know more of what goes on behind the curtain, this talk is for you.

Ember has primarily been known for allowing small teams extremely productive to ship ambitious applications to the web, what does this look like when you scale it out to hundreds of engineers and for a web property that has over 400 million users?

In this talk I will show how we shipped our first Ember application and how we addressed everything from tooling to performance.

Whether you know it or not, you're building a distributed system. This becomes painfully obvious when taking Ember apps into the developing world. Flaky network connections pose real challenges for developers building stateful applications in the browser.

This talk is about my trials and tribulations taking Ember offline in Africa. We’ll look at the tools necessary to venture offline, how they apply to Ember specifically, and a little bit of theory to drive home the hard facts about how much fun you’ll have building a distributed system!

So lets talk about two teams, both with old, messy, outdated code bases. One team chooses a framework, refactors behind the scenes, ships new features and one day have a shiny, modern code base.

The other rewrites it all, from scratch, with sprinkles of JavaScript. How did these two teams fare? In this talk we'll find out. Spoiler alert... both teams are happily using Ember today.

Ember is generally used to build ambitious web applications, but what about ambitious web games starring your cat? In this talk, I'll go over how to use Ember to build, organize, and deploy HTML5-canvas based games.

Using Ember to develop games shares the same benefits of using Ember to develop applications—both the toolchain and the conventions alleviate decision fatigue. For example, route-driven paths are great at handling levels, Liquid Fire provides lovely transitions for menus, and adapters provide a standard way to connect to backends for saving high scores.

Say you're building a chart, what's the most natural representation for specifying a visualization? A configurable chart component? Abstract components which can be used together to create something larger? Or low level primitives which can give you fine grained control over your presentation?

In this talk I will introduce D3 Shape, and demonstrate how you can compose reusable Components which solve all of the above requirements for quickly visualizing information in Ember.

Mocha? Chai? Qunit? Jasmine? What's the difference? Which one is best for me? How do I use these new integration tests? What are mocks and stubs and how should I use them?

With so many different testing frameworks, libraries, and addons, and so many different styles and approaches to testing your Ember apps, it can be daunting to get started building a test suite to meet your needs.

Don't be scared! I'm here with my nonthreatening lightbulb-powered Easy-Bake testing guide to help you out!

With the release of Ember 2.0, many best practices established in the 1.x series are unfortunately no longer relevant. Lessons learnt from the React and Flux communities can help guide the path toward The Ember Way, with "Data Down, Actions Up" being one of the core philosophies.

In this beginner-friendly talk, we'll discuss patterns and anti-patterns for bringing Ember applications into the 2.x paradigm, and discover how ideas from Functional Programming and game rendering engines can inform us. We will also look at the roads ahead to see what future versions of Ember will bring.

For nearly two years now, new Ember addons have been published daily. The availability of quality addons has grown to be a crucial part of the Ember experience.

Let’s talk about how addon developers, Ember contributors, and end-users have contributed to this ecosystem, and how we can each do our part to make Ember’s addon community even better.

Immutability. It may sound like an ominous something from the far-off galaxy of math, but in practice, it's one of the most pragmatic tools for thinking about UI.

In this talk we'll explore the problems that an immutable style solves, and how you can use it as a thought-tool to both design and implement more powerful and composable components.

Throughout we'll see just how deeply Ember supports this mode of thought at every step of the way.

While Ember is designed for building ambitious applications, the documentation and public resources mostly focus on new applications, making lots of things simpler to write from scratch.

This talk will share my experience migrating an existing application to Ember part after part. I'll share tips for how to avoid the unpopular "Big Bang rewrite" (minimizing the costs of adoption), and discuss the integration story and loose coupling of Ember.

Compilers are all around you: Babel, Handlebars/HTMLBars, Glimmer, Uglify, and more. In this talk we'll walk through every part of a compiler from the parser to the generator. Learn about visitors and traversal, paths, scopes, bindings, and everything else. By the end compilers shouldn't seem like magic, and maybe you'll even want to contribute back to them.

Many Embereños use the framework for their side projects, but have not yet had the opportunity to work on an Ember project in their professional lives. This talk will cover one team’s journey migrating a legacy codebase to Ember.js.

Key topics will include the redesign and rewrite of a highly complex and detailed customer-facing user dashboard, challenges faced when porting an application to Ember, and the results of the migration project in terms of improved application speed, security, and overall performance.

This talk is a technical deep dive into the implementation of Glimmer 2, and what it will enable going forward.

It will cover the basic architecture of Glimmer 2, how it integrates with Ember, and how it fits in with FastBoot, Progressive Web Apps, and Off Main Thread rendering.

The bigger a project gets, the more important communication and consistency across the whole team becomes. In order to achieve this, it is critical to establish an integrated workflow with all team members. In this talk, a designer and a developer who worked together on various Ember projects will present an effective way of handling these challenges.

Three levels of documentation will be presented: A living styleguide for designers, a component guide for designers & developers and a JavaScript documentation for developers.

The bigger a project gets, the more important communication and consistency across the whole team becomes. In order to achieve this, it is critical to establish an integrated workflow with all team members. In this talk, a designer and a developer who worked together on various Ember projects will present an effective way of handling these challenges.

Three levels of documentation will be presented: A living styleguide for designers, a component guide for designers & developers and a JavaScript documentation for developers.

This workshop is designed to provide both the beginner and intermediate JavaScript developer in the Ember ecosystem with a solid understanding of test-driven-development. If you're familiar with the concepts behind testing or test-driven-development but you haven't yet applied them in your daily work this course will transform you into a more confident software engineer by working through several hours of live coding.

We start with the basics (ember-cli, testem, ember-qunit) and quickly move into writing real software. Each section has both a lecture and hands-on lab to get you comfortable with the idea that testing can be a powerful feedback tool.

Expert level JS/Ember experience is not required, but because the workshop is only a few hours we won't have enough time to teach the very basics of the language—so make sure you've got that knoweledge in advance. In addition, familiarity with ember-cli will be beneficial as each hands-on lab includes writing features and/or fixing bugs with the command line tooling.

Introduction

• What is 'test-driven' and why should you care?
• A quick overview of ember-cli / testem
• Unit testing with qunit
• Integration testing with ember-qunit
• Acceptance testing with ember-testing

Outside-In TDD

• Start acceptance testing the new feature
• Discuss test friction and how to 'listen' for it
• Integration testing the web component in isolation
• Redefine 'unit test' as we decompose the data modeling requirement

The Feedback Loop in Action

• Describe a production bug that has crept into the system
• Deep dive on the thought process as we sift through routes/services/components
• Use advanced techniques like pauseTest() and done() to get feedback in the browser

Advanced Techniques

• Writing a custom async helper for file upload
• What registration and injection look like without the helpers
• How to extend qunit when necessary

Ticket price of $299, class size limited to 15 students.

This Workshop is open to members of the EmberConf Women Helping Women Program.

This fun workshop is a mix of lecture, exercises, and discussion, focused on practical techniques and principles that can help you level up your skills for speaking to any size of group. Learn how to adapt your body language and content to communicate effectively to dozens, hundreds, or thousands of people—and how to recover when things don’t go as planned.

Details on the WHW program.

Ember stands on the shoulders of hundreds of contributors. Some land a small bugfix, and others refactor entire APIs. Some write documentation or improve CI reliability, and yet other help with deployment and automation. All of them started small before making a larger contribution.

Join us for a loosely structured day of hacker hours and instruction that will include presentations on how to make a PR to Ember, tutorials on how to contribute to documentation, and everything you need to know about how to collaborate on RFCs.

This Workshop is sponsored by 201 Created, and the $29 registration fee will go toward conference scholarship programs.

Lunch will be served.

This is a live training session of Code School's not-yet-released Warming Up With Ember course, a follow-up to the free Try Ember course (both coming in February). This course teaches Ember application development using the current versions of Ember and Ember CLI. Participating in a live training session gives you the opportunity to ask questions and get personalized feedback from our experts and support staff.

This course targets early-to-intermediate Ember developers who are looking to learn and use application testing techniques, create Handlebars helpers, integrate with Ember addons, develop custom components, and, most importantly, work with Ember Data.

Like all Code School courses, this session is broken into small, focused, and comfortably consumable levels. These levels will each present a new set of concepts and techniques. Following each level's training portion, you will immediately use what you've learned to solve various coding and concept challenges.

It is expected that you come to this training session with an understanding of the basic concepts within Ember (the router, routes, templates, models, and components). If you're not there yet, be sure to get familiar with these concepts on your own or by completing Code School's free Try Ember course.

The training is designed to get Ember developers more comfortable with customizing their Ember Data adapters and serializers and help them handle one off issues they might encounter when dealing with strange APIs in the wild. It will help both developers who need to modify their apps to work with APIs which are not fully JSON API compliant as well as aspiring adapter authors.

When you finish this training you will be able to quickly get going with Ember Data using your own adapter for custom backend APIs. And even if you still use the JSONAPIAdapter, you will have a better understanding of how it works and will have learned multiple techniques for quickly solving common issues and customizing for the specific quirks of your backend.

In the first part of this training you will go through a series of exercises which will guide you through writing a basic Ember Data adapter from scratch. This will expose you to the high level adapter APIs and help you understand how the production ready JSON API Adapter works.

The second part of the training will focus on using the knowledge gained from writing the adapter from the ground up and applying it to customizing the JSON API Adapter. We will show several common techniques for modifying the JSON API Adapter in order to solve complex issues when dealing with APIs which are not fully JSON API compliant.

This training assumes basic to intermediate knowledge and experience using Ember as well as a familiarity with using Ember Data.

Ticket price of $299, class size limited to 30. Proceeds of this class will be directed towards funds for conference speakers.

This workshop is designed for both the intermediate and advanced Ember.js developer. Understanding of core Ember.js concepts is assumed, as we plan to cover more advanced topics.

As we know, Ember.js aims to enable developers by giving them leverage of an entire ecosystem. This workshop aims to build on that foundation by distilling advanced patterns used in real life ambitious applications into a series of lab like exercises, discussions and lessons.

In the real world, latency is variable, requests fail, the features are due Tuesday and users still expect a good experience. Attendees should come away from this training enabled, and confident to tackle advanced user interfaces, without succumbing to excess complexity.

As such, the general theme will revolve around building reliable state-full user interface, while keeping implementations idiomatic, maintainable and most importantly enjoyable.

High Level Topics

• TDD/Maintainability
• Ephemeral and Persistent State
• Asynchrony/Latency
• Rich user experiences
• Reliability in the face of failure
• Keeping complexity low and productivity high

Expectations

• Intermediate to advanced Ember.js knowledge
• Laptop with working installation of ember-cli (latest stable version) and npm
• Pair programming encouraged!

Ticket price of $299, class size limited to 30 students.

The training is designed to get Ember developers more comfortable with customizing their Ember Data adapters and serializers and help them handle one off issues they might encounter when dealing with strange APIs in the wild. It will help both developers who need to modify their apps to work with APIs which are not fully JSON API compliant as well as aspiring adapter authors.

When you finish this training you will be able to quickly get going with Ember Data using your own adapter for custom backend APIs. And even if you still use the JSONAPIAdapter, you will have a better understanding of how it works and will have learned multiple techniques for quickly solving common issues and customizing for the specific quirks of your backend.

In the first part of this training you will go through a series of exercises which will guide you through writing a basic Ember Data adapter from scratch. This will expose you to the high level adapter APIs and help you understand how the production ready JSON API Adapter works.

The second part of the training will focus on using the knowledge gained from writing the adapter from the ground up and applying it to customizing the JSON API Adapter. We will show several common techniques for modifying the JSON API Adapter in order to solve complex issues when dealing with APIs which are not fully JSON API compliant.

This training assumes basic to intermediate knowledge and experience using Ember as well as a familiarity with using Ember Data.

Ticket price of $299, class size limited to 30. Proceeds of this class will be directed towards funds for conference speakers.