The UniForm
WorkBench is a tool integration framework offering its services in
Haskell. The following aspects of an
integration process are currently being supported:
-
Data Integration addresses the issue of sharing data between tools.
It is mainly provided by the Reposity Manager.
-
Control Integration is concerned with communication and inter-operation
among tools and between tools and the integration framework. It is provided
by the Subsystem Interaction Manager and the Integration Manager.
-
Presentation Integration addresses the issue of tool appearance
and user interaction, i.e. "Look and Feel". It is provided by the
User Interaction Manager.
You can find more at:
WorkBench Overview
The WorkBench has been designed along the guidelines of the ECMA Reference
Model , which outlines the abstract functionality required to support the
various dimensions of a tool integration process:
-
Platform Integration addresses the integration of tools running on distinct
hardware/software platforms.
-
Data Integration addresses the issue of sharing data between tools. It
is mainly provided by the Reposity Manager .
-
Control Integration is concerned with communication between tools and the
integration framework. It is provided by the Subsystem Interaction Manager.
-
Presentation Integration addresses the issue of tool appearance and user
interaction, i.e. "Look and Feel". It is provided by the User Interaction
Manager.
-
Process Integration is concerned with the functions between tools of the
environment and the end user, i.e. workflow management. It will be provided
by the Development Manager.
The ECMA reference model is also called the "ECMA Toaster Model", with
the integration services in the role of the toaster, and the various development
tools of the SDE in the role of the slices of bread. Together they form
a "well" or "half-baked" SDE, depending on the degree of integration achieved.
The UniForM WorkBench is an instantiation of the ECMA Reference Model.
The main design decision is that the WorkBench uses Haskell as its central
integration language, in other words as Glue-Ware. All components, be it
the generic services of the WorkBench or the individual development
tools, are given a Haskell interface. From then on the Subsystem
Interaction Manager is used to control the tools. The Repository Manager
serves as a persistent store for software objects (specifications,
proofs, test runs) and the User Interaction Manager for providing the user
interfaces to the integrated system. The User Interaction Manager
consists in turn of four components: Netscape, the graph visualization
system daVinci, Tk and Forest.
Concurrency ToolKit
The UniForM Concurrency ToolKit is a
library for concurrent programming in Haskell that extends Concurrent
Haskell with named threads, re-entrant monitors and a
message passing model inspired by Concurrent ML. The shared
memory abstractions extends Concurrent Haskell's concept of MVar's with
re-entrant mutex locks and re-entrant monitors. The message
passing paradigm offers events as first class composable values of type
EV that can be combined using guarded choice (e1
+> e2) and the event action combinator (e
>>>= a). The base events correspond, just as in CML, to synchronous
point-to-point communication over typed channels. Other abstractions
are then build on this kernel that provides time-outs, message queues,
futures and remote procedure calls (among others).
The Subsystem Interaction Manager
The WorkBench views an SDE as a reactive, event driven
system with events amounting to inter working between people (Development
Management), user interaction with tools (User Interaction Manager), interoperation
between tools (Subssytem Interaction Manager), and tool platform inter
function . The central component of this reactive system is the Subsystem
Interaction Manager which takes the role of the control component in a
reactive system architecture, whereas the individual tool components form
the environment of this reactive system. The external tools are controlled
through a number of virtual devices constructed with help of the Integration
Manager. The Subsystem Interaction Manager consists in turn of a network
of concurrently executing and communicating agents (aka interactors or
event listeners).
The Subsystem Interaction Manager provides a uniform approach
to event handling that entirely hides the source of the event by
using adaptors. Using the Subsystem Interaction Manager, it becomes
possible to provide base events in the style of Concurrent ML for user
interactions, tool inter-operations and change notifications
of the Repository Manager. The architecture is inspired by but
improves on existing approaches such as ToolBus and JavaBeans. It builds
upon the concept of:
-
Event Sources are external tool components that generate the events
of the integrated environment.
-
Event Sensors are small pieces of code set up to capture the events
of the environment, i.e. in terms of state polling sensors, file descriptor
readers or signal handlers.
-
Event Listeners that are concurrently executing threads of control
defining the logic of the application by synchronizing on event values
of type EV.
-
Event Adaptors that are interposed between the event sensors and
the event listeners, whose role it is to turn external events, independently
of their physical representation, into first class event values of type
EV, and to delegate such events, whenever they occur, to the relevant event
listeners of the application.
The event listeners, also known as interactors, have been inspired by the
actor model and provide a concept of iterative choice. A new interactor
that repeatedly listens to the events defined by e, can be created by calling
the interactor e command. The interaction pattern can be changed
later on to e' by calling become e'.
The Integration Manager
The UniForM WorkBench is an open ended integration framework. Existing
tools, such as type checkers, model checkers and theorem provers, just
to mention a few, can be made to cooperate by integrating them into the
framework. The first step towards such an integration is to provide
a Haskell encapsulation of the tool, which defines the data, services,
events and exceptions of the tool in terms of an abstract data type
Given this encapsulation, Haskell is from then on used as Glue-Ware
to provide the missing bits and pieces of code required to make the individual
tools work together.
The encapsulation task is supported by the Integration Manager which
provides a variety of utilities by which interoperability between foreign
tools and the WorkBench can be established. One of these integration utilities
is Haskell-Expect - a tool for wrapping Haskell interfaces around
loosely coupled, interactive Unix tools. It allows the Haskell program
to take control over the dialogue with the Unix tool, i.e. to emulate user
interactions, in the form of send commmand-receive response sequences.
Haskell-Expect has been inspired by, but improves on, the expect
utility for Tcl. We also use Green
Card - a foreign language interface by the Glasgow Functional
Programming Group, which can be used to wrap Haskell functions around existing
C libraries, thus providing an interoperability bridge to all kinds of
existing "C-Ware"
The User Interaction Manager
The User Interaction Manager provides features by which presentation integration
can be achieved in terms of a number of components:
-
Haskell-Tk is a concurrent, strongly typed and higher order encapsulation
of Tk that supports the definition of user dialogues. Haskell-Tk
is also the tool to use when one wants to wrap graphical user interfaces
around existing non graphic tools.
-
The graph visualization system daVinci and its corresponding encapsulation
in Haskell provide utilities to construct graph oriented, fully interactive
views such as version, configuration and process graphs.
-
The World Wide Web (WWW) interface provides a number of computations for
constructing HTML documents on the fly, such as hypertext views over the
repository.
The User Interaction Manager provides a fine grained support for
concurrency by treating graphical objects, such as widgets or daVinci graphs,
as reentrant monitors. All kinds of user interactions such as mouse button
clicks, keyboard presses, and menu invocations are furthermore defined
in terms of abstract event values of type EV. Even the events associated
with composite widgets, such as menus, are represented as first class event
values composed from the individual button events using the guarded choice
operator +>.
The User Interaction Manager is a strongly typed, higher order system
making use of Haskell type classes. Just as in object oriented GUI's, the
major bulk of functionality is laid out by an extensive class hierarchy.
The individual virtual devices, representing widgets such as buttons and
menus, are then established by straightforward instantiations of this class
hierarchy. This feature, combined with the fact that event values
are fully composable, means that new
composite widgets offering functionality at a higher level of abstraction
can be developed from existing ones. This feature has been exploited
to provide a toolkit that takes the expressive power far beyond the one
of the Tk Toolkit. Some archetypical user interface components of SDE's
can therefore be developed as reusable, generic ADT's, such as input form
widgets for editing Haskell record structures.
The Repository Manager
To appear
Applications
To appear
Development Team
The WorkBench has been developed within the UniForM project headed by Prof.
Bernd Krieg-Bruckner.
The team consists at the time of writing of:
Walter Norzel contributed, once upon a time, with a preliminary implementation
of the Concurrency ToolKit, and Carla Blanck Purper helped
with some of the lower level details of the daVinci encapsulation.
Some of the applications such as the Z-Workbench are furthermore done in
cooperation with C. Lüth, Kolyang, and B. Wolff.
Literature
C. Lüth, E. W. Karlsen, Kolyang,
S. Westmeier, B. Wolff:
HOL-Z in the UniForM WorkBench
- a Case Study in Tool Integration for Z.
Accepted for ZUM'98,
11th International Conference
of Z Users.
C. Lüth, E. W. Karlsen, Kolyang, S. Westmeier,
B. Wolff:
Tool Integration in
the UniForM WorkBench.
Accepted for TOOLS'98,
Workshop on
Tool Support for System Specification, Development, and Verification.
E. W. Karlsen:
The UniForM User Interaction Manager,
Technical Report,
University of Bremen,
March 10, 1998.
E. W. Karlsen:
The UniForM WorkBench - a Higher Order Tool Integration Framework,
(Draft)
Accepted for International
Workshop on Current Trends in Applied Formal Methods,
Boppard, Germany,
7-9 October, 1998.
E. W. Karlsen:
Integrating Interactive Tools using Concurrent Haskell and Synchronous
Events,
In ClaPF'97, 2nd Latin-American
Conference on Functional Programming,
La Plata, Argentina,
October 3-4, 1997.
E. W. Karlsen, S. Westmeier:Using
Concurrent Haskell to Develop User Interfaces over an Active Repository,
In IFL'97, Implementation
of Functional Languages 97,
St. Andrew, Scotland,
September 10-12, 1997.
E. W. Karlsen:The
UniForM Concurrency ToolKit and its Extensions to Concurrent Haskell,
In GFPW'97, Glasgow Functional
Programming Workshop 97,
Ullapool, Scotland,
September 15-17, 1997.
W. Norzel: Building Abstractions for Concurrent
Programming in Concurrent Haskell.
Master Thesis (in German),
FB3, University of Bremen,
April 1997.
Reference Manuals
E. W. Karlsen:
The UniForM Concurrency ToolKit, Version 0.1, Reference Manual,
Technical Report,
University of Bremen,
June 23, 1998.
E. W. Karlsen:
The UniForM Subsystem Interaction Manager, Version 0.1, Reference Manual,
Technical Report,
University of Bremen,
June 23, 1998.
E. W. Karlsen:
The UniForM User Interaction Manager, Version 0.2, Reference Manual,
Technical Report,
University of Bremen,
June 23, 1998.
Software
The WorkBench is currently under construction and consists off approximately
40 KLOC Haskell
and C code. This makes it the worlds second largest application of
Haskell - to the best of our
knowledge.
The first release of the WorkBench to appear soon will include:
-
the UniForM Concurrency ToolKit,
-
the Subsystem Interaction Manager,
-
the Haskell-Expect component of the Integration Manager,
-
the Haskell-Tk component of the User Interaction Manager,
-
the daVinci encapsulation of the User Interaction Manager.
Prerequisites
The WorkBench is currently running under Solaris using the Glasgow Haskell
Compiler, version 3.1.
The following software components must be installed in order to use
the UniForM WorkBench:
-
GHC 3.10 running
Concurrent Haskell.
-
The regexp library
of Meurig Sage.
-
H-PCTE
implementation of PCTE from the University of Siegen.
-
Tk version 8.0.
-
The graph visualization system daVinci
.
The following systems will be needed as well in the nearest future:
Acknowledgements
The WorkBench would not have seen the light, were it not for the achievements
of the Glasgow Functional Programming Group. The GHC Compiler,
Concurrent Haskell, the regexp utility, the Happy Parser Generator and
Green Card are all essential pre-requisites of the current WorkBench.
We are also pleased about the H-PCTE database from the the group
of Prof. Udo Kelter at the University of Siegen. Last but not least,
Michael Froehlich and Mattias Werner have contributed with daVinci,
and John Ousterhout (altthough he is probably not aware) by keeping Tk
a freely available system of Scriptics.