never complain, never explain

Celebrating Software Modularity

I have recently been involved in the modification of several software systems. In one system, service provider preferences changed, which required code that interfaced with the new provider to be implemented. The presence of engineered software architecture simplifies change. A desirable architecture for a system with uncontrollable external dependencies facilitates changes that are localized to specific parts of the system.

One company wanted to use a hosted Microsoft Exchange Server solution, but their proprietary system depended on an in-house mail server. In this case, the system depended on a single mail component, and implementation of a component that worked with the hosted solutions provider and exposed the same interface to the proprietary system was all that was needed to make the transition. Code that had a direct dependency on the mail component required minor modification of references to the old component. All other code in the system was unaffected.

There are situations when elegantly engineered software architectures cannot be devised and deployed. A client demanding that a system be delivered earlier than completion estimates provided by engineers is such a situation. If a business deal depends on meeting client deadlines, then an engineer may opt to evolve a prototype into the production system. After meeting the deadline, the engineer may want to refactor the system into an architecture that is well thought out. This allows the engineer to make future system changes easily. Refactoring is an incremental approach toward elegant software design.

An excellent software engineer can change the core system into a more elegant architecture without changing the end-user experience. Being able to repeatedly perform this exercise easily indicates modularization of the user interface and the core system. The core system can be developed without affecting the end-user interface, and it can be deployed for many users without affecting their respective user interfaces. The benefits of modularization can be extended to software dependents. Excellent software architecture permits changes to software components without requiring massive changes to the overall system. Excellent software architecture makes effective use of software component modularization. Ease of change is a good reason to invest time in developing software architecture before implementation of the production system.

Leave a Reply