Journal Article Techniques for Genetic Software Architecture Design Get access Outi Sievi-Korte, Outi Sievi-Korte * 1Department of Pervasive Computing, Tampere University of Technology, Korkeakoulunkatu 1, P.O. Box 553, 33101 Tampere, Finland *Corresponding author: [email protected] Search for other works by this author on: Oxford Academic Google Scholar Kai Koskimies, Kai Koskimies 1Department of Pervasive Computing, Tampere University of Technology, Korkeakoulunkatu 1, P.O. Box 553, 33101 Tampere, Finland Search for other works by this author on: Oxford Academic Google Scholar Erkki Mäkinen Erkki Mäkinen 2School of Information Sciences, University of Tampere, Kanslerinrinne 1, 33014 University of Tampere, Tampere, Finland Search for other works by this author on: Oxford Academic Google Scholar The Computer Journal, Volume 58, Issue 11, November 2015, Pages 3141–3170, https://doi.org/10.1093/comjnl/bxv049 Published: 14 July 2015 Article history Received: 01 December 2014 Revision received: 25 May 2015 Published: 14 July 2015

Wide-spread adoption of the agile movement has rapidly changed the landscape of software industry. In particular, Scrum is an agile process framework that has become extremely popular in industry. However, the practical implementation of Scrum in companies rarely follows the text book ideals. Typically, companies deviate from the proposed Scrum practices for different reasons. While some deviations may be well motivated and reasonable, companies are often tempted to adjust Scrum for the company without clearly understanding the consequences of the deviations. In this paper our aim is to identify ways of potentially harmful mishandling of Scrum in industry based on empirical data collected in a survey. The identified (mal)practices are presented in a semi-formal manner as anti-patterns. The study resulted in 10 anti-patterns that express the context of the deviation, the deviation itself, the broken core principles of Scrum, and the possible consequences of the deviation.

Many kinds of software systems benefit from the capability to modify a system's design decisions at run-time. In this paper, design patterns are proposed as the basic elements of dynamic design-level maintenance. The required infrastructure for pattern-based dynamic system maintenance has been implemented for Java. The infrastructure provides a graphical presentation of the system's pattern architecture, and supports injecting and disposing of patterns in a running system. The potential benefits of the approach are demonstrated with an example system.

Genetic algorithms have become a popular heuristic technique to solve difficult search problems. However, in multi-objective problem solving, like software architecture generation, the basic variation mechanisms of genetic algorithms (mutation and crossover) tend to lead to mediocre solutions as the evolution favors balancing of several quality properties. In this paper, we explore the acceleration of genetic software architecture generation using a novel approach based on so-called quality farms, i.e., populations which favor a certain quality property. We hypothesize that by crossbreeding individuals from different quality farms it is possible to create beneficial variance that raises the fitness value to a significantly higher level. Experiments suggest that farm-based crossbreeding improves fitness value about 10%.

Knowledge representation, acquisition, and sharing in software development projects is challenging due to the involvement of different kinds of stakeholders and large heterogeneous repositories of artifacts. In this paper, we argue that the concept of a concern can be used to facilitate the management of knowledge concerning the various system artifacts. Concerns represent pieces of knowledge pertaining to various viewpoints and interests of the stakeholders. In order to represent concerns, we propose the use of a non-intrusive role-based mechanism called a fragment. Using this mechanism, tacit knowledge can be made explicit by mapping stakeholders interests to artifact repositories, concern-based queries can be addressed to the repositories, and concerns can be combined to produce new knowledge. A concern-based prototype tool environment for knowledge management has been built and used for evaluating the approach in the context of industrial case studies.

The automated synthesis of software architecture design and associated work allocation plan is considered, given the requirements of the system and a specification of the available, possibly distributed development teams. The technique applies genetic algorithms, with mutations introducing changes both in the architectural solutions and in the work allocation schemes. The technique is implemented and evaluated using a non-trivial example system, the control system of an electronic home. The results suggest that genetic algorithms are a viable approach to solve this kind of multi-targeted optimization problem, assuming that the architectural quality and work allocation fitness can be given appropriate metrics.

Automated support for software architecture design is discussed. The proposed approach is based on a tool applying genetic algorithms for producing potential architecture proposals. The tool requires a basic functional decomposition of the system and the specification of the quality requirements as input, relying on a repository of standard solutions like patterns and architectural styles. The underlying techniques and the design of the tool are discussed, and the usage of the tool is illustrated by an example.

Techniques exist to synthesize software architecture using genetic algorithms that employ transformations based on mutations and crossover. In this paper, we demonstrate that complementary crossover can significantly improve this technique. We study two versions of complementary crossover, one in which parents are selected so that they complement each other but the genes are inherited randomly from the parents, and another in which the genes are inherited in a more purposeful way. Empirical studies on two sample systems suggest that the complementary crossover outperforms the traditional crossover in genetic software architecture synthesis especially in the presence of mutations that provide delayed reward.

Software architecture design can be regarded as finding an optimal combination of known general solutions and architectural knowledge with respect to given requirements. Based on previous work on synthesizing software architecture using genetic algorithms, we propose a refined fitness function for assessing software architecture in genetic synthesis, taking into account the specific anticipated needs of the software system under design. Inspired by real life architecture evaluation methods, the refined fitness function employs scenarios, specific situations possibly occurring during the lifetime of the system and requiring certain modifiability properties of the system. Empirical studies based on two example systems suggest that using this kind of fitness function significantly improves the quality of the resulting architecture.

Service oriented architecture (SOA) is currently supported by an infrastructure that facilitates model driven development, but reuse issues have received less attention. A key problem in reuse is variability management: how to support the specification and usage of the variation points of the system. In this paper, we propose an approach for model-level variability management, assuming UML activity diagrams as the notation for service composition models in SOA. The approach is based on specifying variation points using so-called specialization patterns, which have been originally developed to support task-driven specialization of application frameworks. We demonstrate the approach with a prototype tool and an example. The approach leads to a guided model customization process focusing on the variation points, making it easy to produce a variant of a basic model.

Abstract In the current trend of software engineering, patterns and profiles lend themselves as two powerful complementary mechanisms for documenting and enforcing design rules. In this paper, we study how unified tool support can be achieved for patterns and profiles by interpreting them as role‐based structural descriptions and exploiting existing tool support for role modeling. The approach is realized using so‐called design profiles, which allow both validation and generation of models according to rules expressed in the patterns and profiles. A prototypical tool environment supporting the approach has been developed. The practical applicability of the approach is demonstrated by specifying design rules of the enterprise Java beans (EJB) platform and by producing an environment for designing EJB‐based applications. We also discuss possible usage scenarios in the context of this case study. Copyright © 2008 John Wiley & Sons, Ltd.

The adoption of Domain-Specific Modeling Languages (DSMLs) for generating framework-based applications has proved to be an effective way of enforcing the correct use of frameworks and improve the productivity of application developers. However, the development of the code generator of a DSML is typically a laborious task with difficulties in what concerns complexity, understandability, and maintainability. In this paper, we address this problem with a new approach for developing DSMLs for frameworks that allows to eliminate the need of implementing code generators. The approach relies on the extension of frameworks with an additional layer based on aspect-oriented programming that encodes a DSML. By means of a generic language workbench, framework-based applications can be generated from application models described in that DSML. The proposed language workbench was implemented in a prototype tool and a case study on the Eclipse Rich Client Platform was performed.

Learning complex software platforms is a challenging task. This paper studies the problem of platform learning from the viewpoint of multidimensional separation of concerns in software systems. In this approach, concerns are used to identify and specify the kinds of learning tasks and interactions that should be supported by a learning environment for software platforms. The approach has been applied to build a concern-based learning environment for a Nokia GUI platform. A generic concern management tool has been used to build the r environment.

A concern-based approach to support software comprehension and analysis is proposed. Concerns represent various aspects of a system, like features, architectural solutions, units of work, etc., which are interesting for some stakeholders. Using concern-based queries on the software artefacts, new derived information on the system can be exposed. The results of the queries are also represented as concerns and added to the concern repository. The approach thus supports the analyzer in gradually building up an understanding on the subject system to be analyzed.

The abstract syntax of a graphical modeling language is often defined by a metamodel. Typically, a metamodel is given as a class diagram, serving as the grammar of the modeling language. Especially in the case of complex metamodels, there is a need for tool support for assisting the creation ofmodels. In this paper, we propose a method for taskdriven creation of models, assuming that the metamodel has been given as a UML class diagram.

Abstract This paper presents an approach to find, specify and use the specialization interface of an object‐oriented framework as a set of framework‐specific patterns. The approach is based on the assumption that the user tries to reuse a framework by setting meaningful goals in the context of their application and then achieves the goals by performing a sequence of programming tasks. The goals can be refined as informal specialization patterns, which are framework‐specific descriptions on how to reach a particular specialization goal. Furthermore, the obtained specialization patterns can be transformed into more precise specifications to enable tool support. As a result, the framework user can use both a cookbook‐like informal documentation and supporting tools to specialize the framework. Copyright © 2006 John Wiley & Sons, Ltd.

We introduce a specification technique that uses a combination of statechart templates and structural models for deriving spoken command languages for the domains specified by the structural models. We apply the technique for the domain of UML editing.

The Unified Modeling Language (UML) provides various diagram types for describing a system from different perspectives or abstraction levels. Hence, UML diagrams describing the same system are dependent and strongly overlapping. In this paper we study how this can be exploited for specifying transformation operations between different diagram types. We discuss various general approaches and viewpoints of model transformations in UML. The source and target diagram types for useful transformations are analyzed and given categories. The potentially most interesting transformation operations are discussed in detail. It is concluded that the transformation operations can automate a substantial part of both forward and reverse engineering. These operations can be used, for example, for model checking, merging, slicing, and synthesis.

Enterprise JavaBeans (EJB) is Java's component architecture for server-side distributed enterprise applications. The architecture of EJB applications is based on well-established solutions common to most distributed business systems, To utilize the architecture in an optimal way, proven EJB specific design solutions have been identified and collected as a set of design patterns. The use of these EJB design patterns as a tightly interconnected pattern system can significantly ease the development process of EJB based applications and improve the quality of the produced software. We will study in this paper how a general architectural tool (Fred) can be used to generate an EJB programming environment, when given the specifications of the EJB design patterns as input. This environment can be viewed as an architecture-centric wizard that guides the user through the development of the application, following the EJB design patterns.

The Unified Modeling Language (UML) provides several diagram types, viewing a system from different perspectives. In this research, we exploit the logical relationships between different UML models. We propose operations to compare, merge, slice and synthesize UML diagrams based on these relationships. In a formal demonstration, we show how statechart diagrams can be synthesized semi-automatically from a set of sequence diagrams using an interactive algorithm called MAS. We also demonstrate how a class diagram, annotated with pseudocode presentations of key operations, can be synthesized from sequence diagrams, and how class diagrams and sequence diagrams can be sliced against each other.

An application framework is a collection of classes implementing the shared architecture of a family of applications. It is shown how the specialization interface ("hot spots") of a framework can be annotated with specialization patterns to provide task-based guidance for the framework specialization process. The specialization patterns define various structural, semantic, and coding constraints over the applications derived from the framework. We also present a tool that supports both the framework development process and the framework specialization process, based on the notion of specialization patterns. We outline the basic concepts of the tool and discuss techniques to identify and specify specialization patterns as required by the tool. These techniques have been applied in realistic case studies for creating programming environments for application frameworks.

Abstract Shimba is a reverse engineering environment to support the understanding of Java software systems. Shimba integrates the Rigi and SCED tools to analyze and visualize the static and dynamic aspects of a subject system. The static software artifacts and their dependencies are extracted from Java byte code and viewed as directed graphs using the Rigi reverse engineering environment. The run‐time information is generated by running the target software under a customized SDK debugger. The generated information is viewed as sequence diagrams using the SCED tool. In SCED, statechart diagrams can be synthesized automatically from sequence diagrams, allowing the user to investigate the overall run‐time behavior of objects in the target system. Shimba provides facilities to manage the different diagrams and to trace artifacts and relations across views. In Shimba, SCED sequence diagrams are used to slice the static dependency graphs produced by Rigi. In turn, Rigi graphs are used to guide the generation of SCED sequence diagrams and to raise their level of abstraction. We show how the information exchange among the views enables goal‐driven reverse engineering tasks and aids the overall understanding of the target software system. The FUJABA software system serves as a case study to illustrate and validate the Shimba reverse engineering environment. Copyright © 2001 John Wiley & Sons, Ltd.

Programs are not read sequentially like a book but rather selectively like an encyclopedia. Instead of linear text we therefore suggest non-linear active text as a medium for structuring and browsing source code. Although common program editors are mainly character based we believe that non-textual information such as pictures, links, folds, and annotations can improve the readability of programs. In this paper we show how a text editor can be extended to include active text elements and give examples for how to apply these facilities to source code. Our approach is different from that of syntax-oriented editors in that our structuring is not based on the syntax of the edited texts. The implementation was done in the Oberon system which offers powerful mechanisms for extending software in an object-oriented way.

Abstract The automatic synthesis of state machines describing the behaviour of a class of objects in object‐oriented software modelling is studied. It is shown that the synthesis can be carried out on the basis of trace diagrams giving possible sequences of events during the execution of the system. An algorithm originally developed for the automatic construction of programs on the basis of their execution traces is applied to the problem, and an experimental state machine synthesizer is implemented. It is demonstrated that such a synthesizer is a highly useful component in a practical object‐oriented CASE system.

Abstract A variant of the well‐known recursive descent parsing technique is developed, based on the assumption that each non‐terminal of the language is implemented through a separate module. The modularization principle requires that the recursive descent parser of one non‐terminal must be written knowing only the production rules of that non‐terminal, and not the other parts of the language. This leads to a parsing technique which is ‘lazy’ in the sense that part of the parser is constructed during parsing, according to the needs of a particular input text. It turns out that this technique can be implemented as efficiently as conventional recursive descent parsing, which is one of the fastest known parsing methods. The main benefit of the technique is that it allows a language to be implemented in small pieces which are easy to modify, replace, and reuse.

Abstract Language processor generators are systems that produce various language processors (including compilers) on the basis of a high‐level specification. The design of language processor generators is discussed on the basis of experiments with a traditional compiler writing system (HLP78) employing pore LALR parsing and general attribute grammars. It is argued that these methods are too primitive from the practical point of view. The design of a new language processor generator, HLP84, is based on this view. This system is an attempt to provide high‐level tools for a restricted class of applications (one‐pass analysis). The syntactic facilities include regular expressions on the right‐hand sides of productions, a disambiguating mechanism that is integrated with regular expressions, and a mechanism for using semantic information to aid parsing. The semantic facilities include automatic support for semantic error handling and for symbol tables. Early experiences with the new system show that in spite of the general overhead caused by the higher automation level, the system allows the generation of reasonably efficient processors.

The object-oriented paradigm is applied to the interpreting of programming languages. An intermediate representation of a program is created as a collection of objects representing various entities in the conceptual world of the source language. These objects cover both the static and the dynamic aspects of a program. As a major advantage of this approach, issues that are traditionally handled by very different techniques (like symbol table management and the generation and execution of intermediate code) can be treated in a unified manner. The specification language of an interpreter generator based on these principles is described.

Abstract Automatic production of one‐pass compilers from attribute grammars is considered. An examination of a one‐pass grammar for the programming language Euclid shows that the present definition of one‐pass grammars is too general: the space behaviour of the produced compilers differs from that found in conventional hand‐written compilers. A new class of attribute grammars is defined. The class models naturally the use of space in a hand‐written compiler. This implies that the compiler produced automatically on the basis of the grammar uses space in the same way as a practical hand‐written recursive descent compiler. Furthermore, a graphical notation is introduced as a design tool for obtaining grammars in the proposed class.