Frontend First

Topics include: 04:01: Welcome to Node Dependency Hell. 14:00: How should the way we declare dependencies change if an addon is an implementation detail of another addon? 21:45: Can Ember CLI address these problems a layer above Yarn/npm? 23:25: Is JavaScript's fractured module ecosystem (CommonJS in node vs. ES6 modules in the frontend) contributing to the problem? 26:21: Someone's app broke when they installed their dependencies due to a Mirage dependency changing. How can we reliably solve this for users? 35:05: Even if the tooling were better, there's a cultural problem where JS library authors don't consider the dependencies they bring in. 39:04: Lessons learned: apps should specify strict dependencies, libraries (including addons) should specify lenient dependencies apps should use lockfiles ember-dependency-lint & yarn resolutions are a good top-level escape hatch addons should use the dependencies key & ember-auto-import for most of their dependencies 41:12: Ember Auto Import attempts some deduplication of dependencies. If you're writing an addon that has a dependency the host app cares a lot about, you can use addPackagesToProject to put the burden on host app. 48:33: Would you build Ember CLI Tailwind the same if you were building it from scratch today? 54:55: Call for input. What are any best practices that we've missed? What did we get wrong? 59:20: Mirage blog using GitHub issues teaser Links: Ember Auto Import Discourse topic on conflicting dependencies Dependency Lint Ember CLI Addon Docs Ember CLI Tailwind

Topics include: 01:17: Mirage's new Addon Docs site 35:55: Ember Bind Helper 45:23: Why start with Acceptance Tests? Links: EmberCLI Mirage Ember Bind Helper Sam Selikoff on Twitter Ryan Toronto on Twitter

Topics include: 0:00 Housekeeping: Upgrades, trainings, and nested dropdowns 12:24: FastBoot bug 1: How HTML responses turn into DOM nodes 37:22: FastBoot bug 2: XMLHTTPRequest and redirects Links: Sam Selikoff on Twitter Ryan Toronto on Twitter

Topics include: 03:16: Incidental complexity in SPA development 33:04: Dealing with undocumented but relied-upon behavior in OSS libraries Links: Sam Selikoff on Twitter Ryan Toronto on Twitter

Topics include: 0:00: Making movies 05:08: Ryan Florence's tweet about Twitter App 18:08: Ember Data stores across browsers 32:58: Laravel's ascending option 35:51: YouTube transition to UI pattern 42:15: Ember's build environments Links: Sam's Star Wars movie Ryan Florence on Twitter's PWA

Sam and Ryan discuss the wording behind the proposed "@tracked" syntax and how it shapes their understanding of Ember's new programming model. They also talk about 404 pages, data ownership, and their upcoming EmberConf trainings. Topics include: 0:00: Tracked properties 13:27: 404 pages 26:38: Smart components 41:00: EmberConf trainings Links: Ember Conf Component Side Effects EmberData Storefront Ember Animation Liquid Fire

Sam and Ryan discuss a new process for upgrading Ember apps and Sam's experience using it on EmberMap's codebase. They also talk about leadership in Open Source projects and lessons learned from Mirage. Topics include: 04:45: What is a leader's job? 13:17: Step-by-Step: Upgrading EmberMap Links: Most leaders don't even know the game they are in ember-cli-update Dependabot

Sam and Ryan discuss the difficulty of working with a design system that doesn't have good escape hatches, how implementing HTML and CSS can be more complex and time-consuming than coding user behavior, and some creative approaches to ensuring JSON:API payloads represent canonical server-side state. Topics include: 04:15: Design systems and when they break down 22:38: The complexity of implementing designs in HTML and CSS 34:38: JSON:API mutations. How incomplete response payloads can put your Ember app into an impossible state. Links: Forms JSON API Spec Conway’s Law

Sam and Ryan discuss getting Mirage and Ember to work in CodeSandbox, how FastBoot affects different approaches to rendering responsive content, and different ways an outside-in mindset can benefit product teams and open-source software projects. Topics include: 2:50: Getting Ember and Mirage working on CodeSandbox. Coding in the browser. 10:30: How FastBoot affects the use of screen width services 24:40: Going all-in on outside-in development. Starting at the end. Links: CodeSandbox Mirage boilerplate in CodeSandbox EmberMap Email Course Conway's Law

Sam and Ryan discuss new videos on async testing and declarative form validations. They also talk about why it's so hard to create good abstractions in Ember, or more generally the front-end landscape. They discuss constraints versus flexibility, and how the size of a library's problem space affects the likelihood of arriving at a good abstraction. Topics include: 01:14: Lessons learned from the Async Testing series 06:20: Forms: declarative validations, building blocks & escape hatches 12:56: Why building forms in UI libraries is hard – unconstrained environments 30:45: Philosophical differences, and over- vs. under-abstracting Links: EmberMap's premium series on Async Testing Andrew Clark on Twitter

Sam and Ryan discuss an elegant solution to the async nested dropdown problem, a FastBoot success story regarding inlined CSS, pre-warming FastBoot's cache, and implementing a new design alongside an existing design language. Topics include: 01:11: Solving the nested dropdown by recursively currying an action 25:00: Inlined CSS and caching with FastBoot 40:22: Challenges implementing a new design in an existing design language Links: PurgeCSS

Sam and Ryan chat about the challenges of testing custom asynchronous code. They also talk about React's new Hooks API, and discuss situations where hooks might be more composable than yields and contextual components. Topics include: 00:00 – Testing custom asynchronous code, like an animated bar chart 25:23 – React's new Hooks API Links: EmberMap Async testing series API docs for Ember's testing helpers Overview of React Hooks with Dan Abramov and Sophie Alpert 90% Cleaner React with Hooks – Ryan Florence Sam Selikoff on Twitter Ryan Toronto on Twitter

Sam and Ryan talk about the challenges of building nested dropdowns, whether a component reading data from its children is an anti-pattern, how angle-bracket syntax encourages new components, and whether “CSS best practices” exist. Topics include: 00:40 – Thinking through a nested drop-down navigation menu 35:15 – Building an component & angle-bracket syntax 45:00 – Layout UI primitives 46:35 – What are CSS best practices? How might Tailwind encourage these? 52:17 – "Semantic" classes. Should developers have to name every UI element, if designers don't?

Sam and Ryan talk about their upcoming email course on Ember component patterns, wrapping up their EmberMap series on Functional CSS, refactoring some FastBoot code in Node, and how Mirage might be useful if it could run as a real server. Topics include: 0:30 - Email course in Ember Component Design 8:00 - EmberMap course on Functional CSS with Ember Do you have a preferred API for styled component variants? See Sam's tweet below. 14:00 - FastBoot, and refactoring and testing Node code 31:10 - Pushing Mirage to run as a non-production server Links: Using Functional CSS with Ember Sam's tweet on styled variants Art of Product Podcast

Sam and Ryan talk about lessons from Jason Fried's Q&A about scoping down product features, and how that applies to our open-source work. They also talk about inlining critical-path CSS with FastBoot. Topics include: Inlining CSS with FastBoot (0:08) Scoping down (14:26) Jason Fried's Q&A at Laracon Scoping down at work and in OSS How to handle OSS contributors who add scope How bugs indicate a larger-than-expected problem space How to say no to new features you can't commit to supporting Are there projects that can't be scoped down? Using OSS checkpoints to avoid burnout Links: Jason Fried Q&A at Laracon

Sam and Ryan chat about two new EmberMap series, Forms and Async testing, as well as Sam's keynote at EmberCamp and the best way to avoid product gaps in open-source software. They also answer some listener questions. Topics include: Forms (1:18) Splitting forms into containers and presenters Avoiding premature abstractions (7:03) Which components do you carry from project to project? Asynchronous testing (14:47) Testing animations Sam's keynote at EmberCamp on Product gaps (19:04) Product gaps at companies vs. in OSS Are small packages and convention over configuration at odds with each other? Convention over configuration that decomposes well The risk of bad high-level abstractions in OSS How to "finish" an OSS project Questions: What's the state of TypeScript support in Ember? (48:15) When are observers actually appropriate to use? (54:57) Any tips on refactoring async relationships? (59:34)

Sam and Ryan continue their discussion about the role of product in an engineer's daily working life. They talk about what product gaps are, the symptoms of product gaps on tech teams, and what you can do about product gaps if you're on a team with no product manager. Topics: 2:05 – All about product More product responsibilities fall on engineers than ever before Coders can help surface valuable info to business teams about the tradeoffs of their product decisions Learning product makes coders better because it influences what they code, it increases their chance of building software that will actually be used, and it helps them focus at work The symptoms of a product gap drives engineers to think that they need to code more Product gaps often creep up on medium-size teams that don't have dedicated product managers Symptoms of a product gap: Having three number one priorities Coding after hours Tons of work being done, but feeling like you're moving an inch in every direction Hard time estimating You finish a sprint, and you're not sure what the value was "We just need more engineers" If you're on a team with no product manager, and you have a product gap, what can you do? Ask a lot of questions, and push the product decisions up. Let the whole organization feel the pain of the product decisions that aren't being made. Surface the tradeoffs being made. "But this is not my job, I'm an engineer! I just want to code." If you ignore this stuff, your "just coding" won't be sustainable How to get your engineers out of meetings and firing on all cylinders: a product roadmap Make sure your product cards are not about implementation details How to recognize which decisions you can make as an engineer, and which you can't Why you shouldn't say yes to every work request How doubling your estimates can surface product issues

Sam and Ryan talk about the cost of using engineering as discovery, the consequences of embedding product decisions throughout the design and development phases of a project, and other lessons that software engineers can learn from product developers. They also chat about how they categorize Github issues. Topics: 0:00 – GitHub issue categorization The importance of issue triage Prioritizing bugs over features Getting Things Done 7:53 – Managing product 7:53 - Engineering issues as a symptom of product/process issues 13:05 - The 3 phases of a software feature: product, design, engineering 16:04 - What happens when you embed product decisions in the design/engineering phases of a project 29:27 – Who's the head of product? Design? Engineering? Who is the decision-maker? 31:22 – Falsely believing that all decisions are final. Stakeholder PTSD. 34:07 – Product and marketing decisions are getting made, whether you are making them explicitly or not. 37:00 – If we care about people being successful with Ember, we need to understand the product decisions that are being made on behalf of Ember. In OSS, we are making product decisions whether we realize it or not. Are we making them as a side effect of our work? If so, we could create better software by thinking explicitly about these decisions. 41:04 - What do you do when you've gone through this phase and you learn something new? 41:55 - Small batches (Lean startup). Envelope example. Unknown complexity at the end of software projects. 45:28 - Getting a cross-discipline team in the same room. Having a decision-maker to avoid design by committee. Links: The Lean Startup by Eric Ries

Sam and Ryan talk about the Ember 2018 Roadmap RFC and its focus on improving communication, completing in-progress work, and shipping Ember Octane. They also talk about how to verify complex addon behavior by using full-blown test apps and addons. Topics: 0:00 – Test apps Using full apps and addons in a subdirectory of an addon to facilitate testing complicated scenarios Avoiding implementation details of the build pipeline in testing 12:14 – Ember Octane The Ember 2018 Roadmap RFC The concept of Ember Editions & the first edition, Ember Octane Discussing the areas of focus from the RFC: better communication, shipping a ton of in-progress work, shipping Ember Octane Discussing non-goals for the year Links: Ember 2018 Roadmap RFC Matthew Beale's MU RFC with the {{use}} helper

Mel chats with Sam about getting into Ember, lessons learned from collaborating at work an in open source, and how to make it easier for JavaScript engineers to use better UI patterns. Topics: 0:00 – How Mel got into Ember at JPMorgan 4:45 – Feeling welcome in the Ember community 7:45 – Investing in Ember for the long-term 9:00 – Communicating vision, removing our ego, and empowering others to do work 17:07 – Learning team projects 19:30 – Improving the native accessibility story for Ember 27:25 – Making it easier for JavaScript engineers to use better UI patterns 34:55 – Ember Styleguide and Ember OSS infrastructure 49:10 – EmberCamp Chicago 51:20 – Leveling up in the Ember community Links: Melanie on Twitter: @melaniersumner EmberCamp, September 21, Chicago: http://embercamp.com Melanie's FizzBuzz in HBS How to talk so kids will listen & listen so kids will talk

Sam and Ryan chat (on new mics!) about Ryan's recent video on declarative keyboard events, changes to EmberMap's FastBoot architecture, and some of Ryan's recent work on FastBoot testing. Topics: 0:00 – Ryan's video on declarative keyboard events; other declarative components that haven't been discovered 9:52 – Our evolving FastBoot architecture; which parts can be generalized; a high Lighthouse score; a long uncanny valley 29:11 – Sam's Mirage work, fixing bugs, approaching 1.0; Mirage as a tool to show off work; question for listeners, how do you show your work to your team? 34:51 – Ryan's work on FastBoot testing; how Mirage could work with FastBoot testing; the joy of ES6 classes and async/await in Node Links: Ryan's video on Declarative keyboard navigation: https://embermap.com/video/declarative-keyboard-navigation Ryan's WIP FastBoot testing addon: https://github.com/embermap/ember-cli-fastboot-testing

Jon joins Sam and Ryan to talk about his recent work on rehydration in FastBoot and all the creative ways we can use Codemods to automate the routine parts of our jobs. Topics: 0:00 – How Jon got into Ember at HashRocket 4:45 – Jon and Chase starting the EmberWeekend podcast 7:30 – Greenfield vs. brownfield projects at a consultancy 13:30 – Infrastructure complexities in Ember's ecosystem 18:07 – Jon's work on FastBoot rehydration 41:29 – Jon's work on Codemods & the new testing APIs Links: Jon on Twitter https://twitter.com/rondale_sc Jon's podcast Ember Weekend https://emberweekend.com/episodes Codemod CLI https://github.com/rwjblue/codemod-cli

Sam and Ryan chat about provider components in Ember, including the first renderless components they wrote, the different types of data components can provide, and the patterns of template composition that providers unlock. They also talk about the need for a unified API for styling Ember components. Topics: 0:40 – Our first provider components 10:12 – Using providers to isolate the business logic for a form 27:35 – Patterns of composition in templates 34:35 – How to constrain more flexible interfaces 39:55 – APIs for styling components

Jen talks to Sam and Ryan about her journey learning from and giving back to Ember, and how she keeps her community contributions sustainable by tying them back to personal goals and rewards. Topics: 7:00 – Learning Ember at General Assembly 9:00 – How did you go from learner to contributor? 13:25 – Thoughts on Slack, Stack Overflow and Discourse 18:12 – What advice do you have for folks looking to contribute back to Ember? 24:66 – What are some things you'd like to see change about Ember? 30:39 – What personal projects are you working on right now? 35:10 – Why do you think someone should start using Ember today? Links: Jen on Twitter: @jwwweber(https://twitter.com/jwwweber) The Ember Times: site

Sam and Ryan talk about their initial attempts to get Mirage running in Node, the benefits and workflows that it will unlock, some different approaches for using code in both the browser and Node, and how we might test FastBoot apps in the future. Topics: 4:28 – Getting Mirage to run in Express 21:58 – How to use addons like Mirage work in Node 42:53 – Testing FastBoot apps

Sam and Ryan talk about how to deal with building non-optimistic UIs using Ember and Ember Data, and how constrained visual design tools might help us build better UIs. They also answer some questions and talk about their current series on Functional CSS and Rendering tests. Topics: 0:00 – What's new on EmberMap 8:06 – Options for non-optimistic UI in Ember Data 22:34 – Visual programming Questions: 34:08 – What techniques do you have for authorization (not authentication)? 40:42 - How might you improve the developer experience of working with Ember Data? 50:14 – When can we get TypeScript in Mirage?

Sam and Ryan talk about bringing the ideas of declarative rendering over to our data layers, how easy it is for data to become stale in SPAs, and more stories from their recent adventures in FastBoot land. Topics: 0:00 – Declarative data fetching 18:50 – Stale data in SPAs 30:46 – FastBoot

Sam and Ryan chat about what to do when a node module breaks in FastBoot, how to best wrap 3rd-party libraries in an Ember Addon, and how to test the filesystem. They also answer some listener questions. Topics: 0:00 – Node modules in FastBoot 13:55 – Ember Addons that wrap 3rd-party libraries 19:07 – Testing the filesystem with Broccoli Test Helpers Q&A: 32:11 – How can I speed up my Ember CLI build times? 38:31 – What do you think about the Angle Bracket Polyfill? Would you use it? 42:08 – I'm building an app and I need to build it with skeleton screens. Do I use a model hook with loading states, do I use Ember Concurrency tasks? What approach should I take? 46:44 – I'm building a table, and each row has a bunch of CRUD actions – edit, delete, view. What are the best UI patterns for this? A few I'm considering: a cog that you click that exposes a dropdown menu; icons in the row; buttons in the row.

Sam and Ryan chat about some ideas around caching in FastBoot, different ways of prioritizing work, and the difference between easy things and hard things in Ember. Topics 0:00 – Caching & FastBoot 16:18 – Project process, workflow, bugs, features, and issue urgency 37:47 – Easy vs. hard things in Ember. Ember focusing on its strengths.

Toran talks to Sam and Ryan about his project Ember CLI Hot Loader, which is an implementation of component-based hot module reloading for Ember apps. Topics: 0:00 – Losing hot reloading when moving from handwritten CSS to functional css 2:16 – Why Toran wrote the Hot Reloader 4:45 – How the hot reloader leverages Ember CLI to reload components 8:31 – The need for hot reloading 14:56 – Are there situations where you don’t want to use the hot reloader? 19:05 – What’s the easiest way to try using the hot reloader today? 21:05 – Design vs. build mindset 22:30 – Engines aren’t currently supported 23:53 – How local state affects hot reloading 27:50 – Fast feedback is the primary motivation 34:05 – What are the next steps for Ember CLI Hot Reloader? 37:51 – What happens to a component’s transient state if it’s hot reloaded? 39:44 – How to help if you’re interested in hot reloading in Ember Links: Ember CLI Hot Loader Toran’s side-by-side hot reloading demo Bret Victor, Inventing on Principle

Sam and Ryan chat about Ember at Microconf, two-way bindings, and TDD vs. "Test before commit". Topics: 0:00 – When direct state mutations make sense 8:15 – Ember at MicroConf & how other communities think about Ember 29:42 – TDD versus “Test before commit” Links: Pure UI by Guillermo Rauch

Adam joins Sam and Ryan to talk about coupling in HTML and CSS, different approaches to styling applications, and his popular open-source library Tailwind CSS. Topics covered: 0:00 – Adam's motivation for creating Tailwind 3:20 – Reusability in CSS 8:20 – Semantics and coupling in HTML and CSS 16:05 – Messy templates in functional CSS 20:52 – CSS patterns in server-rendered apps 24:45 – Component classes in Tailwind 31:20 – CSS patterns in SPAs 39:31 – Experimental design tools 46:00 – What's next for Tailwind Links: Tailwind CSS Advanced Vue Component Design, Adam's new course Modulz, the design tool

Robert and Tom join Sam and Ryan to chat about how LinkedIn uses Ember, when teams should use Engines, build optimizations that are coming to Ember CLI and more. Topics: 0:00 – Engineering challenges of scale at LinkedIn 6:00 – Engines at LinkedIn 8:40 – When should teams use Engines? 15:25 – What are some of the downsides of Engines? 17:38 – Build-time versus AOT library transpilation 21:47 – How just-in-time compilation relates to code-splitting and importing node modules 29:50 – Ember’s philosophy on bringing new JS features to years-old apps 32:55 – How can the community be most helpful when contributing to Ember? 41:32 – Analytics and performance tracking at LinkedIn 46:07 – What are your thoughts on Vue.js? (Question from jamiewhite) 52:18 – How can we help improve the developer experience of using Handlebars templates (autocomplete, error correction, template linting, etc.)? 1:02:40 – Moving questions from Slack to the Discussion forum

Sam and Ryan chat about Tailwind and compilers (again), Ryan's EmberJS homepage teardown, and releasing with git tags. They also answer some listener questions. Topics covered: 0:00 – Compilers, Tailwind, and APIs for styling components 17:00 – Ember.js Homepage teardown 30:48 – git tag for immutable gh references We also answers some listener questions: 37:14 – Q: What's the deal with using websockets in Ember? Any good patterns beyond creating some kind of Ember service to listen to the socket and push data into the store? (@yohanishkin on Slack) 40:57 – Not sure if you’ve talked about it at all yet, but the this topic seems worth further exploration: [Should Ember better define its use of Slack?] @mattmcmanus

Sam and Ryan chat about Sketch’s new Prototyping feature, using Amazon Workspaces to develop Ember apps in a Windows environment on a Mac, and how to use git tag to ensure your project’s dependencies don’t disappear. They also answer some listener questions. Topics Sketch prototyping + design Ember on Windows git tag for immutable gh references Questions Q: with the latest Router service it’s possible to transition to another page from everywhere in the code. Before, we created specific actions in the route, just to transition to another page. Is transitioning to other pages from inside components considered a bad practise, or is it totally fine (My co workers feels it’s ‘dirty’ to transition from inside components.)? Do you have any guidelines when and where to transition with the new service? (edited) (@maarten from Slack) Can you use mirage for other applications as well? (ex: Rails app with same API dependencies as Ember.) (https://twitter.com/keystonelemur/status/979777292745363456) Can you talk about how to upgrade ember.js smoothly? I always have trouble bumping our ember version, mainly I think due to some add-ons. But the error message are not that useful. (https://twitter.com/tantantanmian/status/980662478374805505)

Alex Matchneer chats with Sam and Ryan about challenging routing patterns in Ember, his involvement with the Ember community, and what Ember’s next router might look like. Topics covered: Routing patterns from mobile apps that are difficult with Ember Lessons learned from community involvement The concept of timespans Fighting community conventions Server-driven state changes Declarative routing Alex also answers some listener questions: When are you going to release a full album? If you could improve one thing with Ember, what would it be and why? Do you have strategies for teaching ember-concurrency to someone who doesn't know about generator functions? Do you try to teach those separately first? What are some JavaScript patterns you don't see being used as often as you think they should? What are some concepts/design patterns you wish all developers would know about and internalize? How do non-ember-core members become more involved in ember-core? What are some ways to bridge the gap between basic contributions and the complicated RFC process? How do you drive community change from only addon code?

Sam and Ryan talk about their new series, “Declarative rendering,” and why we should use steelman arguments instead of strawman arguments when talking about technology. They also answer some listener questions. Topics covered: Declarative rendering, their new series Steelman versus strawman arguments Listener questions: I care about lazy loading ember code, like routes. My knowledge is that’s its only possible with ember engines, but I’m not sure. Thanks a lot – @sommer_gerrit on Twitter Podcast about ember-engines might be cool – @iflask on Twitter My question: is it time to pitch PWA instead of native apps for clients wanting a presence on mobile (re: the new Safari release) – @real_ate on Twitter Question for the show -> how might writing glimmer components be different in the coming months as we unlock that as first class (thru the eyes of a traditional ember 2 developer) – @toranb on #topic-embermap from Slack Ember Data can get complicated in a hurry when not using a JSON:API standard API. What are some strategies to work with these kinds of APIs assuming the API cannot be changed? – @localpcguy on #topic-embermap from Slack

Sam and Ryan talk about Functional CSS training at EmberConf Some ideas for hiding styling implementation details from templates A new setup for multiple staging environments An idea from data modeling called “Making the impossible, impossible” How to use data down actions up effectively in forms They also answer some listener questions: When should I use polymorphic or reflexive relationships? When do I need to explicitly name a relationship’s inverse? When should I reference relationships and when should I embed them?

Oli Griffiths joins Sam and Ryan to talk about his experience using typed languages, what kinds of benefits static could bring to the Ember developer experience, and his upcoming EmberConf training on Broccoli.js.

Sam and Ryan talk about the upcoming Operations addition to the JSON:API spec, adding FastBoot support to Storefront, how to think about caching in Fastboot, and a thought experiment around how Ember might niche down and focus on its strengths.

Tom Dale chats with Sam and Ryan about static analysis and compilers, upstreaming learnings from Glimmer, and what sort of size and speed improvements Ember.js will see in 2018.

Sam and Ryan talk about writing Babel plugins, components that can be transformed to plain HTML at compile-time, the differences between run-time and compile-time error messaging, and one way to make integration tests more reusable and domain-specific.

Sam and Ryan chat about Sebastian Markbage’s 2015 React Europe talk “DOM as a Second-Class Citizen” and how to deal with stale data in an Ember app. Sebastian Markbage's talk DOM as a Second-Class Citizen

Sam and Ryan chat about all the different ways you can make sure your app is working, some of their latest thoughts on functional CSS and presenter components in Ember, and how to test asynchronous errors in an acceptance test.

Sam and Ryan talk about a new Storefront API and why routes should declare their data needs, patterns that make your code more disposable, how Ember CLI Update simplifies the process of upgrading your Ember apps, and what teams should consider when choosing Ember for their next project.

Sam and Ryan talk about uploading images to S3, a new Storefront API for dealing with server errors in Ember Data, how to be a good community citizen when it comes to publishing consumable libraries given that our package managers now use lockfiles, and some ongoing work on the Ember CLI Addon Docs addon.

Sam and Ryan discuss community feedback on Ember Data's pain points, including asynchronous relationships, store forking and batch saving.

Sam and Ryan discuss using contextual components to clean up forms, a unique authentication scenario using cookies and JWT, the release blog post about Ember 3.0, and building animations with the Liquid Tether addon.

Special guest Luke Melia chats with Sam and Ryan about styleguides, CSS patterns, Ember Freestyle and more. Links from the episode: Luke Melia on Twitter Suit CSS Ember Freestyle Ember Prop Types Yapp Labs on Github Ember CLI Deploy

Sam and Ryan chat about adding FastBoot to EmberMap's codebase, the difference between reusable and structural components, and the road to adding transactions to Ember Data.