Lessons Learned from Programming Languages will benefit Component-Based
Andrew Tolmach, Dick Kieburtz, Tim Sheard
Pacific Software Research Center
Oregon Graduate Institute and Portland State University
The programming language community has learned lessons about modular systems
and protocols that can help develop more robust and efficient component-based
architectures. This position paper suggests how.
Strongly Typed, Functional Glue
The language and type discipline under which components are "glued together"
has substantial impact on the character of the overall system. Most component-based
systems assume that components are implemented as stateful objects. But
global state is a notorious enemy of modularization, and distributed state
is difficult to maintain in the presence of failures. Purely functional
(i.e., side-effect-free) approaches are much better for building modular
distributed systems. The functional paradigm does not permit hidden state-based
interaction between components; all coupling between components must be
explicit. This restriction serves to discourage coupling and thus increase
Languages supporting higher-order functional types, such as Standard
ML, Haskell, or Scheme, are particularly useful. At present, component
interfaces typically specify simple argument and return types for inter-component
communication, but leave more complex interactions between components unspecified.
For example, simple type systems lack a way to express the idea that a
particular interface function may ``call back'' the client component. This
deficiency leads to awkward notions like ``outerface.'' In the higher-order
functional paradigm, the client simply specifies the call-back function
as a higher-order argument.
Specifying Physical Protocols
Ideally, physical protocols for component communication should be pitched
at the highest possible level, i.e., specialized to express just the information
that must be transferred. This maximizes encoding efficiency and helps
guarantee that only correct and meaningful communications are attempted.
In practice, however, successful component-based systems have generally
adopted a "lowest common denominator" format for physical data transfer.
For example, systems as diverse as Unix pipes, CGI, ActiveX Automation,
and KQML rely on character strings as their basic communication medium.
Using strings vastly lowers the technical barrier for integrating a component
implemented in a new technology, and makes it much easier to debug systems
by snooping on inter-component communications.
String-based communication is only superficially unstructured; the communicated
strings must be in some format that sender and receiver can both understand.
But adherence to this structure is typically enforced by ad-hoc mechanisms
which are prone to error. By viewing communicated strings as sentences
in a formally-defined language, with a grammar and an independently-specified
semantics, protocol errors can be reduced and the clarity and security
of the system can be greatly enhanced. Parsers, semantic checkers, and
pretty printers for the protocol language can be generated automatically
and incorporated into the communicating components; application-level code
in these components can deal directly with structured data having to interpret
or generate strings directly. The protocol language specification can also
double as a partial behavior specification for the components that use
it. Applications can be debugged more easily by inserting language checkers
in between communicating components to verify that protocols are being
Improving System Performance
Modular systems naturally behave well with respect to some of the ``ilities,''
such as maintainability and manageability, but poorly with respect to others,
such as responsiveness, footprint size, and runtime performance. With few
exceptions, modular architectures trade away performance in return for
increased ease in construction and maintenance, and this should be more
frankly acknowledged by proponents of component-based systems. Still, improved
performance may be essential for some applications.
There has been considerable recent progress in whole-program optimization
of modular code based on the idea of specializing modules for use
at particular client sites. Unfortunately, this approach requires that
the module's code be available, and that module and client be written in
same language (or at least be compilable to the same intermediate language).
In component-based systems the code is not all available at all, so a different
approach is required. One promising possibility is to provide enhanced
specifications of components which indicate possibilities for optimized
use. Client code uses the simplest, cleanest specification, but the client
compiler has access to a lower-level, though still abstract, specification,
together with rules that indicate how to optimize high-level calls into
lower-level ones depending on context. For example, a database server component
might offer both one-off and (cheaper) incremental query facilities; the
compiler for a client making a series of related queries could optimize
client code to use the incremental facilities. Appropriate module specification
languages for this task are still a research question, but algebraic approaches
Support for modular system development has been present in programming
languages for many years. Good ideas like functional programming, formal
specification of protocol languages, and optimization by specialization
are not new, but they can help solve old problems now reappearing in component-based
Andrew P. Tolmach
Fri Nov 21 20:05:36 PST 1997