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
Rebuild or Refactor
Sometimes, when an important project is going poorly there’s a desire to start over. Sometimes this comes from management but often this comes from the developers themselves. They say if they only had a second chance and could start over then they can build the right system. But that almost never happens. Take it from …
Continue reading “Rebuild or Refactor”
Read MoreMore on Test-Driven Development
One of the most valuable development practice that has become popular recently is test-driven development. When done correctly, unit tests can dramatically drop the cost of maintaining software while increasing its value. All the things that management wants and needs from the processes that are built around software development are embodied in this simple practice …
Continue reading “More on Test-Driven Development”
Read MoreCode Transformations
A lot of poor designs can be attributed to sticking with an existing design as changing requirements show us the need for a better one. Oftentimes, an initial design is just a stab in the dark. We might not know enough to make an informed decision but we have to get something done, so we …
Continue reading “Code Transformations”
Read MoreWork Through Examples
One of the biggest challenges in building software is specifying what needs to be built. A blueprint captures all of the valuable information we need in order to build a building and details such as the tensile strength of the material and how to build a foundation are available through other sources. Blueprints have no …
Continue reading “Work Through Examples”
Read MorePair Programming Pointers
Pair programming is the one Extreme Programming practice that I get the most pushback from both developers and managers. Most of us have experience programming as a solitary art form and we’ve done it alone. We figured out a bunch of things for ourselves and we don’t necessarily feel comfortable doing our work in the …
Continue reading “Pair Programming Pointers”
Read MoreThe Stigma Around Refactoring
Refactoring is a critically important concept in software. Anyone involved in the software industry should understand exactly what refactoring is and why it’s valuable. Refactoring is not just the redesign of code. The redesign must behave exactly in the same way as it did before. In many situations, this also means bug-for-bug compatibility as well …
Continue reading “The Stigma Around Refactoring”
Read MoreRead, Write, and Refactor
A couple of years ago I got to realize a lifelong dream when I became a published author. I was surprised to learn that many of the skills that I gained in becoming a good software developer were actually useful to me in becoming a good writer. Like code, prose should be well-encapsulated and cohesive, …
Continue reading “Read, Write, and Refactor”
Read MoreMy Second Favorite Refactoring
In my last blog post, I shared with you my favorite refactoring and it might not have been what you were expecting. I can’t leave the topic without sharing with you my second favorite refactoring, as well. Like my favorite refactoring, my second favorite refactoring is also a safe refactoring, which means that if you …
Continue reading “My Second Favorite Refactoring”
Read MoreMy Favorite Refactoring
Refactoring code is an essential activity when working with existing systems, as well as building new ones. Refactoring techniques allow us to safely transform code into designs that are perhaps better suited for future extension. The techniques used to refactor code range from very simple to quite complex and there is a strong emphasis to …
Continue reading “My Favorite Refactoring”
Read MoreSurgery on Legacy Code
One of my early blog posts that I wrote nearly 10 years ago that I called Sony Baloney discussed how the electronics giant cultivated some unusual, yet highly successful practices. One of the practices that Sony is known for is taking young and inexperienced engineers and putting them on new product development, while their senior …
Continue reading “Surgery on Legacy Code”
Read MoreEncapsulate Change
Software development is a unique human activity but it bears resemblance to other activities such as math, writing, and engineering. I think of writing software as a modeling process but unlike modeling physical things that occur in space, we’re modeling processes that occur in time. Therefore, writing software is a process of creating models that …
Continue reading “Encapsulate Change”
Read MoreIntroducing TDD to Managers
In my last blog post, I discussed different ways of introducing test-driven development to teams. The bottom line is to give developers an experience of benefiting from doing TDD. Once they see how their tests catch bugs that otherwise would have perhaps escaped and had to be fixed later, and how TDD helps them keep …
Continue reading “Introducing TDD to Managers”
Read MoreCode Coverage
Like most metrics in software development, code coverage can be a good indicator or it can be heavily abused. I know many teams that have a code coverage standard. For example, 80% of their code must be covered by unit tests. The problem with having a standard for the percentage of code coverage is that …
Continue reading “Code Coverage”
Read MoreMake Your Test Fail First
The test-first development cycle means that first we write a failing test and prove that it fails by running it and seeing the red bar. Then we implement the test so that it passes and we see the green bar. Finally, we refactor the code and the test for quality and maintainability. That’s the test …
Continue reading “Make Your Test Fail First”
Read MoreDon’t Write All Your Tests Upfront
I find that different people have different ideas about what test-driven development really means. Some people think that test-driven development is about writing all of your tests after you write your code. To me, that is not test driven development. I call that test-after development and when we do TDD we write our tests before …
Continue reading “Don’t Write All Your Tests Upfront”
Read MoreIt’s Not a Test of You Write it First
Although I am an advocate of test-first development, I also acknowledge that there’s a bit of a conundrum in the name test-first development. How can you write a test for something before you write the something? There’s nothing yet to test so how can it be a test? The answer to that question is that …
Continue reading “It’s Not a Test of You Write it First”
Read MoreWhy Write the Test First
As you can probably tell by reading my blog, I am a proponent of TDD. But my enthusiasm for test-first development took a long time coming. It took me a long time to convince myself that TDD had great value and was worth the effort. Software developers already have too much to do and not …
Continue reading “Why Write the Test First”
Read MoreOn Implementation Independence
I’ve been looking forward to writing this blog post for a while because I’ve been misinterpreted in the past on what I mean by implementation independence. And this is entirely understandable because the concept is slippery and difficult for people to easily grasp. Yet I feel implementation independence is one of the most important concepts …
Continue reading “On Implementation Independence”
Read MoreContinuous Integration Requires the Right Tests
I see continuous integration as a “gateway practice” because it will lead to other Agile practices. Continuous integration and automating the process of validating release candidates represents a large part of the Agile vision realized. We spend nearly half of our time and effort integrating and testing code. Many companies do this manually, which makes …
Continue reading “Continuous Integration Requires the Right Tests”
Read MoreAvoid Long-Lived Branches
If you ask a hundred consultants what Agile is, you’ll likely get 100 different answers. So, here’s my answer. Agile software development can be summed up by the first principle of the Agile Manifesto, which states, “Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.” To my mind, …
Continue reading “Avoid Long-Lived Branches”
Read MoreThe Power of Continuous Integration
As an Agile technical consultant, people often ask me how to get the most value from their Agile technical practices. My answer is often the same, which is start with continuous integration. Continuous integration is at the heart of all Agile software development. I see continuous integration as the defining characteristic of Agile software development, …
Continue reading “The Power of Continuous Integration”
Read MoreBuild What Users Want
Our users are only human and its human nature not to always know exactly what we want. I realize that sometimes we have to build software on specifications and all the requirements are needed to be identified upfront. But statistically, it is rarely the case that all requirements are needed. It turns out that nearly …
Continue reading “Build What Users Want”
Read More