#1 Interfaces

[Ludvig Svenonius]

I quote Jonathan Burns from the XPL-DEV mailing list:

-- BEGIN QUOTE

Above all, Interfaces. I used to be a skeptic about
object-oriented programming, but my experience with
the Melbourne Pattern Languages discussion group over
the past year has made me a believer.

That, and reading magazines mostly about C++ and
Windows programming, and about the huge struggles
going on, to define a style of programming which is
both distributed and platform-independent. Roughly,
when we have data which is tagged as being objects of
a class, but the class implementation could be
anywhere in a network, then the only form of
communication known which is location- and
implementation-independent, is pure interface or
protocol. Interfaces are the currency of COM and
CORBA, and I am certain that we will only get the XML
virtues into a language if we design the language in
terms of interfaces.

-- END QUOTE

I believe Jonathan Burns has a very strong point with
his request for an interface-based design. Interfaces
are good for standardization, both for RPC systems
such as Corba and COM, but they are also a significant
boon for scalability and standardization of third-
party libraries.

It is no coincidence that Java with its elegant but
simple support for interfaces still today is the
language with the most involved and complete support
for XML, while Python, although praised as one of the
most simple languages to write XML code in, is still
far behind when it comes to the availability of XML
libraries. I credit this to the virtues of interfaces.
In Java, all one would have to do to write an XML
library that one could be sure would work with other
third-party libraries is make sure to implement the
standardized XML interfaces provided by W3C. Thus, I
could write my own XSLT solution which would be based
on another's DOM implementation, whereas in Python I'd
first have to conduct extensive research into the
interfaces of (and quite possibly also the internals
of) the library I would base my own code on. This is
what makes interfaces boonful from a scalability point
of view. Jonathan Burns expressed well enough their
usefulness for RPC purposes.