My previous entry has generated a few interesting comments which deserve
further thoughts…

Pascal writes:

Cedric, while you’re basically right, one should still differentiate about
COM and CORBA (which is probably what you meant with IDL):

Actually no, I was really talking about COM when I mentioned IDL.  Both
COM and CORBA use IDL to define interfaces, and although Microsoft’s version has
a few Windows-specific flavors, they are basically identical and serve the same
purpose.  And you’re right, CORBA fits in category 2/3, and if I didn’t
mention it, it’s simply because it hasn’t succeeded as well as COM.

Thanks for the NetKernel information, I didn’t know about it, I’ll check it

Jeff wonders:

Cedric, why do you think that binaries are more reusable than plug-ins?

I was careful to put these two approaches very close to each other and the
only reason why I said that COM is more reusable than a plug-in approach is
because it belongs in the operating system.  We have come a long way with
OSGi but there is still no real standard plug-in API in Java.  Ideally, I’d
like for such a thing to be shipped with J2SE so that not everybody who wants to
make their application pluggable needs to download external packages (wouldn’t
it be nice if the knowledge you acquired to write Eclipse plug-ins could be
readily reused to write an IntelliJ or JEdit plug-in?).

I don’t really agree on your definitions of plug-in and binary reusability.
The main difference I see between plug-ins and binaries is that the plug-in
invite you to extend it and enhance its functionalities while you can only use
the binaries without affecting its own set of functions.

This is a subtle point (also made by Rob Meyer later in the comments), but
after thinking about it more, I realize you are both right.  Both
approaches are a
manifestation of code reuse but they are definitely serving different purposes. 
However, maybe using the HTML renderer as an illustration of COM’s power is
misleading, and if you look at Outlook’s COM interfaces, you realize that the
line between "reusing core components" and "extending an existing core
architecture" is indeed quite blurred.

Interestingly, Reuters just
published a

very interesting article
describing Office as a full-fledged platform. 
Not only is this important to Microsoft’s business, it’s also a very effective
way to make sure that open-source alternatives to Office and Windows remain
irrelevant regardless of how good they are.

At any rate, there is clearly a need for more thinking on this topic.

Justin says:

Having written an eclipse plugin, I think the two best thing the Eclipse
group ever did were to have the bindings specified by XML and most of the
application functionality implemented via plugins.

I couldn’t agree more, and I like this approach so much that I based
on it.  A careful mix of XML and sound coding patterns is the ultimate
reusability weapon.  Having said that, there are still a lot of pitfalls to
avoid (too much XML or too much modularization, reusing in a flexible but overly
complex architecture), and I suspect that we will be discovering a lot of new
concepts in the next years.

Keep the comments coming, I am trying to figure this out as much as anybody