A repeating theme in my development work has been the use of or creation of an in-house plug-in architecture. I’ve seen it approached many ways – configuration files (XML, .conf, and so on), inheritance frameworks, database information, libraries, and others. In my experience:
- A database isn’t a great place to store your configuration information, especially co-mingled with data
- Attempting this with an inheritance hierarchy requires knowledge about the plug-ins to be coded in, meaning the plug-in architecture isn’t all that dynamic
- Configuration files work well for providing simple information, but can’t handle more complex behaviors
- Libraries seem to work well, but the one-way dependencies have to be carefully created.
As I seek to learn from the various architectures I’ve worked with, I’m also looking to the community for suggestions. How have you implemented a SOLID plug-in architecture? What was your worst failure (or the worst failure you’ve seen)? What would you do if you were going to implement a new plug-in architecture? What SDK or open source project that you’ve worked with has the best example of a good architecture?
A few examples I’ve been finding on my own:
- Perl’s Module::Plugable and IOC for dependency injection in Perl
- The various Spring frameworks (Java, .NET, Python) for dependency injection.
- An SO question with a list for Java (including Service Provider Interfaces)
- An SO question for C++ pointing to a Dr. Dobbs article
- An SO question regarding a specific plugin idea for ASP.NET MVC
These examples seem to play to various language strengths. Is a good plugin architecture necessarily tied to the language? Is it best to use tools to create a plugin architecture, or to do it on one’s own following models?
This is not an answer as much as a bunch of potentially useful remarks/examples.
One effective way to make your application extensible is to expose its internals as a scripting language and write all the top level stuff in that language. This makes it quite modifiable and practically future proof (if your primitives are well chosen and implemented). A success story of this kind of thing is Emacs. I prefer this to the eclipse style plugin system because if I want to extend functionality, I don’t have to learn the API and write/compile a separate plugin. I can write a 3 line snippet in the current buffer itself, evaluate it and use it. Very smooth learning curve and very pleasing results.
One application which I’ve extended a little is Trac. It has a component architecture which in this situation means that tasks are delegated to modules that advertise extension points. You can then implement other components which would fit into these points and change the flow. It’s a little like Kalkie’s suggestion above.
Another one that’s good is py.test. It follows the “best API is no API” philosophy and relies purely on hooks being called at every level. You can override these hooks in files/functions named according to a convention and alter the behaviour. You can see the list of plugins on the site to see how quickly/easily they can be implemented.
A few general points.