Feature-based generation of pervasive systems architectures utilizing software product line concepts

As the need for pervasive systems tends to increase and to dominate the computing discipline, software engineering approaches must evolve at a similar pace to facilitate the construction of such systems in an efficient manner. In this thesis, we provide a vision of a framework that will help in the construction of software product lines for pervasive systems by devising an approach to automatically generate architectures for this domain. Using this framework, designers of pervasive systems will be able to select a set of desired system features, and the framework will automatically generate architectures that support the presence of these features. Our approach will not compromise the quality of the architecture especially as we have verified that by comparing the generated architectures to those manually designed by human architects. As an initial step, and in order to determine the most commonly required features that comprise the widely most known pervasive systems, we surveyed more than fifty existing architectures for pervasive systems in various domains. We captured the most essential features along with the commonalities and variabilities between them. The features were categorized according to the domain and the environment that they target. Those categories are: General pervasive systems, domain-specific, privacy, bridging, fault-tolerance and context-awareness. We coupled the identified features with well-designed components, and connected the components based on the initial features selected by a system designer to generate an architecture. We evaluated our generated architectures against architectures designed by human architects. When metrics such as coupling, cohesion, complexity, reusability, adaptability, modularity, modifiability, packing density, and average interaction density were used to test our framework, our generated architectures were found comparable, if not better than the human generated architectures

Assessing and improving the quality of model transformations

Software is pervading our society more and more and is becoming increasingly complex. At the same time, software quality demands remain at the same, high level. Model-driven engineering (MDE) is a software engineering paradigm that aims at dealing with this increasing software complexity and improving productivity and quality. Models play a pivotal role in MDE. The purpose of using models is to raise the level of abstraction at which software is developed to a level where concepts of the domain in which the software has to be applied, i.e., the target domain, can be expressed e??ectively. For that purpose, domain-speci??c languages (DSLs) are employed. A DSL is a language with a narrow focus, i.e., it is aimed at providing abstractions speci??c to the target domain. This makes that the application of models developed using DSLs is typically restricted to describing concepts existing in that target domain. Reuse of models such that they can be applied for di??erent purposes, e.g., analysis and code generation, is one of the challenges that should be solved by applying MDE. Therefore, model transformations are typically applied to transform domain-speci??c models to other (equivalent) models suitable for di??erent purposes. A model transformation is a mapping from a set of source models to a set of target models de??ned as a set of transformation rules. MDE is gradually being adopted by industry. Since MDE is becoming more and more important, model transformations are becoming more prominent as well. Model transformations are in many ways similar to traditional software artifacts. Therefore, they need to adhere to similar quality standards as well. The central research question discoursed in this thesis is therefore as follows. How can the quality of model transformations be assessed and improved, in particular with respect to development and maintenance? Recall that model transformations facilitate reuse of models in a software development process. We have developed a model transformation that enables reuse of analysis models for code generation. The semantic domains of the source and target language of this model transformation are so far apart that straightforward transformation is impossible, i.e., a semantic gap has to be bridged. To deal with model transformations that have to bridge a semantic gap, the semantics of the source and target language as well as possible additional requirements should be well understood. When bridging a semantic gap is not straightforward, we recommend to address a simpli??ed version of the source metamodel ??rst. Finally, the requirements on the transformation may, if possible, be relaxed to enable automated model transformation. Model transformations that need to transform between models in di??erent semantic domains are expected to be more complex than those that merely transform syntax. The complexity of a model transformation has consequences for its quality. Quality, in general, is a subjective concept. Therefore, quality can be de??ned in di??erent ways. We de??ned it in the context of model transformation. A model transformation can either be considered as a transformation de??nition or as the process of transforming a source model to a target model. Accordingly, model transformation quality can be de??ned in two di??erent ways. The quality of the de??nition is referred to as its internal quality. The quality of the process of transforming a source model to a target model is referred to as its external quality. There are also two ways to assess the quality of a model transformation (both internal and external). It can be assessed directly, i.e., by performing measurements on the transformation de??nition, or indirectly, i.e., by performing measurements in the environment of the model transformation. We mainly focused on direct assessment of internal quality. However, we also addressed external quality and indirect assessment. Given this de??nition of quality in the context of model transformations, techniques can be developed to assess it. Software metrics have been proposed for measuring various kinds of software artifacts. However, hardly any research has been performed on applying metrics for assessing the quality of model transformations. For four model transformation formalisms with di??fferent characteristics, viz., for ASF+SDF, ATL, Xtend, and QVTO, we de??ned sets of metrics for measuring model transformations developed with these formalisms. While these metric sets can be used to indicate bad smells in the code of model transformations, they cannot be used for assessing quality yet. A relation has to be established between the metric sets and attributes of model transformation quality. For two of the aforementioned metric sets, viz., the ones for ASF+SDF and for ATL, we conducted an empirical study aiming at establishing such a relation. From these empirical studies we learned what metrics serve as predictors for di??erent quality attributes of model transformations. Metrics can be used to quickly acquire insights into the characteristics of a model transformation. These insights enable increasing the overall quality of model transformations and thereby also their maintainability. To support maintenance, and also development in a traditional software engineering process, visualization techniques are often employed. For model transformations this appears as a feasible approach as well. Currently, however, there are few visualization techniques available tailored towards analyzing model transformations. One of the most time-consuming processes during software maintenance is acquiring understanding of the software. We expect that this holds for model transformations as well. Therefore, we presented two complementary visualization techniques for facilitating model transformation comprehension. The ??rst-technique is aimed at visualizing the dependencies between the components of a model transformation. The second technique is aimed at analyzing the coverage of the source and target metamodels by a model transformation. The development of the metric sets, and in particular the empirical studies, have led to insights considering the development of model transformations. Also, the proposed visualization techniques are aimed at facilitating the development of model transformations. We applied the insights acquired from the development of the metric sets as well as the visualization techniques in the development of a chain of model transformations that bridges a number of semantic gaps. We chose to solve this transformational problem not with one model transformation, but with a number of smaller model transformations. This should lead to smaller transformations, which are more understandable. The language on which the model transformations are de??ned, was subject to evolution. In particular the coverage visualization proved to be bene??cial for the co-evolution of the model transformations. Summarizing, we de??ned quality in the context of model transformations and addressed the necessity for a methodology to assess it. Therefore, we de??ned metric sets and performed empirical studies to validate whether they serve as predictors for model transformation quality. We also proposed a number of visualizations to increase model transformation comprehension. The acquired insights from developing the metric sets and the empirical studies, as well as the visualization tools, proved to be bene??cial for developing model transformations

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

Context Oriented Software Middleware

Our middleware approach, Context-Oriented Software Middleware (COSM), supports context-dependent software with self-adaptability and dependability in a mobile computing environment. The COSM-middleware is a generic and platform-independent adaptation engine, which performs a runtime composition of the software's context-dependent behaviours based on the execution contexts. Our middleware distinguishes between the context-dependent and context-independent functionality of software systems. This enables the COSM-middleware to adapt the application behaviour by composing a set of context-oriented components, that implement the context-dependent functionality of the software. Accordingly, the software dependability is achieved by considering the functionality of the COSM-middleware and the adaptation impact/costs. The COSM-middleware uses a dynamic policy-based engine to evaluate the adaptation outputs and verify the fitness of the adaptation output with the application's objectives, goals and the architecture quality attributes. These capabilities are demonstrated through an empirical evaluation of a case study implementation

Sustainability evaluation of software architectures

Long-living software systems are sustainable if they can be cost-efficiently maintained and evolved over their entire life-cycle. The quality of software architectures determines sus-tainability to a large extent. Scenario-based software archi-tecture evaluation methods can support sustainability anal-ysis, but they are still reluctantly used in practice. They are also not integrated with architecture-level metrics when evaluating implemented systems, which limits their capabil-ities. Existing literature reviews for architecture evaluation focus on scenario-based methods, but do not provide a criti-cal reflection of the applicability of such methods for sustain-ability evaluation. Our goal is to measure the sustainabil-ity of a software architecture both during early design us-ing scenarios and during evolution using scenarios and met-rics, which is highly relevant in practice. We thus provide a systematic literature review assessing scenario-based meth-ods for sustainability support and categorize more than 40 architecture-level metrics according to several design prin-ciples. Our review identifies a need for further empirical research, for the integration of existing methods, and for the more efficient use of formal architectural models. 1

Genetic Algorithms in Software Architecture Synthesis

Ohjelmistoarkkitehtuurien suunnittelu on kriittinen vaihe ohjelmistokehitystä, sillä arkkitehtuuri määrittelee ohjelmiston rungon: miten ohjelma jaetaan eri komponentteihin, ja miten komponentit ovat yhteydessä toisiinsa. Ohjelmisto voidaan yleensä toteuttaa toimivasti monella eri tavalla, mutta toimiva toteutus ei aina takaa, että ohjelmisto on myös toteutettu laadukkaasti. Laadun takeena onkin huolella ja taidolla suunniteltu arkkitehtuuri. Ohjelmistoarkkitehtuurin suunnittelu on haastavaa. Suunnitelmaa tehdessä tulee ottaa huomioon monen eri sidosryhmän (esim. käyttäjä, toteuttaja, markkinoija) vaatimukset ja miettiä, miten mahdollisimman suuri osa vaatimuksista voidaan toteuttaa arkkitehtuurissa. Arkkitehtuurisuunnittelu vaatiikin kokeneen ohjelmistoarkkitehdin, joka on hankkinut tietotaitonsa vuosien ajalta eri ohjelmistoprojekteista. Kokemukseen perustuvan tiedon lisäksi ohjelmistoarkkitehtuurisuunnittelun käytäntöjä on koottu eräänlaisiksi katalogeiksi, joissa esitellään hyväksi havaittuja ratkaisuja, ns. suunnittelutyylejä ja -malleja, yleisiin arkkitehtuurisuunnitteluongelmiin. Voidaankin ajatella, että arkkitehtuuri tuotetaan etsimällä (kokemukseen nojaten) paras mahdollinen kombinaatio suunnittelumalleja ja -tyylejä. Arkkitehtuurin suunnittelu onkin siis eräänlainen optimointiongelma. Ohjelmistoista tulee jatkuvasti yhä monimutkaisempia. Sovelluksien monimutkaistuessa myös arkkitehtuurisuunnittelu muuttuu entistä vaikeammaksi ja vie yhä enemmän aikaa. Suunnittelun perustuminen hiljaiseen tietoon ja arkkitehtien kokemukseen tekee prosessista yhä hitaamman ja läpinäkymättömämmän. Arkkitehtuurisuunnittelun automatisointi toisikin suuria säästöjä. Henkilöstövaihdosten yhteydessä ei myöskään tarvitsisi pelätä tietotaidon katoamista, kun arkkitehtuurisuunnittelu olisi helposti toistettavissa aina alusta lähtien. Tässä väitöskirjassa on tutkittu, miten parhaan mahdollisen ratkaisun etsintäprosessin (eli suunnittelumallien ja -tyylien soveltamisen) voisi automatisoida. Monimutkaisissa optimointiongelmissa käytetään etsintäalgoritmeja, jotka haravoivat hakuavaruutta jollain satunnaistetulla menetelmällä. Yksi suosituimmista etsintäalgoritmeista on geneettinen algoritmi. Geneettiset algoritmit tarkastelevat aina pientä ratkaisujoukkoa kerrallaan ja etsivät parasta ratkaisua yhdistelemällä osia löydetyistä ratkaisuista sekä muuntelemalla ratkaisuja. Jokaiselle ratkaisulle lasketaan laatuarvo, ja luonnonvalintaa jäljitellen jatketaan parhaiden vaihtoehtojen tarkastelua sekä kehittelyä ja hylätään huonoimmat ratkaisut. Etsintäalgoritmien käyttämistä ohjelmistokehityksen ongelmiin, esim. ohjelmistosuunnitteluun, testaukseen ja projektinhallintaan, kutsutaan etsintäperustaiseksi ohjelmistokehitykseksi. Väitöskirja kuuluu etsintäperustaisen ohjelmistosuunnittelun alaan, ja siinä tutkitaan ns. ohjelmistoarkkitehtuurisynteesiä geneettisten algoritmien avulla. Ohjelmistoarkkitehtuurisynteesi lähtee ns. nolla-arkkitehtuurista , joka toteuttaa järjestelmän toiminnalliset vaatimukset, mutta ei ota kantaa laatuvaatimuksiin. Laatua pyritään parantamaan lisäämällä lähtöarkkitehtuuriin suunnittelutyylejä ja -malleja. Väitöskirjassa laatuarviointiin on käytetty muunneltavuutta, tehokkuutta ja ymmärrettävyyttä. Lopputuloksena saadaan ehdotus arkkitehtuurista, joka toteuttaa toiminnalliset vaatimukset ja on myös laadukas. Geneettisiä algoritmeja ei ole aiemmin sovellettu vastaavantasoisiin suunnitteluongelmiin, joten toteutuksessa on kehitetty uusi tapa mallintaa arkkitehtuuri geneettiselle algoritmille sekä laskukaava arkkitehtuurin laadulle. Perustoteutuksen lisäksi myös geneettisen algoritmin eri ominaisuuksia, ns. risteytysoperaatiota ja laatufunktiota on tutkittu tarkemmin, ja niille on kehitetty vaihtoehtoisia toteutuksia. Tapaustarkasteluista saadut tulokset osoittavat, että tällä hetkellä geneettisiin algoritmeihin perustuvaa arkkitehtuurisynteesi tuottaa suunnilleen samantasoisia ratkaisuja kuin kolmannen vuosikurssin ohjelmistotekniikan opiskelija.This thesis presents an approach for synthesizing software architectures with genetic algorithms. Previously in the literature, genetic algorithms have been mostly used to improve existing architectures. The method presented here, however, focuses on upstream design. The chosen genetic construction of software architectures is based on a model which contains information on functional requirements only. Architecture styles and design patterns are used to transform the initial high-level model to a more detailed design. Quality attributes, here modifiability, efficiency and complexity, are encoded in the algorithm s fitness function for evaluating the produced solutions. The final solution is given as a UML class diagram. While the main contribution is introducing the method for architecture synthesis, basic tool support for the implementation is also presented. Two case studies are used for evaluation. One case study uses the sketch for an electronic home control system, which is a typical embedded system. The other case study is based on a robot war game simulator, which is a typical framework system. Evaluation is mostly based on fitness graphs and (subjective) evaluation of produced class diagrams. In addition to the basic approach, variations and extensions regarding crossover and fitness function have been made. While the standard algorithm uses a random crossover, asexual reproduction and complementary crossover are also studied. Asexual crossover corresponds to real-life design situations, where two architectures are rarely combined. Complementary crossover, in turn, attempts to purposefully combine good parts of two architectures. The fitness function is extended with the option to include modifiability scenarios, which enables more targeted design decisions as critical parts of the architecture can be evaluated individually. In order to achieve a wider range of solutions that answer to competing quality demands, a multi-objective approach using Pareto optimality is given as an alternative for the single weighted fitness function. The multi-objective approach evaluates modifiability and efficiency, and gives as output the class diagrams of the whole Pareto front of the last generation. Thus, extremes for both quality attributes as well as solutions in the middle ground can be compared. An experimental study is also conducted where independent experts evaluate produced solutions for the electronic home control. Results show that genetic software architecture synthesis is indeed feasible, and the quality of solutions at this stage is roughly at the level of third year software engineering students

A survey on software testability

Context: Software testability is the degree to which a software system or a unit under test supports its own testing. To predict and improve software testability, a large number of techniques and metrics have been proposed by both practitioners and researchers in the last several decades. Reviewing and getting an overview of the entire state-of-the-art and state-of-the-practice in this area is often challenging for a practitioner or a new researcher. Objective: Our objective is to summarize the body of knowledge in this area and to benefit the readers (both practitioners and researchers) in preparing, measuring and improving software testability. Method: To address the above need, the authors conducted a survey in the form of a systematic literature mapping (classification) to find out what we as a community know about this topic. After compiling an initial pool of 303 papers, and applying a set of inclusion/exclusion criteria, our final pool included 208 papers. Results: The area of software testability has been comprehensively studied by researchers and practitioners. Approaches for measurement of testability and improvement of testability are the most-frequently addressed in the papers. The two most often mentioned factors affecting testability are observability and controllability. Common ways to improve testability are testability transformation, improving observability, adding assertions, and improving controllability. Conclusion: This paper serves for both researchers and practitioners as an "index" to the vast body of knowledge in the area of testability. The results could help practitioners measure and improve software testability in their projects

Comparing service orientation and object orientation : a case study on structural benefits and maintainability

Service Orientation (SO) is a dominating technique evolving around the use of Object Orientation (OO). The conceptual comparison of both the approaches have been broadly explained in the literature, but the generalizable comparison of the maintainability of two paradigms is still a topic under research. This thesis tries to provide a generalized comparison of the maintainability using two functionally equivalent Online BookStore systems developed with Service Orientation and Object Orientation. This thesis presents a brief explanation of the software metrics used for the comparison. The quantitative comparison revealed that the Service-Oriented version of the system has a lower coupling and higher cohesion between software modules compared to an Object-Oriented approach. Through survey results, it was found that Service Orientation has a better degree of modifiability, encapsulation and abstraction while Object-Orientation provides a reduced degree of testing and system complexity comparatively. Also in expert interviews, participants believe that systems based on service orientation possess a better degree of stability, analyzability and modifiability whereas Object-Oriented System tends to provide a lower degree of structural complexity. Furthermore, experimental results suggest that a Service-Based System has a better degree of extensibility and changeability compared to Object-Oriented System