One of the most challenging areas in software development is about managing complexity. Every new piece of code that we write contributes to the overall complexity of the system. This is the same complexity that urges every one of us to re-design and re-code the whole system from scratch when it reaches to a certain threshold.
Virtual nature of software development combined with ever-changing user requirements urge applications to expand beyond the borders that were initially anticipated and designed for. As applications evolve, their complexity increases unless you actively manage it. Furthermore, the nature of programming languages plays a major role in contributing to this complexity.
Every developer knows that writing a new piece of code is always easier and more fun than reading, understanding and modifying any existing code written by someone else. Most of the time, this difficulty convinces us to re-write. But even if we re-write, it doesn’t take long to realise we eventually end up with “brand new complexity”. Every new line of code we added to the system needs to be debugged, has to be read and understood, has to be tested, supported and maintained. Therefore, some times I think, our best code is the one that we managed to avoid writing.
In order to effectively work with this complexity, we need to renovate, clean, simplify and improve our code continuously. This is not an easy task neither it is that much of fun. But our ability to refactor effectively determines the health of the applications. After all, everyone can write code, but actively tackling complexity requires not only skills but also plan and discipline.