Please use this identifier to cite or link to this item: http://dx.doi.org/10.14279/depositonce-1203
Main Title: Tracing Crosscutting Requirements for Component-Based Systems via Context-Based Constraints
Translated Title: Handhabung von Querschnittsanforderungen an komponentenbasierte Systeme mit Hilfe von Context-Based Constraints
Author(s): Buebl, Felix
Advisor(s): Weber, Herbert
Granting Institution: Technische Universität Berlin, Fakultät IV - Elektrotechnik und Informatik
Type: Doctoral Thesis
Language: English
Language Code: en
Abstract: Bei der Anpassung eines Softwaresystems an neue Anforderungen sollten bestehende Anforderungen nicht versehentlich verletzt werden. Bei komplexen oder sich häufig ändernden Systemen verlieren wir jedoch leicht den Überblick darüber, welches Systemelement welche Anforderung umsetzt. Besonders unübersichtlich sind Querschnittsanforderungen, welche von mehr als einem Systemelement umgesetzt werden. Diese Dissertation schlägt eine neue Art von Constraints vor, um Querschnittsanforderungen (engl: Cross-Cutting Concerns) ausdrücken und ihre Einhaltung überwachen zu können: ein Context-Based Constraint (CoCon) kann die betroffenen Elemente des Systems anhand ihrers Kontextes erkennen. Die hier definierte Context-Based Constraint Language CCL besteht aus 22 verschiedenen Arten von CoCons zur Beschreibung von Anforderungen an komponenten-basierte Systeme in folgenden Bereichen: Access Permission CoCons beschreiben, wer auf was (nicht) zugreifen darf. Distribution CoCons legen fest, welche Komponenten (nicht) auf welchen Rechnern verfügbar sind. Information Need CoCons spezifizieren, wer über was (nicht) informiert wird. Communication CoCons beschreiben, auf welche weise Aufrufe zwischen Komponenten (nicht) erfolgen. Und schließlich definieren Inter-Value CoCons Abhängigkeiten zwischen den Context Property Werten eines Elements. Im Rahmen einer Softwareentwicklung entstehen verschiedene Artefakt, wie etwa Modelle, Source Code oder Laufzeitkomponenten. CoCons formulieren abstrakte Anforderungen unabhängig von Artefakt-Typen. Daher ermöglichen es CoCons, Softwaresysteme sowohl während ihrer Modellierung, während ihrer Konfiguration als auch zur Laufzeit auf die Einhaltung von Anforderungen zu überwachen. Diese Dissertation beschränkt sich auf die Anwendung von CoCons während der Modellierung mit UML. Algorithmen zum Entdecken von verletzten oder widersprüchlichen CoCOns werden vorgestellt. Anders als bei OCL Constraints kann ein Modell auf die Einhaltung von CoCon überwacht werden, ohne das im Modell spezifizierte System zu starten oder zu simulieren. Daher können mit CoCons schon früh im Entwicklungsprozess Systeme auf die Einhaltung von Querschnittsanforderungen geprüft werden. Bisherige Constraints werden direkt an die betroffenen Element annotiert. Es ist aufwendig, eine viele Elemente betreffende Querschnittsanforderung an jeder zugehörigen Stelle zu annotieren. Im Gegensatz dazu werden die von einem CoCon betroffenen Elemente indirekt anhand ihrer Context Properties identifiziert. Dadurch kann ein CoCon eine Anforderungen für möglicherweise zahlreiche, sich häufig verändernde Elemente beschreiben – sogar über Plattform- oder Modellgrenzen hinweg. Daher eignen sich CoCons insbesondere dafür, große oder sich häufig ändernde Systeme während der Modellierung, der Konfiguration oder zur Laufzeit auf die Einhaltung von Anforderungen zu überwachen.
We often fail to keep track of requirements in complex software systems because we cannot cope with all the details – in particular, it is expensive to check a system for compliance with crosscutting requirements where one requirement affects several parts of the system. In order to detect requirement violations, each system element involved in a requirement must be identified and checked for whether it meets the requirement. But, it is difficult to identify which system element is involved in which requirement in complex or frequently changing software systems. In this thesis, I specify crosscutting requirements via constraints in order to automatically check the system for compliance and to automatically identify contradicting requirements. I present a new notion of constraints: a context-based constraint (CoCon) expresses a condition on how its constrained elements must relate to each other. CoCons are adaptive in order to cope with complex system: A CoCon can identify the system elements affected by the requirement automatically because it can indirectly select its constrained elements according to their context. Five different CoCon families for component-based systems are discussed: Access Permission CoCons express which components must (or must not) be accessible to which other components. Communication CoCons control whether a method call between components must be (or must not be) intercepted. Distribution CoCons express which components must (or must not) be allocated to which computers. Information-Need CoCons express which users must (or must not) be notified of which documents. Finally, Inter-Value CoCons express whether an element in a certain context must (or must not) reside in another context. This thesis focuses on applying CoCons in UML models of component-based systems. I present algorithms for detecting both violated and contradicting CoCons automatically. Inter-CoCon conflicts can even be detected if the precise semantics of the checked system artefact are unknown. Moreover, CoCons support the design of software systems from the start of the development process. In contrast to OCL constraints, CoCons specified during modelling can already be checked during modelling at the same metalevel. Hence, the model can be checked for violated or contradicting CoCons already during modelling. CoCons enable us to handle crosscutting requirements for possibly large, overlapping and dynamically changing sets of system elements - even across different artefact types or platforms. Writing down a requirement directly for each individual element involved in each system artefact is expensive in complex systems. Instead, a CoCon automatically constrains those elements whose context properties match with the CoCon's context condition. Hence, CoCons facilitate checking large-scale or frequently changing systems for compliance with crosscutting requirements during (re-)design, during (re-)configuration, and at runtime.
URI: urn:nbn:de:kobv:83-opus-11062
http://depositonce.tu-berlin.de/handle/11303/1500
http://dx.doi.org/10.14279/depositonce-1203
Exam Date: 22-Jun-2005
Issue Date: 11-Oct-2005
Date Available: 11-Oct-2005
DDC Class: 004 Datenverarbeitung; Informatik
Subject(s): Entwurf von Softwaresystemen mit UML
Nichtfunktionale Anforderungen
Querschnittsanforderungen
Softwaretechnik
Cross-Cutting Concerns
Requirements Engineering
Software Engineering
UML
Usage rights: Terms of German Copyright Law
Appears in Collections:Technische Universität Berlin » Fakultäten & Zentralinstitute » Fakultät 4 Elektrotechnik und Informatik » Institut für Softwaretechnik und Theoretische Informatik » Publications

Files in This Item:
File Description SizeFormat 
Dokument_9.pdf4.15 MBAdobe PDFThumbnail
View/Open


Items in DepositOnce are protected by copyright, with all rights reserved, unless otherwise indicated.