Complex Code Redesign: When and How

Is it really necessary to rewrite a complex piece of code to truly understand it? Often, the answer is no, especially in a professional setting where time is of the essence. However, there are moments when such a step is both worthwhile and necessary. Let's delve into the nuances of this practice and explore alternative methods of code comprehension.

Rewriting for Understanding or for Maintenance?

The decision to rewrite complex code should not be made lightly. It is a significant task that carries both risks and benefits. Rewriting a codebase provides an opportunity to gain a deep understanding of its intricacies and to optimize its performance or structure. However, this approach is not the first option when dealing with new or existing projects.

Testing and Known Input

Instead of rewriting complex code, a more practical and efficient method is to test the interface thoroughly. By feeding a program script, function, or library with known input, you can verify that it produces a predictable output. This goes a long way in ensuring that the functionality works as expected without delving into the complexities of the internal code.

Initial Testing and Data Collection

Typically, I start a new project by collecting together the functions I expect to use. This involves testing these functions with known data. At this stage, you should be able to identify several modes or degrees of failure:

Unambiguous algorithm failure, such as fence-post off-by-one errors, failure to converge, or nonsense return values like NaN or Inf. Poor numerical performance, including instability in iterative problems or truncation error in evaluations. Subtle rounding errors, for example, in computing sums or integrals without compensation for floating-point control.

By spot-checking for these types of issues, you can quickly determine if there are any obvious problems. If the problem lies in a library that should be treated as read-only, you can test another function without looking at the source. For codes written by a user, you may opt to isolate the fault by making a copy of the problematic function and running it in stages using print statements or debugging.

Precautions and Considerations

It's crucial to approach the task of rewriting code with caution. Things are often complex for a specific reason—whether it's due to a lack of maintenance or inherent complexity. Always consider the possibility that the complexity hides a solution to an extensive problem rather than an unnecessary hurdle.

The Risks of Redesigning Complex Code

Very few programmers are skilled enough to replace large, complicated functions with their own low-level code effectively. Such a practice, far from improving performance, could introduce new bugs and maintenance issues. Consequently, it is safer to work at a higher level of abstraction with functions that operate as black-box entities.

Concluding Thoughts

In conclusion, while rewriting complex code can provide valuable insights and improvements, it should be done judiciously. In a professional setting, thorough testing and data collection are often sufficient to ensure that the code functions correctly. Only in rare cases, where the codebase is outdated or inherently complex, should you consider a thorough rewrite. Always weigh the benefits against the risks before embarking on such a task.

If you found this content valuable, please share it with your colleagues and peers who may benefit from it!