<?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 Byron Sommardahl on Medium]]></title>
        <description><![CDATA[Stories by Byron Sommardahl on Medium]]></description>
        <link>https://medium.com/@byronsommardahl?source=rss-b92f5fc73b84------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*oPJiWf6_A4WQx8P0i7BQ1g.jpeg</url>
            <title>Stories by Byron Sommardahl on Medium</title>
            <link>https://medium.com/@byronsommardahl?source=rss-b92f5fc73b84------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 17:58:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@byronsommardahl/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[From Disciple-Makers to Spectators: The Enemy’s Greatest Deception]]></title>
            <link>https://medium.com/falling-up/from-disciple-makers-to-spectators-the-enemys-greatest-deception-03a991806a7a?source=rss-b92f5fc73b84------2</link>
            <guid isPermaLink="false">https://medium.com/p/03a991806a7a</guid>
            <category><![CDATA[disciple-making]]></category>
            <category><![CDATA[church]]></category>
            <category><![CDATA[church-leadership]]></category>
            <category><![CDATA[disciple-making-movements]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Wed, 08 Oct 2025 15:27:53 GMT</pubDate>
            <atom:updated>2025-10-08T15:27:53.403Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XYdkLQWlyMdGIGLduUGz9w.png" /></figure><p>For decades the church has told its members that evangelism is as simple as inviting someone to church. It sounds harmless enough, but this approach — what I call <em>invitationalism</em> — has slowly clipped the wings of the modern church.</p><p>Instead of equipping believers to depend on the Word of God and live it out in everyday life, we outsourced evangelism to the Sunday service. At some point in our history, the church lost its ability to study the Bible for itself and with others. And when we lost that ability, we lost the ability to make disciples. Evangelism and discipleship were left to the “spiritual elite” — pastors, teachers, missionaries, and professionals — while ordinary believers were taught their job was to fill the pews and let someone else handle the rest.</p><p>The result is that the church has been on milk for so long that we no longer have teeth for meat. And by meat I do not mean complex doctrines or intellectual arguments. I mean the ability to put faith into action. Somewhere along the way we created two categories of biblical commands: the “basic stuff” for everyone and the “hard stuff” for a spiritual elite. Scripture never makes that distinction. Every command is for anyone who calls on the name of Jesus.</p><p>This is the problem: the modern church has atrophied in disciple-making abilities. Let’s trace it back.</p><h3>Root Cause Analysis: The 5 Whys</h3><p><strong>Problem statement:</strong> The modern church has atrophied in its ability to make disciples.</p><p><strong>Why 1:</strong> Why has the church lost its ability to make disciples?</p><p>Because most believers no longer know how to study the Bible for themselves or with others.</p><p><strong>Why 2:</strong> Why do believers not know how to study the Bible with others?</p><p>Because they have been taught that evangelism means inviting people to church and leaving disciple-making to pastors.</p><p><strong>Why 3:</strong> Why was evangelism reduced to invitations?</p><p>Because church leaders positioned Sunday services as the primary evangelistic event, tailoring them for seekers rather than equipping believers for obedience.</p><p><strong>Why 4:</strong> Why did leaders design services that way?</p><p>Because numerical growth — attendance and decisions — became the measure of success, rather than multiplication of disciples.</p><p><strong>Why 5:</strong> Why did numbers become the primary metric?</p><p>Because the church shifted from confidence in the Word and the Spirit working through every believer to dependence on clergy, programs, and platforms.</p><p><strong>Root cause:</strong> Invitationalism reframed evangelism as “bring them to church” and displaced equipping. This created generations of believers who consume rather than disciple, leaving the church atrophied in its most basic calling.</p><h3>Who Benefits From This Deception?</h3><p>This did not happen by accident. The plan is too effective, too precise, and too devastating to the mission of the church to be a coincidence.</p><p>Jesus warned us about the one who would steal, kill, and destroy (John 10:10). If disciple-making is the central mission Jesus gave His people, then it makes perfect sense that the Enemy would aim his sharpest weapons at exactly that. By separating believers from the Word and reducing their role to spectators, Satan has effectively:</p><ul><li><strong>Stolen</strong> the church’s joy and power in making disciples.</li><li><strong>Killed</strong> the hunger for God’s Word in everyday believers.</li><li><strong>Destroyed</strong> the witness of the church to a lost world.</li></ul><p>Invitationalism looks harmless, even helpful, on the surface. But beneath it lies the Enemy’s greatest deception: the church is busy, active, and well-meaning, yet stripped of its disciple-making power.</p><h3>How Do We Reverse the Atrophy?</h3><p>The remedy is simple and biblical. Leaders must expose this deception, call it what it is, and retrain the church in disciple-making.</p><ul><li><strong>Reframe success.</strong> Stop counting only attendance. Start celebrating obedience, discovery groups, baptisms, and generations of multiplication.</li><li><strong>Equip every believer.</strong> Train ordinary Christians to open Scripture with others using a simple method like Discovery Bible Study (DBS).</li><li><strong>Preach for obedience.</strong> Every sermon should end with “What will you do with this?” not just “What did you learn?”</li><li><strong>Replace invite-to-church with invite-to-discover.</strong> Teach believers to ask, “Would you like to learn how to study the Bible?” and help them begin groups in homes, workplaces, or neighborhoods.</li><li><strong>Partner with local Access Ministries.</strong> Many ministries are already identifying spiritual seekers through practical service. Instead of treating those connections as “their work,” challenge your church members to step in as disciple-makers for those seekers and begin discovery groups with them.</li><li><strong>Recognize the seekers already inside your church.</strong> If your congregation is filled with people who have never truly repented, believed, and followed Jesus, treat them as seekers. Stop assuming attendance equals discipleship. Begin evangelizing from within, and invite them into discovery groups where the Word itself can call them to faith.</li><li><strong>Coach rather than control.</strong> Leaders should model, assist, watch, and then release. Their role is to equip disciple-makers, not to keep them dependent.</li></ul><h3>The Way Forward</h3><p>If invitationalism clipped our wings, obedience-based disciple-making will help us fly again. The church was never meant to be an audience that consumes religious content once a week. It was meant to be an army of everyday believers who live out the Word and help others do the same.</p><p>It is time to grow teeth again. Not to chew on deeper doctrines, but to act in obedience. Every believer can sit with others, open the Bible, listen to God’s Word, and walk in faith.</p><p>The Enemy has deceived the church into becoming spectators. The good news is that Jesus has already given us the way out. The remedy is simple: return to the Word, return to obedience, and return to making disciples.</p><p>Because making disciples is not the task of a spiritual elite. It is the calling of everyone who follows Christ.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=03a991806a7a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/falling-up/from-disciple-makers-to-spectators-the-enemys-greatest-deception-03a991806a7a">From Disciple-Makers to Spectators: The Enemy’s Greatest Deception</a> was originally published in <a href="https://medium.com/falling-up">Falling Up</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Gateway: Turning Humanitarian Ministries Into True Access Ministries]]></title>
            <link>https://medium.com/falling-up/the-gateway-turning-humanitarian-ministries-into-true-access-ministries-9a465362f361?source=rss-b92f5fc73b84------2</link>
            <guid isPermaLink="false">https://medium.com/p/9a465362f361</guid>
            <category><![CDATA[disciple-making-movements]]></category>
            <category><![CDATA[disciple-making]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Fri, 03 Oct 2025 17:09:31 GMT</pubDate>
            <atom:updated>2025-10-03T17:18:52.629Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yqvTocM9mDDH44VC0WRSRw.png" /></figure><p>Across the world, churches and Christian organizations run ministries that meet real and urgent needs. They feed the hungry, clothe the poor, provide medical care, tutor children, and respond to disasters. These are good things and they reflect God’s heart of compassion.</p><p>But here’s the hard (albeit obvious) truth: most of these ministries stop short of making disciples.</p><p>They often look almost identical to secular NGOs. The only difference is a prayer at the beginning, a cross on the flyer, a verse on the wall or an invitation to church. They meet physical needs, but they rarely lead people to discover Jesus in the Word.</p><p>That is because they are humanitarian ministries with Christian branding, not true Access Ministries.</p><h3>Humanitarian vs. Access Ministries</h3><p>Humanitarian Ministries relieve suffering. Access Ministries relieve suffering with disciple-making purpose.</p><p>On the surface, the activities might look the same. The difference is in the intentionality. An Access Ministry is not content to just meet physical needs. It is designed to create bridges into the lives of lost people so that discovery, obedience, and multiplication can happen.</p><p>And that is where the “Gateway” comes in.</p><h3>What Is a Gateway?</h3><p>A Gateway is the simple but intentional step that connects an outward-facing ministry to disciple-making.</p><p>It can take many forms, but often it is as simple as a question:</p><p><strong>“Would you like to learn how to study the Bible?”</strong></p><p>When someone says “yes,” their name and contact information are passed to a disciple-maker. The disciple-maker follows up with a phone call or text:</p><blockquote>“Hi Jennifer, Mike from the clinic gave me your number. You said you would be interested in learning how to study the Bible. I would love to show you a simple way. Are you free Monday?”</blockquote><p>At the meeting, the disciple-maker demonstrates a short Discovery Bible Study (DBS) and then asks:</p><ul><li><em>“Would you like to meet again next week?”</em></li><li><em>“Would you like to invite others from your family or friends?”</em></li></ul><p>And just like that, a Discovery Group begins.</p><h3>Why Gateways Matter</h3><p>Without Gateways, humanitarian efforts end in temporary relief.</p><ul><li>The hungry are fed, but not discipled.</li><li>The sick are treated, but never introduced to the Healer.</li><li>The poor are served, but never shown the riches of Christ.</li></ul><p>With Gateways, the same efforts lead to eternal impact.</p><ul><li>Every act of service becomes a spiritual entry point.</li><li>Every ministry contact becomes a potential Discovery Group.</li><li>Every believer can participate naturally in evangelism.</li></ul><h3>The Harvest Imbalance</h3><p>Gateways reveal a massive imbalance between supply and demand.</p><p>When ministries implement gateways, the floodgates open. Dozens or hundreds of people say “yes” to studying the Bible. Very quickly leaders realize that we do not have enough disciple-makers.</p><p>It is exactly what Jesus said in Luke 10:2:</p><blockquote><em>“The harvest is plentiful, but the workers are few.”</em></blockquote><p>This feels embarrassing, especially in places like the Bible Belt where towns have more churches than gas stations and thousands of people who consider themselves born again Christians. Yet when the need for disciple-makers surfaces, there are not enough people willing to simply sit and study the Bible with seekers.</p><p>But that is not a reason to avoid Gateways. In fact, it is the best reason to implement them everywhere.</p><p>Because when the imbalance is revealed, the church has no choice but to wake up.</p><h3>A Wake-Up Call for the Church</h3><p>Gateways are not only a method to empower evangelism. They are also a mirror for the church.</p><p>They reveal how sleepy we have become.</p><p>They expose how inward-focused we are.</p><p>They highlight how many Christians have been trained to invite people to church, but not to disciple them in the Word (and thus, how spiritually stunted we have become).</p><p>And maybe <strong>JUST MAYBE</strong> that is the wake-up call the church needs.</p><p>As church leaders begin to answer the call and equip their people not just for service but for disciple-making, God could use gateways and true access ministries to reawaken His bride from the inside out. He could use this simple shift to bring about a fresh wave of obedience, multiplication, and revival.</p><h3>Conclusion</h3><p>Humanitarian ministries are good. <strong>Compassion is biblical.</strong> But compassion without disciple-making is incomplete, powerless and short-sighted.</p><p>The difference between a humanitarian ministry and an Access Ministry is a Gateway. And the difference between sleepy churches and multiplying movements might be whether or not we are willing to implement Gateways everywhere.</p><p>Every ministry has the potential to be more than service.</p><p>Every act of kindness has the potential to be more than temporary relief.</p><p>Every believer has the potential to be more than a volunteer.</p><p>With gateways, they can all become disciple-makers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9a465362f361" width="1" height="1" alt=""><hr><p><a href="https://medium.com/falling-up/the-gateway-turning-humanitarian-ministries-into-true-access-ministries-9a465362f361">The Gateway: Turning Humanitarian Ministries Into True Access Ministries</a> was originally published in <a href="https://medium.com/falling-up">Falling Up</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Birth of Competency-Driven Development]]></title>
            <link>https://medium.com/certification-driven-development/the-birth-of-competency-driven-development-4264959cc468?source=rss-b92f5fc73b84------2</link>
            <guid isPermaLink="false">https://medium.com/p/4264959cc468</guid>
            <category><![CDATA[competency-based-learning]]></category>
            <category><![CDATA[tdd]]></category>
            <category><![CDATA[corporate-training]]></category>
            <dc:creator><![CDATA[Byron Sommardahl]]></dc:creator>
            <pubDate>Tue, 19 Jul 2022 20:30:46 GMT</pubDate>
            <atom:updated>2022-07-19T20:54:45.323Z</atom:updated>
            <content:encoded><![CDATA[<p>In one of my previous companies, we stumbled upon a unique puzzle to solve. The company’s brand promise carried a heavy focus on maintainable code and especially Test-Driven Development (TDD). From the first client conversation to the last, TDD was a predominant theme and something our clients knew to expect as part of our delivery. In fact, over time, we had become known in the community as being a TDD development shop and even won clients from competitors simply based on our opinionated development practices.</p><p>To sustain such high engineering standards, we depended on pair programming as our primary vehicle for training and developer assessment. Pair programming, when experts are available, is one of the most effective training methods I have ever seen. However, as the development team grew and became more junior-heavy, pair programming was no longer an effective leading option. We added more training methods like courses, lunch-and-learns and workshops. We invested in a “learning management system” (LMS) to help assign learning materials and track their completion. Soon, all my developers had access to world-class training and were consuming it at will. As a result, I had visibility into training delivery and confidence that my developers were getting the help they needed to meet customer needs and fulfill our brand promises.</p><p>Months later, I received some negative feedback on the code one of our teams was delivering. At first glance, everything looked in order. The code base had a calculated unit test coverage of 81%, which was slightly above our minimum standard. But, upon an inspection of static code analysis, I found that cyclomatic complexity was significantly above our maximum tolerance of 10. A high complexity score meant code was more difficult to understand and test. It was a very odd measurement to find on a TDD project. I decided to dive into the code and do some analysis of my own and was able to see clearly what my tech-savvy customer reported. The code definitely didn’t have the quality I would expect from a TDD development process. It was complex, disorganized, overly-coupled and generally messy. But it didn’t make sense. With unit test coverage so high, how was the quality so low?</p><p>After bringing in some trusted engineers to help me see between the lines, my team and I discovered that the developers were using a trick in their unit tests to artificially drive up unit test coverage so that they could continue building features without the need to write real unit tests. Coverage numbers were high, CI/CD allowed builds to continue and the developers were able to continue sprinting from feature to feature while building the mess higher and higher. When we interviewed the developers involved, we found that they didn’t truly know how to develop in a TDD context and had felt pressure to continue ahead without the proper skills.</p><p>I launched a larger-scale investigation and found that the problem was wide-spread. As the company had grown over the previous years, it had become less and less capable of fulfilling brand promises. Despite our training efforts, only 2 development teams out of 12 had TDD capabilities. So, with almost every line of code, we were converting our salespeople into liars. And even worse, we were delivering ticking time-bombs to our clients instead of high-quality, durable solutions.</p><p>This problem had to be fixed, or my company was going to fail at its original mission. A root cause analysis revealed that my confidence in the metrics from the LMS was misplaced. I believed that providing great training would ensure skill acquisition. I believed that course completion rates were indicative of growth in capabilities. I learned, the hard way, that training cannot guarantee learning. Completing a course doesn’t make you a master.</p><p>In order to rebuild the trust of our customers and deliver on our promises, I needed a more skilled workforce. The dishonest behavior of my developers was inexcusable, but replacing the majority of the development team was not a viable option. In their defense, I believed they would have happily met my expectations if they had possessed the capabilities to do so. So, the best way forward was to upgrade my team’s skills at a rapid pace and renew their commitment to our customers. I also needed more reliable metrics regarding actual skill growth, but didn’t yet know how to get them. And I had to do all that with a team that was too large for manual methods like pair programming, no matter how effective it was.</p><p>Planning our next steps would not be a task I could delegate. I dove deep into educational and assessment theory in hopes to decode and reconstruct the tacit benefits of peer assessment that happens automatically through pair programming. I researched popular and alternative educational models and their outcomes in a corporate setting. After pouring over countless white papers and industry articles, I discovered a unique combination of three concepts that I believed would provide me with the scalability of traditional education, the confidence of pair programming and an unprecedented level of visibility into skill concentration. Those three concepts, born out of “Mastery-Based Learning” were competency modeling, micro-certifications, and live, interview-style assessments. My new way forward was clear and I was ready to build.</p><p>I spent two months building out a competency model based on the skills needed to support the company’s brand promise and strategic goals. Throughout the process, I worked closely with department leaders to be sure we understood and accounted for all the skills we needed. Of course, TDD was a recurring theme in the competency model, but the model included several skills that were prerequisites to TDD and other practices as well.</p><p>I worked with my top performers to design a style of live, interview-style assessment that could be administered in a short amount of time. Although manual, 1-on-1, assessments were not as scalable as written exams, they could provide evaluators with a much higher level of confidence in mastery of skills, much like we get from pair programming. To scale out, we decided to enlist the help of a few in-house developers to evaluate their peers and kept assessments to 30 minutes or less.</p><p>In order to make the competency model actionable for my developers, I packaged bite sized-slices of that model into “micro-certifications.” The micro-certifications would allow developers to discover, acquire and be evaluated for small sets of related skills. Once awarded, micro-certifications served as data points that indicated real skill growth. When combined, those data points clearly demonstrated skill concentration across the company. In a way, I had invented a way to quantify mastery and skill acquisition in a software development team.</p><p>Once the first micro-certifications were ready, department leaders were able to deploy them to their team members. Within the first week, they had completed close to 20 live assessments with 5 evaluators helping out. Over the next few weeks, we leveled out around 15 assessments per week. Within 3 months, micro-certifications based on the company’s top 5 skills (including TDD) had been deployed to all developers which resulted in a 100% improvement in the visibility of concentration of those crucial skills, and also inspired developers to level up or move on. Thankfully, most challenged themselves to acquire the skills they needed to keep up.</p><p>Once earned, the micro-certifications provided us the ability to quantify capabilities and skill concentration in the company. My fellow leaders and I had new inputs into decisions regarding training and performance improvement, but also around hiring, firing, promotions and advancement. Thanks to our developers’ dedication and growth, we had regained confidence in their capabilities and could finally make good on our promises to our customers.</p><p>As a nice side-effect, we noticed a major improvement in onboarding of new developer hires. Since I knew each new developer came with onboarding costs and represented a new risk to our delivery to customers, I decided to challenge them with a set of micro-certifications to test the outcomes. Normally, new developer onboarding took 8 weeks to complete. But, thanks to a simple pathway of micro-certifications, I tracked new hires getting up to speed in as little as 4 weeks (saving a month of salary per developer). Though it took half the time, I had confidence that they were ready based on the micro-certifications they had earned.</p><p>In time, with new metrics in hand, we were able to make better and better decisions and regain the trust of our marvelous customers. I learned to be careful where I put my confidence. Unit test coverage and course completion rates do not always mean what they seem! But I also learned valuable lessons in how to effectively motivate and guide technologists to valuable, strategy-supporting skills in an organization.</p><p>Once we saw the success of the micro-certification program with the developers, I began to implement the same structure in other areas of the company including design, product ownership, quality assurance and human resources. Growth rates and outcomes in other departments were similar to those from the original deployment in the development organization. I consider this methodology a complete success and viable option in almost any company, organization, department or context where concentration of skills determine success.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4264959cc468" width="1" height="1" alt=""><hr><p><a href="https://medium.com/certification-driven-development/the-birth-of-competency-driven-development-4264959cc468">The Birth of Competency-Driven Development</a> was originally published in <a href="https://medium.com/certification-driven-development">Competency-Driven Development</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Unstump a Developer]]></title>
            <link>https://medium.com/agile-product-ownership/how-to-unstuck-a-developer-c0d81e57efce?source=rss-b92f5fc73b84------2</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:41 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[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-b92f5fc73b84------2</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>Wed, 21 Sep 2016 17:00:41 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>
        <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-b92f5fc73b84------2</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>Mon, 05 Sep 2016 14:20:22 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[Why “Quick Work” Turns Into Weeks]]></title>
            <link>https://medium.com/agile-product-ownership/blowing-the-whistle-on-technical-debt-44f9bf9951e6?source=rss-b92f5fc73b84------2</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>Fri, 02 Sep 2016 21:24:26 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[This Parking Garage Will Kill You — A Software Parable]]></title>
            <link>https://medium.com/agile-product-ownership/durable-software-2a96c3933ded?source=rss-b92f5fc73b84------2</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>Thu, 01 Sep 2016 18:32:21 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[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-b92f5fc73b84------2</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>Thu, 01 Sep 2016 18:22:44 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[The “Golden Rule” of Software Development]]></title>
            <link>https://medium.com/agile-product-ownership/the-golden-rule-of-software-development-e7647c24def2?source=rss-b92f5fc73b84------2</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>Thu, 01 Sep 2016 18:07:09 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>
    </channel>
</rss>