Every piece of software will degrade over time when left as is. This is Software Entropy, a natural tendency for things to generally spread out and get messier with time. Disorder gradually increases, an indicator of the fact that a system will always head towards total chaos.
When we begin development of a platform, we aim to build a system as simple as can be to solve the problem and optimize our workflow. Our eyes are on the problem and how best to resolve it with technology and platforms that are available right then.?
Ideally, in a closed system, the software will continue to work as expected without degradation or the need for updates. But sadly, we never operate in a closed system. There is always some interaction with the ever-changing outside world.
As time progresses, technology updates, requirements evolve and complexity increases. This mandates changes in the software and gradually, what started out as one simple system, has now been affected by the environment.
While we cannot stop entropy, we can surely slow it down.?
- Be agile and yet methodological: When starting out for a business use-case, it serves to our advantage to be quick on our feet and bring the solution to the implementation stage as soon as possible. In the process, we end up cutting many a corner. While this approach might serve in the short run, it will hold us back in the long run. It is better to be methodological and plan ahead even as you aim to be agile.
- Take a modular approach: Building a single repository based system might seem attractive at first, considering that you have to maintain one project, but over time, as complexity increases, even small features will end up demanding a downtime of your entire system. It is better to take a modular approach, whereby different modules can be maintained and updated separately.
- Document everything: More often than not, you will end up finding your own code alien to you if you come back to it after a while. Make documentation a part of your project, with a structure parallel to and explaining your project code with the functional flow. Start with a README for setup and deployment instructions, and then with comments. Name variables, functions, classes, etc. appropriately, to have self-explanatory code. In this part, you will find AI helps you speed up the process. It only falls to you to leverage it and make the modifications to the docs needed.
- Maintain continuously: The ecosystem is always continuously evolving, which demands you to keep an eye and monitor as frameworks and language versions change. Each minor upgrade may not shake the system, but the major stable releases of libraries, dependencies, and the core language will definitely cause a shift. Plan for continuous upgrades rather than leapfrogging between huge gaps in between versions.
- Let go: There comes a time when the software has served its purpose. Maintaining a legacy codebase is more cumbersome than not. Be ready to let go and phase out the legacy as you build for the future. Entropy, after all, is inevitable.
You can have control over the entropy of the software. It is the unavoidable outcome: the replacement of the very software that you set out to build. As systems get more complex and obsolete, it is only in preparation for its replacement that makes you ready for the next stage.
With visual builders and language based code generation coming to a state of maturity, we are sure to see a major shift in our process of development of systems. We are heading to a time where on asking an AI for modules that you want, you get them generated automatically. A possible future awaits.
