Programming the Middleware Machine with Finesse
School of Information Technology
CRC for Distributed Systems Technology
The University of Queensland
Middleware platforms are maturing quickly as the demand for distributed
object systems linking desktop software with enterprise information systems
increases. Remote procedure calls (RPC) and the associated interface definition
languages (IDL) provide a rudimentary abstraction of the middleware services
in the same way that macros for function call and return provide abstraction
in assembly languages. In keeping with this analogy, programming over middleware
systems is still largely dependent on the chosen middleware platform.
This position statement explores the possibility of using a higher level
language for programming the middleware. Such a language could provide
many features, including:
The following text discusses the notion of programming the middleware
machine in distributed component systems and introduces an experimental
middleware language called Finesse. An example Finesse program is
presented to demonstrate the power and utility of this approach.
rich semantics for describing middleware behaviour
middleware platform independence
abstraction over component interaction
abstraction over component aggregation
optimisation of communication and configuration through intelligent compilation
a direct realisation of software architecture descriptions
The Role of Languages in Distributed Component Systems
Early distributed systems used a variety of mechanisms for communication
and abstraction of those communications[Andrews91].
More recently, RPC has emerged as the mechanism of choice for commercial
software, evidenced by the widespread availability of middleware platforms
supporting RPC, for example, CORBA platforms, DCE, Microsoft COM and Java
RMI. While RPC is suitable for many applications, efforts to add messaging,
multimedia streams and events to the set of CORBA standards suggest that
alternative interaction mechanisms are useful and necessary. Such interactions
cannot be easily described in IDL.
A further difficulty being encountered, as suggested by the call for
papers, is that middleware platforms are constantly changing. The explicit
dependence of software on the middleware platform creates maintenance and
portability problems, and suggests the need for some level of middleware
independence for distributed applications. An interesting and appealing
approach is to develop the equivalent of a high-level language for programming
the middleware machine, or in other words, a super IDL.
There is mounting evidence that a language-based approach is appropriate.
Recent research in software architecture[Shaw94,Shaw96,Allen95]
strongly suggests that description of the interaction and interconnection
of software components deserves first-class status in the software engineering
process. These conclusions have been reached without, in general, considering
the increased complexity associated with distributed component systems.
This conclusion is also reflected in research into coordination languages[Holzbacher96,Arbab96]
and simulation[Luckham95] where languages for
describing the interconnection and interaction of components are used.
These languages offer significantly richer semantics than IDL, typically
At this point, however, these languages are not appropriate for a super
IDL because they provide a closed, single language environment that
is unsuitable for open systems. With the exception of Rapide[Luckham95],
their failure models are also insufficient for Internet-scale distributed
systems. Finesse attempts to overcome these limitations and provide semantics
for open, distributed systems.
ordering constraints on operations, for example, open -> read/write
-> close on file operations;
explicit, guarded iteration instead of the implicit, unguarded multiple-call
semantics associated with IDL operations;
abstraction and composition of middleware program modules;
minimal protocol assumptions.
An Overview of Finesse
Finesse is an executable language for describing complex interaction models
and distribution mechanisms. Finesse is used to describe a binding,
which is an abstract entity that encapsulates the communication between
distributed software components participating in an application. Bindings
are described in terms of the following fundamental concepts:
A binding is instantiated by nominating a Finesse program (or some compiled
form) and a set of components to fulfil the roles of the binding. The underlying
distributed infrastructure is required to establish an appropriate set
of network connections and supporting components to implement the Finesse
program. A Finesse program can be used to generate stubs for the participating
components in a similar manner to CORBA IDL, meaning that Finesse is somewhat
independent of the language used to build the participating components.
||a binding is an infrastructure-provided configuration of
network connections and behaviour. A binding specification in Finesse describes
a configuration of components and their allowed or expected interactions.
||a binding has a set of roles that can or must be filled
by participating components. One or more components can fulfil a single
role, providing a convenient abstraction for groups.
||components have interfaces through which they interact with
their environment. Each interface is connected to one or more roles in
the binding and must implement the behaviour specified by the roles it
||components participate in a binding (interact) by executing
events at their interfaces. Events have parameters and direction (in or
||event relationships specify the behaviour and interactions
of a binding by describing the relationships between events occurring at
Event relationships provide the basis for describing behaviour in bindings.
Event relationships capture the dependencies between events at the interfaces
of software components participating in a distributed application. Three
distinct types of event relationship are identified:
These concepts, combined with the notions of binding, object,
interface and role provide an extremely powerful technique
for the description of distributed systems interaction. For example, it
is possible to succinctly describe and easily extend remote procedure call,
group communication, and stream behaviour as demonstrated in [Berry98].
The underlying semantic model described in [Rakotonirainy97]
also includes powerful facilities for abstraction and composition of these
behaviours, although only some of those capabilities are visible in Finesse.
||which describe the causal dependencies between events;
||which describe the relationships between parameters of causally
related events. Parameter relationships define the content of messages
passed between interacting components, but in a declarative, application-oriented
||which describe any real-time relationships between events.
These relationships can be used to describe, for example, timeouts or quality
of service requirements of interactions.
Of particular note in this behavioural model is the potential for optimising
communication because event relationships are declarative. For example,
a receive event at some interface might have dependencies on several
send events at another interface. Only a single message need be
sent to implement these dependencies, and only those parameters nominated
in the relevant parameter relationships need be sent in that message.
Example: Video on Demand
The Finesse language is experimental and is intended to adequately support
the behavioural model rather than provide a programmer-friendly syntax.
The comments in the example code point out salient features of the language,
however, a definition of the Finesse
syntax can be referred to if desired.
The video on demand Finesse
program has roles for three components, a MovieBuff, a MovieDatabase
and a VideoStore. The MovieBuff searches the movie database for
a set of movies matching a pattern, with the results passed to the VideoStore
for cost and availability information. The MovieBuff selects a video and
a subordinate VideoTape binding is
established to play the video.
The role definitions of a generic RPC
binding are used to define the behaviours of the roles. This binding definition
is also used to support the pause operation of the VideoTape binding.
This example demonstrates a number of advantages of the Finesse approach
over traditional IDL, in particular:
RPC, stream and event/messaging behaviour involving more than two parties
is described in a flexible, single-language environment. This behaviour
can also include quality-of-service characteristics;
the modularity of the example shows the potential for abstraction and reuse
through binding components like RPC and VideoTape;
the decoupling of output and dependent input makes interactions like delegated
RPC easy to describe;
it captures the architecture of the solution neatly, clearly defining the
three roles and their interrelationships;
This position statement has explored the idea of programming the middleware
machine with a semantically rich language designed. There is considerable
evidence to suggest that this approach to creating distributed component
systems over the next generation of middleware platforms is valuable and
useful. An experimental language, Finesse, has been described and demonstrated
through an example program. The example shows the benefits of this approach,
particularly the ability to describe complex, multi-party, interaction
mechanisms in a single language environment.
While not yet suitable for deployment in commercial applications, Finesse
lights the path towards more flexible, portable, and pliable construction
of distributed component systems.
||R. Allen and D. Garlan, Formalizing Architectural Connection. Proceedings
16th International Conference on Software Engineering, IEEE, May 1994.
||G. Andrews, Paradigms
for Process Interaction in Distributed Programs ACM Computing Surveys,
23(1), March 1991
||F. Arbab, The IWIM Model for Coordination of Concurrent Activities.
Coordination Languages and Models, LNCS 1061, Springer, 1996
||A. Berry and S. Kaplan, Open,
Distributed Coordination with Finesse. Accepted for ACM Symposium
on Applied Computing, Atlanta, February 1998
||A. Holzbacher, A software environment for concurrent coordinated programming.
Coordination Languages and Models, LNCS 1061, Springer, 1996.
||D. Luckham and J. Vera, An event based architecture definition language.
IEEE Transactions on Software Engineering, September 1995.
||A. Rakotonirainy, A. Berry, S. Crawley, and Z. Milosevic, Describing
open distributed systems: A foundation. Proceedings of the Thirtieth
Annual Hawaii International Conference on System Sciences: Software Technology
and Architecture, IEEE 1997.
||M. Shaw, Procedure
Calls Are the Assembly Language of Software Interconnection: Connectors
Deserve First-Class Status, Tech Report CMU-CS-94-107, Carnegie Mellon
University, January 1994
||M. Shaw and D. Garlan. Software Architecture: Perspectives on an
emerging discipline, Prentice Hall, 1996.