<?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 Samuel Mullen on Medium]]></title>
        <description><![CDATA[Stories by Samuel Mullen on Medium]]></description>
        <link>https://medium.com/@samullen?source=rss-d03d716a152------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*sFIjKySHj8eN2_m_kT6v-w.jpeg</url>
            <title>Stories by Samuel Mullen on Medium</title>
            <link>https://medium.com/@samullen?source=rss-d03d716a152------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 21:25:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@samullen/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[TDD: You’ve Been Doing It All Along]]></title>
            <link>https://medium.com/@samullen/tdd-youve-been-doing-it-all-along-6f14568172e2?source=rss-d03d716a152------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f14568172e2</guid>
            <category><![CDATA[tdd]]></category>
            <dc:creator><![CDATA[Samuel Mullen]]></dc:creator>
            <pubDate>Sat, 17 Jun 2017 02:25:15 GMT</pubDate>
            <atom:updated>2017-06-17T02:25:15.757Z</atom:updated>
            <content:encoded><![CDATA[<p>Most people don’t <em>get</em> TDD the first (or second, or third, or fourth) time they’re introduced to the concept. It’s not a topic that is taught in university and it’s not practiced in most development teams. It’s an altogether foreign idea which goes against our sensibilities, prompting us to ask questions like:</p><ul><li>Why would I want to write twice as much code for the same results?</li><li>Why do I need to write a program to tell me what I can plainly see?</li><li>I’m already behind schedule. Why should I spend time I don’t have writing code that’s not even part of the project?</li></ul><p>Even Kent Beck, TDD’s “re-inventor”, didn’t get it at first:</p><blockquote><a href="https://twitter.com/samullen"><em>@samullen</em></a><em> First time I heard of it was when I (re-)invented it. I laughed out loud. Seemed absurd but worth a try.<br> — Kent Beck (</em><a href="https://twitter.com/KentBeck"><em>@KentBeck</em></a><em>) </em><a href="https://twitter.com/KentBeck/status/867023350627008512"><em>May 23, 2017</em></a></blockquote><p>Clearly TDD isn’t a concept which seems reasonable to developers at first, nor is it a technique which comes naturally to us. Or is it?</p><h3>TDD Overview</h3><p>At its simplest, Test Drive Development (TDD) is a technique used to build software by <em>first</em> writing tests describing what the code should do and <em>then</em> writing only the code necessary to make the tests pass.</p><p>Martin Fowler describes the process like this:</p><blockquote>* Write a test for the next bit of functionality you want to add.</blockquote><blockquote>* Write the functional code until the test passes.</blockquote><blockquote>* Refactor both new and old code to make it well structured.</blockquote><blockquote><em>— Martin Fowler </em><a href="https://martinfowler.com/bliki/TestDrivenDevelopment.html"><em>TestDrivenDevelopment</em></a></blockquote><p>More can be said about the process (and has), but that is the core of TDD.</p><h3>Non-TDD Overview</h3><p>The “Non-TDD” development process is what most of us begin using from day one. There is nothing formal about it and there’s definitely nothing automated. There is a problem and we create a solution for that problem according to our understanding at the time. If you were to codify the process, it would look like this:</p><ul><li>Determine the expectations for the next bit of functionality to add</li><li>Write the functional code until it meets your expectations</li><li>Tweak as necessary as you better understand the problem</li></ul><p>Maybe we could add more steps to the process, but this is what most developers begin using in their careers, and what most continue to use.</p><h3>You’re Already Doing TDD</h3><p>If you look closely at the two processes — and maybe squint a little — you’ll see that they’re nearly identical.</p><p>Development Step TDD Not TDD Determine Results Create test to prove results Expect specific outcomes Write Code Complete when tests pass Complete when results meet expectations Cleanup Refactor new and existing code Refactor new code. Fix any noticed errors in existing code</p><p>While each technique goes about the steps differently, they are the same steps. If there is any hard difference between the two techniques, it’s that one stores the expectations for future use. And it’s <em>that</em> difference that makes all the difference.</p><p>Just look at the advantages that come with storing your expectations (i.e. tests) for future use:</p><ul><li><strong>Automation</strong>: By storing a collection of tests, it’s a simple matter to automate the process of verifying that everything in the code still works. Most languages even have a tool that can watch for changes and run the test suite automatically.</li><li><strong>Consistency</strong>: To ensure a block of code meets expectations, every potential outcome needs to be tested. You’ll inevitably miss a step if you do that manually, but keeping a storehouse of tests ensures that code is tested the same way every time.</li><li><strong>Comprehensiveness</strong>: As tests are created and stored, the entire codebase will eventually be covered. This allows us to see errors or problems <em>anywhere</em> in the project resulting from changes <em>anywhere else</em> in the codebase.</li><li><strong>Confidence</strong>: When your project is covered by a suite of tests, it gives you the confidence to make changes. Because with any change, your tests will tell you what broke.</li></ul><p>And those are just the advantages that come with storing a collection of tests. Let’s look at the benefits that come with the intentional practice of TDD.</p><h3>Benefits of TDD</h3><p>TDD is no silver bullet. Many articles would have you believe that by practicing TDD, your code will magically become clean, you’ll intuitively practice <a href="https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)">SOLID</a> principles, and you will work harder. It doesn’t work like that. TDD is just a technique. While adhering to the technique makes some bad practices more difficult, it doesn’t make them impossible, and it certainly won’t turn you into a “rock star” developer.</p><p>What you <em>will</em> find by practicing TDD is that you are forced to really think through the API of your code. When you write tests first, you are attempting to use the code before it’s even written, and by doing so you are asking, “How would the interface work best?” As you answer that question, you’ll find it’s easiest to answer with simple methods and functions. Simpler code is easier to test.</p><p>Not only will you find it easier to write simpler code, but you will also write less code. Too often we, as developers, write code against what <em>might</em> be needed. We’re not trying to over-engineer the code, we’re just trying to anticipate. Unfortunately, this often leads to excessive, unused, or even unnecessary code. Code which must now be maintained.</p><p>By first specifying the expectations with tests, we are constrained to code against those expectations. There is no opportunity to over-engineer the code, because the expectations — real or imagined — don’t exist.</p><p>Not only do the tests force you to think through the interface of your API and write code specifically to address those needs, they also document the behavior of the API. Look at this example:</p><pre>describe &quot;User#name&quot; do<br>  it &quot;returns first and last names joined with a space&quot; do <br>    contact = Contact.new(first_name: &quot;User&quot;, last_name: Example&quot;)<br>    contact.name.must_equal &quot;User Example&quot;<br>  end</pre><pre>  it &quot;returns the first name if the last name is blank&quot; do <br>    contact = Contact.new(first_name: &quot;User&quot;) <br>    contact.name.must_equal &quot;User&quot; <br>  end </pre><pre>  it &quot;returns the last name if the first name is blank&quot; do <br>    contact = Contact.new(last_name: &quot;Example&quot;) <br>    contact.name.must_equal &quot;Example&quot; <br>  end <br>end</pre><p>You don’t need to know Ruby to read the code above. The first line tells us that we are looking at the instance method name. Each “it” line, tells us what name is supposed to do in the given scenarios. We don’t have to read the code, we can read the actual requirements in our language of choice.</p><p>Developers notoriously hate writing documentation. Even when we do write it, we usually fail to maintain it. As they say, “Wrong documentation is worse than no documentation.” Writing tests provides an almost effortless way of documenting our code.</p><p>Let’s look at some hard numbers. In a Microsoft funded research paper, authors <a href="https://www.microsoft.com/en-us/research/wp-content/uploads/2009/10/Realizing-Quality-Improvement-Through-Test-Driven-Development-Results-and-Experiences-of-Four-Industrial-Teams-nagappan_tdd.pdf">Nagappan, Maximilien, Bhat, and Williams</a> discovered that TDD resulted in an increase of 15–30% in initial development time, but a 40–90% decrease in defects. As one author noticed:</p><blockquote><em>It is interesting to note that the figure of 15–30% longer during the coding phase. Then, the testers found 40–90% fewer bugs. That’s 40–90% fewer bugs that need fixing. Now, these bugs that need fixing were found in the functional testing phase. Exact figures will vary, but it is frequently observed that bugs found here will take at least 10 times longer to fix than had they been found during development.</em></blockquote><blockquote><em>— John Ferguson Smart </em><a href="https://dzone.com/articles/fistful-dollars-quantifying"><em>For A Fistful of Dollars</em></a></blockquote><p>Furthermore, Matt Hawley collated the benefits and results of several research papers in his article <a href="https://weblogs.asp.net/mhawley/114005">TDD Research Findings</a> and provided the following list:</p><ul><li>87.5% of developers reported better requirements understanding.</li><li>95.8% of developers reported reduced debugging efforts.</li><li>78% of developers reported TDD improved overall productivity.</li><li>50% of developers found that it decreased overall development time.</li><li>92% of developers felt that TDD yielded high-quality code.</li><li>79% of developers believed TDD promoted simpler design.</li></ul><p>These findings are great if you are making a case to management to allow you and your team to start practicing TDD, or even if you’re just participating in an internet debate. But the real benefit of TDD is summarized by “Uncle” Bob Martin in his answer to a question on Quora:</p><blockquote><em>If you follow TDD, and use it to build a test suite that you trust. And if that test suite executes in seconds (a design goal). Then you will not be afraid of the code. You will not be afraid to clean it. You will not be afraid to fix it. You won’t be afraid to do anything to the code, because your tests will tell you if you’ve broken it.</em></blockquote><blockquote><em>— Uncle Bob Martin (</em><a href="https://www.quora.com/What-are-the-benefits-of-TDD"><em>https://www.quora.com/What-are-the-benefits-of-TDD</em></a><em>)</em></blockquote><h3>Getting Started</h3><p>For the sake of argument, let’s pretend that what I’ve written has persuaded you to take that first step into Test Driven Development. Where do you begin? And what can you do to make that transition smoother?</p><h3>Use Your Language’s Built-in Testing Library</h3><p>Because everyone has their own opinions about how testing <em>should</em> be done, multiple testing frameworks — each with their own API — are available for every language. While having this variety is great, most TDD adherents recommend learning the testing library that comes with your language. The reason for this is this are four-fold:</p><ol><li>That library will always be available to fall back on</li><li>Most non-standard libraries are built upon those from the standard library</li><li>Knowing the foundational library allows you to learn the alternatives more easily</li><li>Most testing suites included in the standard library follow the same patterns across all languages.</li></ol><h3>Start By Only Adding Tests to Code You Are Touching</h3><p>Like most things, when you first start using TDD, you’ll be tempted to start using it everywhere, even on code you’re not currently working on. Although this isn’t necessarily a bad thing, remember that you still have work to perform and the existing code works. Instead, focus on adding tests to the code you’re actively working with.</p><p>As new features are requested, or as bugs are found, you’ll eventually touch more and more of the system. As you do, your test coverage will slowly expand to cover everything.</p><h3>Be Prepared to Throw Your First Tests Away</h3><p>Your first tests are going to be rubbish. They’ll tests too many things in one go; You’ll tests things that don’t need to be tested; You’ll touch parts of the system that shouldn’t be touched; and you’ll just make it harder on yourself than you need to. That’s part of the process. You don’t know where boundaries are or how to do things the “right” way and your initial tests will be you figuring that out.</p><p>That’s okay. That’s part of learning. Just be prepared to laugh at six-months-ago-you and replace those initial tests with what you’ve learned.</p><h3>Skip the Hard Stuff</h3><p>Not everything in TDD is as easy as assert User.name() == &quot;Joe Bagadonuts&quot;. Sometimes figuring out how to test something can be really hard, like interacting with the network or even just stdio. Give it a good try to figure out how to test something, but don’t get trapped. You can always come back to add tests later when you have a better understanding.</p><h3>Be Patient</h3><p>Learning how to test isn’t easy. You’ll make mistakes, test the wrong things, make things too complicated, and even question the value of testing in general. Be patient with yourself and the process. It takes time. Learning always does. You’ll get the hang of it and you’ll see the rest of your code improve as you do.</p><p>Eventually, as your test suite grows, one of those tests is going to catch something and everything’s going to click. For me, it was when I came to a dead end using a particular library. I knew the best choice was to switch it out for something else, and it’s only because I had a suite of tests that I had the confidence to do so. That’s when everything gelled.</p><h3>Stop Doing Things the Hard Way</h3><p>As we saw at the beginning of the article, TDD and the “traditional” development techniques both follow the same steps to meet their goals, but differ in what they do with their expectations. With TDD, expectations are stored in the project and become a suite of tests developers can use and refer to to ensure the code continues to meet the expectations. With the less structured approach, however, expectations are ephemeral, being stored in the developer’s head, or in one-off tests, only disappear into the void or be overwritten when the work is “done”.</p><p>But the work is never “done”, and the customers’ hunger for more features is never satisfied. Every developer eventually needs to revisit and make changes to code which was considered “done”. Will you be able to confidently make changes to that code, knowing that you have a suite of tests to support you, or will you need to recreate the steps necessary to ensure it works? Will your tests tell you what breaks when you make changes, or will your customers?</p><p>At first blush, it may seem like TDD is only piling work onto your plate. After all, you need to learn a new API, new programming practices, and change your mindset. But as your test suite expands and more and more bugs are caught you will find yourself becoming more productive than ever, and you’ll come to wonder how you ever managed to release code to production before.</p><p><em>Originally published at </em><a href="http://samuelmullen.com/articles/tdd-youve-been-doing-it-all-along/"><em>samuelmullen.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f14568172e2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is Technical Debt?]]></title>
            <link>https://medium.com/@samullen/what-is-technical-debt-6ccb797929fb?source=rss-d03d716a152------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ccb797929fb</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technical-debt]]></category>
            <dc:creator><![CDATA[Samuel Mullen]]></dc:creator>
            <pubDate>Thu, 04 May 2017 15:53:07 GMT</pubDate>
            <atom:updated>2017-05-04T15:53:07.066Z</atom:updated>
            <content:encoded><![CDATA[<p>Every industry has terms and phrases it uses to help describe complex concepts and practices. Some are intended for use within the industry, while others are used to help convey industry-specific concepts to those outside the industry. One such term we use in software engineering is “technical debt”.</p><p>Even though the term is used to help “non-developers” more easily understand the state of a code base, I’ve recently had several conversations with startup founders who’ve admitted they didn’t understand what technical debt is or why it’s a problem.</p><p>In programming, there is always more than one way to do something, and it’s a regular struggle for developers to determine which solutions are “best”. Factors such as the experience of the developer, familiarity with the technology, time constraints, and the state of the project all affect which solution the developer will choose. What solution the developer settles on today may not be what he or she would choose in the future or even the past.</p><p>For example, let’s say you have an e-commerce site. To get it launched on time, your programmer, while being experienced and disciplined, had to use some shortcuts for the checkout process to meet the launch date. After a year of your site being in service, business is booming. But in that time, the original checkout code has been tweaked and patched far beyond its original design. In fact, it’s to a point where no new features can be added without rewriting the whole thing.</p><p>That’s technical debt. The first “loan” was taken out when your developer took a shortcut to get your product out the door. Instead of going back and cleaning up the code for the checkout process (i.e. paying off the loan), your team went further into debt by patching the code and making it more complicated. In the end, the checkout process was in so much debt that the only way to get out from under it was to declare bankruptcy and rewrite it.</p><h3>Types of Technical Debt</h3><p>You can see from the example that there are two kinds of debt in play: One which was taken on at the beginning in order to launch the product, and another which wasn’t even noticed until it was too late.</p><p>Martin Fowler recognized the distinctions in technical debt and broke it up into quadrants. The quadrants provide a distinction between prudent and reckless actions, and those which are either intentional or inadvertent:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*4zeZP0-731U9fLo3.png" /></figure><p>By combining the two groups, we end up with four possible types of technical debt.</p><h4>Reckless-Deliberate</h4><p>This type of debt is taken on when your development staff “may know about good design practices, even be capable of practicing them, but decide to go “quick and dirty” because they think they can’t afford the time required to write clean code” (<a href="https://martinfowler.com/bliki/TechnicalDebtQuadrant.html">https://martinfowler.com/blik/TechnicalDebtQuadrant.html</a>). This may happen when a team has a low morale or if there is a culture of producing half-baked products, but it can also occur when management applies pressures to continually push out products. In almost every case, both the development staff and management are to blame.</p><h4>Reckless-Inadvertent</h4><p>This sort of technical debt is traditionally acquired by a combination of both inexperienced developers and management. The team as a whole just doesn’t have the experience necessary to know what they’re doing right or wrong, and instead are just blindly plowing forward.</p><h4>Prudent-Deliberate</h4><p>In this instance both management and the development staff agree that the value of shipping a “quick and dirty solution” now is worth the incurred debt. They know what they’re getting into and have a plan for addressing the debt as soon as possible.</p><h4>Prudent-Inadvertent</h4><p>You are never more ignorant about how things should be done than when you first do them. Prudent-Inadvertent debt is incurred when a team realizes how a solution should have been implemented after the fact.</p><h3>Why Technical Debt is Bad</h3><p>The problem with technical debt is that any time you want to make new investments in your product (new features, bug fixes, performance improvements, etc.,) you must first pay the accumulated interest. However, if all you do is pay the minimum, you will only add to your debt burden with every change you make.</p><blockquote><em>Shipping first time code is like going into debt. A little debt speeds development so long as it is paid back promptly with a rewrite… The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt. Entire engineering organizations can be brought to a stand-still under the debt load of an unconsolidated implementation, object-oriented or otherwise.</em></blockquote><blockquote>Ward Cunningham</blockquote><p>Technical debt always adds complexity, even when that complexity isn’t felt immediately. But as a project continues, those complexities become more and more apparent, revealing themselves in many ways:</p><ul><li><strong>Reduced performance</strong>: Frequently used processes and functions and those which are most central to your application will feel the drag on efficiency most acutely.</li><li><strong>Increased resource requirements</strong>: When processes are hindered by complexity, it takes more processing power to handle the load. The drag caused by technical debt on efficiency may demand extra hardware–and possibly developers–to counteract the effect.</li><li><strong>Bugs/Errors</strong>: Although there is not a 1:1 ratio of debt to bugs and errors, the added debt makes the code more difficult to work with and increases the likelihood of introducing bugs.</li><li><strong>Increased development times</strong>: Complexity always takes longer to work with, and thus requires more effort and time by your development staff to work around.</li></ul><p>As Martin Fowler recognized, the most destructive result of technical debt is the opportunity cost:</p><blockquote><em>One thing that is easily missed is that you only make money on your loan by delivering. The biggest cost of technical debt is the fact that it slows your ability to deliver future features, thus handing you an opportunity cost for lost revenue.</em></blockquote><blockquote>Martin Fowler</blockquote><h3>Why Technical Debt is Good</h3><p>Eventually you need to ship your product or feature. You have two choices: you can ship it when it’s perfect, or you can ship it when it’s done. But as the old saying goes, “perfect is the enemy of done.”</p><p>Intentionally adding technical debt to a project can greatly speed up development efforts and help get your product or feature out the door. It’s not ideal, but some situations demand it. And even if your team had the time to actually perfect the code for a feature or product, how can you be sure that code would remain perfect once it was released to the customers? As Steve Blank wrote, “No business plan survives first contact with the customer.” That goes double for the product.</p><p>Technical debt is part of every project and intentional debt is a sign of productivity. Monitor the state of your debt and keep track of what concessions you were forced to make, but don’t be ruled by the fear that all debt is created equal or that all debt is bad.</p><blockquote><em>At the end of the day, ship the fucking thing! It’s great to rewrite your code and make it cleaner and by the third time it’ll actually be pretty. But that’s not the point — you’re not here to write code; you’re here to ship products.”</em></blockquote><blockquote>Jamie Zawinski</blockquote><h3>Limiting Technical Debt</h3><p>As you may have already guessed, it’s impossible to avoid technical debt completely. To do so would require you to have a perfect understanding of your customer and the ability to see into the future. The only thing we can do is try to limit how much debt we take on.</p><h4>Understand the Problem</h4><p>Much of why unused features, bugs, and technical debt exists in so many applications is because the teams developing them didn’t fully understand the problem(s) they were trying to solve. This can be the result of not having product/market fit (i.e. lots of pivots), a lack of a clear vision, management just chasing squirrels, or any number of other things.</p><p>Regardless of the reason, the results are the same, leaving your product with inefficient and overly complex code, unused code from developers being sent down blind alleys, and features no one uses.</p><p>Limiting this requires you to truly understand the problem and communicating it to your team.</p><h4>Accelerate Iterations</h4><p>“Build. Measure. Learn.” It’s the mantra of “The Lean Startup” movement, and the guiding principle of the fastest and most agile companies. The idea behind it is to discover problems in your theories as quickly as possible and make adjustments, because changing direction is much cheaper early on than later in a product or feature’s lifecycle.</p><p>When it comes to development, this also keeps the programming staff from going down blind alleys too far. The more frequently iterations and releases occur, the easier it is for the team to adjust direction. Also, reducing the amount of work which is thrown away is highly motivational. Nothing is worse than working for months on a feature that is never used.</p><h4>Anticipate Deadlines</h4><p>Another reason technical debt creeps into projects is because the development staff doesn’t believe there’s enough time to do things right. Instead, they’ll just “git’r done”. In some organizations, this is uncommon and the code will be fixed later. But if an organization has a culture of short deadlines, producing lower quality code will also become part of that culture.</p><blockquote><em>One broken window — a badly designed piece of code, a poor management decision that the team must live with for the duration of the project — is all it takes to start the decline. If you find yourself working on a project with quite a few broken windows, it’s all too easy to slip into the mindset of “All the rest of this code is crap, I’ll just follow suit.” It doesn’t matter if the project has been fine up to this point.</em></blockquote><blockquote>Andy Hunt and David Thomas, “The Pragmatic Programmer”</blockquote><p>The solution to this is to limit unanticipated deadlines and scale back requirements to fit those deadlines. Requirements can always be scaled back.</p><h4>Allow for Refactoring</h4><p>You’re busy. It doesn’t matter if you work for a startup or a multinational conglomerate, if you’re a line worker or the CEO. You have deadlines, pressures, and goals. The last thing you want to hear is that your team wants to slow down and go back to clean up the codebase.</p><p>The problem with being busy is it’s not always productive. Just because you’re marking things off your todo list, doesn’t mean you’re moving the needle.</p><p>The same goes for programming. Programmers can work hard, but not get a lot of work accomplished. This can happen when they’re saddled with an inordinate amount of technical debt. The complexity added by that debt slows the development process. It takes longer to reason through, to make changes, and to test. Even worse, it increases the likelihood of introducing bugs.</p><p>By allowing your team the time necessary to clean up the code base, even small parts of it, it can dramatically improve their productivity. When developers work with “clean code”, they don’t have to fight the code to add new features; the code almost invites them to do so. On top of that, it helps with motivation. Developers are craftsmen and craftswomen at heart. Give them permission to care about their work.</p><h3>Going Forward</h3><p>The term “technical debt” was introduced as a metaphor to help us communicate some very involved concepts more easily. As we’ve unpacked the term, we see that not all debt is created equal and debt in and of itself is neither good nor bad; it’s just debt. We’ve also seen that there is no way to avoid it, only ways to limit it.</p><p>As a metaphor, “debt” is the perfect word to use. When a person or a business is starting out, going into a little bit of debt can improve a situation and reduce the time needed to get established. But unless that debt is paid off, it will eventually transform from a tailwind propelling your business forward, to a sea anchor slowing your forward progress.</p><p>Eliminate technical debt when you can, take advantage of it when you must, and avoid it as long as possible.</p><p><em>Originally published at </em><a href="http://pixelatedworks.com/articles/what-is-technical-debt/"><em>pixelatedworks.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ccb797929fb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Startup Fallacies: If You Build It, They Will Come]]></title>
            <link>https://medium.com/@samullen/startup-fallacies-if-you-build-it-they-will-come-f455974b5ddf?source=rss-d03d716a152------2</link>
            <guid isPermaLink="false">https://medium.com/p/f455974b5ddf</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[entrepreneurship]]></category>
            <dc:creator><![CDATA[Samuel Mullen]]></dc:creator>
            <pubDate>Sat, 22 Apr 2017 13:23:03 GMT</pubDate>
            <atom:updated>2017-04-22T13:23:03.498Z</atom:updated>
            <content:encoded><![CDATA[<p>In the movie, Field of Dreams, Kevin Costner plays an Iowa farmer named Ray Kinsella. As a farmer, Ray has fallen on hard times, but while standing in his corn field one day, he sees a vision of a baseball field where part of his cornfield is accompanied by a voice telling him, “If you build it, he will come”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*R3dlmjEm9gE4WMUy.jpg" /></figure><p>Ray then sets out to build the baseball field from his vision, being spurred onward by the disembodied voice telling him that if he builds it, “he” or “they” will come. Ignoring the pleas of his wife and brother, and the advice of his neighbors, Ray builds the baseball field. Slowly, as his friends and family witness long dead baseball players take to the field, he wins them to his vision, culminating with James Earl Jones’ character, Terence Mann, saying:</p><blockquote><em>Ray, people will come Ray. They’ll come to Iowa for reasons they can’t even fathom. They’ll turn up your driveway not knowing for sure why they’re doing it. They’ll arrive at your door as innocent as children, longing for the past. Of course, we won’t mind if you look around, you’ll say. It’s only $20 per person. They’ll pass over the money without even thinking about it: for it is money they have and peace they lack. And they’ll walk out to the bleachers; sit in shirtsleeves on a perfect afternoon. They’ll find they have reserved seats somewhere along one of the baselines, where they sat when they were children and cheered their heroes. And they’ll watch the game and it’ll be as if they dipped themselves in magic waters. The memories will be so thick they’ll have to brush them away from their faces. People will come Ray.</em></blockquote><blockquote><em>–Field of Dreams</em></blockquote><p>This story makes for a great movie, but when applied to business, “if you build it, they will come” will only end in disaster.</p><p>The idea is that you, as an individual or a team, work on a product and eventually release it to the world fully baked. The world, for its part, somehow finds your product, recognizes the obvious need for it, and then beats the proverbial path to your door.</p><h3>Why Doesn’t It Work?</h3><p>Finding product/market fit is the most difficult part of building any product. During this time you should be iterating quickly on your idea by speaking with as many customers, or potential customers, as possible. Without interacting with customers and discovering what their problems are it’s impossible to build a product to solve those problems. It’s impossible even if you are the customer, because you alone can only provide a single perspective. Getting a variety of feedback about features, needs, and solutions is what will give your product width and depth.</p><p>Ash Maurya wrote in <a href="https://www.goodreads.com/book/show/13078769-running-lean"><em>Running Lean</em></a>, “Startups that succeed are those that manage to iterate enough times before running out of resources.” Iterations require experiments, they require feedback, and they require measurements, which means they need customers.</p><p>Finding customers is hard. It’s hard enough that marketers invented the “Rule of Seven” which says, “a prospect needs to see or hear your marketing message at least seven times before they take action and buy from you.” (<a href="http://www.thebabyboomerentrepreneur.com/258/what-is-the-rule-of-seven-and-how-will-it-improve-your-marketing/">The Baby Boomer Entrepreneur</a>) This explains the average conversion rates for web products:</p><blockquote><em>Typical conversion rates are between 0.5% and 4% depending on your price range and customer base. What that means is that for every 1,000 websites visitors, between 960 and 995 will show up and leave without doing a thing.<br> –Rob Walling, </em><a href="https://www.goodreads.com/book/show/9167158-start-small-stay-small">Start Small, Stay Small</a></blockquote><p>A startup is in the business of building something new, something that has never been seen before, something unfamiliar. Unfortunately, people, even early adopters, have a tendency to shy away from new ideas and products. As a species, we don’t immediately see the value in what’s new.</p><h3>Why Do People Believe It Works?</h3><p>With all the evidence against the notion of “if you build it, they will come”, why do founders still believe it works? Why do they still choose this strategy?</p><p>To begin with, I’m not convinced founders believe it works, nor do I believe they purposefully choose it as a strategy. Instead, founders, like most people, take the path of least resistance, with what’s familiar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*KixPL8n7TB0nkYBJ.jpg" /></figure><p>Most founders don’t have a background in either sales or marketing, and even though they’ve read articles and listened to podcasts exhorting them to “<a href="http://www.softwarebyrob.com/2010/10/14/startup-marketing-part-6-why-you-should-start-marketing-the-day-you-start-coding/">Start Marketing the Day You Start Coding</a>”, they just don’t know where to begin. Maybe they know enough to build a landing page to capture email addresses, but do they know what to say on that page and how to say it? Do they know where to go to promote their product and how to do it once they get there?</p><p>Figuring out these answers is difficult and it takes time. Many founders are launching a startup “on the side”. With their limited time, they have to choose between building the product (what they know how to do), and marketing and selling the product (what they don’t know how to do). Improving the product is the path of least resistance, but it’s also “The Product Trap: the fallacy that the best use of your time is always improving your product.” (<a href="https://www.goodreads.com/book/show/22091581-traction">Traction</a>)</p><p>But marketing is only the first half of the problem. Once you’ve attracted customers to your product, the next step is to talk to them and determine if what is being built will meet their needs (i.e. establishing product/market fit).</p><p>For many startups, this can be even more difficult than marketing. After all, building a product takes time, effort, and money: time that could have been spent with your family; effort which could have been put toward other endeavors; and money which could have been invested with less risk. To discover, after having spoken with customers, that the time, effort, and money you’ve invested in your product has been wasted because you built the wrong thing is soul-crushing.</p><p>Rather than discovering what they’ve built is the wrong product, and enduring the heartache of figuring out the truth, many founders would rather blissfully go on unaware of what they’ve done. No founder would put it in those words, of course. They would instead give the excuse that the product needs one or two more features before it’s ready to be shown to customers.</p><h3>What Should You Do Instead?</h3><p>You are not building your product for yourself. You may be a user of it, but you are not your market and you need a market to determine product/market fit. Getting feedback and direction from your eventual customers is why it’s so important to start marketing as soon as you start developing your product. It’s why Gabriel Weinberg wrote, “The biggest mistake startups make when trying to get traction is failing to pursue traction in parallel with product development.” (Gabriel Weinberg <a href="https://www.goodreads.com/book/show/22091581-traction"><em>Traction</em></a>)</p><p>Marketing really wouldn’t be so bad if there was more certainty involved in it. If you could guarantee that doing <em>x</em> would result in <em>y</em> new customers, everything would be grand. But marketing isn’t like that and neither are startups for that matter. “A startup is a human institution designed to create a new product or service under conditions of extreme uncertainty.” (Eric Reiss, <a href="https://www.goodreads.com/book/show/10127019-the-lean-startup"><em>The Lean Startup</em></a>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*qiY_yBTtrd8SBpdn.jpg" /></figure><p>At some point you just have to “embrace the suck” of marketing. No, you won’t know what you’re doing in the beginning, but putting it off isn’t going to grant you any new knowledge later. It’s just going to put you behind, and you need all the time you can get to find where your target customers are, and how to best reach them.</p><p>You have to recognize that developing your traction channels–even when you don’t know what you’re doing–is productive work. You’re finding where your customers are, what they like and what they don’t, you’re learning what terminology to use, and what resonates with their pain points. It just doesn’t “feel” productive because it’s not where you’re most comfortable and because there’s so much uncertainty around the decisions you have to make.</p><p>If everything goes well, not only will you get early signups, but you’ll also get feedback about what you’re doing. That early feedback is crucial for a successful product. It helps you determine what features are needed, what areas in your product need clarity, and more importantly, customer feedback keeps you building the right product.</p><p>The feedback you receive isn’t always positive, and that’s a good thing. Negative feedback is like pain in the body: it tells you something’s wrong. Maybe it’s telling you a feature isn’t needed or there’s a problem with how something work, but it could just as easily inform you that what you’re building is a waste of time.</p><h3>If You Market It, They Will Come</h3><p>I would love to say, “show me a product built with the strategy of ‘If you build it, they will come’, and I’ll show you a hundred others that failed with the same strategy,” but I can’t. Those “hundred others” died in obscurity. Maybe they were the next unicorn or maybe they were just a lifestyle business, but we’ll never know because no one heard about them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*m52ZU3Esk8-TNVWF.jpg" /></figure><p>If you want your product to be successful, you have to start marketing. Start marketing from day one. If you’ve already started building your product, then start marketing today. Put as much effort into gaining traction as you do developing your product, ‘traction and product development are of equal importance and should each get about half of your attention. (Gabriel Weinberg, <em>Traction</em>)</p><p>James Earl Jones’ character was wrong in <em>Field of Dreams</em>. People won’t come. They won’t come to your site without reason. They won’t sign up for your product without knowing for sure why they’re doing it. Believing they will is madness.</p><p>If you have a vision of a dead entrepreneur telling you to build a product and to trust that customers will flock to it once it’s completed, my advice to you is to step away from the computer, go spend time with your family, and possibly seek medical attention. The spirit is lying.</p><p><em>Originally published at </em><a href="http://pixelatedworks.com/articles/startup-fallacies-if-you-build-it-they-will-come/"><em>pixelatedworks.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f455974b5ddf" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>