2024 Public Training Schedule
December 9 – 12, 2024 – Agile Analysis and Design Patterns – Half-Day Sessions
2025 Public Training Schedule
January 14 – 17, 2025 – Agile Analysis and Design Patterns – Half-Day Sessions
Follow me on Twitter:
Blog Post Categories
- Announcements {19}
- Articles {2}
- Bits and Pieces {74}
- Blogosphere {1}
- Bonuses {2}
- Build in Small Batches {27}
- Collaborate {38}
- Create CLEAN Code {34}
- Implement the Design Last {11}
- Integrate Continuously {30}
- Off-Topic but Interesting {3}
- Rants {82}
- Refactor Legacy Code {24}
- Say What, Why, and for Whom Before How {22}
- Seven Strategies {38}
- Specify Behaviors with Tests {17}
- Write the Test First {27}
Archives
Privacy Policy
(c) 2024 To Be Agile
- March 1, 2017
- Rants
Software development has undergone many revolutions over the last few decades and the way we build software today is fundamentally different than the way we did just a few years ago. Our industry is maturing and we are beginning to pay attention to the quality of our work. No longer is just fulfilling the specification enough. We have to write code that’s easy to maintain and extend so we can reduce the cost of ownership. This requires thinking about building software in some fundamentally different ways.
When I ask developers what they can do to make their code more maintainable or conversely, what other people do that makes code difficult to maintain, I rarely get a clear answer because it’s something most of us really haven’t thought about. But there are things we can do to make our code more maintainable, and there are definitely things we must avoid when building software as well.
Many of the most important and valuable technical practices have been embraced in Agile software development, including Scrum, Extreme Programming, and continuous integration.
At its core, Scrum simply says to take complex software problems and build them incrementally. This has the effect of taking a difficult task and breaking it down into several much more easily manageable tasks. The idea works in all fields, and works especially well in software development.
Scrum went on to discover that with an active product owner, the ambiguity in software development—especially in requirements—goes away and again the process of building the right software is simplified. We stay focused on the most important issues and get lots of feedback from our customers.
These two aspects of Scrum software development are largely responsible for its enormous success, but there are other things that can help the development process, specifically the technical practices from Extreme Programming, which goes very nicely with Scrum development.
Extreme Programming, and before that the Smalltalk community, have proven time and time again that big, complex software problems can be broken down into simpler elements and can be made more manageable by a handful of straightforward techniques such as continuous integration, test driven development, and pairing.
Again, these are very simple practices that help guide us in doing the right thing at the right time. The key is to understand their purpose so you can use the practices to their fullest. This is the subject of my book, Beyond Legacy Code: Nine Practices to Extend the Life (and Value) of Your Software.
Previous Post: « Two Big Things
Next Post: Avoiding Integration Hell »