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

Designing Software Architectures As a Composition of Specializations of Knowledge Domains

This paper summarizes our experimental research and software development activities in designing robust, adaptable and reusable software architectures. Several years ago, based on our previous experiences in object-oriented software development, we made the following assumption: ‘A software architecture should be a composition of specializations of knowledge domains’. To verify this assumption we carried out three pilot projects. In addition to the application of some popular domain analysis techniques such as use cases, we identified the invariant compositional structures of the software architectures and the related knowledge domains. Knowledge domains define the boundaries of the adaptability and reusability capabilities of software systems. Next, knowledge domains were mapped to object-oriented concepts. We experienced that some aspects of knowledge could not be directly modeled in terms of object-oriented concepts. In this paper we describe our approach, the pilot projects, the experienced problems and the adopted solutions for realizing the software architectures. We conclude the paper with the lessons that we learned from this experience

Learning requirements engineering within an engineering ethos

An interest in educating software developers within an engineering ethos may not align well with the characteristics of the discipline, nor address the underlying concerns of software practitioners. Education for software development needs to focus on creativity, adaptability and the ability to transfer knowledge. A change in the way learning is undertaken in a core Software Engineering unit within a university's engineering program demonstrates one attempt to provide students with a solid foundation in subject matter while at the same time exposing them to these real-world characteristics. It provides students with a process to deal with problems within a metacognitive-rich framework that makes complexity apparent and lets students deal with it adaptively. The results indicate that, while the approach is appropriate, student-learning characteristics need to be investigated further, so that the two aspects of learning may be aligned more closely

On the design of aspect-oriented composition models for software evolution

Aspect-oriented programming is an emerging approach in software development,\ud which provides new possibilities for separation of concerns. Aspectoriented\ud languages offer abstractions for the implementation of concerns\ud whose modularization cannot be achieved by using traditional programming\ud languages. Such concerns are generally termed as crosscutting concerns. It is\ud generally agreed that separating the right concerns from each other enhances\ud software quality factors such as reusability and adaptability. The separated\ud concerns in software must be composed together so that software behaves\ud according to its requirements in a coherent way. We refer to language mechanisms\ud that separate and compose concerns as 'composition mechanisms'. This\ud thesis evaluates the software composition mechanisms of current aspectoriented\ud languages from the perspective of software quality factors such as\ud evolvability, comprehensibility, predictability and adaptability. Based on this\ud study, the thesis proposes novel extensions to current aspect-oriented\ud languages so that programs written in these languages exhibit better quality.\ud A considerable number of aspect-oriented languages has been introduced for\ud modularizing crosscutting concerns. Naturally, these languages share a number\ud of common concepts and have distinctive features as well. For this reason, we\ud propose a reference model that aims to capture the common and distinctive\ud concepts of aspect-oriented languages. This reference model provides a basis\ud to understand the important characteristics of the state-of-the-art AOP\ud languages and helps us to compare the AOP languages with each other.\ud Furthermore, it exposes the issues that have to be considered when a new\ud aspect-oriented language needs to be developed.\ud In this thesis, we analyse the four main aspect-oriented concepts of the reference\ud model, namely join point, pointcut, advice and aspect, and identify problems\ud related to their use in various AOP languages. Based on this analysis, we\ud propose extensions of the existing concepts and/or design new ones to address\ud the identified problems.\ud In current aspect-oriented languages, pointcuts select join points of a program\ud based on lexical information such as explicit names of program elements.\ud However, this reduces the adaptability of software, since it involves too much\ud information that is hard-coded, and often implementation-specific. We claim\ud that this problem can be reduced by referring to program elements through their\ud semantic properties. A semantic property describes for example the behavior\ud of a program element or its intended meaning. We formulate requirements for\ud the proper application of semantic properties in aspect-oriented programming.\ud We discuss how to use semantic properties for the superimposition of aspects,\ud and how to apply superimposition to bind semantic properties to program\ud elements. To achieve this, we propose language constructs that support semantic\ud composition: the ability to compose aspects with the elements of the base\ud program that satisfy certain semantic properties.\ud The current advice-pointcut binding constructs of AOP languages maintain\ud explicit dependencies to advices and aspects. This results in weaving specifications\ud that are less evolvable and need more maintenance during the development\ud of a system. We show that this issue can be addressed by providing associative\ud access to advices and aspects instead of using explicit dependencies in\ud the weaving specification. To this aim, we propose to use a designating (query)\ud language in advice-pointcut bindings that allows for referring aspect/advices\ud through their (syntactic and semantic) properties. We also present how semantic\ud properties can be applied to provide reusable (adaptable) aspect abstractions.\ud Aspect-oriented languages provide means to superimpose aspectual behavior –\ud in terms of advices - on a given set of join points. It is possible that not just a\ud single, but several advices need to execute at the same join point. Such "shared"\ud join points may give rise to issues such as determining the exact execution\ud order and the other possible dependencies among the aspects. We present a\ud detailed analysis of the problem, and identify a set of requirements upon mechanisms\ud for composing aspects at shared join points. To address the identified\ud issues, we propose a general and declarative model for defining constraints\ud upon the possible compositions of aspects at a shared join point. By using an\ud extended notion of join points, we show how concrete aspect-oriented\ud programming languages can adopt the proposed model.\ud The thesis also presents how the proposed extensions and new constructs are\ud adopted by the aspect-oriented language Compose*. To evaluate the proposed\ud constructs, we provide qualitative analyses with respect to various software\ud engineering properties, such as evolvability, modularity, predictability and\ud adaptability

BIM for landscape design improving climate adaptation planning: the evaluation of software tools based on the ISO 25010 standard

This paper investigates the capabilities and limitations of different software tools simulating landscape design adaptability. The evaluation of tools is based on the ISO 25010 framework, which investigates software functionality, reliability, performance efficiency, usability, compatibility, and information quality. These quality characteristics of software are analysed during objective experiments where five software tools are used for a case study project at the conceptual design phase. These experiments reveal that the existing software tools for climate adaptation planning are focused on different aspects of climate adaptability, generating different types of information. Moreover, all tools deal with some limitations in terms of compatibility, performance efficiency, and functional operations. The ISO 25010 quality model provides a comprehensive framework to compare the capabilities of different software tools for climate adaptation planning. This paper is part of a wider study including an analysis of the needs of project stakeholders regarding climate adaptation software tools. However, this article focuses on technical capabilities of current climate adaptation software tools

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

A case study on adaptability problems of the separation of user interface and application semantics

A large number of software architectures for interactive have been described in literature, like the Seeheim, PAC-Amodeus, and Model-View-Controller architectures. Most of these architectures are based on the traditional view of interactive software, namely the view that an interactive software system can be separated in an application part and a user interface part. The application part contains the functionality of the software – what the system does – and the user interface part contains the representation of this functionality to the user(s) of the system. The motivation behind these architectures is to improve, among others, adaptability, portability, complexity handling, and separation of concerns of interactive software. The principle of separating interactive software in application and user interface parts has its merits. It can however lead to serious adaptability problems in software that provides fast, frequent and intensive feedback, in particular semantic feedback. Semantic feedback refers to feedback the system gives to the user concerning the semantics of the application, i.e. the objects that the user perceives and manipulates. In these systems, the boundary between application and user interface becomes less sharp and the semantics of the interface and the application tend to be highly coupled. Examples of such interactive systems are direct manipulation systems, virtual reality systems, and systems with natural language interfaces. The problem of semantic feedback is that it is functionality that has both application and user interface aspects and crosses the application-interface boundary. It requires excessive use of semantic information from the application part and in this way, it compromises the separation of application and user interface concerns. As a result, it becomes more difficult to modify or extend functionality related to semantic feedback. In other words, the adaptability of the interactive software is decreased. In this report, a case study concerning an interactive CD database system is used to illustrate the adaptability problems of separation-based architectures for interactive software