That a plugin architecture for a complex app is a good idea is one of those things that most people kinda agree on. One thing we don't quite agree is how the heck are we going to make out app modular?
One way to do it (if you are coding python) is using Yapsy.
Yapsy is awesome. Also, yapsy is a bit underdocumented. Let's see if this post fixes that a bit and leaves just the awesome.
Update: I had not seen the new Yapsy docs, released a few days ago. They are much better than what was there before :-)
Here's the general idea behind yapsy:
You create a Plugin Manager that can find and load plugins from a list of places (for example, from ["/usr/share/appname/plugins", "~/.appname/plugins"]).
A plugin category is a class.
There is a mapping between category names and category classes.
A plugin is a module and a metadata file. The module defines a class that inherits from a category class, and belongs to that category.
The metadata file has stuff like the plugin's name, description, URL, version, etc.
One of the great things about Yapsy is that it doesn't specify too much. A plugin will be just a python object, you can put whatever you want there, or you can narrow it down by specifying the category class.
In fact, the way I have been doing the category classes is:
Start with an empty class
Implement two plugins of that category
If there is a chunk that's much alike in both, move it into the category class.
But trust me, this will all be clearer with an example :-)
I will be doing it with a graphical PyQt app, but Yapsy works just as well for headless of CLI apps.
Let's start with a simple app: an HTML editor with a preview widget.
Here's the code for the app, which is really simple (it doesn't save or do anything, really, it's just an example):
But this application has an obvious limit: you have to type HTML in it. Why not type python code in it and have it convert to HTML for display? Or Wiki markup, or restructured text?
You could, in principle, just implement all those modes, but then you are assuming the responsability of supporting every thing-that-can-be-turned-into-HTML. Your app would be a monolith. That's where yapsy enters the scene.
So, let's create a plugin category, called "Formatter" which takes plain text and returns HTML. Then we add stuff in the UI so the user can choose what formatter he wants, and implement two of those.
Here's our plugin category class:
Of course what good is a plugin architecture without any plugins for it? So, let's create two plugins.
First: a plugin that takes python code and returns HTML, thanks to pygments.
See how it goes into a plugins folder? Later on we will tell yapsy to search there for plugins.
To be recognized as a plugin, it needs a metadata file, too:
And really, that's all there is to making a plugin. Here's another one for comparison, which uses docutils to format reStructured Text:
And here they are in action:
Of course using categories you can do things like a "Tools" category, where the plugins get added to a Tools menu, too.
And here's the application code:
In short: this is easy to do, and it leads to fixing your application's internal structure, so it helps you write better code.
For Sale Portobello Mkt by Jason Jones, under a CC-by-nc-sa license.
It would be natural to anyone who doesn't know me to believe I live a life of luxury, international travel and exotic pleasures  but there is a small thing I am kinda ashamed of:
I hardly ever got paid to code.
Really! Most of the money I live on has absolutely nothing to do with whatever you read about on my blog.
I make my living doing things like installing Asterisk in call centers, or configuring MySQL replication, or configuring VPNs using assorted piece-of-crap routers and by all means if you need that kind of work done, please contact Net Managers we are freaky good at it and charge reasonable rates.
But while I like that kind of thing  I like other things better. I like programming much more than I like configuring Asterisk!
Then again, I am not a really great programmer. I am just about an average coder, except that I am faster than most.
And lately, an interesting phenomenon has taken place.
How much money I earned thanks to my first 14 years of open source and free software development? $0 
How much money have I earned in the last year of FLOSS development? $500 (and it is bound to be more than that soon).
To a first-worlder that may seem like peanuts, but down here in the land of cheap beef, that's... about 100 pounds of good meat! Or 10 nice dinners in fine restaurants for me and my wife. 
I am wondering, is this part of a trend? Have others been receiving more appreciation in the form of money lately?
In any case, it's a great feeling when a work of love (and trust me, noone does something for 14 years for free if he doesn't love it) is appreciated.
Just in case: this doesn't mean you have to pay me to get a bug fixed, or to get a feature implemented. However, it does mean that if you like or use any of my programs and want me to feel good about the time I spent writing them... well, you can just send me a nice email, I will be just as happy. Really!
I am one of the speakers in the cycle of open python lectures at La Tribu in Buenos Aires, and here is the one where I speak about virtualenv, buildout, nose, hudson and other things.