Fraunhofer-Gesellschaft

Publica

Hier finden Sie wissenschaftliche Publikationen aus den Fraunhofer-Instituten.

A framework for developing component-based co-operative applications

 
: Tietze, D.A.

:
urn:nbn:de:0011-b-729856 (1.7 MByte PDF)
MD5 Fingerprint: d2b0df625aacf64b0eafb31d1b1363f1
Created on: 24.07.2002


Sankt Augustin: GMD Forschungszentrum Informationstechnik, 2001, 178 pp.
Zugl.: Darmstadt, TU, Diss., 2001
GMD research series, 2001,7
ISBN: 3-88457-390-X
English
Dissertation, Electronic Publication
Fraunhofer IPSI; 2007
computer-unterstützte Gruppenarbeit; CSCW; Groupware Framework; verteilte Systeme; Anpassbarkeit; Erweiterbarkeit; computer supported cooperative work; component-based software development; distributed systems; tailorability; extensibility

Abstract
In today's work environment we are faced with the increasing need to perform tasks and tackle problems cooperatively, in a team. This need is driven, e.g., by the trend towards growing distribution of teams, such as in the context of virtual organizations or extended enterprises, task-specific groups of companies or divisions, working together in a shared project, on the completion of a common product. The goal of CSCW (Computer-Supported Cooperative Work) research is the design and development of systems (often referred to as groupware systems) that support communication, coordination and cooperation between the team members involved in a group process. Groupware systems enable a distributed group of users to collaboratively work on shared objects (documents,etc.). Many of the cooperative work processes which are conducted in these teams are evolving over time and require the support technology to exhibit a high degree of flexibility and tailorability. As work processes evolve,the supporting groupware needs to be adapted to the changing needs and requirements. In this context, we are faced with the need for groupware applications that are not closed and monolithic, but which can be dynamically extended, also by the end-users, in order to adapt the tools to the changing requirements. This thesis aims to provide support for such flexible groupware. One way of developing flexible, modular systems is component-based software development, where systems are constructed from reusable software components, which can be adapted and combined as required. The development of such components is often based on an underlying component framework, which governs the way in which components are created and later combined with each other. The goal of this thesis is to aid the use and development of extensible componentbased groupware systems. This requires the design and development of a component framework, which provides support for the flexible coupling of the components and for dynamic distribution of the components. End-users need to be supported in locating and retrieving the components that they require for their current task. Additionally, the framework needs to support end-users as well as groupware developers in adapting the collaboration support environment to the changing demands. The thesis introduces Groupware Components as the basis for the development of flexible, adaptable groupware systems. Groupware Components are visually interactive components which allow groups of users to collaboratively view and modify shared data objects. Groupware Components can be coupled and assembled into comprehensive collaboration support environments. The resulting collaboration support environments are dynamically extensible: New components can be added to the running system and can immediately be used collaboratively on all connected machines. The coupling of Groupware Components is based on a common shared domain object model, which is dynamically replicated in the distributed system. One problem which needs to be tackled when building flexible component-based collaboration support systems is how to support end-users and developers in finding and retrieving the components required for a specific task. When introducing new components into the system,the previously available components need to be able to access and invoke these new components, without the need to modify the older components. In order to support this, the thesis introduces a programming model termed task-based development. In this model, components publish tasks which can be performed on instances of a shared object model. This task information can be queried by the component server and can be used to determine the required component for a certain activity to be performed on a specific shared object. The tasks can be invoked either interactively by the end-users or by component implementations, leading to an invocation of the related components. In this way, flexible (loose) bindings between components are possible, which allow the collaboration support system to by dynamically extended and reconfigured.The task-based programming model and the separation between component and domain model implementation also allow the coupling of different components (e.g., for different tasks or roles in the collaborative process) on the same shared data objects. End-user tailorability of the collaboration support environment is supported by an interactive composition tool, which allows the combination of components into so-called configurations. These configurations can be deployed via the server and can be used collaboratively right away. This creation of configurations is also based on the taskbased programming model, which serves as the central unifying abstraction underlying the components in the DyCE framework. When developing component-based environments, developers need to communicate their design ideas with each other. In order to support the design of component-based groupware, the thesis introduces a number of extensions to the Unified Modeling Language (UML), which allow developers to create design diagrams which specify issues relevant to component-based groupware, such as component distribution, task bindings, sessions, etc. The development of Groupware Components is supported by the development framework DyCE (Dynamic Collaboration Environment), which has been implemented in Java. The DyCE framework has been used in a number of research projects for developing a wide range of Groupware Components. A number of this components are presented, along with the experiences gathered in the course of their development.

 

Unsere tägliche Arbeitswelt ist zunehmend geprägt von der Notwendigkeit, in Teams gemeinsam Probleme zu bearbeiten und Aufgaben zu lösen. Diese Notwendigkeit ergibt sich z.B. durch den wachsenden Trend zu orts-und zeit-übergreifenden Kooperationsprozessen, z.B. im Kontext Virtueller Organisationen, durch aufgabenbezogene Firmen- oder Abteilungsverbünde, die mit dem Ziel einer gemeinsamen Projektdurchführung oder Produkterstellung auf Zeit zusammenarbeiten. Inhalt der Forschungsrichtung CSCW (Computer-Supported Cooperative Work)ist die Erforschung und Entwicklung von Systemen (sog.Groupware), welche die Kommunikation, Koordination und Kooperation zwischen an Gruppenprozessen beteiligten Team- Mitgliedern adäquat unterstützen. Groupware-Systeme ermöglichen es räumlich oder in der Zeit verteilten Gruppen von Benutzern, miteinander an gemeinsamen Objekten (Dokumente, etc.) zu arbeiten. Die kooperativen Arbeitsprozesse, die in diesen Teams durchgeführt werden, erfordern hierbei ein großes Maß an Flexibilität und Gestaltungmöglichkeiten. In dem Maß, wie sich die Kooperationsprozesse über die Zeit entwickeln, müssen sich die Arbeits-und Kooperationsumgebungen diesen geänderten Erfordernissen anpassen. In diesem Zusammenhang wird es wichtig, kooperative Anwendungen zu entwickeln, welche nicht monolithisch und geschlossen sind, sondern welche sich dynamisch - von den Anwendern - erweitern lassen, um die Arbeitsumgebungen an sich weiterentwickelnde Projektanforderungen anzupassen. Hierzu soll die vorliegende Arbeit einen Beitrag leisten. Ein Weg, flexible und modular erweiterbare Systeme zu konstruieren, ist der komponenten-basierte Ansatz. Die Entwicklung komponentenbasierter Anwendungen erfolgt oft auf der Basis eines Entwicklungs-Frameworks. Ein solches Framework definiert das den Komponenten zugrundeliegende Komponentenmodell ebenso wie die Art und Weise, in der die Komponenten miteinander verbunden werden können. Ziel der vorliegenden Arbeit ist es, die Realisierung komponentenbasierter kooperativer Anwendungen zu unterstützen. Dies erfordert den Entwurf und die Realisierung eines Entwicklungs-Frameworks, welches die Entwicklung kooperativer Komponenten erlaubt. Innerhalb dieses Frameworks sind Mechanismen für die Kopplung der kooperativen Komponenten ebenso vorzusehen wie für die dynamische Verteilung der Komponenten. Endbenutzern muss die Suche nach und der Zugriff auf solche kooperativen Komponenten erm ¨oglicht werden. Darüber hinaus sollen sich die auf Basis des Frameworks entwickelten Komponenten von Endbenutzern kombinieren und an so die Kooperationsumgebung ihre aktuellen Aufgabenanforderungen anpassen lassen. In der vorliegenden Arbeit werden für die Realisierung flexibler kooperativer Umgebungen kooperative Komponenten mit dem Namen Groupware Components vorgestellt. Groupware Components sind visuell interaktive Komponenten, welche mehreren Benutzern die kooperative Anzeige und Modifikation gemeinsamer Objekte ermöglichen. Auf der Basis eines gemeinsamen Objektmodells lassen sich diese Komponenten miteinander koppeln und zu umfassenden kooperativen Anwendungen zusammenstellen. Für die Entwicklung von Groupware Components wurde das Java-Framework DyCE (Dynamic Collaboration Environment) realisiert, welches in der Arbeit vorgestellt wird. Grundlage der Groupware Components ist die Trennung zwischen Komponentenimplementierung und Datenmodell. Für die Entwicklung des objektorientierten anwendungsbezogenen Datenmodells (domain data model)werden in Form eins Metamodells Klassen im Entwicklungsframework bereitgestellt, welche von den Entwicklern entsprechend erweitert werden müssen. Die von den Komponenten gemeinsam genutzten Datenobjekte werden im verteilten System dynamisch repliziert und mittels transaktionsbasierter Modifikationen in einem konsistenten Zustand gehalten. In der Arbeit wird ein Transaktionsmodell und eine Realisierung in Java vorgestellt, welches Konflikte, die bei gleichzeitigen Modifikationen der gemeinsamen Datenobjekte entstehen, erkennen lässt und diese Konflikte mittels selektivem Undo und partieller Neu-Replikation auflöst. In der Arbeit wird des weiteren ein objektgebundener Ereignis-Verteilungs-Mechanismus präsentiert, der dazu dient, Gruppen von Komponenten mittels Ereignissen zu koppeln, die sich nicht direkt auf den gemeinsamen Objektzustand auswirken. Die realisierten Groupware Components werden in einem Server gespeichert und verwaltet, von dem sie zur Laufzeit von den Benutzern abgerufen werden können. Neu entwickelte Groupware Components lassen sich in den Komponenten-Server einfügen (registrieren) und stehen unmittelbar an allen angeschlossenen Clients für den Einsatz in kooperativen Arbeitsprozessen zur Verfügung. Auf diese Weise lassen sich die Kooperationsumgebungen dynamisch zur Laufzeit um neue Werkzeuge erweitern. Eine spezielle Unterklasse der Groupware Components erlaubt die Ausführung einer Komponente auf dem Server. Server-seitige Komponenten erleichtern die Realisierung solcher kooperativen Arbeitsumgebungen, in denen einige Aufgaben nicht sinnvoll von einem bestimmten Client (oder allen Clients) ausgeführt werden können, z.B. weil ihre Ausführung nicht an einen bestimmten Nutzer oder eine bestimmte Nutzergruppe gekoppelt ist, sondern auch geschehen soll, wenn keine Benutzer eingeloggt sind. Beispiele für solche Server-seitigen Komponenten sind Work flow Enactment Engines, welche auf dem Server unabhängig von einem speziellen Client ausgeführt werden können und den Fortgang der Work flow-Prozesse steuern. Die Server-seitigen Komponenten können hierbei, wie alle Komponenten, mit den gemeinsamen Daten interagieren und diese modifizieren. Ein Problem, welches bei der Realisierung flexibler kooperativer Anwendungen auf Basis gemeinsam genutzter Objekte zu lösen ist, ist das Auffinden von und der Zugriff auf die für die kooperativen Aufgaben zu verwendenden Komponenten. Hierbei müssen auch bereits existierende Komponenten auf neu registrierte Komponenten zugreifen können, ohne dass an ihnen nachträgliche Änderungen erforderlich sind. Grundlage hierfür ist das in dieser Arbeit vorgestellte Programmiermodell der Aufgabengestützten Entwicklung ("task-based development"). Eine Komponente greift hierbei nicht direkt auf andere Komponenten zu und sie wird auch nicht direkt aufgerufen. Vielmehr publizieren alle Komponenten sogenannte "Tasks", welche sie auf Objekten des gemeinsamen Objektraumes ausführen können. Tasks können dann sowohl von Komponenten selbst als auch durch Benutzeraktionen (z.B. durch Auswahl des gewünschten Tasks aus einem Auswahlmenü in der Benutzungsschnittstelle) ausgeführt werden. Sie dienen zur Laufzeit dazu, die benötigte Komponente für die kooperative Arbeit an einem gemeinsam genutzten Objekt zu ermitteln. Für die Kooperation unter Verwendung mehrerer verschiedener Komponenten werden laufende Tasks in Kooperationssitzungen (Sessions)zusammengefasst. Wird in einer Session eine Task auf der Instanz einer Klasse des Anwendungsmodells ausgeführt, so ermittelt der ComponentBroker im Server aus den Informationen im Task-Modell die benötigte Komponente. Die Komponentenimplementierung wird dynamisch zu allen in der Session zusammengefasst Clients übertragen und dort instanziiert. Das objektorientierte Task-Modell wird in der Arbeit zusätzlich um Informationen über die verwendeten Endgeräte und die jeweiligen Benutzer ergänzt. Auf diese Weise können Komponentenentwickler Tasks publizieren, welche z.B. nur bei Verwendung bestimmter Endgeräte ausgeführt werden können. Je nach verwendeter Infrastruktur wird für die Ausführung einer Task unterschiedliche Komponenten ermittelt. Diese Komponenten können allerdings auf denselben Daten operieren und die komponenten übergreifende Kooperation erlauben. Dies ermöglicht die Realisierung spezieller Komponenten (z.B. mit einer angepassten Benutzungsschnittstelle) für die Verwendung auf mobilen Endgeräten (PDAs). Im Rahmen der Softwareentwicklung ist es von besonderer Bedeutung, dass die Entwickler in der Lage sind, ihre Entwürfe miteinander zu besprechen und als Bestandteil der Projektdokumentation festzuhalten. Zu diesem Zwecke werden Entwurfsnotationen wie die UML (Unified Modeling Language) mit definierter Syntax und Semantik verwendet. Die Arbeit schlägt eine UML-basierte Entwurfsnotation für den Entwurf kooperativer komponentenbasierter Systeme vor. Die Elemente der Entwurfsnotation verwenden hierbei eine der in UML vorgesehenen Möglichkeiten, die UML-Notation zu erweitern: die sogenannten Stereotype. Es werden für den Entwurf kooperativer Systeme auf Basis des DyCE-Framework Stereotype für Elemente des gemeinsamen Objektmodells, für die kooperierenden Komponenten und für die Beschreibung von laufenden Kooperationsitzungen vorgeschlagen und in der Arbeit für die Beschreibung der präsentierten Konzepte verwendet. Eine wichtige Anforderung an flexible Groupware ist, dass sich die kooperative Anwendung an die Anforderungen der Benutzer anpassen lässt. Eine Form der Unterstützung, die in dieser Arbeit präsentiert wird, ist die Erweiterung der Arbeitsumgebung um zusätzliche Komponenten sowie der dynamische Zugriff auf Groupware Components. Die zweite Form der Unterstützung, die im DyCE-Framework realisiert ist, ist die Bereitstellung eines Werkzeugs, mit dem Endbenutzer vorhandene Komponenten auf grafisch interaktive Weise miteinander kombinieren können. Die auf diese Weise entstandenen Konfigurationen von Komponenten können wiederum über den Server verteilt und kooperativ mit anderen Benutzern verwendet werden. Die Grundlage für die Kombination der Komponenten bildet ebenfalls das Aufgabengestützte Programmiermodell. Das Anpassungswerkzeug bietet den Benutzern interaktiven Zugriff auf das Task-Modell. Instanzen des anwendungsspezifischen Objektmodells lassen sich in diesem Werkzeug zu komplexeren Datenmodellen kombinieren und die auf den Elementen dieses Modells auszuführenden Tasks können interaktiv ausgewählt werden. Wird eine solche Konfiguration, bestehend aus Datenmodell-Instanzen und zugehörigen Tasks, später im Rahmen einer kooperativen Sitzung verwendet, erhalten alle Benutzer in der Sitzung die kombinierten Komponenten sowie die spezifizierten Instanzen des Objektmodells. Auf diese Weise können elementarere Komponenten auf einfache Weise miteinander zu komplexen Funktionalitäten kombiniert und kooperativ verwendet werden. Das in der Arbeit vorgestellte Entwicklungsframework DyCE wurde im Rahmen einiger Forschungsprojekte zur Realisierung mehrerer kooperativer Komponenten eingesetzt. In der Arbeit werden einige dieser Komponente sowie die bei ihrer Entwicklung gesammelten Erfahrungen vorgestellt. Die bei der Entwicklung der Komponenten gemachten und in der Arbeit zusammengefassten Erfahrungen zeigen, dass die komponentenbasierte Entwicklung kooperativer Anwendungen die Verteilung der Aufgaben zwischen mehreren Entwicklern gut unterstützt. Darüber hinaus gewinnen alle auf Basis von DyCE entwickelten Komponenten durch das Hinzufügen neuer Komponenten an Flexibilität und Funktionalität. Die so entwickelten Komponenten lassen sich, ohne vorheriges Wissen voneinander, um andere Komponenten erweitern. So entstehen umfangreiche kooperative Arbeitsräume, in denen Gruppenarbeitsprozesse auf vielfältige Weise durchgeführt werden können.

: http://publica.fraunhofer.de/documents/B-72985.html