The focus of this episode on software architecture patterns is the microkernel pattern. It is a common way to build on core technology without the need for future design. Once the plugin interface is defined, the sky is the limit for enhancements and upgrades. You do all of this without impacting that core.
The Microkernel Pattern Defined
This approach starts with a core piece of functionality. Next, other components are added to it. We see this pattern utilized in many cloud products and commercial software. The core can be protected, and then plugins farmed out. Also, customers can purchase the core and then plugins a la carte. In a technical sense, the core provides shared functionality across the system. The plugins allow us to upgrade or enhance the core in a focused way.
The core is not touched with this pattern and can provide a stable foundation. The enhancements are plugged in and thus not likely to impact the overall system negatively. We define the interface that allows for the plugin, and then it is up to future developers to expand on the solution. The plugin interface is often thin and straightforward, leaving the plugins nearly stand-alone modules. Likewise, we can split a more extensive solution into smaller pieces that are easier to manage.
Applying The Pattern
The opportunities are endless for this pattern. We can solve small problems with hooks included for plugins. Likewise, we can build enterprise systems that allow for future expansion. Of course, there is an overhead cost of a plugin interface. However, that can often be kept to a minimum when limited data needs to be shared. Finally, there are many examples of this pattern out in the wild, and a search can find excellent reference projects.
