Common Pitfalls in Highly Configurable Software
When implementing Highly Configurable Software (HCS), teams face any number of pitfalls or anti-patterns that are easy to identify and avoid. By facing these challenges ourselves, we have compiled a list of problems and solutions. The three most common pitfalls we see are multiple configurations for each environment, copy-and-paste code reuse, and lack of a configuration management strategy. Though not an exhaustive list, these common pitfalls are easily avoided with the proper identification and remediation.
First, one typical strategy is to create multiple configuration sets for each environment. Each environment may require slightly different configurations; consequently, these configurations are often copied across environments. This duplication and sharing of configurations causes confusion and human error. For HCS to thrive, there must be a unique set of key configuration points (KCP). If there are changes across environments that are required, one should evaluate the driving factor for the change, and then create a KCP based on the factor. This new KCP becomes part of the unique set for all environments. For example, if the development environment and the production environment need separate configurations for the main application thread count, then instead of overriding each configuration on the server in each environment, the application will use the main thread count KCP to determine the value. This keeps all of the configuration in the main application and allows the application to dynamically configure itself per environment.
Another typical opportunity for improvement is when code is reused via copy-and-paste. Often, code is copied and slightly modified to satisfy a new requirement, creating a potential for code reduction utilizing HCS. Instead of copying and pasting the code, a KCP should be created to support the different use cases that are needed. This reduces the amount of code to maintain while keeping the code modular following the HCS paradigm.
Furthermore, HCS works best when it is used with a configuration management strategy. A lack of configuration management on KCPs can result in loss of configuration, especially if they exist separately on each of the deployment resources. Using industry standard software configuration management (SCM) tools in conjunction with standard build tools allow the application code to be automatically built with the configuration. This strategy keeps the KCPs close to the code, reproducible and versioned. SCM processes help the organization and application team as a whole, so there is no wrong way to fix this pitfall as long as the above criteria are met.
Though these strategies cover the basics, they provide insight into the common pitfalls that can befall HCS implementers. Identification may require scrutiny, but with the proper care and avoidance, any HCS implementation will be successful, driving teams to deliver timely, high quality maintainable solutions.