<?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[Agile Product Ownership - Medium]]></title>
        <description><![CDATA[Build the right project faster! - Medium]]></description>
        <link>https://medium.com/agile-product-ownership?source=rss----18adf91bba5c---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Agile Product Ownership - Medium</title>
            <link>https://medium.com/agile-product-ownership?source=rss----18adf91bba5c---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 18:25:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/agile-product-ownership" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How to Unstump a Developer]]></title>
            <link>https://medium.com/agile-product-ownership/how-to-unstuck-a-developer-c0d81e57efce?source=rss----18adf91bba5c---4</link>
            <guid isPermaLink="false">https://medium.com/p/c0d81e57efce</guid>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Thu, 15 Dec 2016 23:01:50 GMT</pubDate>
            <atom:updated>2016-12-21T16:04:23.770Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nvyFmTv6onLK5JZYPulTmg.jpeg" /></figure><p>It takes a special breed of problem to stump the developers on my team. I work with some of the hardest working and most talented software developers in the world, and I rarely see them truly stumped. The amazing thing is, even when they are stumped, they never throw up their hands and give up. But if you’re on the other side of the coin, biting your nails as you see sprint or project goals slip, you could easily miss the dev team’s quiet heroics. I believe we all want to celebrate tenacity, persistence, courage, and selflessness in the face of a problem. But, if a developer is truly stumped, they might truly need a hand getting unstumped.</p><h3>When Is a Developer Actually Stumped?</h3><p>Software development is predictable at times, and many times it is definitely not. Problems of any shape and size may arise without apparent warning and delay features or entire projects. Developers do the best they can to prevent delays, firing every arrow they have to solve problems. Sometimes, a feature takes longer than expected, but comes to resolution after the 41st arrow when the problem finally falls down dead (or gets fixed). Other times, no matter how many arrows the developer uses, the problem persists. Though all resources have been spent, often developers have a hard time admitting defeat and will continue working through the problem. To a developer is feels a lot like chasing one’s tail or repeatedly going over the same code, looking for something he missed. That’s when you know developers are stumped.</p><p>When developers get stumped, they may need help getting unstumped. Also, project leaders need to be aware of the problem so that they can plan around the problem. The following humble list is my attempt at providing a bit of structure around the process of getting a developer unstumped.</p><h3>Get Another Brain</h3><p>Two heads are better than one, especially if one head has been banging against a tough problem for awhile. A fresh perspective combined with the necessity of verbalizing the issue can, often times, unclog the drain (so to speak). Not only is pair programming a fantastic way to reach resolution to a problem, it’s also a great way to prevent getting stumped in the first place. Not that pair programming is the silver bullet, but it sure does help to nip those problems that are caused by simple oversight and tired eyes/brains.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZEkEvQXC3UVCHRDiLLpo9Q.png" /><figcaption>From <a href="https://www.flickr.com/photos/damienpollet/5048830734">https://www.flickr.com/photos/damienpollet/5048830734</a></figcaption></figure><p>At Acklen Avenue, the first thing a Scrum Master will ask when a developer when it seems like they might be stumped on an issue is, “Have you been pairing? Can I help you find a pairing partner?”</p><h3>Use Your Circle of Developers</h3><p>Some developers work alone and seem to like it. Still, countless other developers know how truly blessed they are to work alongside a larger team of skilled software craftsmen. If you are stumped on a sticky issue, and you are surrounded by other talented developers, why not tap into their problem-solving energy. Think back to pairing… if two heads are better than one, how much better are twenty or fifty? The first time you try this, you’ll be absolutely amazed at the insight you encounter as your fellow developers pose questions and poke around at your issue. You may have the problem solved in a matter of minutes and you’ll be free to LOL at yourself for bruising your forehead on the wall for the last hour.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PpgxxM1F5QZJQIc-dE9AJw.jpeg" /></figure><p>At Acklen Avenue, developers who have been stumped for an hour or more should head on over to the water cooler (or a channel on Slack) to start socializing the problem to see what questions and insights come up.</p><h3>Alert Project Leaders</h3><p>Nothing is harder to explain to stakeholders than a feature that was estimated at 3 hours and turned into 10 days. It is even harder when there still is no resolution in sight. Developers are extremely hard workers and are sometimes know to sacrifice their own emotional wellbeing to power through a problem, even if it means running in the same circle 1000 times looking for patterns and microscopic anomalies. Now that I’ve complimented my fellow developers sufficiently, I have to admit that they are also horrible at knowing when to come up for air and say, “I’m stumped!” This step in my process is admittedly a bit futile, but we should try all the same. If you’re a developer and you think you might be stumped, alert the project leaders so they can strategize and realign your team’s goals. If you are around a developer who seems to be banging his or her head against the wall (or you happen to hear them weeping quietly in the bathroom), tap them gently on the shoulder and ask them, “hey, are you stumped?” The first step to recovery is admitting the problem. And in this case, getting that information to the project leaders is the first step to saving your project from imminent peril!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fMOtAb2b_aLZpucU38_CGA.jpeg" /></figure><p>At Acklen Avenue, developers must alert the Scrum Master if they have been stumped for more than an hour and a half. An hour and a half might seem like a lot of time, but it can feel like nothing to a developer who is lost in thought in a world of zeros and ones. This step is, as I mentioned, very hard to take, but we need to try!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jh3szRjkWp1lm5ZjVbN0fQ.jpeg" /></figure><h3>Post Problem Publicly</h3><p>Few methods of problem solving have as much potential success as verbalizing and writing. Some developers have found that the solution appears in their minds before even finishing the post. The simple act of organizing thoughts in order to write a cohesive question for the public might be enough to trigger an insight or reveal something you had missed before. If you’re not that lucky, a publicly posted question can still be massively powerful because, if fifty heads are better than one, imagine a thousand! Yes, writing takes time. But the profits far outweigh the investment. Not only will you expose your problem to the developer community and invite questions, feedback and solutions, but you will also have a well thought out description of your problem to which you can refer back by simply pasting a URL. If you’re stumped and nothing has helped to get you unstumped until this point, don’t go a step further without posting about it publicly.</p><p>At Acklen Avenue, developers who have been stumped for 2 hours or more must take this important step and post their problem publicly. From here, the solution is close at hand!</p><h3>Getting Expert Help</h3><p>When posting your issue publicly hasn’t led you to a solution or you need to solve the issue more quickly, it might be time to call in heavy guns from outside. Rest assured, there is help out there. The trick is finding the right people and knowing how to compensate them for their help.</p><p>When it is necessary to compensate someone for helping you solve a problem, and you’re working with an scrum team, talk to your Scrum Master. He/she should be able to handle getting people paid whether it’s via Paypal, credit card, check or bitcoin. It’s probably a good idea to clear potential compensation amounts with the Scrum Master before you agree to anything.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3be0QN6K971aHOD1VmwLHA.jpeg" /></figure><p>At Acklen Avenue, after a developer has been stumped for 4 hours or more, it is essential to reach out to the vast pool of experts at our disposal and seek a helping hand.</p><h3>Contracting Authors and Contributors</h3><p>If the issue you’re facing is related to a library, tool, or component that was developed by someone outside your team, you may be able to contact the people or person who created it. For example, consider an open source library whose code is stored in GitHub. In many cases, the creator’s GitHub profile includes an email address, which means you can email him/her directly asking for help. Other times, a quick look at the recent committers will reveal one or many other developers who might be willing to respond to an email.</p><p>When your problem is related to a commercial product, the path to getting help is as easy or difficult as the provider has decided it to be. Your first mode of attack should be to use the methods they ask you to use. If those methods do not work, then it should not be beneath you to find the names of the company’s management team, look them up on Facebook and LinkedIn, and begin a small email/message campaign until someone responds. Using the “CC” function in email is a good tactic because it causes the folks on the other end to hold each other accountable.</p><h3>Bounties</h3><p>If your public posting has not gotten the answers you needed and time is ticking, you can add a “bounty” to the posting to attract more attention. For example, on StackOverflow.com, you can add a bounty to an existing question for almost any amount (for more info, check out <a href="http://stackoverflow.com/help/bounty">http://stackoverflow.com/help/bounty</a>). GitHub issues have a similar mechanism via a few third parties. A really good 3rd party option is <a href="http://bountysource.com/">BountySource.com</a> which allows you to attach a bounty to an existing issue. In either case, your post gets more attention and, hopefully, gets fixed!</p><h3>Expert Marketplaces</h3><p>When it’s not obvious who to approach with your problem, and you’re not getting the right help from the public post or a bounty, or it seems unlikely that a public post or bounty will do the trick, it might be time to re-post the problem in one of the existing expert marketplaces. Two of the platforms that seem to give good results are <a href="http://hackhands.com/">HackHands.com</a> and <a href="http://codementor.io/">CodeMentor.io</a>. These sites allow you to post your problem using tags and a specified budget and make your problem available to their pool of experts. Ideally, one or more experts will respond quickly and set a time to pair with you to resolve the problem.</p><h3><strong>Better Get a Team!</strong></h3><p>If you’re looking for a team of developers who know to how to power through problems without spending countless hours spinning their wheels, you should check out <a href="http://acklenavenue.com/">Acklen Avenue</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0d81e57efce" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agile-product-ownership/how-to-unstuck-a-developer-c0d81e57efce">How to Unstump a Developer</a> was originally published in <a href="https://medium.com/agile-product-ownership">Agile Product Ownership</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[10 Ways to Kill Pair Programming]]></title>
            <link>https://medium.com/agile-product-ownership/10-ways-to-kill-pair-programming-8370a2b7e03a?source=rss----18adf91bba5c---4</link>
            <guid isPermaLink="false">https://medium.com/p/8370a2b7e03a</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Tue, 22 Nov 2016 18:47:54 GMT</pubDate>
            <atom:updated>2016-09-01T17:39:19.837Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1PVush-TdFON_NjqDco1sg.jpeg" /><figcaption>By Kabren (Own work) [CC BY-SA 3.0 (<a href="http://creativecommons.org/licenses/by-sa/3.0">http://creativecommons.org/licenses/by-sa/3.0</a>)], via Wikimedia Commons</figcaption></figure><p>If you have a hard time working with other humans or find that other humans have a hard time working with you, you may want to continue reading. If you value your own opinion over any other regardless of validity, then listen up. If you are a better coder than anyone on your team and you want to keep it that way, then lean in closer. There is a software development technique that is gaining popularity amongst the “agile crazies” that threatens your quiet, peaceful, lonely existence. They call this technique, “Pair Programming.”</p><p>Wikipedia.com describes “Pair Programming” this way:</p><blockquote><strong>Pair programming</strong> is an <a href="http://en.wikipedia.org/wiki/Agile_software_development">agile software development</a> technique in which two <a href="http://en.wikipedia.org/wiki/Computer_programmer">programmers</a> work together at one work station. One types in <a href="http://en.wikipedia.org/wiki/Code_%28computer_programming%29">code</a> while the other <a href="http://en.wikipedia.org/wiki/Code_review">reviews</a> each line of code as it is typed in. The person typing is called the <strong>driver</strong>. The person reviewing the code is called the <strong>observer</strong> (or <strong>navigator</strong><a href="http://en.wikipedia.org/wiki/Pair_programming#cite_note-0">[1]</a>). The two programmers switch roles frequently.</blockquote><p>Sounds nice, right? Well, if I described you correctly in the paragraph above, then the answer is, “wrong!” Working so closely with another programmer is likely to end badly for you. However, “Pair Programming” has been building momentum over the last few years, especially since there has been an increased focus in software engineering practices, code quality, and ethical programming. But who needs any of those things? You make great software and you don’t feel like you should have to change the way you work… ever.</p><p>It is for those reasons and more that I decided to release this list of useful weapons in the fight against progress.</p><ol><li><strong>EXPRESS YOUR SUPERIORITY: </strong>You’re a better coder and you know it. Be sure your pairing partner knows it as well. Take every opportunity to hold your knowledge over your partner’s head. The best way to elevate yourself is to make your partner a little lower, even if only in your own mind.</li><li><strong>NEVER BACK DOWN: </strong>Your opinion is correct, or else it wouldn’t be yours. A correct opinion is worth fighting for to the bitter end. When one argument tactic begins to fail, switch to another, thereby flanking your opponent. Eventually, they will give up.</li><li><strong>GLOAT: </strong>Remember that discussion from 15 minutes ago where your opinion gained the victory? Of course you do. Well, in case your partner has already blocked it out of his/her mind, bring it back up when you see a place where it applies. Say things like, “See how much better it is since we did this my way?”</li><li><strong>WATCH SILENTLY:</strong> Nothing is more boring than watching someone code, right? Well, why make it better by communicating? Instead, sit silently and watch the code go across the screen. After a few minutes, take our your phone and update your status on Twitter or check your email. You may miss opportunities to discuss coding decisions, but you’ll likely be able to gloat about them later when refactoring becomes necessary (which is inevitable since you’re not in the driver’s seat).</li><li><strong>CODE SILENTLY: </strong>Why should you have to explain what you’re doing in your code. Your pairing partner can see it on the screen! Besides, they probably wouldn’t understand anyhow. Better to just code the way you always have because that’s when you’re at your best. Don’t talk through your code and certainly never explain any decisions you’re making.</li><li><strong>BETRAY TRUST: </strong>When you’re shooting the breeze with your co-workers or chatting on IRC, be sure to bring up funny or embarrassing stories from your “Pair Programming” experience. Of course, avoid subjects that reveal your own deficiencies, but be sure to highlight your pairing partner’s lack or prowess. Doing this behind his/her back is encouraged, since you will likely feel more free to embellish.</li><li><strong>DOMINATE THE KEYBOARD: </strong>Even though you are bent on killing “Pair Programming” in your team, you’re not a complete tool. As the better coder, you feel responsible for getting the project complete despite the handicap the “agile crazies” have placed on your team. To that end, and working within the confines or “Pair Programming”, you should make every effort to keep your position in the driver’s seat.</li><li><strong>CODE ALONE:</strong> Even though your team has decided to adopt “Pair Programming”, it doesn’t mean you can’t sneak in some private coding time (for old time’s sake). Ideal times to code privately are during coffee, lunch or restroom breaks. Be sure to start one or two sections of code while your partner is away from your workstation. As a result, you’ll get more time in the driver’s seat because you’re the only one who knows your intent and direction.</li><li><strong>WIN: </strong>Defeat is not an option for you. Stalemate is also not an option. It is imperative that you argue your point until your pairing partner sees your way of thinking or has laid down his guns and surrenders. One way to know you’ve won is when your partner ceases to express opinions and blindly accepts anything you say. One other benefit to this technique is that you will likely get to drive for the remainder of the project. Victory is sweet.</li><li><strong>COMPLAIN: </strong>Chances are, your organization or team has one or two “agile crazies” that sold the higher-ups on the concept of “Pair Programming.” That means the higher-ups are probably eager to hear about how it’s going. If your other attempts at sabotage are effective, then you should have quite a bit to complain about. Go around your team mates and fire off some emails to your manager or his/her superiors. Be sure to explain the obvious reasons why two programmers on one keyboard simply cannot work. Explain that morale across the entire team is low and that productivity would be back to “normal” if they would just put you in a position of influence. Be sure to taint the reputation of the “agile crazies”, maybe even calling them names like “agile crazies”.</li></ol><p>Above all, remember your greatness. You’re better looking, smarter, more experienced, faster, and certainly more humble than anyone else on your team. Let those truths guide you, and, even though you’ll be viewed by everyone around you as a jerk, you’ll have single-handedly defeated the “Pair Programming” dragon and that should be enough to keep you warm at night… alone… with your cats.</p><p>On the other hand, if you are looking for a team of professional software developers who already pair well together, you should check out <a href="http://acklenavenue.com/">Acklen Avenue</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8370a2b7e03a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agile-product-ownership/10-ways-to-kill-pair-programming-8370a2b7e03a">10 Ways to Kill Pair Programming</a> was originally published in <a href="https://medium.com/agile-product-ownership">Agile Product Ownership</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The “Golden Rule” of Software Development]]></title>
            <link>https://medium.com/agile-product-ownership/the-golden-rule-of-software-development-e7647c24def2?source=rss----18adf91bba5c---4</link>
            <guid isPermaLink="false">https://medium.com/p/e7647c24def2</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Tue, 22 Nov 2016 18:47:43 GMT</pubDate>
            <atom:updated>2016-09-01T18:07:09.691Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*h7jZzejVI0JKh4MuRnAE3A.jpeg" /></figure><p>I’ve gone to church all my life and “The Golden Rule” has been pound into my head since I was a toddler: “Do to others as you would have them do to you.” That’s Jesus talking in Matthew 7:12, by the way. Now, I’m not going to preach, so don’t navigate away too quickly… Well, I’m not going to preach about the Bible anyhow. I guess I am going to preach a little about how I think software developers should change their evil ways.</p><p>It doesn’t matter if you believe in God or follow the Bible, anyone can probably admit that Jesus was teaching something pretty important. Common human decency. An expectation that, if you treat folks badly, you’ll probably get the same in return. Love people so you will be loved. Open the door for someone and smile, because that’s what you want people to do for you. This blog article is my attempt to live out “The Golden Rule” amongst my fellow developers. I am chewing you all out because I would want you to chew me out if I did this crap to you all.</p><p>Before I started writing, I did a little research about “The Golden Rule” and “programming” to see if anyone else had written on the topic. I found out quickly that someone coined “The Golden Rule of Programming” awhile back so it has stuck. But I’m here to tell you, WE are way off on this. Here’s the popular programmer’s golden rule:</p><blockquote>“If it can be null, it will be null.”</blockquote><p>What does that have to do with people?? Nothing. It’s a clever way to help programmers remember to avoid nulls, which is great. But we’ve missed an opportunity to answer a higher calling: <strong>doing to other developers what we would have them do to us. </strong>So I’m reclaiming the phrase for the cause of better code.</p><p>I should have called this article, “How to Make Other Programmers Hate You,” and given a bullet list of ways to piss me off when I look at another developer’s crappy code. Maybe another day.</p><p>When you are writing code, you should consider that you will probably not be the only human being who has to maintain it. Some other poor soul is going to eventually crack open your code and try to implement some fix, requirement change, or new feature. Will it take them days or minutes? Will they be able to decipher your structure? Or will they hate you and call you incompetent? I suggest that all developers, around the world, stop coding right now and change their hearts. It’s time to start thinking of others, and putting their future needs first when it comes to our code. It’s time to start allowing this simple teaching of Jesus to form our ethics as professional programmers.</p><p>Are you ready to repent and turn from your evils ways? Here are some suggestions that I guarantee will set you on the right path:</p><p><strong>Use Test-First Development</strong> — Don’t write production code until you have a failing unit test. Then, only write enough production code to make that unit test pass. This sequence will help you stay disciplined in your unit test coverage and will help you produce better, more modular chunks of code. This will also enable your future readers to be able to look at your tests and understand quickly how you intended things to work. Oh, one more thing. If any future developer messes up something in your code, your unit tests will alert that dev me he/she can fix it more quickly. There are actually SO many other benefits to test-first development that are out of scope for this article. Just do it and you’ll understand.</p><p><strong>Use Documented Architecture</strong> — Don’t try to reinvent the wheel. Architecture has been done and done and done. Learn one that fits your project and stick to it. Creating your own will probably get you into trouble and will rob your future readers of the ability to understand your architectural decisions apart from a ton of documentation that you shouldn’t have to waste time writing.</p><p><strong>Names Matter</strong> — Name your variables, classes, methods, everything with care. Who cares if names get long. If they communicate what’s going on, let it go! This will go a long way in helping your future readers understand your code. It will also cut down or eliminate the need for code comments.</p><p><strong>Use Patterns</strong> — Like anybody who makes things for a living, patterns and templates are essential to reproducing similar types of products or work. Same goes for software development. There are tons of great “pre-thought-out” patterns for programmers to pick up and use. And, later on, other developers, who are also aware of those patterns, can look at your use of this or that pattern and know EXACTLY what is going on. Or you can ignore the patterns out there and do everything your way, alienating and confusing your future readers, making them hate you. Your choice.</p><p><strong>SOLID, Know it, Love it, Use it</strong> — If your haven’t heard of the “SOLID Principles of Software Engineering” by Robert Martin, you should Google it. It is five software engineering principles that, when used together, tend to guide software developers to creating better, more maintainable code. There are tons of principles like these out there, but the nice thing about these five is that most any professional software developer can follow them closely if not to the letter in their day-to-day. So, if a future reader must maintain your code, and you follow SOLID, all they have to do is familiarize themselves with those five principles and they are almost as good as the original dev because they will understand what guides and motivates your decisions. Following a popular set of principles like SOLID sets future readers and maintainers up for success months and years in advance.</p><p><strong>Give a Flip</strong> — Would you want your dear, sweet grandmother to have to maintain your code. How about your baby daughter? How bout yourself 6 months later. Well, the reality is that someone will probably look at your code in the future. If none of these suggestions have resonated with you, an ounce of caring would be SOMETHING. Just remember that a puppy dies every time you check-in crappy code. If that doesn’t motivate you, consider that people will hate you. Just care about people and don’t leave them hanging. Code with care!</p><p>Will you follow the REAL “Golden Rule” in your day-to-day programming, taking the necessary steps to leave future developers with code that can be maintained and extended? For your clients’ sake, for your fellow developers’ sake, for your own soul’s sake, I sincerely hope so.</p><p>On the other hand, if you want to keep putting crappy, unintelligible code out there, be my guest. I’m actually making a pretty good living by cleaning up your messes. I just feel bad for your clients who have to pay for your blunders. Your call.</p><p>And if you’re one of those product owners who have learned to expect higher quality code, and need a team who follows the “Golden Rule”, check out my company, <a href="http://acklenavenue.com/">Acklen Avenue</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7647c24def2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agile-product-ownership/the-golden-rule-of-software-development-e7647c24def2">The “Golden Rule” of Software Development</a> was originally published in <a href="https://medium.com/agile-product-ownership">Agile Product Ownership</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Encrypted Code: How to Get Your Code Completely Re-Written]]></title>
            <link>https://medium.com/agile-product-ownership/encrypted-code-how-to-get-your-code-completely-re-written-3e33bdf4369f?source=rss----18adf91bba5c---4</link>
            <guid isPermaLink="false">https://medium.com/p/3e33bdf4369f</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Tue, 22 Nov 2016 18:47:30 GMT</pubDate>
            <atom:updated>2016-09-01T18:25:12.490Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*ZlTkA0lQ54sGBsa07kBU5Q.jpeg" /><figcaption>From: <a href="https://www.flickr.com/photos/donkeyhotey/12657946083">https://www.flickr.com/photos/donkeyhotey/12657946083</a></figcaption></figure><p>In the past, I have coded with some very bright and talented developers. Software development is like art, and I’ve worked along-side some true code artists. Their code is clean, readable, and expressive. Because of the care that they put into the design of their code, other developers can open the code base and, with a normal level of skill, modify or extend it with little or no prior knowledge. They are efficient and conscientious. I have a lot of respect for software developers like the guys with whom I’ve had the pleasure of working. I want to be just like them.</p><p>And then there’s the other type of developer. We’ll call him Einstein. Einstein is super smart. He thinks on a whole ‘nother level. In fact, he’s so smart that when he writes software, he writes it on a whole ‘nother level. On the UI level, the program runs and performs well. It does everything that it’s supposed to do. It might even do it REALLY well. Einstein has certainly outdone himself. He finished the project a few days early and the client is happy with the product.</p><p>Fast forward 6 months when the client needs to add a feature. Einstein is tied up with another project. The client has to hire another developer to modify the code base. We’ll call him Innocent Bystander. The client says to Innocent Bystander, “We’re really happy with Einstein’s work. You should have no trouble at all modifying this program.” So, Innocent Bystander cracks open the code and starts reading.</p><p>What he finds is a code base that only an author could love. It’s a tangled mess of spaghetti code and obscurely reused code blocks. Variables are named with acronyms that have long since been forgotten. There are no tests to show how code is expected to behave. Classes and methods cover pages and pages of scrolling. Nothing makes sense. It’s like trying to listen in on an encrypted conversation. The code base, for all intents and purposes, is encrypted.</p><p>So, Einstein was so “smart” that he wrote a code base that no one but he could understand. Innocent Bystander has accepted the task of adding a feature to that code base. Innocent Bystander has a couple choices…</p><ol><li>Spend hours of the client’s time decrypting, modifying, and handling regression, or</li><li>Spend hours of the client’s time re-writing a section of the code, re-factoring the code that uses it, and handle regression.</li></ol><p>Either way, the client pays more than he should. Either way, there is regression. At least with the second option, the code base is left a little better than how Innocent Bystander found it.</p><p>Friends, countrymen, fellow developers. PLEASE please pLeAsE hear me out. If you are an Einstein and you’re still reading this… welcome to your first step to recovery. Admit you have a problem and start thinking about others while you code. Think about your client. Think about the next guy who has to come behind you. You don’t want either to hate you, right? Learn how to code in maintainable ways.</p><p>If you want to make sure your code is removed or re-written, just make it complicated and convoluted. No one will be able to follow your code and, boom… mission accomplished. You’ve effectively wasted the money of your client. The world would have been better off if you had applied your vast, immeasurable intelligence to something that lends itself to tangled webs of scattered thought process.. not software development.</p><p>If you want your code to stick around and make a difference, write it so that the next developer can read and understand it. Name your variables and methods to express their intent. Adhere to engineering principles like Single Responsibility, Open-Closed, and Dependency Inversion. Code in standard ways. Don’t try to be clever by stuffing loads of functionality into one reusable function. Spend time learning new ways to make your code expressive and readable.</p><p>No one cares how smart you are. It matters not that you’re on a <a href="https://www.youtube.com/watch?v=YJnGRuidOXI">whole ‘notha level</a>. People only really care about your contribution over the long-haul. Clients may love you when you deliver the product early like a rock star, but the will cease to love you later when they have to pay again for the same code. No one will write blog articles about your awesome “swiss-army-knife-function-that-does-everything”. No, sir… in fact, they’ll write blog articles like this one.</p><p>And if you’re a product owner and you’re tired of paying for crappy code, you should check out my company, <a href="http://acklenavenue.com/">Acklen Avenue</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e33bdf4369f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agile-product-ownership/encrypted-code-how-to-get-your-code-completely-re-written-3e33bdf4369f">Encrypted Code: How to Get Your Code Completely Re-Written</a> was originally published in <a href="https://medium.com/agile-product-ownership">Agile Product Ownership</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[This Parking Garage Will Kill You — A Software Parable]]></title>
            <link>https://medium.com/agile-product-ownership/durable-software-2a96c3933ded?source=rss----18adf91bba5c---4</link>
            <guid isPermaLink="false">https://medium.com/p/2a96c3933ded</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Tue, 22 Nov 2016 18:46:45 GMT</pubDate>
            <atom:updated>2016-09-01T19:51:04.164Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7d0t96YVr6W2ybnU7MyyKQ.jpeg" /></figure><p>“Downtown Parking”, an imaginary start-up, plans to build parking garages in large cities around the world. However, their leaders are a little short sighted and are hurrying through the construction process. Without truly understanding the ramifications, they are encouraging their construction workers to take shortcuts in order to finish faster. Meanwhile, the company leaders are keeping a close watch on the books. They are ensuring that their accounting staff are following best practices and never have errors.</p><p><strong>Fast forward three years.</strong> The company’s bookkeeping records are still perfect after years of close attention to best practices. Well, almost perfect. You see, the quality of their parking garage structures was not a priority and now they are almost unusable. Entire sections of the parking garages cannot even be repaired and have closed. So the company is spending more than it is taking in, and the books are red hot.</p><p>The company leaders realize that it is necessary to tear down and rebuild various parking garages in order to stay in business. So, they start construction again. But, because of the urgency to start generating profits again, we have the same song and dance. Construction is hurried, books are immaculate, and the company is ready to roll again.</p><p>Why so much attention to the books and so little to the quality of their parking garages? Is high quality accounting the most important piece of the business? I believe this kind of thing wouldn’t actually happen in real life. It’s too preposterous. How would the visionaries of a parking garage company neglect the quality of the obvious core of their business: the parking garages?</p><p>Of course, if a real company depends on “X” in order to exist and profit, they will ensure that the quality of their “X” is high so that profits are never damaged and their business is never in danger of closing. This is basic common sense.</p><p>As preposterous as it may seem, business leaders do this kind of thing all the time with their software. Countless companies depend absolutely on software that they design and build to run their business processes. But, without understanding the ramifications, they shortsightedly rush their developers causing them to take shortcuts. The initial result is software that works. The long term result is software that cannot be modified without incurring major expense. Many times the software developers finally throw up their hands and say to the business, “it’s time to tear down and re-build.” And they start the process all over.</p><p><strong>This is no way to run a business. It’s no way to create software. It doesn’t have to be this way. Consider the concept of “durable software”.</strong></p><p>Durable software is like a well-built, high-quality parking garage. It is built with care, not hurried. Longevity is a priority, so the best materials are used. Although less experienced developers work on the project, there are a sufficient number of master craftsmen working alongside of them to guide the project. Everyone working on the project follows industry standards that are proven to yield high quality results.</p><p>Durable software embraces change for the long haul. It doesn’t need to be rewritten every few years because it welcomes new features and changes to existing functionality. Although durable software is more expensive to deliver initially, it is inexpensive to maintain for many years, resulting in less overall cost. In addition, the business is free to profit, unhindered by wasteful months or years of rebuilding software.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2lHPpGbYhf5bjqlpVq7CWA.jpeg" /><figcaption><a href="https://en.wikipedia.org/wiki/Clarendon_Building">Clarendon Building</a> at the <a href="https://en.wikipedia.org/wiki/University_of_Oxford">University of Oxford</a>. Built in 1715. Still providing value. Good investment, wouldn’t you say?</figcaption></figure><p>My company, <a href="http://acklenavenue.com/">Acklen Avenue</a>, has seen the parking garage problem many times. We are frequently called in to existing development teams to help them get moving in the direction of durability. After research and years of experience, we have found that there are four major components of durable software:</p><p>1) <strong>Readability</strong>: Write code that someone can understand a year later.<br>2) <strong>Architecture</strong>: Follow a documented architecture like <a href="http://en.wikipedia.org/wiki/Domain-driven_design">Domain-Driven Design</a> from start to finish.<br>3) <strong>Tests First</strong>: Use <a href="http://en.wikipedia.org/wiki/Test-driven_development">Test-Driven Development</a> to drive out production code.<br>4) <strong>Principles</strong>: Adhere to the <a href="http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29">SOLID Principles</a> of Software Engineering.</p><p>Before starting your next green field project, consider all the costs. Remember that the cost of software doesn’t stop at delivery. If your business depends on your software for profitability, you need software that will be able to change with your business and that won’t make your future developers throw up their hands. You need durable software.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2a96c3933ded" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agile-product-ownership/durable-software-2a96c3933ded">This Parking Garage Will Kill You — A Software Parable</a> was originally published in <a href="https://medium.com/agile-product-ownership">Agile Product Ownership</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why “Quick Work” Turns Into Weeks]]></title>
            <link>https://medium.com/agile-product-ownership/blowing-the-whistle-on-technical-debt-44f9bf9951e6?source=rss----18adf91bba5c---4</link>
            <guid isPermaLink="false">https://medium.com/p/44f9bf9951e6</guid>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Tue, 22 Nov 2016 18:46:31 GMT</pubDate>
            <atom:updated>2016-09-05T14:33:55.360Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zAsN9vJa5KQYu0ZUQWIguQ.jpeg" /><figcaption>From <a href="https://www.flickr.com/photos/yacht-rent/17198845587">https://www.flickr.com/photos/yacht-rent/17198845587</a></figcaption></figure><p>When you go to the cash register to pay for your goods, you have to offer something of value before they will let you leave the store. If you pay with cash, then the deal is sealed. Now the store has your $100, and you have their goods. I prefer not to carry much cash, so I will almost always pay with my credit card. After all, I might need that cash at my next stop and my credit card gives me points that I can use on a flight next month. I get certain benefits from using my credit card. For example, if my paycheck hasn’t been deposited yet, I can still buy things. Also, I don’t have to physically go to the bank to take out some cash. And there’s safety… I live in a dangerous part of the world, so it’s a bad idea to carry around a lot of moolah. So, when I pay with plastic, I get to reap the benefits of a small loan.</p><p>If I pay off my credit cards by the end of the month, the benefits I get from those little loans end up costing me nothing. What a deal! But, if I become undisciplined and I let the month go by without paying, then my small loans turn into “debt”. Credit cards have notoriously high interest rates and costly penalties for debt. Get on bad terms with your credit cards, and you won’t even be able to to remember the benefits you might have had.</p><p>When building software, development teams are constantly taking loans and, potentially, incurring debt. Of course, I’m not talking about financial debt, but about a concept known as “technical debt”. The term “technical debt” was first coined in 1992 by Ward Cunningham as he was trying to describe the challenges in maintaining a large, long-lived software project. His metaphor of technical debt effectively explains how short-term loans can empower developers to deliver features faster, and how long-term debt can suffocate a development team.</p><p>You can think of technical debt much like any other type of debt. Many businesses depend on debt to grow or survive. Over time, small loans turn into much larger debt. If loans are paid back quickly, they don’t accumulate interest. Sometimes payback is delayed for one reason of another. The longer a debt is allowed to exist, the more interest it accumulates and the more it costs. Left unchecked, debts and their cost can grow out of control and may lead to the debtor’s discomfort or even downfall.</p><h3>Short-term Technical Loans</h3><p>A technical loan is any beneficial software development activity that is postponed. A natural occurrence in any software development project, small short-term technical loans can be taken in the form of shortcuts, temporarily messy code, or some experimentation. Developers need to think on their toes and take advantage of their creativity while coding. When developers allow themselves to explore and experiment, they can often arrive at a working solution faster than if they had been held to a high engineering standard throughout the process. Even well-known software engineering techniques like test-driven development encourage short-lived technical loans as part of the “red-green-refactor” cycle (see TDD). The red and green stages of that cycle are for experimentation and creating something that “works”, taking a small technical loan in the process. The refactor stage is for paying off the technical loan by cleaning up the code. Technical loans offer development teams great benefits, much like my credit cards. Take small, manageable loans, reap the benefits, and pay them off before they are able to incur interest and penalties.</p><h3>Technical Debt</h3><p>When technical loans go unpaid, they convert into debt and incur interest and penalties. Technical debt is created in the same way a development team creates technical loans: shortcuts, experimentation, and “temporarily” messy code. However, when that code is left behind and the team allows that code to stay in the code base, it becomes a first-class citizen of the software. The cost started out as a useful tool to help developers innovate. But, once it gets left behind, it converts into something that actually stands in the way of future innovation. Future features are inevitably built on top of that technical debt which further deepens its grasp on the software. Technical debt accrues interest and penalties, which get paid through velocity reduction, missed deadlines, inability to deliver, endless bug lists, overhauls, re-writes and other consequences.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*dQZavnWdtrzlBaxVOG5pAw.jpeg" /><figcaption>From <a href="https://commons.wikimedia.org/wiki/File:Swedish_rowboat_gone_aground_2012.jpg">https://commons.wikimedia.org/wiki/File:Swedish_rowboat_gone_aground_2012.jpg</a></figcaption></figure><p>Technical debt includes but is not limited to…</p><ul><li>complex code</li><li>untested code</li><li>brittle tests</li><li>re-invented wheels</li><li>out-of-date code comments</li><li>out-of-date documentation</li><li>hardcoded values</li><li>nested structures</li><li>large conditional structures</li><li>temporary hacks</li><li>unused code</li><li>poorly-named code structures</li><li>unused database tables and columns</li><li>or anything in design or code that must or should be done in a different way or could stand in the way of future modification or innovation.</li></ul><h3>Technical Debt as a Feature</h3><p>Have you ever used a credit card for a large purchase or expense knowing that you would not pay it off by the end of the month? I wouldn’t say it is wise, but it might be the only option you have, especially if you have to pay for an emergency surgery or repair to your house. The benefit is that you can cover the emergency expense. The consequence is that you will end up paying much more down the road. For some situations, it makes sense to intentionally incur technical debt for the good of the company or the product.</p><p>There are plenty of examples of software projects that have tight deadlines and need to meet certain goals before a trade show or a important stakeholder demo. Still other software projects are focused on beating the competition to market. In these examples, the feature set is not really negotiable. Scope is set based on market research and usability studies. That date I mentioned is immovable and everything absolutely must come off without a hitch for that day. Without speeding up efforts and incurring technical debt, the product or company might not survive.</p><p>The canonical example is Twitter. The software that ran Twitter was thrown together as fast as possible in order to get to market at the right time. When Twitter made it to users desktops around the world it was an instant success. Since it’s first release, Twitter has become a marker in our culture, not just in the United States where Twitter started, but also around the world. But none of the world’s new microbloggers realized that Twitter was sitting on top of a back-end hastily built out of sticks and chewing gum. Twitter worked, and that’s all that mattered. The benefits of technical debt allowed the makers of Twitter to get something valuable to market at break-neck speeds. Technical debt is probably why Twitter is now a household name. Without the intentional use of technical debt, Twitter might not exist today.</p><h3>Unwelcome Technical Debt</h3><p>Technical debt is only acceptable when the product depends on it to succeed or survive. Benefits like speed and developer innovation are huge. But constant, unbridled speed is not always the best way to reach your goal. Let’s be honest. Most deadlines are imaginary or not nearly as important as we make them out to be. Are we really racing the clock, or do we just want to apply some healthy pressure? If your software is so important to your business, and you have time to build it with care, then “care” that’s the standard you should accept from your development team. Technical loans are expected and should be tolerated so long as they are paid off quickly. When your software doesn’t depend on speed to market to succeed or survive, then technical debt should not be a part of your team’s expectations or standards.</p><h3>Consequences of Technical Debt</h3><p>As mentioned, the benefits of short-lived technical loans are increased innovation and speed. But, once the loans begin to accrue interest, they convert to technical debt. The consequences of technical debt are decreased speed, innovation, stakeholder confidence, and team engagment.</p><h4>Speed</h4><p>Technical debt usually results in slower development speeds. Many times we compare technical debt to “mud”. As you can imagine, walking in mud is much slower than walking on a firm surface. Your feet get stuck, sometimes you lose a shoe, you’re concerned about getting your pants dirty, and you end up having to clean off later on. On the other hand, on a solid surface, you’re able to walk, run, skip, flip or jump at top speeds. You can go as fast as you want. Development speed at the beginning of a project is very much like running on a solid surface. It feels great. Everything seems smooth and easy. In contrast, working in a project with heavy technical debt is like trying to run in a muddy swamp. Everything takes way too long. What used to take an hour now takes days or weeks.</p><h4>Innovation</h4><p>Writing software is a creative process. Consider an artist painting a tapestry. The painter has paint brushes, various colors and a clean canvas with which she can realize the image in her mind. Artists innovate as they create. They depend on quick feedback loops and responsiveness of their tools and their medium in order to maintain the flow of innovation. Any break down in the process threatens the completion of the tapestry. Getting slowed down by mistakes (technical debt) that have accumulated over time is something that can rob a project of its innovative potential. Software that can no longer flex, bend and respond to innovation quickly is software that is marked for death.</p><h4>Stakeholder Confidence</h4><p>Software projects exist because stakeholders want them to exist. As long as they have confidence in the team and development process, the development team has breathing room and freedom which is beneficial to productivity. When technical debt slows down improvements, fixes, and innovation, stakeholders inevitably (and rightfully) lose confidence in the development team. Micromanagement ensues and freedom is replaced with slavery.</p><h4>Team Engagement</h4><p>An engaged development team one understands and believes in the vision of the product they are building. Engagement drives better questions which lead to greater ownership and superior decisions. An engaged team is more productive and produces a higher-quality product. As technical debt builds, the software project becomes less and less enjoyable to work with. Developers find friction at every corner. Team leads become frustrated with missed deadlines. Pressure increases and, as a result, the team becomes less engaged. Eventually, teams that deal with technical debt on a daily basis experience high turn-over, which affects engagement even more because of the need for constant training and internal product evangelism.</p><h3>Recognizing Technical Debt</h3><p>Unfortunately, technical debt is hard to spot. In fact, technical debt it mostly invisible to users. In many cases, for non-developers, technical debt is like the wind. You can see the effects of the wind, but you can’t see the actual wind. And worse, many times we can’t see even the effects of technical debt until the project is already paying the consequences of it.</p><p>You might have technical debt if…</p><ul><li>Your once-performant development team is now releasing features and fixes at a snail’s pace.</li><li>Your bug backlog has been your priority for weeks.</li><li>Your developers are pushing for overhauls and re-writes.</li><li>You are hiring new team members to replace the ones who you can’t seem to keep.</li></ul><p>Though it is nearly impossible to detect technical debt from a user’s or stakeholder’s perspective, we can certainly lift the hood and see what’s going on from a more technical vantage point. There’s a lot that the code can say about itself as to the level of technical debt it carries. By running your codebase through tools like static analyzers, compilers, linters, and more, you can get a window into a wealth of information about the health of the stuff under the hood. Of course, the merits of each calculated metric can be argued, so it’s best to view them with a grain of salt. Here are a few potential metrics that could help reveal some warning signs:</p><ul><li>Lack of Unit Test coverage</li><li>High cyclomatic complexity</li><li>High Halstead complexity</li><li>High number of lines (compared to similar projects)</li><li>High coupling</li><li>Low cohesion</li><li>High occurrence of duplicate code</li><li>Compiler/linter warnings</li><li>Style &amp; consistency rule warnings</li></ul><p>All of these metrics are explained in more detail in later chapters.</p><h3>Who Decides?</h3><p>As destructive and costly as technical debt can be, wouldn’t you think that the decision to incur it falls on the business or product owner? It’s true, at times the costs of technical debt can be justified because it allows the team to get to market faster. This results in a business decision, premeditated or inferred, to lay quality aside and push the team to race to the finish line. However, such demands for extreme speed are not the norm. And, if you ask most product owners if they would rather high or low quality, they would choose high quality. So, it seems like it should be a simple business decision, doesn’t it? Sadly, most technical debt it incurred by accident. It starts as a small loan in the form of a shortcut, but is left behind and forgotten. Call it lack of skill, lack of experience, or lack of engagement, but technical debt is almost always unintentional. But don’t go blaming the programmers. The decision to tolerate technical debt was made before the project began by a lack of communication between the product owner and the team about expectations of quality.</p><h3>Technical Debt is Avoidable</h3><p>It’s probably impossible to avoid all technical debt, especially considering larger systems. Software projects that dissolve into muddy swamps of technical debt are far too common, but should not be lifted up as the standard. For systems that include quality as a feature, there’s no reason why technical debt should go unchecked and be allowed to grow out-of-control. Constant awareness of technical debt and a team-wide commitment to fighting it will yield a system that is flexible and agile for years to come.</p><p>In case you’re looking for a development team who hates technical debt as much as you do, you should check out my company, <a href="http://acklenavenue.com/">Acklen Avenue</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44f9bf9951e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agile-product-ownership/blowing-the-whistle-on-technical-debt-44f9bf9951e6">Why “Quick Work” Turns Into Weeks</a> was originally published in <a href="https://medium.com/agile-product-ownership">Agile Product Ownership</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[7 Ways to Win with Pair Programming]]></title>
            <link>https://medium.com/agile-product-ownership/7-ways-to-win-with-pair-programming-c678c235be2d?source=rss----18adf91bba5c---4</link>
            <guid isPermaLink="false">https://medium.com/p/c678c235be2d</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Tue, 22 Nov 2016 18:46:18 GMT</pubDate>
            <atom:updated>2016-09-05T14:20:22.353Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D57ynYOAB_q1o4rwIkfLww.jpeg" /><figcaption>From <a href="https://www.flickr.com/photos/damienpollet/5048830734">https://www.flickr.com/photos/damienpollet/5048830734</a></figcaption></figure><p>One of my recent articles was a tongue-in-cheek tutorial entitled, “<a href="https://medium.com/@byronsommardahl/10-ways-to-kill-pair-programming-8370a2b7e03a#.salpnk6dl">10 Ways to Kill Pair Programming</a>”. I’ve always been more interested in focusing on solutions instead of problems, so I can’t just release an article like that and not follow up with some suggestions on how to make “Pair Programming” work.</p><p>I started to learn computer programming around 1986 with my good friend, <a href="http://www.linkedin.com/in/hamanng">Garret Hamann</a>. We didn’t know it at the time, but we were practicing a technique that would soon be known as “Pair Programming”. Garret learned from his dad who was an engineering student at Vanderbilt (probably via pairing). Garret transferred what he knew to me when we would pair for hours on the weekends. We would write RPG’s on my Commodore 64, taking turns on the keyboard, talking, arguing, learning. Then we would re-write those games on Garret’s Apple II. What a great way to learn to code!</p><p>“Pair Programming” is kind of a big deal these days. Adoption is widespread, especially amongst those who run in Agile circles (ever increasing, thankfully)… and with good reason. The benefits are huge. I can attest to that from experience.</p><p>My friend, Colin Callahan, and I started <a href="http://acklenavenue.com/">Acklen Avenue</a> back in 2010. Right out of the gate, we decided to take a stand on a handful of practices that we were certain produced higher quality code and better team experience. Pair Programming was one of those practices. Since then, it has paid off in SO many ways. We are now 50+ in size with almost no team turnover and we are consistently cranking out quality products. Pair Programming is to thank for much of our success! Here are a few wins that we get every day from Pair Programming:</p><ul><li><strong>TRIBAL KNOWLEDGE:</strong> Even if you never switch pairing partners, your team feels the benefits or pairing simply because you’re not the only person on the team that knows how a section of code works. If you get hit by a bus or win the lottery, your team has another way to access your knowledge through your partner.</li><li><strong>NO NEED FOR CODE REVIEWS: </strong>Code is reviewed as it’s written. This provides a much more thorough and meaningful code review process and saves time.</li><li><strong>BETTER DESIGN MEANS LESS REFACTORING: </strong>Two heads are better than one, no matter how smart you think you are. When done right, pairing partners can help each other make better design decisions as the code unfolds. Because the code is designed better, you will naturally have fewer needs to go back and refactor code.</li><li><strong>CONSISTENT FOCUS: </strong>Ever feel like your focus is waning? It happens to everyone, but it doesn’t always happen at the same time for everyone. When pairing, when one partner’s focus begins to suffer, the other partner can help keep the ball rolling with a word or two. Better focus means more forward progress.</li></ul><p>Without realizing some of the benefits, it might be easy to look at “Pair Programming” as a waste of time or a productivity reducer. But, in fact, coding in pairs make the overall software development process much more efficient and enjoyable.</p><p>In my earlier article about “Pair Programming,” I proposed some ways to kill it off. Today, I’d like to suggest a few ways to help your team thrive in pairs.</p><ol><li><strong>BE WILLING TO LOSE: </strong>When you have an opinion and your pairing partner has an opposing opinion, you should talk it out. Maybe draw some circles and lines on the whiteboard. The goal is to arrive at the best decision, not for your opinion to be the winner. Sometimes, the best decision might be to stop discussing it and pick one. After all, you can always refactor later if it turns out you went the wrong direction. Being willing to lose is an essential part of working as member of a team and is even more essential for pairing.</li><li><strong>BE AN ENCOURAGER: </strong>You like to be praised for a job well done. Give the same consideration to your pairing partner. Take opportunities to build him/her up in front of the team and make it genuine. Talk about your partner more than yourself. Call attention to his/her best contributions.</li><li><strong>VOCALIZE CODE: </strong>Code certainly isn’t English, but we all have the ability to speak an English version when we’re explaining code to someone. Instead of coding silently, vocalize as you code. Keep a constant conversation going. If the only sound in the room is fingers on keys, you’re doing it wrong.</li><li><strong>EXPECT AND ACCEPT CORRECTION: </strong>Part of the huge benefit to pairing is the combining of two sets of experience. The only way to truly tap into that combined experience is to correct and discuss. Expect your pairing partner to question your decisions. When they do, put your pride in the trash can and discuss it like you care about the project more than your own opinion. If your partner isn’t starting discussions, start them yourself and invite him/her to interrupt at any moment.</li><li><strong>LEAVE SOME SPACE:</strong> Even though it’s a good practice to correct and discuss while pairing, it’s not so good if you go crazy with it. If your partner misses a semicolon or enters a typo, give them more than a half second before chiming in.</li><li><strong>ALLOW SPEED DIFFERENCES: </strong>Some programmers like to zip through code like it’s a race. Other programmers take their time and move at a much slower pace. Decide as a pair how you will handle the differences in speed and stick to it for an entire iteration. If you’re vocalizing your code, you will naturally slow down at some points and speed up at others. The main thing is to respect your partner’s pace.</li><li><strong>SWAP DRIVERS OFTEN: </strong>Being in the driver’s seat is admittedly more fun. With that in mind, swap seats every so often. If your partner doesn’t request it, you should offer it.</li></ol><p>For more information on “Pair Programming” and how to make it work for you or your team, check out these great articles:</p><ul><li>Pair Programming in Extreme Programming (XP) Rules –<a href="http://www.extremeprogramming.org/rules/pair.html">http://www.extremeprogramming.org/rules/pair.html</a></li><li>Wikipedia’s Take — <a href="http://en.wikipedia.org/wiki/Pair_programming">http://en.wikipedia.org/wiki/Pair_programming</a></li><li>Jeff Atwood’s comparison of Pair Programming and Code Reviews –<a href="http://www.codinghorror.com/blog/2007/11/pair-programming-vs-code-reviews.html">http://www.codinghorror.com/blog/2007/11/pair-programming-vs-code-reviews.html</a></li><li>Alan Shorkin’s views on effective and ineffective pair programming –<a href="http://www.skorks.com/2009/07/effective-vs-ineffective-pair-programming/">http://www.skorks.com/2009/07/effective-vs-ineffective-pair-programming/</a></li><li>Rod Hilton expresses his undying love for Pair Programming –<a href="http://www.nomachetejuggling.com/2009/02/21/i-love-pair-programming/">http://www.nomachetejuggling.com/2009/02/21/i-love-pair-programming/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c678c235be2d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agile-product-ownership/7-ways-to-win-with-pair-programming-c678c235be2d">7 Ways to Win with Pair Programming</a> was originally published in <a href="https://medium.com/agile-product-ownership">Agile Product Ownership</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 Lessons Learned from the Death of My Company]]></title>
            <link>https://medium.com/agile-product-ownership/3-lessons-learned-from-the-death-of-my-company-321143e9af09?source=rss----18adf91bba5c---4</link>
            <guid isPermaLink="false">https://medium.com/p/321143e9af09</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Tue, 22 Nov 2016 18:46:04 GMT</pubDate>
            <atom:updated>2016-09-21T17:26:01.420Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I3bYKlWKBc9ANA0a5y4_0g.jpeg" /></figure><p>It happened on an cold, rainy afternoon in late autumn of 2010. I will never forget that day. The decision I made that day left a deep mark on my soul that will surely never fade away completely. It was the right decision, but a bit too late for “right decisions.” Damage done.</p><p>In the late 2000’s, just before startups became “cool”, a friend and I had an idea for a neighborhood-based social network. We were sure it would be a huge hit and make a lasting social impact, especially in America’s neighborhoods. We decided to invest in the idea and devote ourselves to development. Ben, my partner, handled the business side of everything. I handled the tech and development. Ben and I were a great team.</p><h3>Go Speed Racer, Go!</h3><p>Over the course of 12 months, we developed an amazing amount of functionality. Ben and I were generating ideas left and right. A team of developers and I set out to turn ideas into code. We spent a lot of time on news aggregation systems that would go out to different sources and collect local news. We created a system that allowed neighbors to band together and petition government officials. We created a crime mapping solution to alert neighbors when bad people were doing bad things. We spent time on messaging, chat, groups, profiles, coupons, advertisements, and an impressive list of features, all meant to make people fall in love with our product. Demos were impressive, especially when an idea came up during a demo and a developer had it implemented before the demo was over! We were making progress like a speeding freight train. Amazing times.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/677/1*DDUAKjiEfrIWU3NaJHIF5w.jpeg" /><figcaption>From <a href="https://en.wikipedia.org/wiki/Train">https://en.wikipedia.org/wiki/Train</a></figcaption></figure><p>We started to get some attention from outside investors and large tech companies like Microsoft, AOL, and Yahoo. That brush with “fate” stoked our fire and made us walk a little taller. We added some more features to the product and did some more demos. We also added some “shareholders” to the company to help us get to the next level. Feeling great.</p><h3>Quicksand Rising</h3><p>And then we started slowing down. New features took longer to implement. New developers took longer to spin up. The bug list was growing faster than we could patch. Code that went in super fast took 10 times longer to modify, breaking countless disparate parts of the system along the way. It was like trying to run in quicksand. Our once nimble team had been reduced to a pack of sad sloths. After 6 months of death march, we made the decision to start over with a new code base and new technology.</p><p>And just like that, we were fast again! That’s how it felt to the developers, at least. We were given the chance to “get it right this time.” But 6 months into our new shiny code base, we started to feel the quicksand rising again. What was it we were doing here again? What are we trying to build? Who is this for, anyways? We had lost our way.</p><p>The idea that once woke me up early in the morning and fueled my 18-hour coding binges got lost somewhere along the way. My passion for my company and what we were building had been replaced with a feeling of helplessness, anxiety, and despair. So, on a cold, rainy afternoon in late autumn of 2010, I finally threw up my hands and stopped coding. Development stopped, meetings stopped, momentum bottomed out, and our company drowned mid-river.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5394aoIbov3xNDJnpCIdbA.jpeg" /><figcaption>From <a href="https://en.wikipedia.org/wiki/Cygnus_CRS_Orb-3">https://en.wikipedia.org/wiki/Cygnus_CRS_Orb-3</a></figcaption></figure><p>In 2010, according to the Standish Group’s 2011 Chaos Report, “37% of all projects [succeeded] (delivered on time, on budget, with required features and functions).” I didn’t realize it at the time, but I and my company had just become a permanent part of the 63% that fail.</p><h3>Lessons Learned</h3><p><strong>Release Something — </strong>Did I ever say anything about our users? Nope, because we had none. We just kept on cranking out feature after feature without regard for the people who could be using our product. Don’t get me wrong. We were definitely focused on our users, working hard to develop and <strong>perfect</strong> our functionality so that the product would absolutely delight the neighborhood-dwellers of the United States. We kept telling ourselves that the 30 some odd features we had weren’t enough. Therefore, we must keep developing. In our quest for the proverbial kitchen sink, we never released. If we had known what we know now, we would have developed the most compelling/valuable features first and then released them for use. Then, we would have listened to the feedback from our users to make sure we were building the right pieces and solving the right problems. Even if it was incomplete, it would have made the difference between life and death for our company if we had just released <strong>something</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*A8_pxZ4DFsUkut4TyjDEiQ.png" /></figure><p><strong>Fast Code is not Good Code — </strong>At the beginning of each phase of development, we were hauling tail! Coding and producing at a rapid pace is a rush that’s hard to describe for non-programmers. But even non-technical folks enjoy seeing features flying out the door at breakneck speeds. The truth is, though, that fast code is not necessarily good code. Our fast code, over time, ended up paralyzing our development team. That’s not fast at all! Knowing what I know now, we would have used proven engineering techniques and practices to ensure high quality across the board and over time. We would have worked in tight collaboration with one another and with the business. We would have sacrificed our hubris and accepted strong code instead of speed. We would have listened to experts like Robert Martin and Kent Beck when they tell us that a clean, maintainable code base makes us faster in the end and protects the project from failure. Fast code is great for prototypes and throw away ad campaigns on Facebook, but it’s can be dangerous for anything else. Fast code is not always good code and can lead to the demise of your project (or your company).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VJpc-BG3hA6rluWQo13rtg.jpeg" /><figcaption>Take time if you expect it to last. From: <a href="https://www.flickr.com/photos/oxlaey/21160523738">https://www.flickr.com/photos/oxlaey/21160523738</a></figcaption></figure><p><strong>Developers Should Not Be SME’s—</strong>For this next one, I take full responsibility. I never intentionally made myself into a subject matter expert for our project. It just happened. Yes, programmers are experts. But when a programmer is an expert over a section of code, a piece of functionality or a system, he becomes so important that he is irreplaceable. My knowledge of the entire system made me too important to lose. That feeling of importance is hard to resist. I can say that I never maliciously accepted so much importance, but I can also say I didn&#39;t turn it away. There were several times when I felt like I wanted to get away from the project, especially as things started to slow down and I felt frustrated. But I realized that, if I left, the project would come to an end. And when I finally left, it did. If I could go back in time, I would&#39;ve shared my knowledge with other developers. I would have encouraged techniques like pair programming to prevent myself from becoming a silo of knowledge. Still, I might have left the project, but at least my departure wouldn&#39;t have meant the downfall of the company.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*eS5MJrbn_S4Fgu98CBE35w.jpeg" /><figcaption>Collaborate and spread expertise. No silos! From <a href="https://en.wikipedia.org/wiki/Collaboration">https://en.wikipedia.org/wiki/Collaboration</a></figcaption></figure><h3>This Time We’ll Get It Right!</h3><p>My favorite line from “Batman Begins” is when Thomas Wayne asked his son, “Why do we fall, Bruce?” Bruce answered, “So we can learn to pick ourselves up.” I like success just like you. But life comes with this guarantee: WE WILL FALL. We will not always be successful, and we may even hurt ourselves or others on the way to failure. But you and I will not stay down. We will get up, brush ourselves off, and forge ahead with the determination to get it right the next time. I hope the lessons I learned from my own failures can serve to help you lead your own software development projects to long-term success.</p><p>And if you need a development team who has already learned from their mistakes and is poised to build a high-quality, successful software project, you should check out my most recent venture, <a href="http://acklenavenue.com/">Acklen Avenue</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=321143e9af09" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agile-product-ownership/3-lessons-learned-from-the-death-of-my-company-321143e9af09">3 Lessons Learned from the Death of My Company</a> was originally published in <a href="https://medium.com/agile-product-ownership">Agile Product Ownership</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>