When designing a software platform, what are the key elements that make up a successful pluggable architecture?

Question

I've been really impressed by the growing number of software platforms that let outside developers contribute code through a pluggable architecture (plugins/extensions).

I've been studying which platforms have the best plugin communities...

Excellent Plugin Architectures with thriving plugin communities:

• WordPress (and WordPress MultiUser) for blogging: 4245 plugins
• bbPress for message boards: 165 plugins
• Firefox for browsers: 1265 extensions
• Magento for e-commerce: 732 plugins

Then there are platforms with less active plugin communities:

• MediaWiki for wikis: 22-38 extensions?

(For the sake of focus, let's put aside or ignore platforms that enable full-fledged software apps, like Microsoft Windows, iPhone, and Facebook.)

What would you say gives a software platform a successful plugin architecture with lots of plugins, versus another platform with a smaller or inactive developer community?

Just to get things started, here's a partial list:

• The platform does something broadly useful: let's people browse the web, buy and sell stuff, publish blogs and message boards, etc.
• The platform is open source (or at a minimum, the source code is freely available).
• All important functions in the platform are fully plugabble through hooks and filters.
• All or most pluggable functions are well documented (or there's a wiki so developers can document it for you).
• There's a forum or email list where developers can share plugins, and share tips and tricks
• There's a forum or email list where less sophisticated users can get help installing and configuring the plugins.

What kind of things can a platform developer do to create a pluggable architecture that encourages lots of outside developers to create plugins?

Answer 1

Personally there's 3 major contributers to whether I learn to (and do) write apps for any given system:

Is the system very useful so that I'd want to use it enough to be motivated enough to extend it?

Is the system using a language that I'm familiar with, or is easy to learn as opposed to some obscure or proprietary or otherwise overly complicated solution (see elisp)?

Is the plugin system extremely well documented in clear language so that I can go about the work of writing my plugin and not spending hours (or days) deciphering the system?

If these things are all true, the only reason you would not want to develop for a platform is that somebody else has already written plugins for all your ideas. :)

I think it's also extremely helpful/important to have a central and well known repository to house user contributed plugins (as per your example projects). I hate having to scour the web to find individual, possibly low quality or even possibly malicious add-ons for something I'm trying to do. This should be a website or wiki as even forums or mailing list archives can be annoying and time-consuming to dig through.

Answer 2

You're missing the point.

The JVM is a pluggable architecture. Every class file plugs into it and extends it.

Apache is a pluggable architecture at several levels. There are the "mods". Some mods run other interpreters, which are themselves pluggable architectures. PHP, mod_wsgi/Python, etc. are all plugged into Apache.

Python is a pluggable architecture with Python .pyc files and object files (.DLL's, .SO's) that plug into it.

Every language framework is -- in effect -- a pluggable architecture.

Answer 3

The Platform is a Foundation

One view of a software platform is as a foundation upon which other software relies in order to perform another task. This may seam a simple and rather obvious statement, but it's an important one.

The Basics Should Be Easy

A platform must have a purpose and platform developers should be aware of this when designing APIs so that it becomes obvious what the primarry use cases are and the APIs around them should be made as straightford as possible to use with respect to the way they are designed but also with respect to the doccumentation around them.

Extension Points Should Be Obvious

Extensibility in a platoform is about providing developers the oppotunity to extend or change the platform. If this is something you want to encourage then you need to make very clear the nature and limitations of this extensibility and provide a well-defined set of interfaces to allow for this.

This might all sound obvious, but if you want a community to develop around a platform, that platform must have a use and extending it should be a straightforward experience.

Sorry if this seams a little "achitectural astronaught", I do think I made some valid points, I may well have made them poorly, feel free to point this out or add to them

Answer 4

Don't forget Eclipse (with >1000 registered 3rd party "plugins" (in fact they are made of even smaller plugins in Eclipse terminology)). Part of its success may come from that there are good rules of thumb on how to design a plugin that is also extendable by others. There's also a strict API versioning policy (which of course has its drawbacks, too).