Beyond Legacy Code: Nine Practices to Extend the Life (and Value) of Your Software
The posts in this group of categories relate in some way to my book, Beyond Legacy Code (http://BeyondLegacyCode.com). Post related to one of specific nine practices from the book are assigned subcategories. For more information about my book, Beyond Legacy Code: Nine Practices to Extend the Life (and Value) of Your Software, please visit my publisher’s website
https://pragprog.com/book/dblegacy/beyond-legacy-code or check out my Amazon webpage https://www.amazon.com/Beyond-Legacy-Code-Practices-Software/dp/1680500791
The Heartbeat of a Project
For me, software agility is best summed up in the first principle from the Agile Manifesto, which talks about continuous delivery of valuable software. Agile software development is supposed to be a flow that doesn’t conform to prescribed phases. Instead, it breaks projects down into features and tasks. We build the features that are most …
Continue reading “The Heartbeat of a Project”
Read MoreProgramming by Intention
In my blog post The Single Level of Responsibility Principle, I talked about the virtues of separating out perspectives in code so that any entity is only dealing with a single perspective. In this post, I’d like to tell you about the practice I use that helps me separate out perspectives in code without even …
Continue reading “Programming by Intention”
Read MoreStory Splitting Techniques in a Nutshell
There are many techniques for splitting stories depending upon the situation you’re in. The goal is to break down work into the smallest increments that still provides some value, but the value can simply be a step in the right direction—as long as it produces visible results. Most big stories are compound stories, meaning they’re …
Continue reading “Story Splitting Techniques in a Nutshell”
Read MoreSplitting Stories
A number of Agile methodologies rely on artificial time boxes such as sprints or iterations. The purpose of these time boxes is to get you good at breaking down work so you’re only building a small piece of functionality at a time. One of the critical skills in Agile development is being able to split …
Continue reading “Splitting Stories”
Read MoreThe Single Level of Abstraction Principle
It’s virtuous to separate out different perspectives in code because it helps make code more testable, extendable, and understandable. We want to use entities at the same level of perspective so that code is easier to read and understand code. The same thing is true within entities where we want to do tasks at the …
Continue reading “The Single Level of Abstraction Principle”
Read MoreAutomate Deployment
Different people have different ideas of what it means to be Agile. For some, Agile means doing standup meetings and two-week iterations. For others,it means doing all the practices from Scrum, Lean, and Extreme Programming. For me, what it means to be Agile comes right out of the Agile Manifesto, which says: “Our highest priority …
Continue reading “Automate Deployment”
Read MoreWhat Makes a Good Test?
Many developers assume they know how to write a good test, but in my experience few developers really do. They test units of code rather than units of behavior and their tests become implementation dependent and break when the code is refactored. Rather than providing a safety net for developers to catch errors when refactoring, …
Continue reading “What Makes a Good Test?”
Read MoreRequirements Aren’t Required
In traditional software development, up to half of all development time is spent writing, maintaining, and interpreting requirements. Even more than bugs, requirements are the single largest time sink in developing software. But what’s the alternative? How will developers build what the customer wants if they aren’t told what the customer wants? The full answer …
Continue reading “Requirements Aren’t Required”
Read MoreSeven Strategies for Continuous Delivery
Continuous delivery is the single most important step in agility. Regardless of whether you do big releases or not you should always build software incrementally so it is always in a releasable state. Why? Because the only way to know if code will work in a system is to test it in the system. This …
Continue reading “Seven Strategies for Continuous Delivery”
Read MoreSeven Strategies for Solving Problems Test-First
Using tests to drive development in TDD concertizes abstract requirements making them easier to understand and work with. This is a very powerful way of solving software problems while at the same time creating maintainable code. Here are seven strategies for solving problems test-first: 1. Think outside-in Before solving a problem we must first understand …
Continue reading “Seven Strategies for Solving Problems Test-First”
Read MoreSeven Strategies for Building Smaller
Big tasks are hard to work on. When we break a big task down into smaller tasks they become much more manageable. Suddenly, insurmountably large tasks become manageable as a series of smaller tasks, each of which is easily achievable on their own. Building smaller simplifies tasks making them easier to define, create, and verify. …
Continue reading “Seven Strategies for Building Smaller”
Read MoreSeven Strategies for Fixing Bugs
Bugs are the bane of the software industry. They can be difficult to find and costly to fix. How we deal with bugs has a big impact on our software development process. We can use bugs to show us ways of improving our process so that similar bugs aren’t created again. Here are seven strategies …
Continue reading “Seven Strategies for Fixing Bugs”
Read MoreSeven Strategies for What to Refactor
Okay, you got the time and management approval to refactor some code. What do you do with it? Refactoring legacy code can be like unraveling a knotted rope and it can be hard to figure out where to start. Here are seven strategies for determining what to refactor. 1. Remove dead code Dead code is …
Continue reading “Seven Strategies for What to Refactor”
Read MoreSeven Strategies for When to Refactor
Given that there’s more code that could be refactored than our industry can handle, we have to decide what code should be refactored and what code doesn’t need it. If production software works fine and doesn’t need to be extended then there’s no need to refactor the code. Refactoring code is risky and expensive so …
Continue reading “Seven Strategies for When to Refactor”
Read MoreSeven Strategies for Helping You Justify Why to Refactor
Refactoring is improving the internal structure of code without changing its external behavior. Refactoring gives developers another chance to improve their designs and often gives management a cheaper and less risky way to ready an existing system for adding new features. Here are seven strategies to help you justify why to refactor code. 1. To …
Continue reading “Seven Strategies for Helping You Justify Why to Refactor”
Read MoreSeven Strategies for Effective Retrospectives
Scrum is all about inspecting and adapting so it’s important to make time to reflect with the team and gain insights on what can be improved. Regular retrospectives are a good way to get the team in the habit of looking at what they did and how they can improve. Here are seven strategies for …
Continue reading “Seven Strategies for Effective Retrospectives”
Read MoreSeven Strategies for Better Code Reviews
Code reviews are an important way for the team to learn and understand the parts of a system they aren’t working on. Code reviews also give developers feedback on their work. They help the team provide consistency in the code they write and help propagate good development practices throughout the team. Here are seven strategies …
Continue reading “Seven Strategies for Better Code Reviews”
Read MoreSeven Strategies for Increasing Code Quality
People define quality in software in many ways. Some define quality as software that does what the customer wants. Others define quality as software that runs fast. Still others define quality as software that’s error-free. We all agree these are good things but are they all effects of a single cause, and if so, how …
Continue reading “Seven Strategies for Increasing Code Quality”
Read MoreSeven Strategies for Splitting Stories
The shorter the story the better. Short stories are easier to estimate, understand, and implement. Short stories help create cohesive, uncoupled code. Short stories are easier to test. But how do we turn big stories into shorter ones? Here are seven strategies for splitting stories. 1. Break down compound stories into components If a story …
Continue reading “Seven Strategies for Splitting Stories”
Read MoreSeven Strategies for Writing Better Stories
“As a blogging developer, I want to share a post on writing stories so that readers find value in it.” It helps to focus on what we want to build and for whom. Here are seven strategies for writing better stories. 1. See it as a placeholder Stories alone are not meant to replace requirements. …
Continue reading “Seven Strategies for Writing Better Stories”
Read MoreSeven Strategies for Product Owners
Often we find at the core of a great product is a great Product Owner (PO). The Product Owner holds the vision for the product and prioritizes the work to be done. They steer the team to create the product. If the product they define is not ultimately what the customer wants then no matter …
Continue reading “Seven Strategies for Product Owners”
Read MoreSeven Strategies for Team Agreements
One of the most valuable documents teams can create is a Team Agreement. Team Agreements for software development can range from very detailed specifications of coding standards and practices to a general statement of moral and ethical conduct, or anywhere in between. Team agreements help set the context for team member expectations and provide a …
Continue reading “Seven Strategies for Team Agreements”
Read More