Debugging Techniques for Locating Defects in Software Architectures

The explicit design of the architecture for a software product is a well established part of development projects. As the software architecture descriptions are becoming larger and more complex, there is more likelihood of defects being present in the software architecture. Studies have shown that a defect in the software architecture that has propagated to the development phase is very expensive to fix. To prevent such propagation of defects, this research proposes to provide debugging support for software architecture design. Debugging is commonly used in programming languages to effectively find the cause of a failure and locate the error to provide a fix. The same should be accomplished in software architectures to debug architecture failures. Without debugging support, the software architect is unable to quickly locate and determine the source of an error. In our work, we define a process for debugging software architecture and provide analysis techniques to locate defects in a software architecture that fails to meet functional and non-functional requirements. We have implemented the techniques and provide an evaluation of the techniques based on examples using an industry standard architecture definition language, Architecture Analysis and Design Language (AADL)

Architectural stability of self-adaptive software systems

This thesis studies the notion of stability in software engineering with the aim of understanding its dimensions, facets and aspects, as well as characterising it. The thesis further investigates the aspect of behavioural stability at the architectural level, as a property concerned with the architecture's capability in maintaining the achievement of expected quality of service and accommodating runtime changes, in order to delay the architecture drifting and phasing-out as a consequence of the continuous unsuccessful provision of quality requirements. The research aims to provide a systematic and methodological support for analysing, modelling, designing and evaluating architectural stability. The novelty of this research is the consideration of stability during runtime operation, by focusing on the stable provision of quality of service without violations. As the runtime dimension is associated with adaptations, the research investigates stability in the context of self-adaptive software architectures, where runtime stability is challenged by the quality of adaptation, which in turn affects the quality of service. The research evaluation focuses on the effectiveness, scale and accuracy in handling runtime dynamics, using the self-adaptive cloud architectures

A Design-by-Contract based Approach for Architectural Modelling and Analysis

Research on software architectures has been active since the early nineties, leading to a number of different architecture description languages (ADL). Given their importance in facilitating the communication of crucial system properties to different stakeholders and their analysis early on in the development of a system this is understandable. However, practitioners rarely use ADLs, and, instead, they insist on using the Unified Modelling Language (UML) for specifying software architectures. I attribute this to three main issues that have not been addressed altogether by the existing ADLs. Firstly, in their attempt to support formal analysis, current ADLs employ formal notations (i.e., mostly process algebras) that are rarely used among practitioners. Secondly, many ADLs focus on components in specifying software architectures, neglecting the first-class specification of complex interaction protocols as connectors. They view connectors as simple interaction links that merely identify the communicating components and their basic communication style (e.g., procedure call). So, complex interaction protocols are specified as part of components, which however reduce the re-usability of both. Lastly, there are also some ADLs that do support complex connectors. However, these include a centralised glue element in their connector structure that imposes a global ordering of actions on the interacting components. Such global constraints are not always realisable in a decentralised manner by the components that participate in these protocols. In this PhD thesis, I introduce a new architecture description language called XCD that supports the formal specification of software architectures without employing a complex formal notation and offers first-class connectors for maximising the re-use of components and protocols. Furthermore, by omitting any units for specifying global constraints (i.e., glue), the architecture specifications in XCD are guaranteed to be realisable in a decentralised manner. I show in the thesis how XCD extends Design-by-Contract (DbC) for specifying (i) protocol-independent components and (ii) complex connectors, which can impose only local constraints to guarantee their realisability. Use of DbC will hopefully make it easier for practitioners to use the language, compared to languages using process algebras. I also show the precise translation of XCD into SPIN’s formal ProMeLa language for formally verifying software architectures that (i) services offered by components are always used correctly, (ii) the component behaviours are always complete, (iii)there are no race-conditions, (iv) there is no deadlock, and (v) for components having event communications, there is no overflow of event buffers. Finally, I evaluate XCD via five well-known case studies and illustrate XCD’s enhanced modularity, expressive DbC-based notation, and guaranteed realisability for architecture specifications

Factors Affecting the Quality of Enterprise Architecture Models

We start our research by introducing the subject of Enterprise Architecture (EA), its content and purpose, as well as discussing what we mean by a ‘model’, and ‘quality’, building on concepts from semiotics and in particular on conceptual model quality. We set out to answer three questions. The first deals with how we measure the quality of a set of Enterprise Architecture models, and to answer this we produce a mathematical framework and then test it using a case study. This extends the conceptual model quality work done by Lindland and Krogstie into the realm of Enterprise Architecture, adding new aspects related to completeness of sets of models, modelling maturity as well as conditions for increasing quality. This incorporates mathematical concepts, including set theory and calculus, and proposes three specific metrics for the quality of sets of models (related to truthfulness, syntax and completeness). This uses a simple case study, based upon purely quantitative data, sampling the contents of an existing Enterprise Architecture repository. The second deals with how we measure the effectiveness of the language used in Enterprise Architecture models. We again use mathematical techniques to construct metrics, this time related to comprehension and utility: the former incorporating a triangulation technique based upon Kvanvig’s concept of moderate factivity of objectual understanding, and the latter being a more subjective measure (i.e. self-assessment). From these two metrics we provide a new conceptual visualisation of the effectiveness of language concepts. We then test this framework using a mixed-mode case study, carrying out 68 interviews, based mostly upon quantitative data again but with additional elements of qualitative data. Although the conceptual framework is independent of any particular language, in order to test it we actually need to select an Enterprise Architecture framework, or more specifically, the modelling language within such a framework; the framework we choose for this purpose is ArchiMate. Through the use of alternative modelling notations in the survey process, we gain insights not just into the understanding and utility of various ArchiMate concepts, as perceived by respondents, we also gain insights into the effect of understanding and utility of using the specific notation provided by ArchiMate through the use of differential analysis of the result sets thus obtained. The final question we address is more practically focused and deals with how we can specify and automate various kinds of changes to Enterprise Architecture models based upon the previous research. We construct a conceptual framework illustrating the kinds of transformations that may be required, given what we have learnt in the previous chapters, demonstrate that these can be deterministic and finally demonstrate, by use of a specific Enterprise Architecture modelling tool (BiZZdesign), that they can be implemented in software, and thus automated. vii In the course of our research, we deliver reusable methodologies and frameworks that will assist future researchers into Enterprise Architecture and related frameworks, as well as Enterprise Architecture practitioners