<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Andrew Ettinger on Medium]]></title>
        <description><![CDATA[Stories by Andrew Ettinger on Medium]]></description>
        <link>https://medium.com/@andru?source=rss-4bdfd32651c8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Kn8cpJzI1yuJTV3r.jpg</url>
            <title>Stories by Andrew Ettinger on Medium</title>
            <link>https://medium.com/@andru?source=rss-4bdfd32651c8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 10:18:16 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@andru/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Delivering New Products for Fun and Profit, Part 2]]></title>
            <link>https://medium.com/@andru/delivering-new-products-for-fun-and-profit-part-2-6ea41a5a8e94?source=rss-4bdfd32651c8------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ea41a5a8e94</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[product-development]]></category>
            <dc:creator><![CDATA[Andrew Ettinger]]></dc:creator>
            <pubDate>Tue, 29 Jan 2019 00:57:17 GMT</pubDate>
            <atom:updated>2019-01-29T00:57:17.010Z</atom:updated>
            <content:encoded><![CDATA[<h3>Discovery</h3><p>In <a href="https://medium.com/@andru/delivering-new-product-for-fun-and-profit-e748a85d43b1">Part 1</a>, we gave an overview of the process:</p><ul><li><strong>Discovery</strong>, where we identify the customer problem and set the vision.</li><li><strong>Pre-work</strong> to ignite understanding, where the team begins to digest the market and technical information to understand the problem.</li><li><strong>The Kickoff</strong>, where we decide what is in and out of scope and identify the minimum viable system (aka, the steel thread).</li><li><strong>Innovation &amp; Experimentation</strong>, where we answer our biggest technical questions and test ideas with customers.</li><li><strong>Customer Advisory</strong>, where we engage with customers to guide our direction. (This customer advisory group is usually set up at the same time as Innovation &amp; Experimentation.)</li><li><strong>Iteration</strong>, where we build our product until it is “good enough”, continuously learning, making tough decisions, and testing with customers.</li><li><strong>Delivery</strong>, where we launch our product successfully.</li></ul><p>In this post, I’ll talk more about our expectations for the “Discovery” phase of work.</p><p>Discovery is primarily in the realm of Product Management or Product Development. It is usually an ongoing process, and many projects and ideas never get out of discovery. To exit discovery, we need to take in data from a variety of data sources and output a<em> product vision</em> that, when built and sold, will generate revenue for the firm. Once this vision is in an acceptable state we can go to the next phase of work (which can sometimes be done concurrently), which is Pre-Work.</p><p>Discovery is our opportunity to get alignment from our stakeholders, get laser focused on the real value, and make critical tradeoffs before work even begins — what we’re <em>not</em> doing is usually just as important to decide as what we <em>are</em> doing.</p><p>The data used to synthesize our vision can come from any number of a variety of sources:</p><ul><li>Surveys</li><li>Industry research, like from Gartner</li><li>Customer interviews or, better yet, onsite research</li><li>Sales feedback</li><li>Market and competitive analysis</li><li>Exercises like SWOT analysis</li><li>Executive leadership feedback</li></ul><p>There are some traps to effective discovery. One trap is to conflate the “what” and the “how” when generating your vision. When your vision describes data formats, includes architecture diagrams, or UX mockups you have fallen into the “what vs. how” trap. We want to describe the overall value proposition not the technical details.</p><p>One of my many theories is that the distance between our vision, the technical details, and the actual customer experience is where innovation happens — where we challenge our teams to develop sophisticated and innovative solutions to deliver on our vision.</p><p>Another trap is what I call “going off to the mountain.” This is where you are building your vision in isolation. Much like how we want to test our minimum viable product (MVP) with customers, we should be testing our vision with stakeholders, sales staff, even customers. The more aligned we can get before we start work the better our overall outcome will become.</p><p>Going to the mountain can also lead you to set your vision too far into the future and become unachievable. Sometimes this might be desirable — when we need to cause organizational disruption, for example.</p><p>Stakeholder alignment, whether that is just your boss, the executive team, or the board of directors, is a key function of the vision. Without this alignment at the inception of your project you run a much higher risk of encountering additional pressure to deliver something different, faster, and usually bigger after you’ve already started work. In my opinion, this is the primary reason that projects churn partway through development, which is extremely costly. When engaging stakeholders on a draft of your vision, remember that you are listening for their concerns so that you can address them and drive alignment and understanding.</p><p>So what makes a good vision? Here’s some tests for a decent vision with some made up examples for FreshHomeDelivery, a grocery delivery service.</p><ul><li>A vision clearly states the problem the customer is experiencing. “Before, shopping for the ingredients for meals was slow and time consuming. You needed to identify recipes, make a list, find the right store, and shop. After a long day at work this significantly delayed the start of dinner preparation.”</li><li>A vision should differentiate. “Until now, other meal services lock you in to certain days and don’t work around your schedule for delivery.”</li><li>A vision should describe the value that we unlock. “Now, with FreshHomeDelivery, ingredients for pre-planned meals are delivered to your door fresh and ready to use. No shopping is required, the household can coordinate and manage their choices, and dinner preparation can begin immediately.”</li><li>A vision should show the business model. “Local markets are excited to get FreshHomeDelivery’s business. ‘With FreshHomeDelivery we’ve seen an increase in sales with no effort since groceries are handpicked from local stores,’ said Timothy T, a store manager at Safersons Markets. ‘I’ve been able to spend more time with my family, and the flat charge fits my budget and is well worth the time and effort saved,’ said Suzy Q, who uses FreshHomeDelivery an average of three times a week.” *</li><li>A vision should provide a litmus test for work we discover: When we discover things we <em>could do</em>, the vision should provide the test if we should proceed with the work now or delay it. To help with this we usually add a FAQ to our vision to address corner cases or answer specifically what our vision <em>is not</em>.</li></ul><p><em>* Yes, these quotes are made up. Yes, we do add fake quotes for illustration.</em></p><p>There are a variety of great techniques that are already out there to help guide your discovery results. <a href="https://hitenism.com/amazon-working-backwards/">Amazon’s Working Backwards</a> is one of our favorites: You build a “fake” press release (similar to above examples) as the vision. It cleanly separates the “what” from the “how” and can be very clarifying in a single page description.</p><p>Another option is a <a href="http://s.casual.pm.s3.amazonaws.com/toolkit/Nike%20Creative%20Project%20Brief%20Sample.pdf">product or project brief</a>, which usually includes market data, competitive analysis and a proposal for the shape of the product. In my opinion, these can more easily fall into the “what vs. how” trap, but they also include more market background than the Working Backwards framework.</p><p>Now that we’ve aligned on a vision, we can exit discovery and begin <em>pre-work,</em> which I’ll cover in my next post.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ea41a5a8e94" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Delivering New Product for Fun and Profit]]></title>
            <link>https://medium.com/@andru/delivering-new-product-for-fun-and-profit-e748a85d43b1?source=rss-4bdfd32651c8------2</link>
            <guid isPermaLink="false">https://medium.com/p/e748a85d43b1</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Andrew Ettinger]]></dc:creator>
            <pubDate>Wed, 19 Dec 2018 17:37:14 GMT</pubDate>
            <atom:updated>2019-01-29T00:57:38.384Z</atom:updated>
            <content:encoded><![CDATA[<h4>Part 1 of 9: An Introduction</h4><p>New software projects are filled with peril, fear, angst, and unknowns — and can also be some of the most fulfilling and rewarding work to be done. Getting from a proposed vision for a new product offering to a successful new product launch is fraught with guesswork, bad estimation, leadership alignment woes, technical assumptions that can lead to debt, and poor morale caused by increasing urgency as schedules slip or plans change.</p><p>The number of people that think they enjoy, and are good at, this type of work is high — but in practice, the number of people that actually enjoy the discomfort associated with being lost in what I call the “new product development desert” is low.</p><p>One of the primary reasons I believe that people don’t find new product development comfortable is a lack of understanding of the journey that must happen to deliver first generation projects. This series will outline the journey we take to successfully navigate from vision to launch.</p><p>On our journey there are distinct phases and turning points:</p><ul><li><strong>Discovery</strong>, where we identify the customer problem and set the vision.</li><li><strong>Pre-work</strong> to ignite understanding, where the team begins to digest the market and technical information to understand the problem.</li><li><strong>The Kickoff</strong>, where we decide what is in and out of scope and identify the minimum viable system (aka, the steel thread).</li><li><strong>Innovation &amp; Experimentation</strong>, where we answer our biggest technical questions and test ideas with customers.</li><li><strong>Customer Advisory</strong>, where we engage with customers to guide our direction. (This customer advisory group is usually set up at the same time as Innovation &amp; Experimentation.)</li><li><strong>Iteration</strong>, where we build our product until it is “good enough”, continuously learning, making tough decisions, and testing with customers.</li><li><strong>Delivery</strong>, where we launch our product successfully.</li></ul><p>These steps are not meant to confer any sort of waterfall decision process, but a type of map you can use to identify where you are at, and where you should try and go next.</p><p>The goal is to limit our time lost in the new product desert — a dangerous place where we aren’t sure what to do next, decision making grinds to a halt, and the organization is unsure of the value they are getting from the effort. The team that embraces each evolution will find the journey motivational and rewarding, limit their time in the desert, and gather alignment along the way.</p><p>One principle we use is that it is far better to evaluate and concede our assumptions early in the project. This map gives leadership a way to ensure that teams have safety to try ideas, see if they work, and alter course quickly (and early). Leaders should recognize that changing course is a courageous act: We are recognizing our assumptions were wrong and are correcting them. It is a great sign that the team feels psychological safety.</p><p>The ramifications of these techniques for organizations that want pre-committed deliverables is a high potential for contention. Using this process, it will be difficult for organizations to track a pre-determined checklist of committed deliverables to determine if teams are meeting expectations — this isn’t an easy ask for most orgs. In the last part of the series I’ll go into some thoughts around organizational impact, how to measure effectiveness, and how organizations can support these types of efforts.</p><p>My teams have built a track record of delivering innovative products that are on time with measurable customer value. In addition, my team has confidence in each other and in leadership’s support for the new product development effort, and feel the safety to innovate and deliver.</p><p>These tools and techniques work at scale: We have delivered multiple team projects with lots of dependencies, and delivered them early.</p><p>The techniques we’ll talk about in this series have been built up over the last couple of years by my teams. Over time our processes have jelled into something that I believe is repeatable. My hope is that you find some parts are helpful to you on your own journey!</p><p><em>Next: </em><a href="https://medium.com/@andru/delivering-new-products-for-fun-and-profit-part-2-6ea41a5a8e94"><em>Discovery in depth</em></a><em>, where we learn about setting a vision, finding alignment, and initializing the system.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e748a85d43b1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Some thoughts on early career resumes.]]></title>
            <link>https://medium.com/@andru/some-thoughts-on-early-career-resumes-348ba8f7f3fb?source=rss-4bdfd32651c8------2</link>
            <guid isPermaLink="false">https://medium.com/p/348ba8f7f3fb</guid>
            <category><![CDATA[resume-writing]]></category>
            <category><![CDATA[junior-developer]]></category>
            <category><![CDATA[job-hunting]]></category>
            <dc:creator><![CDATA[Andrew Ettinger]]></dc:creator>
            <pubDate>Thu, 18 Oct 2018 22:29:09 GMT</pubDate>
            <atom:updated>2018-10-25T22:46:22.708Z</atom:updated>
            <content:encoded><![CDATA[<p>Building a resume can feel daunting early in your career. Maybe you’ve been to a code school or college, maybe you’ve had an internship — or maybe you’re trying to move to a developer role from QA or support. <em>What do hiring managers want to see? How do I stand out? What skills are they really looking for? How does my current experience even apply to that job description??!</em></p><p>Here’s the thing: You probably have more applicable experience than you think.</p><p>There are a couple of ways you can express that value that will help me, as a hiring manager, better understand the value that you are capable of delivering, even with a short work history.</p><p>Remember that these are just my opinions having looked at a number of resumes, and your mileage with any business or particular hiring manager may vary. And although I see these things more often with early career resumes, I’m sure the advice below would work for any resume.</p><h3>In one short sentence, describe what each business’ (or project’s) value is.</h3><p>This does several things: I don’t have to look it up if I’m not familiar with the business or project, it shows that you understand what the business was trying to do, and it shows off that you can communicate effectively!</p><p><strong>Example</strong>: “TodoProject is a SaaS offering that helps customers coordinate their todo lists around project deliverables. My team was responsible for delivering todo workflows to end users.”</p><h3>Talk about the value you delivered.</h3><p>After your description, show the value you delivered using a technology or approach with specific examples! Be wary of adjectives that are descriptive only to <em>your understanding</em> of what you did: I don’t understand what you found “challenging” or how you “leveled up” unless you can tell me what you actually delivered.</p><p>I also can’t tell what your impact was if the description doesn’t tell me <em>the what</em> and <em>the how</em> — I don’t know what “implemented logic” or “contributed to” means unless you tell me specifics. Did it talk to a database? Did you use any libraries? Did you write all of the code, or just some parts? Did you use caching or an API? How did you track state? Did a designer help? Did you use a message queue or a background job?</p><p><strong>Example</strong>: “At TodoProject, I built a way to store and find metadata about projects and todo items to help customers find relevant related tasks faster in ElasticSearch and React. I scaled and tuned ElasticSearch to be able to store the project and task data, and built a tagging interface in React to make it easy for customers to add metadata which stored the data in ElasticSearch through a Java API I built.”</p><p><strong>Another example (because I know this is tough!): </strong>“At TodoProject, I added Mocha tests to our GANTT chart feature to help maintain test coverage of 70% and reduce shipped UI bugs. I also added form components and workflow to allow customers to create and edit their task lists in a GANTT Chart view in React. These components included error handling, API calls, rendering different states through redux, and maintained consistent styling with the rest of the product via CSS.”</p><h3>Be careful just listing technologies.</h3><p>When you list out a variety of technologies early in your career, I know you aren’t an expert in all of them — and when you list a lot of unrelated technologies it makes it difficult for me to know which ones you might actually be proficient in.</p><p>If you are going to include a list of technologies, draft your list to best match up with the job description you are applying for. If you don’t have direct experience with a technology, but do have experience in something similar, explain why you’ve included them if they don’t perfectly match the job description. Are the languages strongly typed, or run on the JVM? Do you have experience with a different framework that is similar (React vs. Vue)?</p><h3>Include a cover letter.</h3><p>A resume, almost by definition, only defines the things you’ve done and where you’ve been. It doesn’t help anyone understand <em>you,</em> and <em>what you are passionate about.</em> My job as a hiring manager is to get the right people, with the right skills and passions, working on the right problems. What are you interested in that relates to this role? How would your technical itches get scratched by working here?</p><p><strong>Example</strong>: “Working on my own projects, I have found todo lists organized around project deliverables very valuable to help me deliver on-time. I’ve used the TodoProject trial to help me organize my work personally and professionally, learning about how I work and how fast I can get things done. I’d love to help the opportunity to build the next iteration of TodoProject to help others improve their projects.”</p><h3>Build a strong base.</h3><p>Write out all of your experiences in detail with lots of examples. This will make your resume long — this version of your resume becomes your <em>base.</em></p><p>This probably has way more detail than you should send, but it makes crafting your resume to showcase your experience for a particular position <strong>much</strong> easier.</p><p>When applying, take your base resume and carefully read the job description. Remove or reword sections that don’t match what they are asking for and send that.</p><h3>Interviews are an opportunity to grow.</h3><p>This is probably the most difficult advice: If you aren’t selected, ask for feedback on what you can do better. Be earnest about growing from the feedback, because it isn’t always easy to ask for — and isn’t always easy to receive.</p><p>Not everyone is good at giving this type of feedback. Here are some questions you can ask to help them provide actionable feedback:</p><ul><li>“Where would you suggest I focus my energy based on my interview?”</li><li>“What key concepts were you looking for that I didn’t demonstrate?”</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=348ba8f7f3fb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How that new app just broke your User Experience.]]></title>
            <link>https://medium.com/@andru/the-sandwich-building-app-and-how-it-can-break-your-ux-ea914fa2e5a6?source=rss-4bdfd32651c8------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea914fa2e5a6</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[organizational-culture]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[user-experience]]></category>
            <dc:creator><![CDATA[Andrew Ettinger]]></dc:creator>
            <pubDate>Fri, 02 Feb 2018 03:47:39 GMT</pubDate>
            <atom:updated>2018-02-23T00:50:17.984Z</atom:updated>
            <content:encoded><![CDATA[<p>I love working with design, and they are a core piece of the way I like to build software. But I’ve seen some unintended things that can happen without a good plan for how software teams interact with design.</p><p>We’ll start at the beginning with market analysis. You channel your market, a la <a href="https://www.pragmaticmarketing.com/">Pragmatic Marketing</a> or something similar, and decide that the right thing to build is a new Sandwich Building App. “Yes!”, you say, “This is a clear indicator from the market that we can finally disrupt sandwich making.” You pull in a designer from your bullpen and embed them with a full-stack team dedicated to delivering the Sandwich Building App. They will sit together, run standup together, and work very closely. The designer on this team will be somewhat separated from the rest of the design team. Sure, they’ll go to design standup, but they are basically full time on shipping Sandwich App.</p><p>The engineers build out a data model, a storage solution, and proxy some API’s while design and product work through some of the potential flows and test them with customers.</p><p>Ultimately, the designer discovers that we’ve been building sandwiches wrong since basically the dawn of time and creates a new application flow that changes some of the UX patterns you use in your flagship “Cafe Suite” of applications you support — it requires some different tools than the Burrito Building App, which needed tweaks to some core concepts used by the Omelet Building App.</p><p>The autonomous software and design team hunkers down and prioritizes features, working closely with their designer to build the app. After a few iterations and customer feedback the team goes to market and it’s a hit! Sandwich shops are a thing of the past!</p><p>But here is the rub: If you have many teams, working on many apps, you are making an intrinsic tradeoff by making design mission-oriented. You just broke the UX for your Omelet and Burrito apps by changing things around on your customers!</p><p>There’s a natural tension in embedding a functional role (design) in a mission oriented team (deliver Sandwich Building App). We want the designer to help organize the flow of the new system so that the customer gets an “Aha!” moment. But if you have many teams, this can conflict with having a consistent experience across teams.</p><p>Why is design “functional”? Aren’t they just building up user experience? Yes and no. Embedded in a team, design is prioritizing getting the right experience for the problem at hand — they are oriented to the <em>mission at hand</em>. When they are purely doing their <em>function</em> (the “design bullpen”), they are trying to make holistic decisions about the language of design in your application suite. And once the toothpaste is out of the tube it is difficult to put it back in without having clear, and strong, and enforceable design guidelines up front — in other words, once you have disparate experiences across multiple product lines it can be very difficult to achieve a consistent user experience without a massive effort.</p><p>It gets even more complicated when you have designers with different skillsets and goals — research, design, or UX.</p><p>One “<a href="https://en.wikipedia.org/wiki/Code_smell">smell</a>” of this happening is that your customers can see your product and team silos when you are attempting to make a seamless experience.</p><p>I’m not advocating that design <em>shouldn’t </em>be embedded on teams. Having autonomous teams that can be really responsive and deliver that “Aha!” is what we want.</p><p>Some possible solutions:</p><ul><li>Early investment in developing libraries. Cost: Initial setup cost is higher. Frontend libraries can have high cost to configuration as UX and data gets complex. Benefit: Composition of components makes it easier to experiment with new products.</li><li>Enforcement of design guidelines by a design council. Cost: Approval by an outside body slows things down. Benefit: Consistency in design language.</li><li>Purely functional design bullpen. Cost: Limits design to only a couple of projects at a time. Benefit: Those projects fit into the product suite.</li><li>Pay the cost later. Cost: Forklift upgrade across all units once a design language is developed. Benefit: Allows teams true autonomy to innovate… for a while.</li></ul><p>I’m curious: What are some of the ways you are solving this problem?</p><p>When you are designing your organizational structure, setting the constraints with which teams operate, encouraging fast innovation with design and engineering, try to pay attention to the problems you are solving and what the tradeoffs of that structure might be.</p><p>You may be introducing unintended consequences for Future You by tearing down the sandwich industry — but breaking your user experience!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea914fa2e5a6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ember & Me]]></title>
            <link>https://medium.com/@andru/ember-me-ed5d1eab0363?source=rss-4bdfd32651c8------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed5d1eab0363</guid>
            <dc:creator><![CDATA[Andrew Ettinger]]></dc:creator>
            <pubDate>Wed, 15 Apr 2015 16:34:29 GMT</pubDate>
            <atom:updated>2015-04-16T17:37:45.551Z</atom:updated>
            <content:encoded><![CDATA[<h3>How I learned to accept the design decisions of Ember… sort of.</h3><h4>First things First</h4><p>I’ve only had the privilege of working with Ember for a couple of weeks. I had trouble wrapping my head around some of the Ember terminology and practices, so I hope this helps someone in a similar state.</p><p>Some of this overview may be technically incorrect; but that’s why I’m trying to provide an overview rather than a deep technical digression.</p><p>Also, <em>I’m not a fan of Ember</em>. I have tried to leave my saltiness at Ember off of this post. But please keep that in mind (just in case some of it slips through).</p><h4>Synopsis of how Ember is set up</h4><p>Why is there so much code in the <em>routers</em>? What’s up with <em>.get(“allthethings’’)</em>?</p><p>Let’s start with an overview and then we’ll get into terminology. Ember has a couple of key design decisions that inform the entire framework.</p><p>First, everything should be encapsulated so that at the end of the day there is one place for any particular data’s truth to be located. This means that properties are never accessed ‘raw’ — everything is accessed through getters and setters. It also means that things that augment a data’s truth need to be nested. Ember does this through data augmenters it calls <em>controllers</em>. They aren’t really controllers in the standard sense though — they act more like agents that bind a <em>model </em>down to a <em>template.</em></p><p>Second, all of your logic should be in JavaScript and not in your view. It does this partially by using Handlebars (which is logic-averse anyway), but also by inserting a variety of layers and runtime-fu to ensure there are hooks all the way down to bind your eventing and loading logic to whatever your application may need. The side effect of this is that it also means that Ember has a lot of terminology for all of these hooks, and the order they fire off at are not readily clear without understanding the whole stack, and that can be confusing.</p><p>How does this play out? Here’s a primer:</p><ul><li><a href="http://guides.emberjs.com/v1.10.0/routing/"><strong>Route</strong></a><strong>.</strong> A route is basically a device to set up the Controller. If you come from other frameworks, the Route is really where your controller logic resides. It sets the initial state of your widget / page. Ember uses a named and nested route capability that gives you reuse of existing routes at the expense of a proliferation of routes. Also: Be careful how you name your routes. Nesting can be both a blessing and a curse.</li><li><a href="http://guides.emberjs.com/v1.10.0/controllers/"><strong>Controller</strong></a><strong>.</strong> Your controller is really less about ‘actions’ on a page and more about ‘data binding’. It binds some data from your models through to your template. It can inherit properties from other controllers, which is one of the ways Ember provides it’s SSoT (“Single Source of Truth”).</li><li><a href="http://guides.emberjs.com/v1.10.0/models/"><strong>Model</strong></a>. The model is your data framework. Everything in Ember is encapsulated, for better or worse. Since things are wrapped you can inject things and inherit things in novel ways when you bind down into your template. But it also means that mocking models requires additional tooling, and JSON by itself is no longer Ember friendly.</li><li><a href="http://emberjs.com/api/classes/Ember.Mixin.html"><strong>Mixins</strong></a>. In order to cope with the prolific amount of code strewn about, Ember does provide <a href="http://en.wikipedia.org/wiki/Mixin">mixin behavior</a>.</li><li><a href="http://guides.emberjs.com/v1.10.0/models/customizing-adapters/"><strong>Adapters</strong></a>. One of the things that <em>does</em> make sense is the adapter framework for plugging in an ORM. But it looks like <a href="https://github.com/emberjs/data">ember-data</a> was the clear winner.</li><li><a href="http://emberjs.com/api/classes/Ember.View.html"><strong>Views</strong></a><strong>. </strong>Remember that you can’t have logic in your templates? This can make normal web page interactivity tricky. Since the Route initializes and isn’t sure of the render layer, you can’t put render logic in there. Enter the <em>view</em>, which basically is a lower level binder to eventy logic.</li></ul><p>If I have time I’ll add in more details on each, but a lot of the technical details can be found on the <a href="http://emberjs.com/">Ember</a> or <a href="http://www.ember-cli.com/">Ember-cli</a> website… or whatever else they eventually decide is ‘canon’.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed5d1eab0363" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[UX Idioms]]></title>
            <link>https://medium.com/@andru/ux-idioms-5cc574a2d1be?source=rss-4bdfd32651c8------2</link>
            <guid isPermaLink="false">https://medium.com/p/5cc574a2d1be</guid>
            <dc:creator><![CDATA[Andrew Ettinger]]></dc:creator>
            <pubDate>Mon, 13 Apr 2015 18:25:22 GMT</pubDate>
            <atom:updated>2015-04-13T20:19:13.652Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*z6Mie6iCgpd4eC4-Wxs8RQ.jpeg" /></figure><h4>So you want to port a front end project. Get your ducks in a row.</h4><p>I was working for a big shoe company for a minute, and came in to help them analyze moving front end frameworks around on some internal tools.</p><p>But the first question I had was: What idioms were they using if we were really going to port their technology stack?</p><p>Some of them have to be there in some form for a project to function:</p><ul><li>Errors</li><li>Validation</li><li>Testing</li><li>Configuration management</li><li>Authentication</li><li>Build systems</li></ul><p>Then there’s the more esoteric ones:</p><ul><li>Date</li><li>Forms</li></ul><p>Then there’s the UI dependent ones:</p><ul><li>Two way binding</li><li>Modal</li><li>Filter / search / sort / limit</li><li>Job / wait / async</li><li>Pagination</li><li>Multiple select</li><li>Right click for menu</li><li>Infinite scroll</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5cc574a2d1be" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Tree by Any Other Name.]]></title>
            <link>https://medium.com/@andru/a-tree-by-any-other-name-4ba850f2a98f?source=rss-4bdfd32651c8------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ba850f2a98f</guid>
            <dc:creator><![CDATA[Andrew Ettinger]]></dc:creator>
            <pubDate>Mon, 20 Jan 2014 23:32:20 GMT</pubDate>
            <atom:updated>2014-01-20T23:32:20.281Z</atom:updated>
            <content:encoded><![CDATA[<h4>Get a black belt in branch discipline.</h4><p>Tools like git give us a wonderful opportunity to change how we build software. Unfortunately, many teams are missing the biggest opportunities that easy branching provides: stability &amp; sanity.</p><p>Let’s take a look at a few cases of how we hinder ourselves.</p><h4>The Case of the Tied up Trunk</h4><p>A new feature rolls in with the start of a new sprint. The last release went ‘alright’ — the team had to work extremely late only a couple of days this time.</p><p>Tim designs a new feature and commits it into trunk, expecting it to get completed by one of the engineers. Before the assigned engineer, John, can take a look at adding in functional components, the changes are pulled down by the rest of the team — who discover that the changes break their build and their ability to make progress.</p><p>This may cause a brief team-wide disruption, but if the build gets broken late in the game just before release, a tied-up-trunk can turn disastrous.</p><h4>The Case of the Last Minute Quality Assurance</h4><p>The team has worked extremely hard to try and get through the laundry list of tickets for the current sprint. As the last one is marked ‘Ready for QA’, the team dusts off their hands and relaxes. After all, they just finished all of their required features two days before the scheduled release!</p><p>Unfortunately, due to dependencies and breakages in core code, QA could not begin their process until the last ticket was marked as done.</p><p>As they begin to go through the same long list of features &amp; fixes, the team realizes that with a kick-back rate of nearly 50%, it means another string of exhausting evenings trying to stabilize the feature set just prior to launch.</p><h4>The Case of the Empty Toolbelt</h4><p>John, our engineer, finishes up a new feature in a branch. Tom, our project manager, doesn’t have the tools to check out and test the branch, so he advises the branch get merged into development first then deployed to a staging server.</p><p>John merges and deploys the code to a staging area, where Tom promptly discovers that the changes to core code have unintended consequences.</p><h4>Branches (For the Most Part) Have Already Been Solved</h4><p>We already have a great model in branch discipline — open source &amp; github. When we contribute to open source projects, we <em>fork</em> the original. We make our changes. We add in <em>testing</em>. We make a <em>pull request</em>. This gets <em>merged</em> back into trunk once tests pass and everyone agrees that the patch meets the request’s goals.</p><p>This process has been proven to work very nicely. It doesn’t always translate perfectly to a business environment, but there’s a lot we can learn.</p><p>Let’s look at the real reasons why we should branch and maybe formulate some rules of thumb on merging.</p><p>First, when to branch:</p><ul><li>Branching should not be so convoluted that our semi-technical team members cannot participate (The Case of the Empty Toolbelt).</li><li>Branches should match up with your ticket tracking system so that everyone can map the branch to the original discussion of the feature / issue. For example, we branch based on the Jira ticket number &amp; a short description.</li><li>Branches should encapsulate something that you want <em>tested</em>. We should be testing and validating things in isolation as much as possible to prevent pollution of our main line of code in case something fails catastrophically.</li><li>Alternatively, if multiple people may be needed to complete the requirement then a branch should be necessary (The Case of the Tied Up Trunk).</li></ul><p>Merging is more difficult because it takes discipline — the gut reaction is to ‘just merge it’. We need to be careful of when we merge: <em>Untested code should never be merged.</em> And after it is merged it should be tested again before it is deployed.</p><p>I would also argue that at least some form of stakeholder demo should be done before merging, but that’s usually a touchy subject; I will say that during a stakeholder demo can tell you pretty quickly how close you are to being ‘done’, or if you have missed the mark and need an overhaul. If it’s the latter, you shouldn’t merge yet.</p><p>Branching and merging <a href="http://www.codinghorror.com/blog/2007/10/software-branching-and-parallel-universes.html">is a difficult business</a>, but our goals should align with the <a href="https://medium.com/p/5207066a9fb3">problems we’re trying to solve</a> and in my opinion we should seek out stability &amp; sanity in all of our development tasks.</p><blockquote>Trees are sanctuaries. Whoever knows how to speak to them, whoever knows how to listen to them, can learn the truth. — Herman Hesse</blockquote><p>More to come.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ba850f2a98f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Assembly Line Software]]></title>
            <link>https://medium.com/@andru/assembly-line-software-5207066a9fb3?source=rss-4bdfd32651c8------2</link>
            <guid isPermaLink="false">https://medium.com/p/5207066a9fb3</guid>
            <dc:creator><![CDATA[Andrew Ettinger]]></dc:creator>
            <pubDate>Fri, 17 Jan 2014 18:28:34 GMT</pubDate>
            <atom:updated>2014-01-17T18:39:36.451Z</atom:updated>
            <content:encoded><![CDATA[<h4>Agile, Waterfall and Just-in-time Software Development</h4><p>Waterfall isn’t necessarily dead. In fact, I think it can play nicely with agile methodologies. Before you bring out the pitchforks, I think it might be time to take another look at the evolution of delivering great software.</p><h4>Getting the Product Rolling</h4><p>We all start, with any luck, with the discovery of how a feature fits into our customers’ needs and how that fits into our pricing model. The age old question of cost vs. value should always be answered first.</p><p>Great! We have a need. Let’s look at delivering it.</p><p>First we need to figure out how it is going to work. We still need an <em>ideation </em>phase, where we build prototypes, sometimes using paper, to evaluate our existing paradigms and how competitors have tried to solve the problem. This will probably still require some sort of buy-off from stake-holders. We may even need to do some technology feasibility testing.</p><p>By the way, this ideation phase is the best opportunity to find out the real cost of what you are about to build since estimating prototypes is easier than estimating an engineer’s capability for imagining what you actually want.</p><h4>Construction</h4><p>After we know what the moving parts are we can branch off our main code and begin the creation of the feature. The <em>building </em>phase usually includes front-end designers and engineers, maybe some back end engineers. For anything that requires testing, it should always be done in a branch so it can be tested in isolation; we don’t want to cause pollution of our always-deployable trunk, right?</p><p>Once we’re done with development, we wrap things up tidily and enter the first phase of isolated QA testing. I say ‘isolated’ because we should test the feature in the branch before we merge it. With any luck this will pass and the branch will be merged into the main release trunk for a second set of integration testing before launch.</p><p>It might fail QA for some arcane reason, either planning or personnel or technology, sometimes at the last minute. This needn’t fail our entire release, however, since if we are QA’ing in the branch we can simply decide to not merge and release it quite yet. This takes a lot of willpower to not-merge-until-tested, but trust me, it will earn you spades of stability and is the key to this entire process.</p><p>If it passes isolated QA testing, we merge it into trunk, run everything through integration testing (with any luck with time to spare before launch to fix any regressions) and deploy it to happily paying customers who are amazed by our code stability and our ability to deliver in a timely manner.</p><p>Note that all of this is from the <em>feature’s </em>perspective. And it all sounds rather waterfall-y.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s3_zxibmTWN1uCyQlNefyA.jpeg" /></figure><h4>From Waterfall to Just-in-Time + Agile</h4><p>From a resource perspective, each stage of an organization’s kanban — this whole market research to ideation to design to development to QA to integration process — each step can still be swapped out just-in-time for higher priority items as they appear to the organization. And teams can begin the first phases of the next feature while other teams continue forward on the current one, allowing your organization to maximize productivity in an assembly line fashion. And it is the branching strategy that gives you the opportunity and safety to make the just-in-time decisions, mitigating risk and moving everyone up in the timeline.</p><p>In the event of a feature priority swap (due most likely to business discovery), teams can always resume where they left off. We essentially have waterfall in our agile, and agile in our waterfall.</p><p>There are risks to this process. High kickback rates from QA can cause thrashing; over zealous management can cause priority thrashing; code can become stale in branches in fast paced environments due to neglect; bottlenecks can still develop for various reasons. I’ll talk more about mitigating these risks in later posts.</p><p>On the other hand, the benefits are staggering in consistent feature delivery, codebase stability, and resource optimization.</p><p>Most task oriented kanban boards with swim lanes are great for seeing small scale, but in most cases we miss the bigger picture and the benefits of moving our features through an assembly line process with a just-in-time mentality.</p><blockquote>“There is one rule for the industrialist and that is: make the best quality goods possible at the lowest cost possible, paying the highest wages possible.” — Henry Ford</blockquote><p>It’s a wonderfully waterfall-agile-kanban-just-in-time software development world.</p><p>More to come.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5207066a9fb3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>