Hi, In the past few days an offline conversation sparked about the possibility of applying a certain degree of modularisation to oak-core. I will try to summarise the main points of this conversation.
Some team members expressed the will to extract some parts of oak-core into their own modules. The reason for this refactoring are the following: - Bundles that do one and only one thing are more cohesive in their implementation. Currently, oak-core does too many things and exposes a low degree of cohesion. - Bundles that are highly cohesive are easier to understand and, as a consequence, to test and maintain. Some newcomers found difficult to approach oak-core because they find it hard to understand. - A better modularisation would allow semantic versioning for the modularised components. A better versioning scheme would make clear if a new version of a component is breaking client code or is an acceptable replacement for a previous version. - Providing and distributing a focused, small fix for a component is easier if that component is contained in its own bundle, because it prevents the release of oak-core in its entirety. Some other team members didn't agree on the modularisation for the following reasons: - Oak is easy to understand because all the logic is contained in a single project. Oak is a library and not a framework. - Semantic versioning will not be of a big help, because the release notes already give a good overview of the impact of every release. - Too many modules are difficult to manage, burdening the development process. I hope to have provided a comprehensive summary of the offline conversation we had. If this is not the case, feel free to add or clarify your point of view. What is your take on modularisation?
