Mads Ingstrup

Exploring quality attributes using architectural prototyping

A central tenet of software architecture design is to base this on a formulation of desired quality attributes, such as buildability, performance, and availability of the target system. Thus there is a need for architectural evaluation—ensuring the architecture’s support for desired quality attributes—and a variety of evaluation techniques have been developed, described, and used. Architectural prototyping is an experimental approach that creates executable ‘skeleton’ systems to investigate architectural qualities of a future system. Architectural prototyping is a learning vehicle for exploring an architectural design space as well as an evaluation technique. The contribution of this paper is to explore the evaluation aspect of architectural prototypes from an analytical standpoint. We present an analysis and discussion of architectural prototyping in the context of two well-established quality frameworks. Our analysis concludes that architectural prototyping is a viable evaluation technique that may evaluate architectural quality attributes and especially valuable in cases where the balance between opposing qualities must be assessed.

Modeling and analyzing architectural change with alloy

Although adaptivity based on reconfiguration has the potential to improve dependability of systems, the cost of a failed attempt at reconfiguration is prohibitive in precisely the applications where high dependability is required. Existing work on formal modeling and verification of architectural reconfigurations partly achieve the goal of ensuring correctness, however the formalisms used often lack tool support and the ensuing models have uncertain relation to a concrete implementation. Thus a practical way to ensure with formal certainty that specific architectural changes are correct remains a barrier to the uptake of reconfiguration techniques in industry. Using the Alloy language and associated tool, we propose a practical way to formally model and analyze runtime architectural change expressed as architectural scripts. Our evaluation shows the performance to be acceptable; our experience that the modelling language is convenient and expressive, and that our model accurately repesents the implementation it is used to reason about.

A Genetic Algorithms-Based Approach for Optimized Self-protection in a Pervasive Service Middleware

With increasingly complex and heterogeneous systems in pervasive service computing, it becomes more and more important to provide self-protected services to end users. In order to achieve self-protection, the corresponding security should be provided in an optimized manner considering the constraints of heterogeneous devices and networks. In this paper, we present a Genetic Algorithms-based approach for obtaining optimized security configurations at run time, supported by a set of security OWL ontologies and an event-driven framework. This approach has been realized as a prototype for self-protection in the Hydra middleware, and is integrated with a framework for enforcing the computed solution at run time using security obligations. The experiments with the prototype on configuring security strategies for a pervasive service middleware show that this approach has acceptable performance, and could be used to automatically adapt security strategies in the middleware.

Towards Self-Managed Executable Petri Nets

An issue in self-managed systems is that different abstractions and programming models are used on different architectural layers, leading to systems that are harder to build and understand. To alleviate this, we introduce a self-management approach which combines high-level Petri nets with the capability of distributed communication among nets. Organized in a three-layer goal management, change management, and component control architecture this allows for self-management in distributed systems. We validate the approach through the Flamenco/CPN middleware that allows for self-management of service-oriented pervasive computing systems through the runtime interpretation of colored Petri nets. The current work focuses on the change management and component control layers.

Modeling architectural change: Architectural scripting and its applications to reconfiguration

We detail the notion of architectural scripting (ASL) as a way to model the dynamic aspects of runtime and deployment-time software architecture. This is complementary to the ability of architecture description languages to model architectures statically in that we define scripting operations to modify architectures at runtime. The scripting operations have as verification of the approach been implemented in an interpreter bundle on the OSGi platform. This implementation is used in our self-management system for generating correct reconfiguration plans in a self-managed system.

A Declarative Approach to Architectural Reflection

Recent research shows runtime architectural reflection is instrumental in, for instance, building adaptive and flexible systems or checking correspondence between design and implementation. Moreover, experience with computational reflection in various branches of computer science shows that the interface through which the meta-information of the running system is accessed, and possibly modified, lies at the heart of designing reflective systems. This paper proposes that such an interface should be like a database: accessed through queries expressed using the concepts with which architecture is described. Specifically, our contributions are: (1) a presentation of the general idea of a query-based approach to architectural reflection, (2) a definition of an Architectural Query Language (AQL) in which perspectives on an architectural model can be expressed as queries, (3) a prototype of a system which both creates runtime models of specific distributed architectures and allow for evaluation of AQL queries on these models. We illustrate the viability of the approach in two particular applications of such a model: constraint checking relative to an architectural style, and reasoning about certain quality attributes of an architecture.

Beyond the Archive: Thinking CSCW into EHRs for Home Care

The current electronic health records (EHR) are not build to adequately support pervasive healthcare, but overcoming certain challenges could change that. In this paper we explicate that point by presenting results of applying participatory design to two scenarios: treating diabetic foot ulcers at home, and providing support for women during their pregnancy. In particular, the contributions of this paper are: (1) to explicate the diversity of the domain, and how this leads to complex issues in practice, (2) to present four particular issues that need to be addressed in the design of EHRs as found through application of participatory design in our two scenarios, (3) to establish promising approaches to handling those four issues, and (4) to present the core of a software architecture that supports these approaches

REST based service composition: Exemplified in a care network scenario

This paper presents an ongoing work developing and testing a Service Composition framework based upon the REST architecture named SECREST. A minimalistic approach have been favored instead of a creating a complete infrastructure. One focus has been on the systems interaction model. Indeed, an aim is to allow users in different healthcare scenarios to experiment with service composition to support highly individual and changing needs.