Programming the Middleware Machine with Finesse

Andrew Berry¹, Simon Kaplan^1,2 {andyb, simon}@dstc.edu.au School of Information Technology ¹ CRC for Distributed Systems Technology (DSTC)² The University of Queensland Australia

Introduction

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:

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 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.

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 including:

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.

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.

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:

Binding:	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.
Role:	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.
Interface:	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 fills.
Events:	components participate in a binding (interact) by executing events at their interfaces. Events have parameters and direction (in or out).
Event relationships:	event relationships specify the behaviour and interactions of a binding by describing the relationships between events occurring at object interfaces.

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.

Behavioural Model

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:

Causal relationships	which describe the causal dependencies between events;
Parameter relationships	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 manner;
Timing relationships	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.

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.

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;

Conclusions

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.

Bibliography

Allen95	R. Allen and D. Garlan, Formalizing Architectural Connection. Proceedings 16th International Conference on Software Engineering, IEEE, May 1994.
Andrews91	G. Andrews, Paradigms for Process Interaction in Distributed Programs ACM Computing Surveys, 23(1), March 1991
Arbab96	F. Arbab, The IWIM Model for Coordination of Concurrent Activities. Coordination Languages and Models, LNCS 1061, Springer, 1996
Berry98	A. Berry and S. Kaplan, Open, Distributed Coordination with Finesse. Accepted for ACM Symposium on Applied Computing, Atlanta, February 1998
Holzbacher96	A. Holzbacher, A software environment for concurrent coordinated programming. Coordination Languages and Models, LNCS 1061, Springer, 1996.
Luckham95	D. Luckham and J. Vera, An event based architecture definition language. IEEE Transactions on Software Engineering, September 1995.
Rakotonirainy97	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.
Shaw94	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
Shaw96	M. Shaw and D. Garlan. Software Architecture: Perspectives on an emerging discipline, Prentice Hall, 1996.