Some good indicators that a system is structurally stable, aka maintainable.
- It is easy to add new functionalities.
- Thinking of any MVC framework - we can add an unlimited number of controllers, the system would just be happy to execute them. Why is that? It is because the system has a well-defined interface, which is a built-in extension point for the system without the need to change the structure.
- Some concerns (process execution, process flow control, scheduling, logging, audit, retry, exception handling, etc.) have been handled at the framework level, which greatly reduces the complexity of controllers. There are lots of things happening before or after controller execution, like identity establishment, request routing, pipeline components execution, model serialization/deserialization, model binding, but controllers have no context with any of these things.
2. It is easy to replace existing functionalities like security provider, logging provider, and serialization provider since the system has very well-defined interfaces and the process flow control has been extracted/elevated to the framework level. Additionally, since the individual process has no context of when or where it would be executed, the required information would be handed to it by a flow control mechanism, so the individual processes behave like “pure” functions.
3. It is relatively safe to change the existing functionality since the changes are well-contained within a small scope, and it is easy to test those changes.
4. Some interfaces have more than just one implementation, meaning that those interfaces have the right abstraction/level.
5. It is relatively easy to scale development efforts. The system is totally composed of modules that have a very limited scope and well-defined boundary; developers can avoid stepping on each other’s toes and getting things done without too much context/asking around for information.
6. Concerns being handled at framework level vs component level (repetition of some of the above) - the overall workload has been reduced since some common functionalities have been abstracted and elevated to the framework level, which leads to the benefits of unified, centralized, and focused elements. As the individual processes become smaller, the process cohesion would be very high.
6. Very well-defined types – the separation of data, data source, data structure, data routing/flowing, and data operation.
7. It is easy to scale services because of all the above.
8. Team morale is high, and developers would enjoy working on the project since we can feel the beauty of the system, and get things done faster. Normally there would be a lot of promotion/pat on the back going on because of the accomplishments at the end of the project.