Keeping software maintainable

Software products are usually growing. Already existing functions are getting extended. Features are added. Workflows are changing.
This is common thing for software products which are in real use by someone.

So what is key while getting your software product bigger and more rich on functionality?

In my opinion the only way to achieve this is by getting your product separated into what I call modules. Those modules can be modules in classical meaning like libraries but also of course a separation into services. Key is, those parts have to be separated in meaningful parts and those parts have to work independently. What does it mean? Working independently does not actually mean those parts need to do everything by themselves if they are deployed as singular instance. No. Of course in your product many parts probably make only sense if they are working together. But is means:

• they can be developed in different streams
• they can be deployed by themselves
• they make sense by themselves and acting on specific areas
• they have some kind of stable interface to communicate to other modules or services
• within one product you should pay attention that those interfaces are similar or better generically the same. This improves extensibility extremely
• they have a reasonable size of codebase (very important!) If they are getting to big they need to get separated again

One way to do this, is, if you are experienced enough in your field, you can design it first hand in modules. Very often you either are not exactly know how it will be in the end or you do this kind of project the first time. So it is growing and evolving with time. In this case you really need to “think about” splitting up almost every time you act on it. It is not necessary that you get to piggy with separation but consider every time the new features as potential new streams.

Especially in manufacturing environments there are also strong dependencies and security requirements which have to be considered as well.