Thorsten Keuler

Architecture compliance checking at run-time

In this paper, we report on our experiences with architecture compliance checking - the process of checking whether the planned or specified software architecture is obeyed by the running system - of an OSGi-based, dynamically evolving application in the office domain. To that end, we first show how to dynamically instrument a running system in the context of OSGi in order to collect run-time traces. Second, we explain how to bridge the abstraction gap between run-time traces and software architectures, through the construction of hierarchical Colored Petri nets (CP-nets). In addition, we demonstrate how to design reusable hierarchical CP-nets. In an industry example, we were able to extract views that helped us to identify a number of architecturally relevant issues (e.g., architectural style violations, behavior violations) that would not have been detected otherwise, and could have caused serious problems like system malfunctioning or unauthorized access to sensitive data. Finally, we package valuable experiences and lessons learned from this endeavor.

A light-weight load-time weaving approach for OSGi

In the context of dynamic, component-based systems, the OSGi platform (Open Standard Gateway Initiative) supports the dynamic deployment of software services in form of so-called bundles. Since aspect-oriented programming offers facilities for managing crosscutting code adaptations efficiently, OSGi needs to be equipped with that kind of capabilities. Existing approaches (e.g. JBOSS-AOP) for aspect-oriented programming, however, have to be adapted due to restricted class visibility within OSGi. To that end, approaches that are intended to be used with OSGi have to be supported in terms of physically separating aspect code from concrete pointcut implementations. Existing efforts that aim at integrating AOP technology with OSGi have shown some insufficiencies. Some even require the OSGi specification to be extended. In this paper, we show a concept that enables a light-weight integration of AOP by enabling customized load-time weaving within OSGi without having to change the platform at all.

Architecture Compliance Checking at Runtime: An Industry Experience Report

In this paper, we report on our experiences we made with architecture compliance checking at run-time. To that end, we constructed hierarchical colored Petri nets (CP-nets), using existing general purpose functional programming languages, for bridging the abstraction gap between architectural views and run-time traces. In an industry example, we were able to extract views that helped us to identify a number of architecturally relevant issues (e.g., style constraint violations) that would not have been detected otherwise. Finally, we demonstrate how to systematically design reusable hierarchical CP-nets, and package valuable experiences and lessons learned from the example application.

Efficient Quality Impact Analyses for Iterative Architecture Construction

In this paper, we present an approach that supports efficient quality impact analyses in the context of iteratively constructed architectures. Since the number of established architectural strategies and the number of inter-related models heavily increase during iterative architecture construction, the impact analysis of newly introduced quality strategies during later stages becomes highly effort-intensive and error-prone. With our approach we mitigate the effort needed for such quality impact analyses by enabling efficient separation of concerns. For achieving efficiency, we developed an aspect-oriented approach that enables the automatic weaving of quality strategies into architectural artifacts. By doing so, we are able to conduct selective quality impact evaluations with significantly reduced effort.

Architecture Engagement Purposes: Towards a Framework for Planning "Just Enough"-Architecting in Software Engineering

Software architecture has been proven as a conceptual tool to manage the development and evolution of a software product. However, integrating architecting as an activity in software engineering is still perceived as a major challenge in practice. Our observation from many projects centered around architecture is that most organizations actually fail to plan architecting activities and align them in product development. The consequence is that the value of the architecture is underrated and the power of architecture remains more often than not unexploited. In this paper, we introduce the notion of architecture engagement purpose -- an auxiliary construct to align architecting with other engineering activities in the product lifecycle. We gained first promising results in applying it in industrial projects, where explicit architecture engagement purposes enabled the organization in planning and tracking architecting as an activity within their software engineering.

Recovering Component Dependencies Hidden by Frameworks--Experiences from Analyzing OSGi and Qt

In this paper we present experiences we made in the identification and analysis of software dependencies in the context of two popular software development frameworks: OSGi and Qt. Both frameworks are designed for minimizing coupling between software entities by enabling late binding. In case of OSGi, it is the service-oriented bundle concept, in Qt it is the signals and slots mechanisms, that hide dependencies from the programmer at development-time. However, in order to keep an overview of the system it is mandatory to reveal a bigger picture in terms of components and their connections as they are going to exist during runtime. In this paper, we elaborate on the experiences we made in dependency identification and analysis in the context of an industrial and an academic project. In particular, we show how the framework mechanisms of Qt and OSGi can be analyzed in order to reveal a systems component dependencies without having to execute the software.

Efficient implementation of intelligent office appliances with software product lines

To support the handling of documents in organizations, office appliances have to adapt to the work processes of that organization. To efficiently handle changes in the software imposed by these adaptations, we present an approach to use business process models to compose the basic features of an office appliance into customer-oriented, process-specific services offered by office devices. Software product lines shape the key concepts that enable cost-effective and therefore realistic implementations of the ideas presented.

Leichtgewichtige Traceability im agilen Entwicklungsprozess am Beispiel von Scrum

Motivation Einer der wichtigsten Erfolgsfaktoren der agilen Softwareentwicklung ist die schnelle und unkomplizierte Verteilung von Informationen. Dabei reicht das Spektrum der Informationsverteilung von einfachen Dokumenten uber Wikis, Videos und Telefonaten bis hin zum “Face-to-Face” Gesprach. In der traditionellen Softwareentwicklung lag der Fokus typischerweise auf einer dokument-basierten Erfassung und Verteilung von Informationen. Explizite Dokumentation beruht auf der Annahme, dass sich die festgehaltenen Informationen nur in bestimmtem Mase andern. Da dieser Umstand insbesondere in der Softwareentwicklung nicht automatisch gegeben ist, hat man dies im Kontext der agilen Vorgehensweisen als ein Kernproblem von schwergewichtigen Prozessen identifiziert. Als Konsequenz dazu wird in der agilen SoftwareEntwicklung der Umfang der Dokumentation minimiert. Dies spiegelt sich im Manifest fur Agile Software-Entwicklung wider (s. agilemanifesto.org): Obwohl die umfassende Dokumentation als wichtig erachtet wird, wird der Wert funktionierender Software hoher eingeschatzt. Nach den zwolf inizialen Prinzipien hinter dem Agilen Manifest gilt die direkte personliche Ubermittlung als effizientestes und effektivstes Verfahren. Funktioniert diese Kompensation besonders gut solange die Entwickler moglichst nah zusammen arbeiten, so ergeben sich jedoch Herausforderungen beim Versuch, agile Entwicklung in mehreren Teams und Standorten zu realisieren. Insbesondere fehlt es in der aktuellen Praxis an Techniken, welche die Dokumentation und Traceability der Entwicklungsartefakte optimal unterstutzen. Somit kann es in der Praxis vorkommen, dass Anforderungen oder Entwurfsentscheidungen dem Rest des Teams nicht mitgeteilt werden und diese Wissenslucke die weiteren Implementierungsund Testaktivitaten negativ beeinflusst.

Interaction-sensitive synthesis of architectural tactics in connector designs

During architectural design, the architect has to come up with architectural structures and tactics that aim at the fulfillment of quality attribute requirements. Architectural structures are built from components are supposed to interact. Since connector types typically crosscut connector designs and demand for modularized treatment during architecture design. The synthesis of tactics withing connector designs, however, turns out to be a major challenge. This is due to the fact that they are likely to affect each other in the final system where they need to be mutually integrated. This mutual affection is called tactic interaction. In this paper, we describe an approach towards detecting such tactic interactions during connector design.Our approach is integrated in a commercial architecture design tool supporting interaction-sensitiv synthesis of architectural tactics during connector design activities.

An aspect-oriented approach for improving architecture design efficiency

Major issues in software engineering today are the ever increasing size and complexity of systems with, at the same time, high demands for quality. Software architectures are a means for coping with size and complexity of systems and also for assuring required qualities. The processes of creating architectures, however, remain affected by these issues. Since, in practice, architectures have to be constructed iteratively, the number of established architectural strategies and the number of inter-related models heavily increase over time. Hence, the impact analysis of newly introduced quality strategies during later stages becomes highly effort-intensive and error-prone. With our approach we aim at the mitigation of effort needed for such quality impact analyses by enabling efficient separation of concerns. For achieving efficiency, we introduce an aspect-oriented approach that enables the automatic weaving of quality strategies into architectural artifacts. By doing so, we are able to conduct selective quality impact evaluations with significantly reduced effort.