7 Aspects Of Design That Make Its Review More Important Than That Of Code
Importance of the design and why you should get the design reviewed
It is evident that each time a problem is given to a programmer to solve he tends to kick off with the code. This comes from habit, the eagerness of finding a solution, or the pleasure a programmer experiences from writing the code.
Regardless of the domain and the expertise of the developer, if the code is being written without putting a design in place, it's like constructing a building without the foundation.
I have come across many such occurrences. I have done it myself quite a few times. Software design plays a critical role in the software development process.
Software design is the mechanism that breaks down the problem in smaller and easy to solve pieces, resolves ambiguities and helps you choose most optimal/feasible path from many options.
Most of the time more emphasis is placed on the code like coding standards, code readability, code maintainability, etc. Programmers tend to ignore the design review and focus more on the code review.
There are many aspects of design that need the review of fellow teammates to make the software development process better and smooth.
Few of the reasons to get your design reviewed:
Design is the solution
“First, solve the problem. Then, write the code”
— John Johnson
As John Johnson said, design is the solution to the problem, you would definitely want to get the solution reviewed by someone on the team. This reduces the risk of finding issues in the next stages of the development.
It’s always better to catch the bugs as early as possible. And a wrong design is potentially a wrong solution. Going ahead with the wrong design will need a lot of patchwork later on, and redesign is a possibility.
Review raises questions
A design created by a developer is his/her approach to solve the problem on hand. There could be better ways to solve the problem that are more efficient, scalable, or most importantly simple.
Reviewer's questions can give you a new perspective to design a solution. You should get these suggestions/questions as early as possible in the interest of time.
Helps you choose the best path from many approaches
One of the most important aspects of the design process is to find the best way of solving the problem. Generally, you evaluate these different paths on the basis of timeliness, efficiency, scalability, cost, etc.
Walking on these paths with a fellow teammate or the team can bring up more clarity and help you choose the right path to follow. This can get confusing as well. The focus of the process is to converge to a single solution that can be a combination of different approaches.
Checks if your design is covering enough use-cases
When you are designing a solution, you tend to ignore the bigger picture. You are biased and may miss a few important use-cases.
Design review can bring up these subtle but important use-cases to your notice. This helps you make early changes in the design to accommodate these use cases.
I have seen developers design for hypothetical use-cases that complicate things up. I suggest keeping the design as simple as possible.
Scalability aspect
This is one aspect where I have seen many developers go wrong with their designs. Sometimes developers try to solve the scalability at the beginning itself without knowing if the product/feature is going to be a hit or not.
Design the solution for the immediate requirements. Don’t try to solve a problem that does not exist yet. In the future, if you hit a problem you have to redesign anyways. Hence, it is important for the reviewer to analyze this aspect of the design.
Code change is easier than design change
As compared to the code change, design change impacts the project on a bigger scale. Design change means you might not just redesign the whole system, but you have to rewrite the tested code and test it again.
This makes the design review all the more important than the code review. Dirty code is something you can slowly change over time, but the design is hard to change.
Simplicity
“The function of good software is to make the complex appear to be simple.”
— Grady Booch
Well, this is not easy for the developers. ‘Simplicity’ starts with identifying the essential parts of the solution. You develop the solution around the most important and common use-cases and try to keep it as simple as possible.
I have developed quite complex solutions myself that could have been much simpler. Most of those I have redesigned to eliminate a lot of points of failure from the system.
Simple design does not come naturally to the developers, people in general. It requires a lot of questions from the reviewer and the team.
Final Words
There is no doubt about the importance of a good design. A good design leads to a good solution. We as developers are always eager to write code and don’t give the design its due respect. We all have been there.
As I have gained experience I started to appreciate the design process and the advantages it brings in the later stages of the software development life cycle.
In this article, I have presented my views on why the review of the design is important as well for a good solution.
