Now that the dust has settled on EmberConf 2019, I thought I’d take some time to write up my experience and what I learned.
EmberConf is one of my favourite conferences, not only because I get to geek out with fellow engineers about Ember.js, but mainly due to the stellar organization by Leah Silber and the amazing EmberConf team. EmberConf places a big emphasis on inclusivity, with no space for harassing behavior or anything that makes anyone’s experience unpleasant as is outlined in their code of conduct. It’s great to be part of such a welcoming community and the organisers should be very proud of the atmosphere that they foster, I didn’t see one unhappy face!
The night before the storm
Conference day one rolls around, and it’s keynote time, the room is packed with 1000 or so people, the lights dim and Yehuda and Tom approach the stage. As is customary for EmberConf, they start off with reiterating that EmberConf is an inclusive conference and if you feel someone looks uncomfortable to go and interject into the situation to disperse it or speak to a conference organiser. I’ve never seen anyone look uncomfortable at EmberConf — quite the opposite for that matter, which is fantastic.
Tom covers a bit of Ember’s history, being 8 years old this year, and highlights how much the web has changed since Ember was released. The web has evolved so much in the last 8 years, and Ember has kept up and in a lot of cases spearheaded those changes. Ember was founded on the idea of being a framework to “Build ambitious web applications” and one of the founding values of Ember is “Climb the mountain together” (borrowed from DHH). So the mountain is “ambitious web applications” and we climb it together through shared tools, shipping features, and with big changes we move as a community. This really is a fundamental benefit of Ember, that the shared conventions, tooling, and features avoid bike-shedding over things that we as a community collectively agree on and allows Ember to focus on innovation and new ways of solving common problems in a cohesive manner.
A quick recap of some of the things that Ember has done in the past 8 years:
Things like the six-week release cycle, the RFC process, and engaging in standards and code mods have made it easy and predictable for everyone who uses Ember to upgrade as a community and benefit from all the enhancements that come with that. To that end, the Ember Community Surveys show that the majority of users are on the latest LTS or newer version of Ember.
Using the same tools is also important, Ember CLI allows everyone who uses Ember to use the same build tool, and combined with Addons allows for shared extensions to Ember and the build pipeline and allows for the community to experiment and extend Ember in predictable and collaborative ways. Due to the shared conventions anyone opening an Ember application should immediately feel at home and understand how the app is structured, how the build pipeline works, and how additional functionality can be added through shared endeavors.
Stability & Progress
Frameworks must strike a careful balance with the tension between stability and progress. On one hand we don’t want to break peoples apps when they upgrade, but at the same time we don’t want that to necessarily hold us back from progress, we must climb the mountain together. As such one must strike a balance between aggressive changes cause community fragmentation and cautious changes that leave Ember falling behind its competition.
During the Ember one lifecycle, lots of aggressive changes were made at the expense of leaving some users behind who were unable to upgrade. Comparatively in the 2.0 release cycle, very few major features landed with most releases saying “No new features are added in Ember core”, but focused more on internal non-breaking changes to improve stability and coherence. On that note, the fact that the core team managed to ship an entirely new rendering engine under the hood without breaking existing apps, but whilst simultaneously taking advantage of new technologies and improving rendering performance of over 2x is pretty staggering. The Ember 3.0 release cycle tried to strike a balance between shipping things incrementally whilst keeping an eye on the direction of the whole system, driving towards coherence.
Coherence is about how features and APIs interact with one another, and making commitments to stability without designing the entire future. For example it means we don’t need to land all the changes to a specific programming model in a single release, we can improve the model in one so that new features can be adopted and peoples lives become easier, and finish it off in another thus rounding out the full model and making the API coherent.
An example of this is the component getter and setter model, and how to get rid of
this.foo = 'bar' would have in the 2.0 series been held back by not having a good story for the setter and this make an asymmetrical and incoherent API. However in the 3.0 series the decision was made to ship the getter syntax, and continue working on the setter syntax until a good solution had been found, and when it does, symmetry was restored and the API became coherent again. So long as there is a long term goal of where we need to get to, we can get there iteratively without having to land everything at once. This strikes a balance between progress and stability.
The problem with this idea of intentionally making something incoherent for the sake of progress leads to the intermediary state potentially being confusing to developers. This confusion state has been termed “the pit of incoherence”, it’s the middle point between where we are and where we want to be.
The side effect of this is the idea of “churn”, that developers have to continually upgrade their apps and adopt new models and ways of thinking, rolling with the punches if you will. So there needs to be a way to communicate to developers when a set of APIs and features have all landed and are all coherent, that documentation is ready and the set are officially supported by the core teams. Traditionally this would be done by cutting a new major release, but Ember uses major releases to signify things that have been finally removed after being deprecated instead of new features being added. This really is the idea of a major version change, signifying that change have been made without preserving backwards compatibility. What most frameworks tend to do however is bundle end of life features with new features, which makes it difficult to upgrade and developers are faced with not only features being removed, but also having to learn new paradigms for the new major version. As an attempt to solve this, Ember is introducing “Editions”.
And with that, Ember will be releasing its first “official” edition: Octane. Octane is a snapshot of the Ember framework at a given time when a set of features are cohesive and represent “the new way” of building an Ember application. These features are as follows:
Octane is a snapshot, a “peak” of coherence where the core teams have landed a bunch of great new features and now is a good time for the community to adopt them.
To find out more about Octane, checkout the offical preview website.
I think editions is an awesome way of packaging a set of features that together for a cohesive experience, that isn’t coupled to a semver major release but allows developers to adopt a complete set of changes in one go, invest in learning the “new” ways of doing things and collectively we as a community move up the mountain together.
I think Tom said it best at the end of the keynote:
“I got into web development in the first place because I wanted to make cool things for my friends, and I really love the web because I could write a little bit of code, save the file and instantly I got that feedback loop and I saw something happening on the screen. A little bit of code gave me something really visual and fun and interactive, and I could share it with my friends and they loved it as much as I did. I want that feeling when I’m building things at work.”
And Tom is absolutely right, using Ember Octane really does have that similar feedback loop, it really does feel fun.
You can find out more about Ember Octane on the Ember.js website https://emberjs.com/editions/octane/ or watch the EmberConf keynote (and the rest of the conference) in full here: https://www.youtube.com/watch?v=O3RKLHvpUAI
I personally want to give a huge shout out to all the Ember core team members who have made this possible, bravo 👏