Embracing Imperfection in Software Development: The "Good Enough" Approach
This year marks the 25th anniversary of one of my favorite development books, The Pragmatic Programmer. I thought I would share summaries of some of my favorite pragmatisms throughout the year to commemorate the occasion. This is the second one: Good-Enough Software.
In software development, striving for perfection often feels like chasing a mirage in the desert. The quest for bug-free, flawless code can be both time-consuming and frustrating. But is perfection truly attainable, and is it even necessary? Let’s explore the concept of “good enough” software development and how it can lead to more productive and satisfying results for both developers and users.
The Reality of Imperfection
The real world often refuses to let us create perfect, bug-free software. Factors such as time constraints, rapidly evolving technology, and budget limitations all contribute to the imperfections that inevitably creep into software projects. While this has been truer than ever with Business Central in the past few years, it doesn’t have to be disheartening.
Before delving further into the concept of “good enough,” it’s important to clarify that it does not mean writing sloppy or poorly produced code. All software systems must meet their users’ requirements to be considered successful. “Good enough” implies giving users the opportunity to participate in deciding when the software meets their satisfaction criteria.
Make Quality a Requirements Issue
Software development is typically done for other people, so you gather your requirements from them. However, how often do you ask your users how good they want the software to be? Depending on the project, you might have different constraints. If you’re working on a mission-critical system like pacemakers or the space shuttle, stringent requirements are non-negotiable. But if you’re developing a custom app for Business Central, there might be room for trade-offs. Users may prefer software with some rough edges today rather than waiting for and spending more for a more polished version a year from now.
The scope and quality of the software you produce should be explicitly defined as part of the system’s requirements, but most of the time, the quality of the software is assumed. Custom code is just as important to the client’s business as something they might download from AppSource, and they’re likely paying significantly more for it, so the quality of the solution must be even better, right?!
The reality is that custom development services are not cheap, and we developers know that. We want to make customers happy by delivering solutions as quickly as possible. We are as susceptible to the psychological impact of price and time pressures as anyone. Most of the time, these solutions are just that, “good enough” – to us.
The problems often arise when the two sides come back together during the testing phase, resulting in statements like “I can’t believe I found so many bugs in this solution! What have you been spending your time on?!” On the flip side, introducing quality measures like design reviews, code reviews, and automated testing can add time to the overall solution. This extra effort tends to come out after the fact on the billing side: “Why did you do all of these extra things?! You’re an expert and should just know!”
Making quality a requirements issue and coming to a standard definition of “good enough” helps set clear expectations and ensures that quality is not sacrificed in pursuit of endless refinements. This approach also has the advantage that it allows you to know when you’re done. Software development can be compared to painting. You start with a blank canvas, apply science, art, and craft to create the code, and, like an artist, you need to know when to stop. Over-refinement and over-embellishment can lead to diminishing returns.
In a world where perfect software is an elusive goal, embracing the idea of “good enough” can lead to more realistic and productive software development. It allows developers to make informed trade-offs and deliver functional software that meets user needs without getting bogged down in a never-ending quest for perfection. By involving users in the process and making quality a requirement, software development can become more efficient, users can be happier, and results can be better.
Learn more about ArcherPoint’s development and integration services.