<?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 Chris Klapp on Medium]]></title>
        <description><![CDATA[Stories by Chris Klapp on Medium]]></description>
        <link>https://medium.com/@klappy?source=rss-b9df4597e4d7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*gBs4RFu3ZSxV0unk37CPXw.jpeg</url>
            <title>Stories by Chris Klapp on Medium</title>
            <link>https://medium.com/@klappy?source=rss-b9df4597e4d7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 11:01:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@klappy/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[Bulldoze Your App (But Keep the Blueprint)]]></title>
            <link>https://medium.com/@klappy/bulldoze-your-app-but-keep-the-blueprint-ac0cc2951218?source=rss-b9df4597e4d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac0cc2951218</guid>
            <category><![CDATA[software-development-ai]]></category>
            <category><![CDATA[engineering-culture]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[product-thinking]]></category>
            <category><![CDATA[agentic-systems-design]]></category>
            <dc:creator><![CDATA[Chris Klapp]]></dc:creator>
            <pubDate>Sat, 17 Jan 2026 05:00:14 GMT</pubDate>
            <atom:updated>2026-01-17T16:20:46.123Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ix65g9Zf7H9ChRoyhs3IQ.png" /></figure><h3><strong>Lessons from Building with AI When Code Stops Being the Asset</strong></h3><p>Imagine spending three hard months building a custom house.</p><p>You hire the contractors. You pour the foundation. You frame the walls. The paint dries. You stand back and think: <em>okay, I can imagine living the rest of my life here.</em></p><p>Then the architect walks in, looks around, nods, and says:</p><blockquote><em>“Great. Bulldoze it.”</em></blockquote><p>In the physical world, that’s absurd. You don’t bulldoze a perfectly good house. You sue someone.</p><p>But then the architect adds:</p><blockquote><em>“The house wasn’t the point. The blueprint was. Now that we have it, we can build the real one in about ten minutes.”</em></blockquote><p>That idea sounds irresponsible when applied to buildings.</p><p>It sounds less crazy once you’ve felt the ground shift under software development in the last year.</p><p>Because AI didn’t just make coding faster. It changed what’s scarce.</p><p>Code generation is no longer the bottleneck. <strong>Intent</strong> is.</p><p>And in a world where generation is abundant, the work stops being “make something.”</p><p>The work becomes:</p><ul><li>ask for the right thing</li><li>verify reality</li><li>preserve what you learn</li><li>discard what you can’t trust</li></ul><p>This post is about the system I backed into while trying to do that — not all at once, and not intentionally at first.</p><p>In hindsight, this isn’t a new philosophy for me — it’s the same instincts I’ve been writing about for years: treating code as a signal rather than an asset (Code Smell — When to Refactor), separating learning artifacts from production commitments (Lean Expectations — PoC, Prototype, MVP), and embracing parallel, disposable attempts long before AI made them cheap (Build All the Things!). AI-assisted development simply forced those instincts into clarity.</p><p>I eventually had to name it.<br>I call it <strong>Outcomes-Driven Development (ODD)</strong>.</p><p>Not because outcomes are new.</p><p>But because, in an AI-assisted world, outcomes — and the evidence behind them — are the only thing that doesn’t collapse under scrutiny.</p><h3>A quick note on why I care about this (background, not the thesis)</h3><p>If you heard the <a href="https://etenlab.transistor.fm/episodes/ai-in-software-development">ETEN Innovation Lab podcast episode</a> Ian and I did recently, you already know the headline: we went from skepticism to actually getting leverage out of AI.</p><p>That story matters, but I don’t want this post to be <em>about</em> the podcast.</p><p>I mention it for one reason: the Bible translation space forces you to be honest about trust.</p><p>If your software is wrong, you don’t just annoy users.</p><p>This is an extreme domain, but the pattern generalizes anywhere the cost of being wrong is high: you can mislead people.<br>You can waste months.<br>You can ship something that <em>looks</em> helpful and quietly isn’t.</p><p>So when I talk about “evidence over explanation” or “guardrails,” that’s not abstract engineering virtue.</p><p>That’s just what happens when the cost of being wrong is real.</p><p>Okay. Back to the point.</p><p>This is the part that sounds abstract until you’ve felt the cost yourself.</p><h3>How these projects actually start (and why that matters)</h3><p>There’s a detail I haven’t mentioned yet, and without it the whole system sounds more abstract than it really is.</p><p>None of these projects start with code.</p><p>They start with a <em>conversation</em>.</p><p>Almost every serious Proof of Concept I’ve built in the last six months begins the same way: a real meeting with real people. Stakeholders talk. I ask questions. We clarify what problem we’re actually trying to solve, what would count as success, and what <em>wouldn’t</em>. That meeting is recorded and transcribed using an AI meeting assistant. Not because transcription is novel — but because it gives me something objective to work from.</p><p>I take that transcript and hand it to an adversarial AI instance whose job is <em>not</em> to be helpful, but to be precise. It challenges assumptions, surfaces ambiguities, and helps turn a fuzzy conversation into a concrete PRD (Product Requirements Document). Sometimes I use a simple PRD template and an adversarial review pass to force clarity. That part works surprisingly well.</p><p>The thing that broke my brain was what came next.</p><p>This is the moment where most AI-assisted workflows quietly start to fail.</p><p>One good prompt now gets you 80–90% of the way there. Sometimes more. The remaining gap usually isn’t bugs — it’s under‑specificity. The Definition of Done wasn’t sharp enough. An edge case wasn’t named. A constraint was implied but never written down.</p><p>And here’s the uncomfortable part: with AI, that last 10% can consume <em>more time than the first 90%</em>.</p><p>Because the longer you stay in the same conversation, the worse things get.</p><p>Anyone who’s used an LLM seriously has felt this: context drifts, hallucinations increase, confidence erodes. Start a fresh conversation and — suddenly — it’s sharp again.</p><p>Now imagine that dynamic applied to code.</p><p>After the first prompt, quality decays fast. Not because the model is bad — but because the conversation itself is polluted.</p><p>So instead of fighting that decay, ODD leans into a different strategy — one that initially felt counterintuitive, and later felt obvious:</p><p>Take what you <em>learned</em>, not what you <em>built</em>, and start fresh.</p><p>The PRD evolves. The Definition of Done tightens. The next attempt gets a clean slate — and better outcomes.</p><p>That’s the real reason restartability matters.</p><p>It’s not about throwing work away.</p><p>It’s about preserving clarity.</p><h3>The uncomfortable shift: when code stopped being the asset</h3><p>For most of my career, code <em>was</em> the asset. That assumption sat so deep I didn’t realize I was carrying it.</p><p>You protected it. You polished it. You carried it forward like an investment.</p><p>AI broke that mental model by breaking the scarcity model underneath it.</p><p>When code generation becomes cheap, variation explodes.<br>And when variation explodes, maintenance becomes the real cost.</p><p>At some point I realized something that felt almost offensive:</p><blockquote><em>If it costs less to regenerate it than to understand it, you should delete it.</em></blockquote><p>The hardest part isn’t deleting code — it’s admitting you trusted it too early.</p><p>That’s not a motivational quote — it’s just economics showing up where we didn’t expect it.</p><p><strong>But it creates a problem:</strong> if you’re willing to delete code, what stays?</p><p><strong>Answer:</strong> the things that make regeneration <em>safe</em>.</p><ul><li><em>the intent</em></li><li><em>the constraints</em></li><li><em>the decisions</em></li><li><em>the evidence</em></li></ul><p><strong>In other words:</strong> <em>the blueprint.</em></p><h3>Epistemic hygiene (or: why your repo lies)</h3><p>There’s another, more practical reason this matters — one I learned the hard way once I started doing agentic AI coding at any real scale.</p><p>If you’ve ever let AI agents loose on a codebase, you know what happens next. Files multiply. Helpers spawn helpers. Temporary artifacts become permanent residents. You end up with <em>dozens</em> — sometimes <em>hundreds</em> — of orphaned files scattered everywhere, each one plausibly important, none of them obviously safe to delete.</p><p>The cleanup is brutal.</p><p>To clean it “safely,” the agent has to re-ingest huge portions of the codebase just to decide what’s still relevant. That means more context. More tokens. More time. More money. I’ve had cleanup passes that cost <em>more</em> — in dollars and attention — than the original coding run that created the mess.</p><p>That’s when it clicked: in an AI-driven workflow, residue isn’t just untidy — it’s expensive. And worse, it actively poisons your ability to reason about what’s true.</p><p>What surprised me most wasn’t just <em>that</em> cleanup was painful — it was how fast the costs compounded.</p><p>In long-lived agentic coding sessions, context itself becomes a liability. Every new response has to carry the weight of everything that came before it. Token counts grow. Costs add up. By the end of the day, you’re no longer paying primarily for <em>new work</em> — you’re paying to keep the past alive.</p><p>I’ve watched cleanup passes cost more than the original implementation. Hundreds of dollars burned not to build something new, but to explain an overgrown codebase back to the model well enough that it wouldn’t break it.</p><p>Fresh starts changed that equation. One-shot — or near one-shot — attempts keep context small, costs predictable, and make it feasible to use the latest state-of-the-art models instead of downgrading out of fear. Restartability isn’t just cleaner. It’s cheaper.</p><p>Which is why epistemic hygiene isn’t aesthetic. It’s economic.</p><p>Here’s the thing nobody tells you when you start “AI coding” seriously:</p><p>A dirty repository is indistinguishable from a good prompt.</p><p>If an attempt succeeds, was it because your intent was clear?<br>Or because a leftover config file from three days ago happened to make it work?</p><p>You can’t know.</p><p>And if you can’t know, you’re not engineering.<br>You’re accumulating folklore.</p><p>That’s what I mean by <strong>epistemic hygiene</strong>.</p><p>It’s the discipline of keeping your knowledge clean in an environment that can generate infinite plausible nonsense.</p><h3>Register, then nuke</h3><p>This is the rule that sounds the most aggressive on paper and is the least dramatic in practice.</p><p>Before an attempt starts:</p><ol><li><strong>Register</strong> who (or what) is doing the work and with what model.</li><li><strong>Nuke</strong> the application source directory.</li></ol><p>Not as a tantrum.</p><p>As a guarantee of independence.</p><p>If you inherit old code, you’re not testing your intent.<br>You’re testing your ability to patch a ship that might already be sinking.</p><p>And if you don’t capture provenance first, you lose the ability to learn from results.</p><p>Restartability isn’t a failure mode — it’s a feature that makes learning cheaper and safer.</p><p>This isn’t nihilism — it’s controlled experiments.</p><p>It’s also what keeps AI-assisted work economically sane as systems scale, because every clean restart avoids dragging yesterday’s uncertainty — and yesterday’s token bill — into today’s attempt.</p><p><strong>A real example:</strong> late last year, <a href="https://etenlab.transistor.fm/episodes/tracking-progress-toward-the-2033-bible-translation-goals">Peter and I were pulling together All Access Goals</a> data from multiple sources (Progress.Bible, Rev79, and other inputs). He did the first pass the old-school way: spreadsheets, filters, manual splicing, careful assumptions.</p><p>My job was not “build a dashboard.” My job was: <strong>make the analysis repeatable</strong>.</p><p>So I treated Peter’s spreadsheet outcome as the “golden truth,” and used AI to help me rebuild the pipeline so we could drop in new exports and get the same result without redoing the whole exercise by hand.</p><p>That’s register → nuke thinking in disguise: preserve what’s true (intent + constraints + evidence), and don’t get emotionally attached to the code that happened to produce it the first time.</p><h3>Evidence beats explanation</h3><p>ODD is allergic to “trust me.”</p><p>This is where many AI-first teams start to get uncomfortable.</p><p>In an AI-assisted workflow, explanations are cheap.<br>Confidence is cheap.</p><p>So “it works” is meaningless without proof.</p><p>Definition of done gets strict in a very specific way:</p><ul><li><em>observable behavior</em></li><li><em>screenshots / short recordings for UI changes</em></li><li><em>produced artifacts</em></li><li><em>explicit checks against constraints</em></li></ul><p>An explanation is a claim — A screen recording is evidence.</p><p>Here’s the part that still feels uncomfortable to say out loud: I don’t look at the code anymore. Not because it’s unimportant — but because it stopped being the most reliable signal. Instead, I look at behavior, constraints being honored, performance under load, repeatability, and whether independent attempts converge on the same outcome. When those signals are strong, reading the code usually adds confidence theater, not confidence.</p><p><strong>A small failure that taught this the hard way:</strong> one attempt confidently claimed the app was “mobile-ready.” No caveats. No warnings. When I actually loaded it on my phone, it was unusable — text overlapping, controls off-screen, basic interactions broken. Nothing was <em>technically</em> crashing, which made the explanation sound plausible. But there was no evidence — no screenshots, no mobile recording, nothing. The moment it touched reality, the claim collapsed.</p><p>That’s why ODD doesn’t accept explanations.</p><p><strong>Another real example:</strong> when we turned that All Access Goals analysis into an internal dashboard, the impressive part wasn’t “it can render charts.”</p><p>The impressive part was that we could take <strong>raw exports</strong> (hundreds of thousands of records), load them, filter them, and ask questions in plain language — <em>and</em> verify that the outputs matched Peter’s original spreadsheets <strong>verbatim</strong>, row‑for‑row and aggregate‑for‑aggregate, against the stated requirements.</p><p>Then the AI suggested computing pace metrics — and the first version took many minutes. That was unacceptable, because it made the work feel like a batch job instead of an instrument.</p><p>So we pushed for optimization until the same computation ran in <strong>under two seconds… in the browser</strong>.</p><p>That’s the pattern: once something proves useful, you harden it until it becomes <em>interactive truth</em>, not a one-off report.</p><h3>Quantum development: let attempts compete</h3><p>In ODD, the PRD is the hypothesis. Everything else exists to test it.</p><p>This framing matters more than it sounds.</p><p>AI is non-deterministic.<br>Same prompt, different architecture.</p><p>Instead of fighting that, ODD treats each run as an independent observation.</p><p>Multiple attempts can be run in parallel against the same PRD.</p><p>One becomes the champion.</p><p>The others aren’t “waste.”<br>They’re sealed as evidence.</p><p>And the most important output of a failed attempt often isn’t the code.</p><p>It’s the clarification you add back into the PRD.</p><p>Evidence merges. Code only ships if it wins.</p><p><strong>If you want a concrete mental picture:</strong> one of these efforts started as a single meeting transcript about “tracking AAG risk better.” The first PRD <em>mostly</em> worked. The second attempt failed quietly — not catastrophically, just enough to erode confidence. The third attempt, after tightening the Definition of Done and restarting clean, produced a dashboard people actually trusted.</p><p>(In a <em>different</em> project later on, with a different team, there’s a visible line in the commit history where it becomes “Codex assistant, Codex assistant, Codex assistant.” That’s a separate story.)</p><p>That’s not a gimmick. It’s a signal that the bottleneck moved. The work shifted from <em>typing code</em> to <em>defining intent, setting guardrails, and picking winners</em>.</p><h3>Misuse patterns (how people ruin this)</h3><p>If this starts to sound like a methodology you should adopt, that’s already the wrong vibe.</p><p>ODD has predictable failure modes:</p><ul><li><strong>God prompts</strong> (stuffing the universe into one prompt)</li><li><strong>Outcome theater</strong> (measuring tickets while claiming outcomes)</li><li><strong>Evidence substitution</strong> (“trust me” instead of proof)</li><li><strong>Residue drift</strong> (dirty repo, invalid conclusions)</li></ul><p>The point isn’t perfection.</p><p>The point is making failure modes visible <em>before</em> they become expensive.</p><h3>Maturity matters</h3><p>This is where a lot of people misread ODD as dogma.</p><p>It’s not.</p><p>Governance is progressive.</p><p>A Proof of Concept should move fast and learn.<br>A production workflow should be auditable and unforgiving.</p><p><em>Rigor too early kills creativity.<br>Rigor too late kills credibility.</em></p><h3>The freedom to delete</h3><p>This is not a philosophy of optimism.<br>It’s a discipline of restraint.</p><p>It assumes:</p><ul><li><em>generation is abundant</em></li><li><em>trust is not</em></li><li><em>maintenance is the tax you pay forever</em></li></ul><p>So it protects the only things worth protecting:</p><ul><li><em>intent</em></li><li><em>evidence</em></li><li><em>decision history</em></li><li><em>the ability to restart cleanly</em></li></ul><p>And that’s the real freedom here.</p><p>Not the freedom to ship garbage faster.</p><p>The freedom to learn without being anchored to a failed artifact.</p><p>So here are the questions I keep coming back to:</p><blockquote>What would change if we stopped being afraid to delete our work?<br>What changes when the blueprint becomes the asset?</blockquote><p>For readers who want to hear how these ideas showed up in real projects:<br> • <a href="https://etenlab.transistor.fm/episodes/ai-in-software-development">Using AI in Software Development — Episode 4</a><br> • <a href="https://etenlab.transistor.fm/episodes/tracking-progress-toward-the-2033-bible-translation-goals">Tracking Progress Toward the 2033 Bible Translation Goals — Episode 5</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac0cc2951218" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build All The Things! — is concurrent development possible?]]></title>
            <link>https://medium.com/@klappy/build-all-the-things-is-concurrent-development-possible-607b3298b2d7?source=rss-b9df4597e4d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/607b3298b2d7</guid>
            <category><![CDATA[mental-health]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[life-lessons]]></category>
            <dc:creator><![CDATA[Chris Klapp]]></dc:creator>
            <pubDate>Thu, 09 Mar 2023 22:48:59 GMT</pubDate>
            <atom:updated>2024-12-18T16:39:15.100Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<p><em>I know my brain, it is single threaded. Developing “Asynchronously” would be a better title but does not seem to create the same mental picture.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*w2mSgccBYkh1WhqX1ysgiw.png" /></figure><h3>Build all the things!</h3><p><em>There were three future apps that needed to be built. They are all related, use the same data types and sources, and interact with the same servers. Instead of building a Proof of Concept then maturing it to Production before starting the next project, I decided to take a different approach. </em><strong><em>Build all the things!</em></strong></p><p>Rotating projects has many benefits especially if there are similarities between them. What you learn from one app can help with the next, and the previous. It also gives you a chance to try new things as well as A/B test development tools and frameworks. While that sounds so exciting, it’s not all sunshine and rainbows.</p><p>Returning to a codebase after working on another can leave your head spinning. Consistency between the projects is crucial to maintainability, but that requires frequent refactors. Continually refactoring can be a beautiful thing when you’re solo, but challenging in a team environment to keep everybody updated. You can read one of my recent articles for more about <a href="https://medium.com/@klappy/why-you-no-iterative-refactoring-18280a01b123">iterative refactoring</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KbUDTwLmaZeHQYP3" /><figcaption>Photo by <a href="https://unsplash.com/@kristinwilson?utm_source=medium&amp;utm_medium=referral">Kristin Wilson</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Move locations</h3><p><em>Maintaining multiple immature projects concurrently is challenging but worth it. Context switching between them can be a major strain on your brain. If you change physical locations such as rooms in your home or getting out to a coffee shop, it can help your brain adjust.</em></p><p>Over time I have trained my brain for certain types of tasks at different locations. I setup multiple home office nooks around my house. Each one dedicated to certain Zoom meetings. Occasionally I’ll need to mix it up and rotate them. Some areas are dedicated for creative writing and others for focused programming where I zone out. When my home office doesn’t cut it I have coffee shops, and business lounges that I go to get in the zone and be productive. When I’m programming multiple projects at the same time, I employ the same tricks. Each project has it’s own physical space.</p><p>Bedtime routines help your brain fall asleep faster and you feel more rested when you wake up. Why can’t we have routines and physical spaces to train our brain to help us context switch? When something isn’t working mix it up and rotate locations until you get the right environment for each type of task.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kphf_V_zhdeaQiSWrBQQ6Q.jpeg" /></figure><h3>Maximize work not done</h3><p><em>Think of your codebase like a home. There are all types for different environments, cultures and life styles. If you know where you want to live and find the house you love, you can buy it already built. Some people have a clear vision of what to build and found the time, money and the lot to build it on. Others are nomadic and love exploring the unknown.</em></p><p>When you are building the unknown you need to stay light and nimble, ready to pack up and move at a whim. In this case only a tent or camper will likely work. Pouring a foundation and building a building with bricks will only slow you down because even if you are building the right building it may not be in the right location.</p><p>For my PoCs and Prototypes, I avoid Test Driven Development, TypeScript, and documentation. They bog down my code and more importantly my mind. I know it’s blasphemy but prototyping is different than building an MVP. Especially when the projects I’m rotating through are related. I can more easily apply lessons learned on another project. When working on Prototypes, I can start abstracting the code shared between projects to portable and extensible libraries.</p><p>You can quickly become bogged down by many tasks if you implement them too early. Many projects are really just a Proof of Concept or a Prototype. If you write tests first, you may be rewriting your tests as many times as you change directions and that can be a dozen times before production. Why pour a cement foundation just to pitch a tent for a weekend camping trip? To read more about my thoughts on this check out my post on <a href="https://medium.com/@klappy/lean-expectations-poc-prototype-mvp-140749383fd4">PoCs, Prototypes, and MVPs</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lt2bcmf9ltIha4Sn3jJY0w@2x.jpeg" /><figcaption>Photo by todd kent on Unsplash</figcaption></figure><h3><em>Don’t literally build “all” the things</em></h3><p><em>Programming is like solving puzzles. It’s more fun when you solve them yourself.</em> <em>It’s tempting to build everything from scratch. When you do everything you write you will likely have to maintain. Use existing libraries and frameworks before you go building your own solutions to common problems. There are some tradeoffs to be cautious about but don’t let that be an excuse to literally build all the things.</em></p><p>But when I Google for solutions, StackOverflow is chocked full of answers. More often than not, libraries are already published on NPM that I can leverage. I quickly learned that boilerplates are tedious and frustrating, and “zero configuration” is a lie. Sometimes I end up jumping through hoops to make them work but get a lot of use from them before I have to look for an alternative. When I am building multiple projects at the same time, I am able to try multiple frameworks and libraries at the same time and compare them. Once I find one that does the job with the least amount of setup and configuration, I refactor the other projects to use the selected implementation for consistency.</p><p>Before you start building everything yourself, try to find a library that already does what you are looking for and borrow it and bend it to your use case. Once it quits bending and starts to break, then it‘s time to build your own library to replace it. Before you do, see who else might be interested in it and see if you can be a stakeholder. You may have to wait a while but it may save you much time and energy long term. If you can’t find anybody to build it for you, then it’s time to build it yourself. I call this: “Borrow, Bend, Break, Beget, then Build.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dgqoohhfTMEPft7wL1qTkQ@2x.jpeg" /><figcaption>Photo by JESHOOTS.COM on Unsplash</figcaption></figure><h3>Pre-optimization is futile</h3><p><em>Every time I spent the time improving performance, it ends up being refactored while adding features, negating the time invested.</em></p><p>I focus on making the code work first. Then I circle back to optimizing performance once performance is an issue. Yes, some things will be slow and could always be 1000x faster if you did it another way. But why spend a few days on each code block eeking out 10ms per page load when the user won’t even notice. While I do continuously refactor, I avoid the urge to pre-optimize.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KAKU7bTNL36DlZyEGp2i9g@2x.jpeg" /><figcaption>Photo by Jonathan Kemper on Unsplash</figcaption></figure><h3>Conclusion</h3><p><em>If you find yourself needing to develop multiple projects at the same time try the following: move locations when context switching, maximize the amount of work not done, leverage frameworks as much as possible, avoid certain time sinks, abstract common functionality, and avoid pre-optimization.</em></p><p>I wrote this post a few years ago and just stumbled across the draft and decided to publish it as is. I am now on the other side of these projects now and realize how important these lessons were in my growth as a developer.</p><p>There are many pros and cons to “concurrent” development. What are your thoughts? How do you accomplish it or do you avoid it altogether?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=607b3298b2d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Ensure React is Not Destroying Components]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/better-programming/how-to-ensure-that-react-is-not-destroying-components-db52a653eadf?source=rss-b9df4597e4d7------2"><img src="https://cdn-images-1.medium.com/max/2600/0*i3Hsvim72Ull1OXW" width="3977"></a></p><p class="medium-feed-snippet">Once we know which components are problematic, it&#x2019;s much easier to fix the&#xA0;problem.</p><p class="medium-feed-link"><a href="https://medium.com/better-programming/how-to-ensure-that-react-is-not-destroying-components-db52a653eadf?source=rss-b9df4597e4d7------2">Continue reading on Better Programming »</a></p></div>]]></description>
            <link>https://medium.com/better-programming/how-to-ensure-that-react-is-not-destroying-components-db52a653eadf?source=rss-b9df4597e4d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/db52a653eadf</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Chris Klapp]]></dc:creator>
            <pubDate>Mon, 06 Jun 2022 19:19:25 GMT</pubDate>
            <atom:updated>2022-06-07T04:06:15.685Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
        </item>
        <item>
            <title><![CDATA[Why you no?! — Iterative Refactoring]]></title>
            <link>https://medium.com/@klappy/why-you-no-iterative-refactoring-18280a01b123?source=rss-b9df4597e4d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/18280a01b123</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Chris Klapp]]></dc:creator>
            <pubDate>Tue, 08 Feb 2022 19:33:39 GMT</pubDate>
            <atom:updated>2022-02-09T12:12:28.797Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h3>Why you no?! — Iterative Refactoring</h3><p>As a programmer it’s easy to be passive agressive with our code. We wait until we can’t stand our code and it makes us sick to our stomach before we consider it. Refactoring doesn’t have to be done as a major single effort that is done infrequently. Instead, refactor interitively and continuously.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/576/1*7d72VoJ4j6JlE_btYOauHw.jpeg" /><figcaption><a href="https://imgflip.com/i/64fqa8">https://imgflip.com/i/64fqa8</a></figcaption></figure><h3>Always be refactoring</h3><p><em>There are many things you can do to practice continous and iterative refactoring. Here are a few things that you can try out.</em></p><ol><li><strong>Keep things tidy</strong>: leave everything better than you found it.</li><li><strong>I did what?!</strong>: use git blame for good.</li><li><strong>Test driven refactor</strong>: use tests to confirm you didn’t break everything.</li><li><strong>Less is less!</strong>: use small changes for less technical debt.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UzDqRgZseVp95qPXr6LLiA.jpeg" /><figcaption>Refactoring can feel like finding hay in a needle stack when we wait too long.</figcaption></figure><h3>Keep things tidy</h3><p><em>Over time we develop our skills as programmers and improve our knowledge of best practices. Best practices change and so should our ability to code. When you revisit a codebase to add a feature or fix a bug, we should look for things to improve every time.</em></p><p>Most of the refactors that I’ve done through the years have been made up of a lot of little things. Many of them could be handled quickly individually. It has always been easier to iteratively refactor my Proof of Concepts and Prototypes as they are typically smaller and easier to work with. My goal is to share the joy I find when I am always in the state of refactoring.</p><p>It’s so much easier to keep a house clean than it is to clean it once a year. If it only takes a few minutes to clean up the offending code smell, why wait until it cascades out of control? Every time you edit a file, look for something to pick up. Then when it comes time for an architectural refactor, it isn’t as overwhelming.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*ucycS94H93RuHdd1V7IjHQ.jpeg" /></figure><h3>I did what?!</h3><p><em>Git blame is a powerful tool that is commonly used as an accusatory weapon. It’s so much more than that. It’s a great tool for figuring out the context of the changes that evoked those lines of code. More importantly it can help you know who you need to talk to if you don’t understand why something was done that way.</em></p><p>While working on an issue, I frequently scratch my and wonder why things were done a certain way. I’ll use Git blame to figure out who to get more details from, only to find out it was me… a couple of years ago. I tell myself it’s a good thing, a sign that I’m getting better! Sometimes it would be easier if it was somebody else. That way I can reach out to them and collaborate on a way to make things more readable and maintainable.</p><p>Try to use Git blame to get more information about code you have questions about. If you don’t know how to use the command line for it, use Github. Just open the repo/file on Github, click the line number in question, then the three dots beside that, and then select “View git blame” for the who and the commit link.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/430/1*EcfSzR2gwiBpPGqhQssoHQ.jpeg" /></figure><h3>Test driven refactoring</h3><p><em>We’ve all heard of TDD or Test Driven Development. What about TDR? Test Driven Refactoring can help us ensure we didn’t break things while we refactor. Yes, this adds time to our refactor, but helps us iteratively add tests to improve our test coverage. Try this the next time you make changes to your codebase, you also have a better chance of not accidentally breaking something.</em></p><p>At the start of my current refactor, I was guiding another developer through my thought process. At first we weren’t sure what we could divide and conquer. We realized that we could do something in tandom. One of us could write tests and the other could refactor. Once we are done we will ensure that the refactor passes tests that work off of known good.</p><p>Pair programming during a refactor can be quite difficult. Assigning one dev to write the tests and the other to refactor, can help both be productive without stepping on each others toes in the process. Combine that with continuous and iterative refactoring and you are continuously and iteratively increasing your test coverage. <em>Your QA team will thank you.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/1*gbvjQREm4iHYKA_B8xA1Wg.jpeg" /></figure><h3>Less is less!</h3><p><em>Less is less! Less long term frustration. Frustration that comes from piled up technical debt. Less long code reviews for those large refactors. Less time in spent needing to explain or get help. Less breaking of functionality as it is easier to test. Less long meetings planning large releases.</em></p><p>I commonly fall into the trap of making tons of small changes at once and pushing them through to QA. It sounds counter productive to have more releases (you got me to say less <em>is</em> more) but bundling a lot of changes in a release have always lead to longer release cycles that cascade out of control. In the end continuous iterative releases, whether it’s new features or small refactors, mean less time overall.</p><p>Once we get started implementing a best practice or cleaning up our code it’s hard to stop. Then we run into huge cumbersome peer reviews of our pull requests. To combat this try to address one thing at a time. Make your commits small and meaningful. Make your pull requests small and meaningful. Less is more, more or less.</p><p>I’ll be honest and admit that I don’t always follow these as strict rules but I usually regret when I don’t. Maybe that’s why I started writing this series, to help reinforce the patterns that worked well in the past and avoid the ones that caused problems.</p><p>If you want to read more about my perspective and thought process on refactoring, read my previous post, <a href="https://medium.com/@klappy/code-smell-when-to-refactor-e18f1dca2f01">Code Smell — When to Refactor</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=18280a01b123" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Code Smell — When to Refactor]]></title>
            <link>https://medium.com/better-programming/code-smell-when-to-refactor-e18f1dca2f01?source=rss-b9df4597e4d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e18f1dca2f01</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Chris Klapp]]></dc:creator>
            <pubDate>Sat, 05 Feb 2022 13:04:05 GMT</pubDate>
            <atom:updated>2022-02-14T17:49:50.010Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h4><em>Refactoring is improving the quality of code in a project that reduces technical debt while improving readability and maintainability. When do we know it’s time to refactor? You can smell it</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3kQIN_Cpk1zysLcQ" /><figcaption>Photo by <a href="https://unsplash.com/@synkevych?utm_source=medium&amp;utm_medium=referral">Roman Synkevych</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Perfection is not the goal</h3><p>Personally, I continuously and iteratively refactor when my code develops a series of symptoms of code smell. I will commonly refactor 5–10x before I’ll feel good about most projects, even <a href="https://medium.com/@klappy/lean-expectations-poc-prototype-mvp-140749383fd4">PoCs, and Prototypes</a>. Not that I am trying to obtain perfection, far from it.</p><p>I am okay with writing pseudo-code, in the beginning, to get my thoughts out and I focus on making that work. Then I keep addressing the worst smell that I can’t stand until things work well enough. Most of the time I move on the way before it’s anywhere near perfect.</p><figure><img alt="Something is rotten and you can smell it." src="https://cdn-images-1.medium.com/max/1024/1*KuWoSZ2gx2OOujgwK6bYiw.jpeg" /><figcaption>Something is rotten and you can smell it.</figcaption></figure><h3><strong>The smell of technical debt</strong></h3><p><em>Over time many of our projects start to develop a certain smell. For some of us we can’t smell our own code but we just know there’s something off and we can’t quite point it out. There are certain indicators that do make it a little more obvious.</em></p><ol><li><strong>Feature creep</strong>: <em>current expectations excede the original assumptions.</em></li><li><strong>Cognitive load</strong>: <em>it’s too hard to trace the logic or data flow.</em></li><li><strong>Difficulty skyrockets</strong>: <em>simple changes take too long or seem impossible.</em></li><li><strong>Performance conundrums</strong>: <em>you just can’t figure out why it’s slow.</em></li><li><strong>Best practices</strong>: <em>they changed again and your code starts to look dated.</em></li></ol><p>This is far from an exhaustive list. These are just some of the common ones that I encounter and trigger me into starting a refactor.</p><h3>Feature creep</h3><p><em>Feature creep isn’t bad. It’s a necessary pain that shows that the project is being used that provides us with a valuable learning experience.</em></p><p>This can easily be the number one cause of technical debt. When you started the project, there were certain expectations. Everything was architected off of that limited set of knowns. Inevitably, things change… regularly.</p><p>Each feature request, bug fix, and user feedback shows us how little we knew about how the project would actually be used. After a couple of months to a year, the readability and maintainability plummets. This can start a chain reaction of other code smells.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CSbBqar6QAjKpqze" /></figure><h3>Cognitive load</h3><p><em>Each time we add a new feature, address a bug, and implement user feedback, we do our best to do so in a timely manner to keep our users happy. This leads to shortcuts that we may or may not be aware of at the time. Many times it was so obvious that if we just add this code here, it works, so why would I overcomplicate it?</em></p><p>This thinking leads to functions and files that just do too much and grow in length and complexity. My simple rule for this is to keep files short by doing one thing well with each file and in turn each function and component. Personally, I look for folders with too many files, files over 100 lines, functions over 10 lines, nested blocks deeper than 3 indentations. That doesn’t mean I don’t have a lot of code that exceeds these. I use this as my indicator to investigate if it’s necessary.</p><p>Some projects would end up with too many tiny files if you were too strict on this. Find your thresholds that works for your project and team. Once you start to break up these larger chunks of code, it generally becomes easier to spot what belongs together and where to put things. Not to mention writing tests for single purpose functions is much easier to implement and keep up with.</p><p>By keeping our code concise and easy to read, its much easier for others to look at our code and know exactly what it does and how it does it. Your future self will thank you for doing so. Especially when you don’t have to spend your time apologizing for long explanations. My embarrassment has led to so many apologies and subsequent refactors.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oB2QCc5Eax2QEOMf" /><figcaption>Photo by <a href="https://unsplash.com/@frankbusch?utm_source=medium&amp;utm_medium=referral">Frank Busch</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Difficulty skyrockets</h3><p><em>Each subsequent bug fix and feature request we implement gets increasingly more difficult as it takes longer to trace the data flow and logic of the project. If we are not careful, we run into a simple request requiring you to have a map of the project as the codebase is no longer intuitive.</em></p><p>Things like inconsistent race conditions, performance issues, and other bugs can just get harder to debug, let alone adding new features confidently. Adding a simple action to a confirmation dialog can feel near impossible, even with the help of your peers. This was what led to our team’s latest refactor. There was already a growing series of other smells.</p><p>When you start finding yourself spending more time on each issue, it’s probably past time to refactor. If you need an excuse to clean up technical debt and you are afraid to ask your project owner, this could be your magic ticket.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ygV1MFouKPxJp85p" /><figcaption>Photo by <a href="https://unsplash.com/@dcemr_e?utm_source=medium&amp;utm_medium=referral">Joshua Eckstein</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Performance conundrums</h3><p><em>When you just can’t figure out why it’s slow, it may be time to start refactoring. So many times everything looks “fine”. The code runs but it just doesn’t run like it use to. Profiling just seems too complicated with too many tiny things and no one thing seems to be worth optimizing.</em></p><p>It’s not uncommon while I am debugging performance issues to come across tiny syntax problems and a few odd anti-patterns that I just can’t ignore. Most of them I introduced to the project, by the way. Magically, while cleaning up the offending lines of code here and there, I’ll notice some small incidental and incremental performance boosts. It doesn’t always happen but it sure is nice when it does. Other times, it takes much longer but I eventually stumble across some hidden bottlenecks. Recently, I was able to get a 90s pagination issue down to a reasonable &lt;2s render time by doing this.</p><p>Even if you don’t discover the root issue while refactoring, the resulting improvements in readability should make it much easier in continuing the search for your bottlenecks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SITzMoTGlrJ7gykF" /><figcaption>There’s a reason why we don’t commonly use CDs and DVDs anymore.</figcaption></figure><h3>Best practices</h3><p><em>Technology moves in a forward direction and in programming, best practices are always changing. When the language and frameworks we use were created, best practices evolved in the community to solve common issues and make it easier for outside contributors to get involved. About the time we get a handle on the latest best practice… they change again.</em></p><p>There’s a reason why best practices change. The current best practices now have new problems that plague the community. New major versions of our frameworks are released to address these issues. In turn, new best practices are required. Many times the code smells we encountered can be addressed by researching updated best practices and following them.</p><p>We should always be learning. If we ignore best practices, our “personal” design patterns prevent others from easily figuring out what in the world we were trying to do. Failing to do so makes us and our projects difficult for others to help us maintain them.</p><p>Imagine keeping a large distributed team working on a large project on the same page without best practices. Been there; done that. I’ve conceded to learning best practices and try to resist the urge to find a better way. Not that I always succeed but I do try. This makes it easier to train others as you can refer to existing articles and tutorials. Then you don’t have to spend all of your time training everybody when you could be working on something else.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*En0XLMiM5oBXdweRUaq2jg.jpeg" /></figure><h3>Clean the fridge</h3><p><em>What happens if we don’t address this early? It only gets worse. As with any bad smell, it doesn’t go away until you address the source of the odor.</em></p><p>Sometimes there are just too many smells to know where to begin. You need to be prepared to schedule a meeting with a team member to do a code audit. Start by making a list of all the things that don’t look right and best practices you would like to implement. Categorize the list by those best practices and coding principles you want to follow.</p><p>One of the things I strive to do is to abstract any code that could be reusable into libraries that can be consumed in other projects. This allows much of the code in an app to be boiler plate and easier to do what I’m about to recommend but may make you sick to your stomach.</p><p>It is okay to throw everything away. Start over by creating a new clean project and using the new best practices that you just learned to import your abstracted libraries into a shiny new app. If this is too much work, maybe you haven’t abstracted enough of your code out into their own portable and extensible libraries. Sounds like a candidate for your next refactor!</p><p>Since I primarily create Proof of Concepts and Prototypes, most of my code is regularly thrown away or sits on a shelf for months or even years before somebody finds value in it. So I don’t have an emotional attachment to my code. This makes it easier to claim code bankruptcy. I discuss this more in one of my previous articles, <a href="https://medium.com/@klappy/lean-expectations-poc-prototype-mvp-140749383fd4">Lean Expectations — PoC, Prototype, MVP</a>. Read it to see more of my perspective on when it makes sense to start over.</p><p>If you want to read more about my perspective and thought process on refactoring, read my next post, <a href="https://medium.com/@klappy/why-you-no-iterative-refactoring-18280a01b123">Why you no?! — Iterative Refactoring</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e18f1dca2f01" width="1" height="1" alt=""><hr><p><a href="https://medium.com/better-programming/code-smell-when-to-refactor-e18f1dca2f01">Code Smell — When to Refactor</a> was originally published in <a href="https://betterprogramming.pub/">Better Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Virtues — How to Prioritize]]></title>
            <link>https://medium.com/@klappy/what-are-software-virtues-and-how-to-prioritize-them-f0b583741afe?source=rss-b9df4597e4d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/f0b583741afe</guid>
            <category><![CDATA[agile-project-management]]></category>
            <category><![CDATA[prioritization]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[quality-software]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Chris Klapp]]></dc:creator>
            <pubDate>Sun, 09 Sep 2018 16:33:03 GMT</pubDate>
            <atom:updated>2019-11-29T13:02:09.761Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h4>Software development is a complex dance of competing priorities. Priorities vary not only by each team and project but also the maturity of the project.</h4><p>Clarifying priorities can greatly reduce the number of lengthy debates around what to focus time, energy, and money on when developing software. Prioritizing the values clarifies the aggregate thought process of which features to invest in and when to do so. This includes the stories that the Product Owner chooses to put in each sprint as well as guides every line of code that a developer contributes to the project. Priorities are not always directly proportionate to the amount of effort invested but rather what to choose when a choice must be made.</p><p>Many times a lack of consensus on priorities leads to much confusion, frustration, and missed expectations throughout the lifecycle of a project. Communicating these priorities to stakeholders helps them understand where their needs are in the priorities. It gives a lens to view and discuss why their issues may not be on the top of the list but are nevertheless important.</p><h3>Applying Priorities</h3><p>Before we can meaningfully interact with the virtues of software, we must first discuss where and how they should be applied. Each team should have a baseline of their prioritized virtues that can act as a template for their projects. Each project should have their own virtue prioritization. As each project starts out it is impractical to hold the early phases of the project to the same standards as the release, requiring separate priorities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*h3f6MV4Q7mQB6LD6" /><figcaption><a href="https://unsplash.com/@rawpixel?utm_source=medium&amp;utm_medium=referral">rawpixel</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Team Priorities</h4><p>Each team is made up of individuals that see the world through their values. They see a need that must be met and feel that they have the proper perspective to solve the respective problems.</p><p>A team’s aggregate priorities guide the overarching approach in their development. There is a positive friction that must be lubricated between the team members or the friction creates too much heat and impedes productivity. Developers have a different perspective than managers. Leveraging each team member’s values by encouraging forthright communication can help reinforce a balanced approach. Everybody is heard and has input even though their priorities are not the same as the aggregate.</p><h4>Project Priorities</h4><p>Each project is supposed to meet a use case. That use case should govern the priorities of the project and be reflective of the needs of the users. Without this, the project can seemingly be chasing invisible goals. This leads to great confusion and every decision for a project seems ambiguous and requires lengthy debates as to what should be done each step of the way. Better understanding the user and the use case are paramount to assessing the priorities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*O6gCgY3HHBxwfjMc" /><figcaption><a href="https://unsplash.com/@rawpixel?utm_source=medium&amp;utm_medium=referral">rawpixel</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Lifecycle Priorities</h4><p>Every project has phases and each phase can have a different set of priorities than the others. While a project is still an idea it is governed by abstract ideas and concepts. When it is delivered to users it demands concrete realities. In between these phases, the priorities evolve and change shape. You can read my <a href="https://medium.com/@klappy/lean-expectations-poc-prototype-mvp-140749383fd4">prior article</a> on setting expectations on phases of lean software development. Without recognizing the phase of development we can hold the wrong priorities and improper standards that ultimately impede the project’s delivery.</p><blockquote>“Software architecture is all about appropriate compromises. For small projects, having a highly involved software architecture is probably an overkill. For large enterprise applications, it becomes a necessity.”</blockquote><blockquote>— Ash Isaac, <a href="https://dev.to/ashokisaac/software-architecture-virtues-22hj">Software Architecture “Virtues”</a></blockquote><h3>Software “Virtues”</h3><p>You may be familiar with the <a href="https://en.wikipedia.org/wiki/Project_management_triangle">Project Management Triangle</a>, where the quality of work is determined by the deadlines, scope, and budget. Any modification to one of those requires a reassessment of the other two. Engineers also have their iron triangle, and frequently repeat the mantra, “faster, better, cheaper: choose two.” In reality, it is more flexible but there are clear tradeoffs and a natural tension between them. It would be nice if software development was as simple as teasing out our priorities using just three parameters.</p><blockquote>“The Project Management Triangle is clearly insufficient as a model of project success because it omits crucial dimensions of success including impact on stakeholders, learning, and user satisfaction.” — Wikipedia, <a href="https://en.wikipedia.org/wiki/Project_management_triangle">Project Management Triangle</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cUCuz_Z6gJqIOIiL" /><figcaption><a href="https://unsplash.com/@samuelzeller?utm_source=medium&amp;utm_medium=referral">Samuel Zeller</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>So what are some priorities that compete in software development that need to be assessed for teams, projects, and phases of a project? Think of these as the “virtues” of software. They are also known as <a href="https://en.wikipedia.org/wiki/List_of_system_quality_attributes">System Quality Attributes</a>. Here are some that should be considered. Not all of them are immediately apparent or represented without careful thought. There are others that should also be on the list but these are the ones commonly competing. When looking at the full list <a href="https://en.wikipedia.org/wiki/List_of_system_quality_attributes">here</a>, consider how they may be grouped together or nested as secondary virtues.</p><h4>Virtues</h4><ul><li><strong>Usability/Simplicity</strong> — Can the software be used by the user to accomplish their needs?</li><li><strong>Originality/Innovation</strong> — Does the project have a differentiation from other software?</li><li><strong>Stability/Reliability</strong> — Is the software stable and reliable?</li><li><strong>Urgency/Timeliness</strong> — Will the software be delivered in time?</li><li><strong>Efficiency/Scalability </strong>— How fast can the software perform under load?</li><li><strong>Maintainability/Manageability</strong> — Can the project be continued by a new team?</li><li><strong>Versatility/Adaptability</strong> — How narrow is the use case and can it be used for similar tasks?</li><li><strong>Interoperability</strong> — How much effort is required for the user’s data to be used with related software? The reverse?</li><li><strong>Affordability/Sustainability</strong> — Can the user afford the software? Is the cost of delivering the software sustainable?</li><li><strong><em>Reality</em></strong> — How realistic are the goals of this software?</li></ul><p>Not all virtues are directly applicable for each project. Others may be missing and need to be added. For example financial software highly values <a href="https://en.wikipedia.org/wiki/Auditability">auditability</a>. Software for power users will likely prioritize <a href="https://en.wiktionary.org/wiki/customizability">customizability</a>. Developers, engineers, and architects have concerns that need to be further prioritized, such as debugability, <a href="https://en.wiktionary.org/wiki/deployability">deployability</a>, <a href="https://en.wikipedia.org/wiki/Extensibility">extensibility</a>, <a href="https://en.wiktionary.org/wiki/recoverability">recoverability</a>, <a href="https://en.wiktionary.org/wiki/securability">securability</a>, <a href="https://en.wikipedia.org/wiki/Testability">testability</a>. Some are completely ignored purposely depending on the phase. Many of them have natural enemies and careful consideration should be taken to balancing them. Some of them even have subcomponents that can be further prioritized. These secondary virtues may be assessed by the development team once they understand the primary virtues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PnASm4lyFzVvOSvA" /><figcaption><a href="https://unsplash.com/@ronmcclenny?utm_source=medium&amp;utm_medium=referral">Ron McClenny</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Usability/Simplicity</h4><p><a href="https://en.wikipedia.org/wiki/Usability">Usability</a> of software is directly tied to the effectiveness of the user’s ability to use the software. Manuals and walkthroughs help address gaps in usability but greatly compromise maintainability. Intuitive interfaces address the root issue. Keeping the software as simple as possible helps remove unnecessary complexity. Learnability can be described as the difficulty for a user to learn the software and can be coerced as a secondary virtue. It can also refer to the software itself learning.</p><p>The natural enemies of usability are originality, urgency, and versatility. New innovative features are rarely understood enough to be simplified and showcase a natural tension between these virtues. Urgency leads to rushing or even skipping user testing. Versatility invites ambiguity that may undermine intuitiveness.</p><p>Usability should gain a higher priority as the project matures.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZQ1oNpTfdQ6KBKh0" /><figcaption><a href="https://unsplash.com/@fiveohfilms?utm_source=medium&amp;utm_medium=referral">Eddie Kopp</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Originality/Innovation</h4><p>Innovation in software can sometimes steal the limelight and temptingly overshadow other virtues. Original ideas are how most projects start and make it easier to sell the project to investors. These new approaches are usually what gives the projects their intrinsic value.</p><p>The natural enemies of originality are usability and stability. Many times usability and stability suffer at first but as the approach is tested and usage is studied, both can be improved.</p><p>Innovation’s priority typically declines as the project matures. This does not mean that the project can no longer be innovative but each new innovative functionality should repeat the process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DxMHuIEezlBWUmCx" /><figcaption><a href="https://unsplash.com/@lucabravo?utm_source=medium&amp;utm_medium=referral">Luca Bravo</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Stability/Reliability</h4><p><a href="https://en.wikipedia.org/wiki/Stability_Model">Stability</a> covers the typical freezes and crashes associated with software bugs. Reliability is associated with the ability to recover without the loss of data. These may be treated as one or as two primary virtues depending on the need. There may be times where reliability is mandatory but crashes are acceptable.</p><p>Stability’s natural enemies are urgency and originality. Rushing something out of the door increases the chances for bugs. New innovative approaches are inherently less tested in the real world and consequences are unknown.</p><p>The priority of stability has a direct relationship to the maturity of the project. Expecting stability and reliability in a proof of concept or alpha release is unrealistic. It pulls a lot more weight in a prototype or beta release but is expected to be mandatory in a production release. This is why patch releases happen so quickly after a major release.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4EGnMMKDXTt4LvYM" /><figcaption><a href="https://unsplash.com/@pic_parlance?utm_source=medium&amp;utm_medium=referral">Karen Lau</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Urgency/Timeliness</h4><p><a href="https://en.wikipedia.org/wiki/Timeliness">Urgency</a> ensures that the project is delivered in time to meet the users need before they solve their issues another way. In production software, the tyranny of the urgent needs to be kept in check. In preproduction software, it may not be prioritized enough. Some users cannot wait for releases and move ahead on a similar path that might not be parallel. This can lead to more work of interoperability if they choose other software in their workflow. Rushing to meet their timeline may sacrifice other priorities. Harness the missed opportunity to study the use case to help a future user base.</p><p>Urgency’s natural enemies are maintainability, efficiency, and usability. Rushing leaves little to no time for ensuring that code is either maintainable or efficient. User testing also takes time and may lead to redesign.</p><p>The priority of urgency prevails throughout all phases but typically increases as the project matures. Unsurprisingly, there always seems to be more time available at the start of a project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dug8YV6Z4JZSL1dQ" /><figcaption><a href="https://unsplash.com/@imgix?utm_source=medium&amp;utm_medium=referral">imgix</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Efficiency/Scalability</h4><p><a href="https://en.wiktionary.org/wiki/efficiency">Efficiency</a> can keep hardware costs down as more work can be done on less hardware. As long as the software performs at a pace that keeps up with users development time is wasted on optimization. Efficiency is a never-ending quest. There are always ways to increase performance and architect a better solution. This is what many developers value most. <a href="https://en.wikipedia.org/wiki/Scalability">Scalability</a> is a form of efficiency under changing load and can prevent wasted hardware resources from going idle while not under load. <a href="https://en.wikipedia.org/wiki/Serverless_computing">Serverless computing</a> is a great example of this. It is easy to think this is only a concern of developers and engineers but needs to be prioritized by all stakeholders.</p><p>Efficiency’s natural enemies are urgency, maintainability, and versatility. Many times refactors sacrifice one or two of these.</p><p>The priority of efficiency should be assessed when the performance impedes the user. Rarely is it a priority in the early phases and usually the highest priority once all other major issues are addressed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xa1erZrhWR035lN1" /><figcaption><a href="https://unsplash.com/@rawpixel?utm_source=medium&amp;utm_medium=referral">rawpixel</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Maintainability/Manageability</h4><p><a href="https://en.wikipedia.org/wiki/Maintainability">Maintainability</a> is widely underappreciated and covers a wide gamut of secondary virtues. This can include code understandability, modularity, testability, and hire-ability, among others. Primarily this focuses on the project transcending a few contributors holding the keys to the project. This also affects the ability to add more team members to the same project. Understandability allows other developers to quickly read and intuitively know what the code does and how to work with it. Modularity allows more parts of the project to be worked on simultaneously as well as reuse of code. Testability can help verify that the existing code acts as intended and ensures future changes are less likely to break previously working code. Hire-ability is assessing how likely your choices affect finding a qualified developer to work on this project. Avoid obscure languages and frameworks unless the use case demands it.</p><p>The natural enemies of maintainability are urgency and efficiency. Rushing to get features out the door or obsessing over performance typically trap a project from achieving long-term maintainability. Technical debt is a common side effect of not prioritizing this virtue.</p><p>Placing a priority on this early on a project slows the natural progression and increases waste. As a project matures it’s maintainability should increase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gBV-N0CHHlhDpehf" /><figcaption><a href="https://unsplash.com/@servuspaul?utm_source=medium&amp;utm_medium=referral">Paul Felberbauer</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Adaptability/Versatility</h4><p><a href="https://en.wikipedia.org/wiki/Adaptation_(computer_science)">Adaptability</a> is the ability to adapt or be adapted to multiple use cases. There is a balance to applying this versatility. Attempting to make software that is too versatile can reduce its effectiveness for any single use case. Designing software workflows to handle too few use cases limit the usability in related use cases. Studying related use cases help identify areas of natural versatility without sacrificing focus or effectiveness.</p><p>The natural enemies of versatility are usability and efficiency. The more a usability workflow and code efficiency are optimized for a particular use case the less versatile it becomes.</p><p>The priority of versatility typically increases as the project matures. Applying this too early and it makes the project lack focus. Sometimes but rarely versatility is reduced to limit applicable use cases unless it was to provide needed focus.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*T1s7APZTxBpL35aB" /><figcaption><a href="https://unsplash.com/@edderrico?utm_source=medium&amp;utm_medium=referral">Ed Derrico</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Interoperability</h4><p><a href="https://en.wikipedia.org/wiki/Interoperability">Interoperability</a> is the ability to import, export, and use data between separate software systems. This can increase applicable use cases and market share for users that already rely on or would like to integrate other related software in their workflow.</p><p>The natural enemies of interoperability are originality and urgency. Innovation can be stifled if too much focus is placed on interoperability. Rushing to meet deadlines can sometimes lead to skipping the study and integration of existing standards.</p><p>The priority of interoperability should be considered throughout all phases of the software development but will naturally increase as the project matures.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8APoOOYPoPJfAVZO" /><figcaption><a href="https://unsplash.com/@rawpixel?utm_source=medium&amp;utm_medium=referral">rawpixel</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Affordability/Sustainability</h4><p><a href="https://en.wiktionary.org/wiki/affordability">Affordability</a> is addressed from two angles. The price of the software to the user and the development team. <a href="https://en.wikipedia.org/wiki/Sustainability">Sustainability</a> is the intersection of the two. If a team can not afford to deliver the software from the income of the software, they must fund the project by another means. This is common in open source software and can be done in different ways. Assessing the costs ensures pet projects are kept in check and that each project’s invested effort is proportionate to the vision and mission of the team.</p><p>Affordability’s natural enemies are nearly every other virtue as they each incur a cost. Theoretically, they should pay off once implemented. Usability testing reduces support costs and should grow a user base. Efficiency keeps hardware costs down. Maintainability reduces technical debt. Other priorities are kept in check by their return on investment with sustainability in mind.</p><p>The priority of affordability should be underlying every other virtue and keep them in check.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nOA-kL2kh0DUKbaC" /><figcaption><a href="https://unsplash.com/@guilhermestecanella?utm_source=medium&amp;utm_medium=referral">Guilherme Stecanella</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Reality Assessment</h3><p>All of the above virtues have to be balanced with reality. Some problems just take time to solve especially to accomplish it in a stable way. Since software development takes time it also costs money. Inexperienced users may take time to learn a new piece of software and initial usability testing might be misleading. Choosing the wrong userbase during testing may lead to ineffective software for the intended users. Is it realistic to or advantageous to focus on interoperability? Does this project really need maintainability or is it a small enough scope to rewrite it if there is no one who can maintain it? Reality helps ensure costs are assessed and that there is enough budgeted to complete the project.</p><ul><li>Costs (effort and resources)</li><li>Benefits (advantages of success)</li><li>Risks (probability of failure)</li><li>Dependencies (requirements)</li><li>Penalties (consequences of not)</li><li>Compliance (regulatory requirements)</li></ul><p>The natural enemies of reality are originality, versatility, and urgency. Sometimes innovation purposefully ignores known realities to address what is thought of as impossible. Many times it is unrealistic to achieve broad versatility. Chasing the tyranny of the urgent can ignore realistic timelines to deliver a stable product.</p><p>The priority of reality should be balanced and help keep everything in check. Placing too high of a priority on perceived realities can stifle innovation and delay timelines. Not placing a high enough priority is unsustainable.</p><h3>Prioritizing Virtues</h3><p>Each team member holds different values it is important for the team to collaborate and agree on the aggregate values of the team. Prioritization should be repeated for each project and again at new milestones such as <a href="https://medium.com/@klappy/lean-expectations-poc-prototype-mvp-140749383fd4">promoting from one phase of development to another</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*21xGLVEqZAQvq76H" /><figcaption><a href="https://unsplash.com/@nikolayv?utm_source=medium&amp;utm_medium=referral">Nikolay Vorobyev</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>One simple approach to sorting the virtues for a team, project, and phase is the <a href="https://en.wikipedia.org/wiki/MoSCoW_method">MoSCoW method</a>. Allow everyone to label each virtue as Must (mandatory), Should (high priority), Could (preferred but not necessary), or Would (can be postponed). Associate a point value of 4, 3, 2, and 1 respectively. Once everyone has labeled them, sort them by the most points and assess if they properly reflect the necessary values. Take time to discuss the order and if adjustments need to be made, repeat the process until a consensus is found. Sometimes anomalies occur and everyone can agree on manual order adjustments.</p><p>There are <a href="https://apiumhub.com/tech-blog-barcelona/software-requirements-prioritization-techniques/">other approaches to prioritizing</a> such as the Hundred Dollar Method where everyone gets a fictitious $100 to spend on each virtue. This one is simple and helps reduce indecision and lengthy debates. It also prevents sticky notes from falling off the wall from being moved too many times. A simple <a href="https://docs.google.com/forms/d/e/1FAIpQLSe_-X7SVHCavwfGYMmZvcnr0Pn6Xf1hCy2mewmrdmCM8fS0BQ/viewform">Google Form</a> can be created to list each virtue with the options of MoSCoW as a linear scale of 1 (would) to 4 (must). Using Google Sheets to sum the values of the entries and sort the virtues by totals should also be a straightforward task.</p><p>Once these Software “Virtues” are set, there may be less need for prioritizing individual features in a lengthy assessment because this acts as a lens to naturally sort them. Then realities such as cost, benefit, risk, dependency, penalty, and compliance can take over.</p><h3>Summary</h3><p>To be able to prioritize the virtues of software, we first had to understand where to apply them, what they are, and how to assess and sort them. Knowing where to apply them gives us context since that can be unique to each team, project, and phase of each project. While there are many software virtues, it is important to focus on which ones are applicable to the project. Many of them have a natural tension with each other. Reality is what keeps the virtues in check. Assessing the software virtues in able to sort them can be an arduous task for any team. There are a few to try and should help the team to come to a consensus.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0b583741afe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lean Expectations — PoC, Prototype, MVP]]></title>
            <link>https://medium.com/@klappy/lean-expectations-poc-prototype-mvp-140749383fd4?source=rss-b9df4597e4d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/140749383fd4</guid>
            <category><![CDATA[minimum-viable-product]]></category>
            <category><![CDATA[lean-software-development]]></category>
            <category><![CDATA[proof-of-concept]]></category>
            <category><![CDATA[mvp]]></category>
            <category><![CDATA[prototype]]></category>
            <dc:creator><![CDATA[Chris Klapp]]></dc:creator>
            <pubDate>Sat, 08 Sep 2018 15:03:45 GMT</pubDate>
            <atom:updated>2018-09-08T15:03:45.688Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<p>For new software to have intrinsic value, it typically introduces innovative approaches to solving a problem. This can come in many forms but is usually improvements on functionality, usability or performance. Sometimes it is addressing new use cases by greeting new market segments that are not currently being addressed by existing software. Whether introducing new approaches or exposure to new markets, there are assumptions made that need to be tested.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DAFH98-skSQFhmbT" /><figcaption>Photo by <a href="https://unsplash.com/@templecerulean?utm_source=medium&amp;utm_medium=referral">Temple Cerulean</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>If we fail to put our assumptions to the test, we risk investing heavily in building a flawed solution or worse, a solution to the wrong problem. Whether or not these new approaches have fully tested assumptions prior to starting development, much learning should be done along the way.</p><blockquote>“Life’s too short to build something that nobody wants. “ — Ash Maurya, Spark59</blockquote><p>We live in a rapidly changing world and software can be out of date by the time it is released. Users are smart and rarely wait for us to solve their problems for them. They adopt other tools or devise clever work arounds to fill the void we are attempting to address. The original assumptions that the software was based upon will continue to evolve while our software is being developed.</p><p>It is important to be purposeful in the iterative learning process since it can take time to deliver software and the use cases we set out to solve are ever changing. Adopting the tools of <a href="https://en.wikipedia.org/wiki/Lean_software_development">Lean Software Development</a> is ideal as it focuses on the following principles: eliminate waste, amplify learning, decide as late as possible, deliver as fast as possible, empower the team, and build integrity in. Transitioning from the traditional <a href="https://en.wikipedia.org/wiki/Waterfall_model">Waterfall</a> to the more modern <a href="https://en.wikipedia.org/wiki/Agile_software_development">Agile methodology</a> is a great place to start as it fosters many of the lean principles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*I5HKKuoaiS-ieSCu" /><figcaption>Photo by <a href="https://unsplash.com/@rawpixel?utm_source=medium&amp;utm_medium=referral">rawpixel</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now that we are a part of a Scrum team using Agile methods we can iteratively improve our development practices by introducing more principles of Lean Software Development. We set the stage for being able to keep up with the rate of change of our users and are ready to develop new software. It doesn’t take long to make it appear functional. We worked out the kinks in the workflow and it demoes so well. We built it directly along the happy path. No matter how much time we invest, it can appear perfect until users start to, well, use it. That’s when the frustration begins. We fix the bugs, adapt the workflow, and once again present it as a working product. The cycle repeats continuously and discouragement can begin to set in. Some of this is inevitable. We cannot produce error free code. If we did we probably took too long to do it.</p><p>It only seems logical that more programming flaws and design holes exist earlier in the product’s development. This leads to the initial impression of the application to be marred very quickly. So how do we set expectations early in the development to prevent frustration and discouragement?</p><p>There are quite a few misconceptions along the way that can be cleared up by setting proper expectations, especially early in the software’s lifecycle. While we may be able to convince our stakeholders of the value of adopting lean principles, the expectation remains that the software produced will be immediately usable and address the use cases the first time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8dPREpu0CIKcZmDIvbvsSg.jpeg" /><figcaption>The scope of learning and changes should decrease as the product matures increasing stability. This is similar to a coin spinning down a funnel. Each reduction in scope allows for a faster iteration.</figcaption></figure><h3>A Solution</h3><p>Software development priorities can evolve as the project matures. One important concept to explore is the inverse relationship between the scope of learning and stability. This sounds like a far stretch but has a simple and logical explanation. True freedom to learn and apply what is learned requires freedom to introduce change. Significant changes undermine stability. Stability is gained by limiting the scope of change in the learning process. We want to always encourage a fast rate of learning but reduce the scope of changes incurred as the product matures.</p><p>To strike a balance of this natural tension, we follow the second principle of Lean Software Development, <a href="https://en.wikipedia.org/wiki/Lean_software_development#Amplify_learning">amplify learning</a>. Shorten your learning cycles by frequently involving user input and user testing. This can introduce change in a more predictable manner and over time offer a sense of increased stability to the users. When there is much to be learned, prepare to introduce drastic changes. As the learning from the users results in smaller changes, a more stable product naturally emerges.</p><p>One of the ways to help set proper expectations while learning to meet user’s needs in a timely manner can be implemented in an iterative cycle of Proof of Concept (PoC), Prototype, and Minimum Viable Product (MVP). While we may already be familiar with the terms it is helpful to understand and communicate the value of each so that we keep ourselves and others from being frustrated along the way. This provides a framework of terminology that can help shape the conversations about our progress and how much change should be expected.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mmOpsfCuixqXDwMf" /><figcaption>“Proof of Concepts are like using the scientific method in software development. You have to design your experiment before you begin testing your hypothesis.” — photo credit <a href="https://unsplash.com/@chuttersnap?utm_source=medium&amp;utm_medium=referral">chuttersnap</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Proof of Concept</h3><p>A Proof of Concept (PoC) is basically a stand-alone project that covers a very small scope and is quickly developed or hacked together so that it can test assumptions. Using the scientific method, you devise experiments to test your hypothesis. This can be accomplished in a multitude of ways such as stand alone codebases, web pages, user workflow diagrams, or even spreadsheets with macros. I’ve seen great functional ones built on FileMaker Pro that also served as a Prototype. There are even applications made for this phase. Regardless of which tool you use, you should always know up front what you want to learn and how to measure success or failure. This ultimately guides whether or not to continue investing in this approach or try something new.</p><p>There are two goals during the testing of the PoC, to test assumptions and to share the vision. Either you fail quickly and learn from it or you learn that you proved the concept and are now ready to share the vision. Both outcomes are a step forward as stated in the book The Lean Startup, “you will always succeed — in seeing what happens.” Adapting your approach based on your failed experiments during this early phase can prevent years invested in a project that was based on incorrect assumptions. If you do end up with a successful PoC, it is evident when you are no longer spending much of your time convincing others. Let the PoC speak for itself and others will confirm it. This makes raising the funding much easier for both the PoC and subsequent development.</p><p>It is important to not expect a PoC to be used long term by users for more than testing due to little effort placed in software architecture and user management. A major question that can be answered is if a new standalone product is needed or if it should it be included as a new feature inside another application to extend the definition of the respective MVP. This is more difficult to answer if it was built in the codebase of another project and quite complex to extract if that is what is necessary. PoCs can also sit on the shelf for a couple months or even a couple years before the timing is right to invest further.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9QFQOjEt6g7j1E3J" /><figcaption>“Mockups of a user interface” — photo credit <a href="https://unsplash.com/@firmbee?utm_source=medium&amp;utm_medium=referral">William Iven</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>PoCs are ideal for new projects and major features. New features can include user interface design and workflows. You can test this by creating mockups of the interface and get user feedback. This is commonly skipped and much development time is wasted in integrating untested user interfaces. While professional designers have specialized tools for this, it can be done in presentation software like Apple’s Keynote. Every hour of a designer’s time can save a day of a developer’s time, and days spent here can save weeks. Diversifying the team to include this role or even contracting this out can help scale the effectiveness of the team.</p><p>There are times where the concept does not have to be proven. This can be the case with small incremental feature improvements or small features. Creating a PoC outside of an existing project for these can be counter productive. Even when this is the case be careful not to invest too much time without user testing these new features or improvements.</p><p>The key in developing a PoC is to use the tools you know and focus on the easiest way to get it done quickly. This is common in hackathons. Resist the urge to optimize performance or test too many assumptions concurrently or your PoC will take way too long. You can always circle back and combine other successful PoCs into a new one. Try to keep the scope small enough of each to complete in a couple of weeks using 1–2 people. This doesn’t have to be done by a developer. Many times non developers are quite effective at creating PoCs. The prerequisites are motivation and passion to solve the problem. This can also allow developers to stay focused on their other projects.</p><p>The PoC typically has the smallest scope and has limited usability but is crucial in testing assumptions with minimal investment. Be prepared to start over a few times and introduce a lot of change because there is the most to be learned here. This phase is immensely helpful in sharing the vision while obtaining funding.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6rdiw2Xu2JQ9aHYb" /><figcaption>“Electronic prototyping” — photo credit <a href="https://unsplash.com/@nicolasthomas?utm_source=medium&amp;utm_medium=referral">Nicolas Thomas</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Prototype</h3><p>A Prototype can be thought of as the step between a PoC and MVP. Once the concept has been proven in a limited scope, you can take a little more time proving whether or not the concept works in a more integrated implementation. Unless the prototype was specifically user experience related, this usually focuses on functionality rather than design or even usability.</p><p>The Prototype is typically not a refactor of the PoC but a rewrite because of the shortcuts taken previously and applying what was learned. This should be more thoroughly user tested to further understand the bottlenecks of things such as software architecture and user management. This typically has a lot of bugs that have yet to be addressed and labeled as Alpha or Beta. While using <a href="https://en.wikipedia.org/wiki/Software_versioning#Degree_of_compatibility">Semantic Versioning</a>, it can be signified as a release less than 1.0.</p><p>There are use cases such as internal software, that is not customer facing, that can get away with using prototypes in production. In these cases, the software is built to complement the services offered by the company or organization rather than built for the customer’s direct consumption. Updates come as inspiration hits and frequently after firefighting sessions. Releases aren’t usually planned and appear erratic. A common sign of using prototypes in production can be internal staff being frustrated by bugs and downtime that prevent them from delivering their services.</p><p>Prototypes are ideal for taking the next step of a PoC. While the concept has already been proven there may be uncertainty as to how it is integrated and architected. This provides a safer environment for peer feedback which lead to clearer separation of concerns, refactoring large portions of the code and architecture improvements to address performance bottlenecks. Avoid pre-optimization as most of the time it would be nullified by design changes. The Prototype minimizes the impact of the above as there should be fewer dependencies compared to directly developing the MVP by skipping the Prototype phase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FMy5huQhuxRoB53j" /><figcaption>“close-up photo of motherboard” by <a href="https://unsplash.com/@nenadg?utm_source=medium&amp;utm_medium=referral">Nenad Grujic</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>There are times when the separation of concerns are already clearly known and the architecture is predetermined. This can be the case when implementing an existing feature from another software project. In this case, a Prototype can feel like a waste of time. However, it is easier to promote a Prototype than it is to iteratively refactor and improve the code if this phase is skipped. It is also easier to exceed expectations this way. Introducing a refactor when this phase is skipped is much harder to sell to the development team and stakeholders.</p><p>If the PoC took a couple of weeks, the Prototype would typically take a couple of months of 1–3 developers. A complex Prototype can take much longer. The time is more proportional to complexity than it is to the number of developers. In fact many times this is fastest by the “lone wolf” developer but lacks the advantages of peer feedback.</p><p>Adding more developers rarely speeds up the development process as it complicates team dynamics and the complexity of code. The <a href="https://en.wikipedia.org/wiki/Ringelmann_effect">Ringelmann Effect</a> applies here. It states that a smaller team can be more productive than a larger one. As the code is properly modularized it makes it easier for more team members and even multiple teams to contribute without slowing the process down as much because they are working on separate but integrated projects. This is discussed in a bit more depth in the MVP section.</p><p>Much insight is gained during testing of the Prototype as to what the separation of concerns are and what architecture should be used in the MVP. Showcasing the progress made and learning of the Prototype helps set expectations for the MVP. Be prepared for a lot of changes here which help minimize wasted development time if refactoring code integrated in the MVP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rDOFEzsfQRbf2NUE" /><figcaption>“The MVP Camera. No bells, no whistles, just the basics. It is nearly as instant as our modern digital cameras.” — credit <a href="https://unsplash.com/@hermez777?utm_source=medium&amp;utm_medium=referral">Hermes Rivera</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Minimum Viable Product</h3><p>The Minimum Viable Product (MVP) is typically the minimal functionality required to meet the root needs of the user. Many times this sacrifices the non-essential but desired features. While the name infers being stripped down to the bare essentials, it includes much more than the previous phases. The development team should not make the decisions of the included functions and features in isolation. Stakeholders were important before but are invaluable in this phase. Much more planning is required developing the MVP.</p><p>Clearly designed software architecture and user interfaces are crucial in this phase. Don’t stop learning at the Prototype phase. Continue to let users test your designs and interfaces along the way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UPmcn5BK5ZcsccAl" /><figcaption>“If we knew that arial photography was the destiny of drones, we might have built out from the existing camera and tried to make it fly. Instead drones technology was matured in its own path until they found their shared destiny.” — credit <a href="https://unsplash.com/@dose?utm_source=medium&amp;utm_medium=referral">Dose Media</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Once the MVP is released with the minimal feature set, new major features can then be added using the natural progression of the PoC, Prototype, then MVP. Starting with the PoC to test that the feature will meet the needs. Ideally this is done externally at least as a module to ensure a clean separation of concerns. If it is too integrated, you run the risk of blurring lines and undermining the approach. Next, rewrite the feature in a more integrated way, as the Prototype, but not necessarily in its final form to be released. The Prototype integration can help decide whether it’s most appropriate home is included in the original product, needs to spin off on its own, or requires a whole new platform to be developed. Finally, integrating the feature into the original product is expanding the definition of the product’s minimum viable-ness.</p><p>This MVP phase can have an indefinite timeframe due to its iterative nature but expect as much as a year for a stable release using a small team of about 2–4 developers. This is most dependent on the scope of the software more than the number of developers. According to <a href="https://en.wikipedia.org/wiki/Brooks%27s_law">Brook’s Law</a> introduced in <a href="https://en.wikipedia.org/wiki/The_Mythical_Man-Month">The Mythical Man-Month</a>, throwing more developers at the problem does not always speed up the process and has increasingly diminishing returns. With <a href="https://en.wikipedia.org/wiki/Modular_programming">Modular Programming</a>, where the codebase is organized by functionality as modules, more team members can be added. Multiple teams can work in tandem on separate modules which can improve timelines but requires ample communication and planning, in turn increasing the inherent complexity of team dynamics. Clear examples of this are with front-end user interface and back-end business and data logic. User interface design as well as software architecture design can also be further abstracted to speed up implementation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PQFCZBAMBdSMAK3k" /><figcaption>“Drone photography did not start as someone setting out to build flying cameras but the integration of two fully developed technologies.” — photo credit <a href="https://unsplash.com/@mitchnielsen?utm_source=medium&amp;utm_medium=referral">Mitch Nielsen</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>While much of the same iterative learning can be made by starting with the MVP, opportunities can be missed by skipping the PoC and Prototype phases. PoCs encourage teams to be more receptive to raw feedback. Sensitivity to criticism tends to be directly proportionate to the amount of effort invested. Prototypes play a similar role but the critics tend to be peer developers. There is something liberating about sharing a prototype with a team for input in place of defending your approach. Directly building features that miss the mark in the MVP come at a higher price including emotions. If the goal is reducing the investment of the learning cycle, PoCs and Prototypes have value.</p><p>The MVP should naturally have a higher priority of stability over learning in comparison to the PoC and Prototype phases. Try not to let that be an excuse for failing to learn.</p><h3>Life after MVP</h3><p>There are quite a few online articles that discuss other approaches that include phases after MVP. After creating dozens of PoC’s and Prototypes through the years, half a dozen have made it to the MVP phase and brought to market in one form or another including patent applications on a few and one awarded. The MVP phase is usually where I hand the project to a full Scrum team and either fulfill the role of Product Owner or slide over to being a stakeholder when we find the right person to fulfill the Product Owner role.</p><blockquote>“The reason to build a new team to pursue an idea is that you believe you can accelerate through the Build-Measure-Learn feedback loop faster than anyone else can.” <br><em>— The Lean Startup</em></blockquote><p>Depending on your definition of what is considered minimally viable, you can keep adding features to meet the purpose of the application. Most software has a limited shelf life of only a couple years before the competition over takes it or a new version includes new features that can be integrated through this lifecycle. To stay relevant, it seems strategic to reassess the entire product by then. The lifecycle of new features can help the team know when it is time for that rebirth. If each iteration is developed in modules, code can be reused so that not all of the pieces have to be rewritten.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VnjWTcENrpYFf3iu" /><figcaption>Photo by <a href="https://unsplash.com/@new_data_services?utm_source=medium&amp;utm_medium=referral">NEW DATA SERVICES</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Example Application Lifecycle</h3><p>One of the applications that has used the PoC, Prototype, MVP development lifecycle in multiple phases is translationCore (tC). While there were other applications in the domain to fulfill similar roles to check Bible translations, this one had new innovative approaches that addressed new use cases and even new customer segments. We decided that this phased approach would help us test our assumptions and help manage expectations around it.</p><p>First, a simple PoC was developed in a matter of weeks. It was a stand-alone web page, quickly hacked together by a single developer. It was used to test the assumptions and explore limits. The PoC and its findings were used to test assumptions, cast a vision, raise funding and build a future user base. Once we achieved enough buy-in and learned from user testing, we moved on to the Prototype.</p><p>At first it seemed logical to integrate it into the existing application we had that was already on the market, translationStudio. This application used many of the same resources and had some common functionality. However, we knew that the existing application was designed with a complete different set of assumptions. It had already been heavily modified through the years and would need a major refactor or likely a rewrite to handle this new functionality. We further identified that there might even be a different user base and risked making the original product less effective for the existing users.</p><p>We decided to build a new platform. Since the prototype needed to be more stable and robust than the PoC, nearly half a year was spent on it. With our testing and learning from the Prototype, we started rewriting the app piece by piece working towards our MVP. Due to the modularity of the Prototype, we were able to do so in iterative phases allowing some portions of legacy prototype code to stay around until it no longer served its purpose and was important enough for us to clean up. We learned a lot along the way, balancing what we defined as a minimum feature set and implementing an iteratively cleaner separation of concerns to minimize technical debt in the long term.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Dn8QV43nsvFCUk70" /><figcaption>Photo by <a href="https://unsplash.com/@dreamevile?utm_source=medium&amp;utm_medium=referral">Raphael Koh</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Lifecycle of Modules</h3><p>While the main tC application was being built, we created modules that we called tools that run inside the application with their own development lifecycle of PoC, Prototype, MVP. Their code is managed in separate repositories allowing for a manageable way to replace each tool’s Prototype with its MVP.</p><p>Features of one of the tools, WordMAP, also has its own lifecycle as well. Two years ago, it was a PoC that helped cast a vision for automated alignment with minimal requirements. It worked offline and in a browser. We used it to test assumptions and cast a vision. It sat idle for nearly two years before it was rewritten in a more planned manner as a Prototype. While it is a stand-alone module, it is able to be integrated into tC and it’s tools. The external nature of the module allows it to have its own lifecycle and not have to be directly tied to the fate of any other project and be used in other modules and applications. It is undergoing testing and we plan to have features of WordMAP with their own PoC and Prototypes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EMFHRL-rz1UPCBVdIye6Hg.jpeg" /></figure><h3>Summary</h3><p>Hopefully in reading this far you understand the value of pacing your software development into phases such as Proof of Concept, Prototype and Minimum Viable Product and have an idea on how to set the proper expectations of each phase. PoCs are great for building excitement by trying something new without being held back by existing limits. They are hacked together by design and typically not meant for users but to test assumptions. Prototypes are great for improving on the PoC by learning from the mistakes made and seeing how the software fits into the greater workflow it will serve. Minimum Viable Products are great for building usable software without unnecessary features that will slow the time to market.</p><p>This lifecycle is scalable and when coupled with modular design decouples the pieces of a monolithic application into bite-size pieces. This fosters best practices and makes it easier to contract out work on portions of the application. This also encourages external collaboration on software from partner organizations and the open source community.</p><blockquote>“Remember, planning is a tool that only works in the presence of a long and stable operating history. And yet, do any of us feel that the world around us is getting more and more stable every day? Changing such a mind-set is hard but critical to startup success.”</blockquote><blockquote>—The Lean Startup</blockquote><p>There is <a href="https://en.wikipedia.org/wiki/The_Mythical_Man-Month#No_silver_bullet">no silver bullet</a> in software development. However, iterative learning is still paramount even if enough field research has been done to study the use cases. Since the world is continuing to change at a growingly rapid pace, research may be out of sync by the time the software application is built. Think of this approach as a part of field research. Test assumptions made in the PoC and Prototype during the research phase, that way there is less of a disconnect between the research and the development efforts. Continue testing during the MVP phase to ensure the user needs are adequately met.</p><p>Have you had a difficult time setting expectations for your software? Share these ideas and concepts with your team to see if it is a good fit for your current or future projects. How might applying the concepts shared help you turn frustration into satisfaction? Let me know in the comments how you have applied this in the past or any stories of success and failures.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=140749383fd4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>