A Framework for Evaluating Model-Driven Self-adaptive Software Systems

In the last few years, Model Driven Development (MDD), Component-based Software Development (CBSD), and context-oriented software have become interesting alternatives for the design and construction of self-adaptive software systems. In general, the ultimate goal of these technologies is to be able to reduce development costs and effort, while improving the modularity, flexibility, adaptability, and reliability of software systems. An analysis of these technologies shows them all to include the principle of the separation of concerns, and their further integration is a key factor to obtaining high-quality and self-adaptable software systems. Each technology identifies different concerns and deals with them separately in order to specify the design of the self-adaptive applications, and, at the same time, support software with adaptability and context-awareness. This research studies the development methodologies that employ the principles of model-driven development in building self-adaptive software systems. To this aim, this article proposes an evaluation framework for analysing and evaluating the features of model-driven approaches and their ability to support software with self-adaptability and dependability in highly dynamic contextual environment. Such evaluation framework can facilitate the software developers on selecting a development methodology that suits their software requirements and reduces the development effort of building self-adaptive software systems. This study highlights the major drawbacks of the propped model-driven approaches in the related works, and emphasise on considering the volatile aspects of self-adaptive software in the analysis, design and implementation phases of the development methodologies. In addition, we argue that the development methodologies should leave the selection of modelling languages and modelling tools to the software developers.Comment: model-driven architecture, COP, AOP, component composition, self-adaptive application, context oriented software developmen

Criticality meets sustainability: Constructing critical practices in design research for sustainability

Sustainability requires a wider awareness of the changing conditions for design today – rather than focused solely on preserving nature or conserving energy, per se, this opens up for challenging assumptions about relations between design and society and for constructing new forms of critical practice. Tracing tendencies in conceptual and (post)critical design, this paper argues for further developing the critical discourse within design today and design research as an important arena for extending the ideological and artifactual production of such discourse to users and stakeholders. In relation to my own experiences within the Static! and Switch! design research programs, these perspective are anchored in conceptual, operational, and practical examples of critical practices applied in the area of energy awareness

Early aspects: aspect-oriented requirements engineering and architecture design

This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications

The style of the present: Karel Teige on constructivism and poetism

In this essay the Czech avant-gardist Karel Teige's dual program of Constructivism/Poetism is interrogated in the context of his own claim that architectural historicism was degraded by the rupture into a duality of structure and ornament. This inability to escape the terms of his own critique is shown to be the result of Teige's articulation of avant-garde culture as the embodiment of the historical identity or style of the present. (c) 2005 The Regents of the University of California. All rights reserved

Towards a theory of software engineering

A theory of software engineering (SE) is presented and its application to explaining and analysing SE situations is illustrated. The theory is based on a characterization of SE representations and the fundamental activities that are applied to them. Motivations for developing a theory and means of establishing its validity are also discussed

Work in Process: Inhabiting Matter in Time

The typical American house is conceived of and constructed as a permanent and singular object. This method of permanent design and construction is not conducive to sustainable resource and material protection. The permanent connections and material customizations used in construction disallow most C&D (construction and demolition) materials from being salvaged, reused or recycled once the house has reached its end-of-life. As a result, residential demolition in America produces for over 19 million tons of material waste each year (US EPA 6). Deconstruction offers a valid alternative to demolition but is not commonly practiced for two main reasons. First, deconstruction remains a more expensive alternative. Second, the perception of the house as a singular and permanent object undermines the reusability of its material constituents. The following thesis includes research of typical construction design and methodology, a proposed construction design and methodology, a precedent analysis of architectural projects designed for deconstruction, and a design case study testing the validity of the proposed construction design and methodology. The research of typical construction design and methodology analyses those aspects that prohibit deconstruction as a viable method for dealing with the end-of-life of residential structures. The subsequent proposed construction design and methodology outlines a design hypothesis that would promote deconstruction over demolition. The precedent research analyzes past architectural projects that were designed with the intention of later being disassembled rather than demolished. The proposed construction design and methodology research is tested through the design process of the two case studies. These studies employ and develop design principles focused on creating a dynamic architectural design system that can adapt to changes in the needs of its inhabitants. The design utilizes locally bought materials that can be reused or recycled completely after use

Improving Usability of Interactive Graphics Specification and Implementation with Picking Views and Inverse Transformations

Specifying and programming graphical interactions are difficult tasks, notably because designers have difficulties to express the dynamics of the interaction. This paper shows how the MDPC architecture improves the usability of the specification and the implementation of graphical interaction. The architecture is based on the use of picking views and inverse transforms from the graphics to the data. With three examples of graphical interaction, we show how to express them with the architecture, how to implement them, and how this improves programming usability. Moreover, we show that it enables implementing graphical interaction without a scene graph. This kind of code prevents from errors due to cache consistency management

A Generic Module System forWeb Rule Languages: Divide and Rule

An essential feature in practically usable programming languages is the ability to encapsulate functionality in reusable modules. Modules make large scale projects tractable by humans. For Web and Semantic Web programming, many rule-based languages, e.g. XSLT, CSS, Xcerpt, SWRL, SPARQL, and RIF Core, have evolved or are currently evolving. Rules are easy to comprehend and specify, even for non-technical users, e.g. business managers, hence easing the contributions to the Web. Unfortunately, those contributions are arguably doomed to exist in isolation as most rule languages are conceived without modularity, hence without an easy mechanism for integration and reuse. In this paper a generic module system applicable to many rule languages is presented. We demonstrate and apply our generic module system to a Datalog-like rule language, close in spirit to RIF Core. The language is gently introduced along the EU-Rent use case. Using the Reuseware Composition Framework, the module system for a concrete language can be achieved almost for free, if it adheres to the formal notions introduced in this paper

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow