Calitko Architectural Aims
We at Calitko Project put great value at extensibility and reusability. We want to create an extremely extensible architecture built of highly reusable software components. It should be possible to extend the functionality of Calitko by adding one or more new software components (in the form of plug-ins for example). It should be possible to create new components that build upon and extend the functionality of existing ones. The architecture and design should nevertheless be simple and flexible.
Calitko Design Principles
From the architectural aims described above, we have tried to derive a number design principles. We believe these will guide the development of Calitko towards achieving our architectural aims:
- Keep it simple. Achieving simplicity is essential for solving complex problems. Actually, this principle is the basis of all other principles discussed here.
- Use the power of problem decomposition. If you have a complex problem, you'd better split it in a number of sub-problems using either parallel or hierarchical decomposition. Each problem would be simpler that the original one. If a sub-problem is still not simple enough, then proceed with problem decomposition.
- Use the power of abstraction. Another way to reduce the complexity of a problem is to abstract some of the details. You gain simplicity on the price of multiple levels (or layers) of abstraction. One could say that when using abstraction, the problem is split vertically. On the other side, when using problem decomposition, the problem is split horizontally.
- Work incrementally. It is much harder to do many things at once compared in doing a single simple thing at once. In the latter case there is very little that can go wrong. Even if it does, you can easily find out what exactly went wrong. Therefore, always prefer doing only a single small step at a time. It is fine to do multiple independent small steps at the same time though. This could even increase your efficiency.
- Avoid making classes too clever. The cleverer a class is, the more specific its usage becomes. As a result, the class is less general and thus less reusable. Prefer inheritence or composition to add cleverness to more generic classes.
Proceed to Calitko Architecture Overview.