A prior post discussed some of the challenges with using code generators. One thing we did not cover was the value of re-inventing the wheel. In particular, this holds true when we are learning problem-solving. That means one of the ways to become better developers is to solve problems that have already been solved. The objective is not so much the solution as the process.
Skipping Ahead Without Re-inventing The Wheel
Software developers often use frameworks and code generators to improve productivity. They also can find ways to quickly code a series of common modules through libraries and pre-built scripts. That approach is obviously a route to rapid development. However, it also is a potential way to allow skills to rust from lack of use. We can say we do not need to re-invent the wheel, there is no value in solving something where the solution is known. However, that is not completely true. There is value in analyzing a problem and finding a solution even when it is known. We learn how to think in a critical and logical manner. There are also repeated patterns in developing solutions.
Repetition Across Solutions
The idea of patterns emerging in problem-solving is not often discussed. They tend to be a sort of obvious secret or maybe even common sense. Nevertheless, we need to be able to apply these patterns to become better problem solvers. The stories about Sherlock Holmes show some of these. Sometimes it is all a matter of deduction, or maybe a process of elimination. There are these sorts of solution patterns that can be used over and over in solving even very complex problems. The more we are familiar with these patterns, the more we can combine them into new and complex solutions. When we skip to the solution on common problems, as we do with code generators, we also pass on that learning opportunity.
I think that persistence is often undervalued. That is another skill we do not develop when we take the shortest path to a solution. There is value in spending time banging one’s head against a problem while we try to solve it. We also can develop good habits as we struggle through those “simpler” problems. Think of code generators and frameworks as a way of pushing the cost of developing skills down the road. There are times that is needed. However, we may end up paying an exorbitant price in the future. That is not much different from pushing upgrades off to the future and eventually paying a huge price or even being blocked from an upgrade path.
The Power of Persistence
One of the traits of a strong developer is persistence. We encounter all manner of obstacles that require us to persevere as developers. These are well-known among us and range from simple headaches like a hard-to-find misspelling to magic numbers and complex configuration combinations. Re-inventing the wheel can be a path to practice such patience and perseverance. The benefit of these well-known problems is that we have ways to move us forward when we are blocked. We get to go through the motions with a form of training wheels to help us get past steps that stop our progress.
These are areas where practice helps us. Thus, using tools that help us skip ahead on problems can remove that practice and the related benefits. A similar example is a basketball player that skips free throws because they know they can make them. We also have mental “muscles” that can be exercised to create muscle memory and better performance in other areas of problem-solving.