Search

We report on our success stories in developing and using Model-Driven Engineering (MDE) tools for information systems on real-world projects within different application domains. It is necessary that we ensure the extensibility and adaptability of code generators if we want to reuse them for different domains. Up to now, research on reusing software has been mainly conducted in the software product line community but rarely discussed in the context of code generators. This paper introduces the generation framework MontiGem and shows how it has been used and evolved within five different research and industry projects in the domains of financial management, IoT, energy management, privacy policy, and wind turbine engineering. We have developed the code generator within the first project and further refined it with each of the following projects. This paper describes the projects, shows how MDE helped us in the software engineering process, and discusses the lessons we learned. These examples show how MDE techniques can be successfully applied to the development of information systems in practice, although further requirements have been met over time. [ABSTRACT FROM AUTHOR]

Code smell detection is one of the essential tasks in the field of software engineering. Identifying whether a code snippet has a code smell is subjective and varies by programming language, developer, and development method. Moreover, developers tend to focus on code smells that have a real impact on development and ignore insignificant ones. However, existing static code analysis tools and code smell detection approaches exhibit a high false positive rate in detecting code smells, which makes insignificant smells drown out those smells that developers value. Therefore, accurately reporting those actionable code smells that developers tend to spend energy on refactoring can prevent developers from getting lost in the sea of smells and improve refactoring efficiency. In this paper, we aim to detect actionable code smells that developers tend to refactor. Specifically, we first collect actionable and non-actionable code smells from projects with numerous historical versions to construct our datasets. Then, we propose a dual-stream model for fusion learning of code metrics and code semantics to detect actionable code smells. On the one hand, code metrics quantify the code's structure and even some rules or patterns, providing fundamental information for detecting code smells. On the other hand, code semantics encompass information about developers' refactoring tendencies, which prove valuable in detecting actionable code smells. Extensive experiments show that our approach can detect actionable code smells more accurately compared to existing approaches. • We provide a method to collect actionable code smells automatically. • We propose a dual-stream model for detecting and identifying actionable code smells. • We comprehensively evaluate our approach on the publicly available and collected datasets. • We provide several valuable suggestions for practitioners and a benchmark for identifying actionable code smells. [ABSTRACT FROM AUTHOR]

During agile requirements engineering, developers need to assimilate and transform the original requirements information into system functions in the form of user stories. Obviously, this is a challenging cognition-based process, in which developers' cognition plays a key role. However, prior research has not explored developers' cognition during the process. The purpose of this study is to investigate and understand developers' cognitive representation styles and interaction patterns in agile requirements. A classification of developers' cognitive representation styles and interaction patterns was first proposed based on literature review. Then, an empirical research was conducted in a capstone software engineering course. Students were playing the role of developers and engaging in agile software development during this course, so their conversation about splitting and defining user stories was recorded and analyzed to examine developers' cognition via a content analysis method. The results show that, even when facing requirements analysis, developers tend to exhibit a technology-oriented cognitive representation style. Additionally, developers have more cognitive difficulty in determining activity and granularity than the role and business value of a user story. Developers also exhibit a preference for cognitive interaction pattern; assertion, comment, and two question-patterns are the major four patterns in our paper rather than information sharing, which was considered a major pattern in previous research. This paper contributes to our understanding of developers' cognition, further predicting and guiding developers' behaviors toward achieving good quality requirements analysis. • We propose developers' cognitive representation styles and interaction patterns in agile requirements. • We examine developers' cognition by their utterances of splitting user stories. • Developers prefer to technology-oriented cognitive representation style even in requirements stage. • Developers have more cognitive difficulty in user stories activity and granularity. • Developers have a preference for four major cognitive interaction patterns. [ABSTRACT FROM AUTHOR]

Model transformations play a key role in model driven software engineering approaches. Validation of model transformations is crucial for the quality assurance of software systems to be constructed. The relational logic based specification language Alloy and its accompanying tool the Alloy Analyzer have been used in the past to validate properties of model transformations. However Alloy based analysis of transformations suffers from several limitations. On one hand, it is time consuming and does not scale well. On the other hand, the reliance on Alloy, being a formal method, prevents the effective involvement of domain experts in the validation process which is crucial for pinpointing domain pertinent errors. Those limitations are even more severe when it comes to transformations whose input and/or output are themselves transformations (called compound transformations) because they are inherently more complex. To tackle the performance and scalability limitations, in previous work, we proposed an Alloy-based Domain Specific Language (DSL), called F-Alloy, that is tailored for model transformation specifications. Instead of pure analysis based validation, F-Alloy speeds up the validation of model transformations by applying a hybrid strategy that combines analysis with interpretation. In this paper, we formalize the notion of “hybrid analysis” and further extended it to also support efficient validation of compound transformations. To enable the effective involvement of domain experts in the validation process, we propose in this paper a new approach to model transformation validation, called Visualization-Based Validation (briefly VBV). Following VBV, representative instances of a to-be-validated model transformation are automatically generated by hybrid analysis and shown to domain experts for feedback in a visual notation that they are familiar with. We prescribe a process to guide the application of VBV to model transformations and illustrate it with a benchmark model transformation. [ABSTRACT FROM AUTHOR]

Software Product Lines (SPLs) constitute a popular method for encouraging the methodical reuse of software artefacts. Just like any other piece of software, SPLs require management throughout their evolution, namely to preserve the consistency between requirements and the code. Over time, for a given SPL, many change requests are made and all of them need to be integrated in a consistent and coordinated way. The evolution of an SPL is facilitated if there exist links between its artefacts, namely between each feature and its respective pieces of implementation code. This paper proposes FMap, a systematic feature mapping approach to be used within SPLs. FMap traces a Feature Model (FM) to other artefacts of an SPL, the reference architecture, and the code, and it establishes connections between each feature of the FM and its locations in the code-base. Additionally, we have created a tool called friendlyMapper to provide some automatic support for the approach. Using two case studies from two different companies, FMap and friendlyMapper are evaluated. The evaluation of the case studies indicates that the FMap approach outperforms the baseline approach (i.e., the branching approach). This work contributes with FMap, a novel tool-based approach that supports feature-architecture-code mappings based on reference architecture. FMap assists software engineers in adapting the evolution of the SPLs to accommodate new features and change requests as the SPLs evolve. The case studies for both companies demonstrate that the approach is applicable to real-world products and is able to support feature traceability and maintain consistency among features, architecture, and code. [ABSTRACT FROM AUTHOR]

Continuous Experimentation (CE) has become increasingly popular across industry and academic communities. Major software organizations use CE to increase their revenue by adding value to end-users, and researchers are investigating the CE adoption process and usage to expand its success. Given this rapid evolution, observing a shared understanding of CE definitions, processes, and experiment strategies is difficult, potentially jeopardizing new implementations and focused research efforts. To characterize CE from the perspective of its definitions, processes, and strategies for experimentation available in the technical literature and to evolve the understanding perspectives for "continuous experimentation" and "data-driven development" definitions. To select and analyze sources of information in the technical literature dealing with different aspects of continuous experimentation through a Literature Study using an ad hoc search improved with snowballing (backward and forward). Organize the findings into new perspectives for CE definitions, processes, and experiment strategies. It was possible to identify many different definitions, processes, and experimental strategies used to describe CE in the 72 analyzed empirical papers, making it difficult to decide on their combination to be applied in a real software development project. Therefore, it has been proposed to evolve the CE understanding perspective, to categorize its experiment strategies, and to offer a combined development process for CE combining parts of other processes. Besides, conjectural requirements have been identified, which can contribute to better differentiating requirements and hypotheses in the CE context. Likely, a better understanding of CE is still missing. It can contribute towards organizing a common taxonomy to facilitate the possible choices for the experiment strategies. Therefore, there is space for more investigations on its applicability and value in different categories of software systems, despite all the advancements of CE and its promotion in developing modern software systems. • It largely extends and brings new contributions regarding the paper presented at CibSe2022. • It offers an organized evidence-based characterization of Continuous Experimentation in Software Engineering. • It presents a Combined Process for Continuous Experimentation in Software Engineering. • It raises the discussions on new perspectives on Continuous Experimentation in Software Engineering. [ABSTRACT FROM AUTHOR]

Software architectures are subject to several types of change during the software lifecycle ( e.g. adding requirements, correcting bugs, enhancing performance). The variety of these changes makes architecture evolution management complex because all architecture descriptions must remain consistent after change. To do so, whatever part of the architectural description they affect, the effects of change have to be propagated to the other parts. The goal of this paper is to provide support for evolving component-based architectures at multiple abstraction levels. Architecture descriptions follow an architectural model named Dedal, the three description levels of which correspond to the three main development steps – specification, implementation and deployment. This paper formalizes an evolution management model that generates evolution plans according to a given architecture change request, thus preserving consistency of architecture descriptions and coherence between them. The approach is implemented as an Eclipse-based tool and validated with three evolution scenarios of a Home Automation Software example. [ABSTRACT FROM AUTHOR]

Bridging the gap between informal requirements and formal specifications is a key challenge in systems engineering. Constructing appropriate abstractions in formal models requires skill and managing the complexity of the relationships between requirements and formal models can be difficult. In this paper we present an approach that aims to address the twin challenges of finding appropriate abstractions and managing traceability between requirements and models. Our approach is based on the use of semi-formal structures to bridge the gap between requirements and Event-B models and retain traceability to requirements in Event-B models. In the stepwise refinement approach, design details are gradually introduced into formal models. Stepwise refinement allows each requirement to be introduced at the most appropriate stage in the development. Our approach makes use of the UML-B and Event Refinement Structures (ERS) approaches. UML-B provides UML graphical notation that enables the development of data structures for Event-B models, while the ERS approach provides a graphical notation to illustrate event refinement structures and assists in the organisation of refinement levels. The ERS approach also combines several constructor patterns to manage control flows in Event-B. The intent of this paper is to harness the benefits of the UML-B and ERS approaches to facilitate constructing Event-B models from requirements and provide traceability between requirements and Event-B models. [ABSTRACT FROM AUTHOR]

There has been a growing interest in the role of theory within Software Engineering (SE) research. For several decades, researchers within the SE research community have argued that, to become a ‘real’ engineering science, SE needs to develop stronger theoretical foundations. However, so far, the role of theory is neither fully appreciated nor well understood in SE research. Without a good common understanding of what theory is , what it constitutes in SE research, and the various roles it can play in SE research, it is difficult to appreciate how theory building can help to strengthen SE research. In this paper we discuss the importance of theory and conceptualization, and review the key components that comprise a theory. We then present the Research Path Schema (RPS), which is an adaptation of an analytical framework from the social sciences. The RPS defines a research study as consisting of three components: some phenomenon, system or substance that a researcher is interested in; some technique or method to study that substance; and some form of conceptualization or theory that provides an explanation for, or abstraction of the observations made in a study. Different research studies have a different archetypical ‘architecture,’ depending on the selection of these three components. Consequently, the role of the conceptualization or theory will be different for each archetypical study design, or selected research path . We conclude this paper by outlining a number of implications for future SE research, and argue for a Theory-Oriented Software Engineering research perspective, which can complement the recent focus on Evidence Based Software Engineering. [ABSTRACT FROM AUTHOR]

The contribution of this paper to a general theory of software engineering is twofold: it presents the model system concept, and it integrates the software engineering design process into a decision making theory and a value-based decision-under-risk process. The model system concept is defined as a collection of interconnected and consistent components that work together for defining, developing, and delivering a software system. This model system concept is used to represent the multiple facets of a software engineering project such as stakeholders and models related to domain/environment, success, decision, product, process, and property. The model system concept is derived from software development practices in the industry and academia. The theoretical decision framework acts as a central governance component for a given software engineering project. Applying this decision framework allows for effectively managing risks and uncertainties related to success in the project building stage. Especially, this puts the design process in an economic perspective, where concepts such as value-of-waiting, value-of-information and possible outcomes can be coped with explicitly. In practice, the decision framework allows for the optimal control of modern adaptive software development. In particular, one can use dynamic programming to find the optimal sequence of decisions to be made considering a defined time horizon. In this way we can relate our contribution to a theory of software engineering to the well-studied areas of automatic control, optimization, decision theory and Bayesian analysis. Computational case studies exemplify the conceptual innovations proposed in this paper. [ABSTRACT FROM AUTHOR]

Following calls for greater theory development in software engineering, this paper formulates a process theory of software development practice. Sensemaking-Coevolution-Implementation Theory explains how complex software systems are created by cohesive software development teams in organizations. It posits that an independent agent (the development team) creates a software system by alternating between three categories of activities: making sense of an ambiguous context, mutually refining schemas of the context and design space, and manifesting their understanding of the design space in a technological artifact. This theory development paper defines, illustrates and conceptually evaluates Sensemaking-Coevolution-Implementation Theory. It grounds the theory's concepts and relationships in existing software engineering, information systems development and interdisciplinary design literature. [ABSTRACT FROM AUTHOR]

General theories of software engineering must balance between providing full understanding of a single case and providing partial understanding of many cases. In this paper we argue that for theories to be useful in practice, they should give sufficient understanding of a sufficiently large class of cases, without having to be universal or complete. We provide six strategies for developing such theories of the middle range. In lab-to-lab strategies, theories of laboratory phenomena are developed and generalized to other laboratory phenomena. This is a characteristic strategy for basic science. In lab-to-field strategies, theories are developed of artifacts that first operate under idealized laboratory conditions, which are then scaled up until they can operate under uncontrolled field conditions. This is the characteristic strategy for the engineering sciences. In case-based strategies, we generalize about components of real-world cases, that are supposed to exhibit less variation than the cases as a whole. In sample-based strategies, we generalize about the aggregate behavior of samples of cases, which can exhibit patterns not visible at the case level. We discuss three examples of sample-based strategies. Throughout the paper, we use examples of theories and generalization strategies from software engineering to illustrate our analysis. The paper concludes with a discussion of related work and implications for empirical software engineering research. [ABSTRACT FROM AUTHOR]

Semantic processing of conceptual models is a focus of research for several years, bridging the disciplines of knowledge-based systems, conceptual modeling, and model-driven software engineering. With Knowledge Graphs, this research area gained momentum. In this paper, we introduce CM2KGcloud, a generic and extensible Web-based platform for transforming conceptual models into Knowledge Graphs. The platform can work on models created by state-of-the-art metamodeling platforms (e.g., EMF, Papyrus, ADOxx) and transforms models created with them into standardized Knowledge Graph representations like GraphML, RDF, and OWL. CM2KGcloud can be used as a service and can be integrated into software systems by its exposed API. • We introduce CM2KGcloud, a cloud platform for transforming conceptual models into Knowledge Graphs. • CM2KGcloud can process models created with ADOxx, EMF, and Papyrus-based modeling tools. • CM2KGcloud comes with pre-defined queries that are able to detect models smells. • Query results are graphically superimposed to the transformed Knowledge Graph. • The software is available at http://me.big.tuwien.ac.at/cm2kg. [ABSTRACT FROM AUTHOR]

Studying the interactions and relationships between non-functional requirements (NFRs) is important when developing software applications. This is because that a specific NFR may conflict, overlap or complement other NFRs. Moreover, one NFR may include characteristics and features of other NFRs. Most of the current studies focused on classifying NFRs into distinct different categories without considering the common characteristics or the relationships between these categories. This paper provides a study on how the results of various machine learning (ML) classifiers can be visualized and analyzed with the help of confusion matrices and principal component analysis (PCA) tools in order to examine the commonalities, mappings and relationships between NFRs. And to define which NFRs are mostly distinct and which NFRs are mostly overlapping. The paper also defines which ML classifier achieves the best performance through various classifications of NFRs. The experiments were performed using five different ML classifiers on the newly expanded PROMISE dataset and the achievements of these classifiers are evaluated based on precision, recall and F1-Score metrics. The results of this research help practitioners and researchers in the field of software engineering to pay more attention on the behavior of various NFRs. • ML techniques help in examining the behavior of NFRs. • ML techniques assist in defining the mostly distinct NFRs and the mostly overlapped NFRs. • ML classifiers perform better when understating the behavior of NFRs. • It is not necessarily for a classifier to perform better when the number of NFRs and their labels becomes smaller. [ABSTRACT FROM AUTHOR]

Abstract: This paper introduces the Special Issue on Component-Based Software Engineering and Software Architecture, which contains extended versions of a selection of the best papers presented at the CompArch 2012 conference, held in June 2012, in Bertinoro, Italy. [Copyright &y& Elsevier]

Abstract: This paper reports the experience of WebRatio, a company focusing on Model-Driven Engineering (MDE) tools (WebRatio and WebRatio BPM) and services since 2001. The adopted MDE approach is based on the transformation of models expressed in a Domain Specific Language called WebML (Web Modeling Language) into running applications, with the unique feature of creating not only the back-end data and business logic but also the Web/RIA front-end, without posing any limitation on the graphical and interaction quality of the user interface. WebRatio has been applied in many industrial projects, some of which have delivered large-scale enterprise applications, generated and maintained completely through MDE practices over the years. In this paper we present the lessons learned within this experience, describe some success stories and show some quantitative information and evaluation on the usage of the approach. [Copyright &y& Elsevier]

Abstract: This inaugural Special Issue on Experimental Software Engineering in the Cloud (ESEiC) contributes to the further development of experimental software tools while also demonstrating ways in which the empirical evaluation of software engineering results can be improved. The open call for papers to this issue invited academic software developers to publish entire software environments together with a paper that focuses on the empirical evaluation of the related engineering techniques. Out of five submissions, two have been accepted. Both papers are the result of long term research efforts by multiple authors, and are supplemented by a multitude of software environments: all of the software engineering tools under study are available via virtual machines (VMs) in the academic SHARE cloud. The first paper cites 13 VMs, each containing one tool, while the second one cites one VM containing five tools under study. Both papers contribute new frameworks for comparing the tools under study. To the best of our knowledge, this is the first informatics journal issue that offers reproducible comparisons of such depth and breadth. In this editorial, we clarify the background of the special issue, introduce the SHARE cloud platform, and summarize the two papers. [Copyright &y& Elsevier]

Abstract: This paper presents the InterMod methodology. By combining the widely accepted Agile Methods, Model-Driven Developments and User-Centred Design it allows us to develop high-quality interactive applications. As a main characteristic, it plans and organises the software project as a series of iterations that are guided by the User Objectives in an agile and user-centred manner. At each iteration, the software development work can be distributed to different teams according to some developmental and integration activities. Each activity is driven by models that are validated by a multidisciplinary team composed of developers and users. The requirements are incrementally collected and formalised by means of models based on user-centred design. Besides, the Semantically Enriched Human–Computer Interaction model is proposed to speed up project validation. This model enriches a human–computer interaction model with some visual characteristics and the application semantic. Thus, the enriched model provides enough information to generate prototypes so users and developers can easily validate this model. Diagram project is a real case study that is used to illustrate the application of the InterMod methodology through the whole paper. [Copyright &y& Elsevier]

Abstract: Recent approaches to component-based software engineering employ coordinating connectors to compose components into software systems. For maximum flexibility and reuse such connectors can themselves be composed, resulting in an expressive calculus of connectors whose semantics encompasses complex combinations of synchronisation, mutual exclusion, non-deterministic choice and state-dependent behaviour. To increase the expressiveness of connectors, notions of context-dependent behaviour have been proposed. Context dependency can be used can express the priority of one behaviour over another and the inhibition of actions due to changing context. The notion of context we consider in this paper is given by the pending activities on the ports of a connector. Context-dependent behaviour occurs whenever the choices available to a connector change non-monotonically as its context changes. Capturing context-dependent behaviour in formal models is non-trivial, as it is unclear how to propagate context information through composition. In this paper we present an intuitive automata-based formal model of context-dependent connectors, and argue that it is superior to previous attempts at such a model for the coordination language Reo. [Copyright &y& Elsevier]

Abstract: Software modernization is critical for organizations that need cost-effective solutions to deal with the rapid obsolescence of software and the increasing demand for new functionality. This paper presents the XIRUP modernization methodology, which proposes a highly iterative process, structured into four phases: preliminary evaluation, understanding, building and migration. This modernization process is feature-driven, component-based, focused on the early elicitation of key information, and relies on a model-driven approach with extensive use of experience from the previous projects. XIRUP has been defined in the European IST project MOMOCS, which has also built a suite of support tools. This paper introduces the process using a case study that illustrates its activities, related tools and results. The discussion highlights the specific characteristics of modernization projects and how a customized methodology can take advantage of them. [Copyright &y& Elsevier]

Abstract Any software development process needs to consider non-functional requirements (NFR) in order to deliver a system that complies with its stakeholders' expectations. In a previous mapping study about model-driven development (MDD) for service-oriented architectures (SOA) we found a limited number of approaches managing NFR. The present work aims at analyzing in detail the state of the art in the management of NFR in MDD processes which produce SOA. We have conducted a systematic literature review following a rigorous protocol. We have taken as initial point the mapping study mentioned above and have used the subset of the 31 papers from this study (clustered into 15 approaches) that referred to NFR. We have analyzed them qualitatively in order to answer six research questions. We have built a Software Engineering theory to formalize this analysis. As result we highlight that most of approaches focus exclusively on security and reliability and we observe that NFR are expressed mainly as annotations of functional models represented in UML. From our perspective, existing research on the topic of this study is still scarce and without any evidence of transferability to industry. This situation suggests the need for further investigation efforts in order to produce validated MDD methods capable of generating SOA satisfying NFR stated by stakeholders. Highlights • Any software development process needs to consider non-functional requirements (NFR) to fulfill stakeholders' expectations. • A systematic literature review on the management of NFR in MDD processes which produce SOA systems has been conducted. • Most of approaches focus on security and reliability and express NFR as annotations of functional models represented in UML. • Existing research seems to be still scarce and without any evidence of transferability to industry. [ABSTRACT FROM AUTHOR]

Abstract Data-intensive Web applications are usually developed by means of specific Web application frameworks, which provide, among other features, the proper tools to automate redundant tasks, e.g. the implementation of CRUD operations. However, although Model-Driven Web Engineering (MDWE) approaches have defined specific languages and tools to significantly reduce development efforts, the provision of such automation tools has been traditionally neglected. This paper presents AutoCRUD, a WebRatio plug-in automating the generation of CRUD operations in OMG Interacting Flow Modelling Language (IFML). It has been developed as a joint effort by academia and industry to assess its validity in a real scenario. Highlights • A MDWE tool (WebRatio plugin) to automatically generate CRUD operations specification in IFML by pattern instantiation. • New patterns may be defined to enlarge its default repository. • For teaching purposes, a step-by-step generation of IFML may be performed. • Easy and guided visual instantiation of patterns. • It may significantly increase development team productivity. [ABSTRACT FROM AUTHOR]

Highlights • An architectural assumption management process with guidelines is developed. • Two case studies were conducted to validate the process. • The process can help to make architectural assumptions explicit. • The process can help to identify and reduce invalid architectural assumptions. Abstract Context Architectural assumption management is critical to the success of software development projects. In this paper, we propose an Architectural Assumption Management (AAM) process, comprised of four AAM activities: Architectural Assumption Making, Description, Evaluation, and Maintenance. Objective Evaluating the AAM process in architectural assumption management, regarding the ease of understanding and the effort of conducting the AAM process, as well as the effectiveness of using the AAM process to make architectural assumptions explicit and to identify and reduce invalid architectural assumptions. Method An explanatory study with 88 first-year master students in software engineering, and an exploratory study with five practitioners from five companies. Results (1) the ease of understanding the AAM process is moderate for first-year master students but easy for practitioners; (2) the effort of conducting the AAM process is moderate for first-year master students; (3) Making and Evaluation took the students more time than Description and Maintenance; (4) the practitioners considered Evaluation as the most time consuming activity; (5) the AAM process can help to make architectural assumptions explicit and to identify and reduce invalid architectural assumptions in projects. The majority of the students and practitioners agreed that Architectural Assumption Evaluation is the most helpful activity for all these three aspects. For other activities, there are different opinions about their helpfulness; and (6) there are various factors identified that can impact the aforementioned results. Being aware of and properly adjusting these factors can facilitate the application of the AAM process in projects. Conclusions The AAM process aims at systematically managing architectural assumptions in software development. The results of the case studies provide preliminary empirical evidence for the evaluation of the AAM process. [ABSTRACT FROM AUTHOR]

Abstract: Mathematical expressions in tabular form (also called “tabular expressions” or “tables”) have been shown to be useful for documenting and analysing software systems. They are usually easier to read than conventional mathematical expressions but are no less precise. They can be used wherever mathematical expressions are used. To avoid misunderstandings, and to support users with trustworthy tools, the meaning of these expressions must be fully defined. This paper presents a new method for defining the meaning of tabular expressions. Each definition of an expression type names the expression’s constituents, and provides a restriction schema and one or more evaluation schemas. The restriction schema defines the class of well-formed expressions of the type. An evaluation schema maps a well-formed tabular expression of the type to a mathematical expression of a previously defined type. Since the meaning of conventional mathematical expressions is well known, describing an equivalent expression fully defines the meaning of a tabular expression. In this approach, indexation is used to decouple the appearance of a tabular expression from its semantics. A tabular expression is an indexed set of grids; a grid is an indexed set of expressions. The expressions in a grid can be either conventional expressions or tabular expressions of a previously defined type. Defining the meaning of a tabular expression in this way facilitates the building of tools that faithfully implement the semantics. The decoupling of syntax and semantics by means of indices overcomes some limitations of older approaches. The method presented in the paper is illustrated by defining several previously known types of tabular expressions and some new ones. The use of the new model to build a suite of tools for the input, presentation, validation, evaluation, simplification, conversion and composition of tabular expressions is discussed. [Copyright &y& Elsevier]

Abstract: Software analysis, evolution, and reengineering are important areas of the software life cycle. The quest to maintain and keep operational large mission critical systems has always been a challenge for software practitioners. This special issue presents a compilation of papers covering six major areas namely, program understanding, tools and environments, source code modeling, component recovery, migration to network-centric platforms, and binary reverse engineering and reengineering. These papers are re-worked and extended versions of papers that appeared in the Working Conference on Reverse Engineering. We hope that the readers will find this collection of papers useful as it provides an indicative view of the current work in the areas of software analysis, evolution, and reengineering. [Copyright &y& Elsevier]

Abstract: This paper introduces the “Safe Instantiation Principle”, a new design criterion for evaluating extensions of Java that support generic types. The paper initially focuses on the GJ and NextGen formulations of Generic Java and the implications of safe instantiation for both approaches. Then it applies the safe instantiation principle to the problem of adding mixins to Java as generic types. Finally, it shows that the hygienic formulation of mixins is the only way to maintain safe instantiation and type soundness in Java with mixins and to prevent the introduction of insidious bugs with no clearly defined point of blame. [Copyright &y& Elsevier]

Abstract: This paper examines the relationship between the static coupling between objects (CBO) metric and some of its dynamic counterparts. The dimensions of the relationship for Java programs are investigated, and the influence of instruction coverage on this relationship is measured. An empirical evaluation of 14 Java programs taken from the SPEC JVM98 and the JOlden benchmark suites is conducted using the static CBO metric, six dynamic metrics and instruction coverage data. The results presented here confirm preliminary studies indicating the independence of static and dynamic coupling metrics, but point to a strong influence of coverage on the relationship. Based on this, this paper suggests that dynamic coupling metrics might be better interpreted in the context of coverage measures, rather than as stand-alone software metrics. [Copyright &y& Elsevier]

There is a well documented problem in the software engineering field relating to a structural mismatch between the specification of requirements for software systems and the specification of object-oriented software systems. The structural mismatch happens because the units of interest during the requirements phase (for example, feature, service, capability, function, etc.) are different to the units of interest during object-oriented design and implementation (for example, object, class, method, etc.). The structural mismatch results in support for a single requirement being scattered across the design units and a single design unit supporting multiple requirements—this in turn results in reduced comprehensibility, traceability and reuse of design models.This paper presents an approach to designing systems based on the object-oriented model, but extending this model by adding new decomposition capabilities. The new decomposition capabilities support a way of directly aligning design models with individual requirements. Each model contains a design of an individual requirement, with concepts from the domain (which may appear in multiple requirements) designed from the perspective of that requirement. Standard UML is used to design the models decomposed in this way. Composition of design models is supported, and it is specified with a composition relationship. A composition relationship specifies how models are to be composed by identifying overlapping concepts in different models and specifying how models should be integrated. This paper describes changes required to the UML metamodel to support composition relationships. Two kinds of integration strategies are discussed—merge and override. [Copyright &y& Elsevier]

Medical devices are safety-critical systems since their malfunctions can seriously compromise human safety. Correct operation of a medical device depends upon the controlling software, whose development should adhere to certification standards. However, these standards provide general descriptions of common software engineering activities without any indication regarding particular methods and techniques to assure safety and reliability. This paper discusses how to integrate the use of a formal approach into the current normative for the medical software development. The rigorous process is based on the Abstract State Machine (ASM) formal method, its refinement principle, and model analysis approaches the method supports. The hemodialysis machine case study is used to show how the ASM-based design process covers most of the engineering activities required by the related standards, and provides rigorous approaches for medical software validation and verification. [ABSTRACT FROM AUTHOR]

The growing role of Model Driven Engineering (MDE) techniques in industry has emphasized scalability of existing model persistence solutions as a major issue. Specifically, there is a need to store, query, and transform very large models in an efficient way. Several persistence solutions based on relational and NoSQL databases have been proposed to achieve scalability. However, they often rely on a single data store, which suits a specific modeling activity, but may not be optimized for other use cases. This paper presents NeoEMF , a tool that tackles this issue by providing a multi-database model persistence framework. Tool website: http://www.neoemf.com [ABSTRACT FROM AUTHOR]

• Effort estimation-based Use Case Points method is increasingly used among researchers. • Among 127 searched papers, only 75 quality papers have been selected for investigation. • Most of publications on UCP effort estimation were published in conference proceedings. • Top software engineering journal do not include papers on UCP effort estimation. • Researchers usually do not refer to previously published relevant papers on the same research topic. Context : Predicting software project effort from Use Case Points (UCP) method is increasingly used among researchers and practitioners. However, unlike other effort estimation domains, this area of interest has not been systematically reviewed. Aims : There is a need for a systemic literature review to provide directions and supports for this research area of effort estimation. Specifically, the objective of this study is twofold: 1) to classify UCP effort estimation papers based on four criteria: contribution type, research approach, dataset type and techniques used with UCP; and 2) to analyze these paper from different views: estimation accuracy, favorable estimation context and impact of combined techniques on the accuracy of UCP. Method : We used the systematic literature review methodology proposed by Kitchenham and Charters. This includes searching for the most relevant papers, selecting quality papers, extracting data and drawing results. Result : The authors of UCP research paper, are generally not aware of previous published results and conclusions in the field of UCP effort estimation. There is a lack of UCP related publications in the top software engineering journals. This makes a conclusion that such papers are not useful for the community. Furthermore, most articles used small numbers of projects which cannot support generalizing the conclusion in most cases. Conclusions : There are multiple research directions for UCP method that have not been examined so far such as validating the algebraic construction of UCP based on industrial data. Also, there is a need for standard automated tools that govern the process of translating use case diagram into its corresponding UCP metrics. Although there is an increase interest among researchers to collect industrial data and build effort prediction models based on machine learning methods, the quality of data is still subject to debate. [ABSTRACT FROM AUTHOR]

• Some say that ignorance of the domain of a computer-based system to be built helps in doing some development tasks. • A survey of software development managers determined what development tasks are perceived as helped by domain ignorance. • New hires and immigrants, i.e., newbies, are generally initially ignorant of the domain of their new project. • Mining third-party interviews of newbies determined what tasks were assigned to newbies that had successful immigrations. • It appears that newbies who are assigned tasks perceived as helped by domain ignorance might have successful immigrations. A big problem in a computer-based systems (CBSs) development organization is how to improve the immigration of a newbie (a new hire to the organization or a mover within the organization) into a CBS development project of the organization that is already in progress. The newbie, who is ignorant of the domain of the CBS, must be brought to the same awareness of the domain that the project veterans have (1) without becoming a drain on his or her mentor and (2) while becoming useful to the project as soon as possible. Based on other work that shows that some CBS development activities benefit from the out-of-the-box thinking of a domain ignorant, it is hypothesized that a newbie who starts his or her immigration with CBS development activities requiring or enhanced by domain ignorance has a more successful immigration than a newbie who starts with other activities. The current paper reports a two-part empirical test of the hypothesis. First, a survey was conducted among CBS development managers of varying experience to determine what CBS development activities they thought were helped by domain ignorance. Second, transcripts from fourteen interviews of domain-ignorant immigrants to new CBS development projects at one large company were examined to determine if the activities performed by those with the most successful immigrations were activities that are considered by CBS development managers to be helped by domain ignorance. In the end, there is some modest support for the hypothesis, despite all the opportunities for the data to show a different conclusion because of the existence of many other factors that influence immigration success. Following a discussion of the threats to the validity of the result, the paper concludes with recommendations for tasks to assign to newbies to improve their immigrations, recommendations for project staffing in general, and recommendations for future research. [ABSTRACT FROM AUTHOR]

Today, PHP is one of the most popular programming languages, and is commonly used in the open source community and in industry to build large application frameworks and web applications. In this paper, we discuss our ongoing work on PHP AiR, a framework for PHP Analysis in Rascal. PHP AiR is focused especially on program analysis and empirical software engineering, and is being used actively and effectively in work on evaluating PHP feature usage and system evolution, on program analysis for refactoring and security validation, and on source code metrics. We describe the requirements and design decisions for PHP AiR, summarize current research using PHP AiR, discuss lessons learned, and briefly sketch future work. [ABSTRACT FROM AUTHOR]

Much of Software Engineering research needs to provide an implementation as proof-of-concept. Often such implementations are created as exploratory prototypes without polished user interfaces, making it difficult to (1) run user studies to validate the tool's contribution, (2) validate the author's claim by fellow scientists, and (3) demonstrate the utility and value of the research contribution to any interested parties. However, turning an exploratory prototype into a “proper” tool for end-users often entails great effort. Heavyweight mainstream frameworks such as Eclipse do not address this issue; their steep learning curves constitute substantial entry barriers to such ecosystems. In this paper, we present the Model Analyzer/Checker (MACH), a stand-alone tool with a command-line interpreter. MACH integrates a set of research prototypes for analyzing UML models. By choosing a simple command line interpreter rather than (costly) graphical user interface, we achieved the core goal of quickly deploying research results to a broader audience while keeping the required effort to an absolute minimum. We analyze MACH as a case study of how requirements and constraints in an academic environment influence design decisions in software tool development. We argue that our approach while perhaps unconventional, serves its purpose with a remarkable cost-benefit ratio. [ABSTRACT FROM AUTHOR]

MAZE is an extension of the Object-Z specification language supporting the specification and development of multi-agent systems (MAS). Following recommendations from the agent-oriented software engineering community, it supports three distinct levels of abstraction: (i) the macro level which focusses on the system's overall, global behaviour, independently of how the agents of the system operate and interact, (ii) the meso level which focusses on agent interactions, and (iii) the micro level which focusses on the operation of individual agents. Object-Z's high-level support for component-based specification, which is well suited to modelling MAS, is complemented in MAZE with support for action refinement to facilitate the top-down development process from the macro to micro level, and with a number of syntactic conventions aimed at abstractly specifying the low-level mechanisms required for dealing with asynchronous communication and timing constraints at the micro level. The latter are shorthands for existing Object-Z notation and so require no redefinition of Object-Z's semantics. In this paper, we provide an overview of MAZE and illustrate its use on a non-trivial case study: a swarm robotic algorithm for self-assembly. [ABSTRACT FROM AUTHOR]

Knowledge management within companies and institutions is one of the main problems when defining and developing new solutions to improve information systems. Currently, information systems have evolved into technological ecosystems that are a set of different components related to each other through information flows in a physical environment that supports these flows, where users are part of the ecosystem. Particularly, during the last several years, the Open Source software has been used to develop these technological solutions. The aim of this paper is to formalize an architectural pattern to support the right description and implementation of eLearning ecosystems. The theoretical basis has been provided in previous works by using a comparative analysis of the Strengths, Weaknesses, Opportunities and Threats of several real case studies developed in different contexts. The problems detected through the previous analysis have been modelled using the Business Process Model and Notation. Next, the pattern has been formalized with the Service-oriented architecture Modelling Language. Finally, the pattern has been tested in a real context, namely, an institutional development for the Spanish Public Administration, which has demonstrated that the pattern works properly. As a result, we have obtained a set of Business Process Model and Notation diagrams that provide a high abstraction level for the main detected problems in eLearning ecosystems. We have also obtained an architectural pattern composed of several layers and a set of external elements that provides a solution to these problems. [ABSTRACT FROM AUTHOR]

Nowadays applications that require the interaction and collaboration of two or more users simultaneously via different devices such as web browsers and mobile phones are becoming more and more frequent in a time where cross-device and cross-play features are demanded by final users, thus, to ensure high quality of those products, software engineers are adopting test automation techniques that can optimize their quality assurance processes. In previous work we presented Kraken 2.0, a publicly available cross-device testing tool that completely reconstructed the Kraken 1.0 architecture and enables a tester to write, run, and validate test scenarios that involve the interaction of web and mobile devices in parallel by implementing test scripts created with the Gherkin syntax. In this paper, we provide more details about the Kraken 2.0 architecture and describe new features such as extraction of GUI snapshots and definition of test scripts in an automation API fashion. • Automated testing for cross-device and cross-platform (web and mobile) scenarios is not well explored yet. • Mobile applications that involve the interaction of two or more users are becoming more common nowadays. • Kraken allows E2E testing across multiple Android and web devices. [ABSTRACT FROM AUTHOR]

In this paper, we propose a new approach to inheritance and abstraction in the context of algebraic graph transformation by providing a suitable categorial framework which reflects the semantics of class-based inheritance in software engineering. Inheritance is modelled by a type graph T that comes equipped with a partial order. Typed graphs are arrows with codomain T which preserve graph structures up to inheritance. Morphisms between typed graphs are “down typing” graph morphisms: An object of class t can be mapped to an object of a subclass of t . Abstract classes are modelled by a subset of vertices of the type graph. We prove that this structure is an adhesive HLR category, i.e. pushouts along extremal monomorphisms are “well-behaved”. This infers validity of classical results such as the Local Church–Rosser Theorem, the Parallelism Theorem, and the Concurrency Theorem. [ABSTRACT FROM AUTHOR]

Model-driven engineering is the generation of software artefacts from abstract models. This is achieved through transformations that encode domain knowledge and implementation strategies. The same transformations can be used to produce quite different systems, or to produce successive versions of the same system. A model-driven approach can thus reduce the cost of development. It can also reduce the cost of verification: if the transformations are shown or assumed to be correct, each new system or version can be verified in terms of its model, rather than its implementation. This paper introduces an approach to model-driven engineering that is particularly suited to the development of critical information systems. The language of the models, and the language of the transformations, are amenable to formal analysis. The transformation strategy, and the associated development methodology, are designed to preserve systems integrity and availability. [ABSTRACT FROM AUTHOR]

Software engineering is complex and success depends on many inter-related factors. Theory Based Software Engineering (TBSE) is about providing a practical way for software teams to understand the relationships and the influence of these factors to thereby adapt the way they work. This paper proposes an approach to TBSE based on Essence, a software engineering kernel distilled by the SEMAT (Software Engineering Method and Theory) initiative. Essence supports TBSE by providing a domain model that is useful for organizing and relating software engineering factors. Essence also helps make recommended practices precise and actionable to software teams. We provide a step-by-step application of our approach on an industrial software process improvement case study. The case study achieved 21% productivity gains and 58% decrease in defects. But more importantly than these results, it demonstrates the value of Essence in supporting TBSE. [ABSTRACT FROM AUTHOR]