Software Product Lines

Frontmatter

Applying Incremental Model Slicing to Product-Line Regression Testing

Abstract

One crucial activity in software product line (SPL) testing is the detection of erroneous artifact interactions when combined for a variant. This detection is similar to the retest test-case selection problem in regression testing, where change impact analysis is applied to reason about changed dependencies to be retested. In this paper, we propose automated change impact analysis based on incremental model slicing for incremental SPL testing. Incremental slicing allows for a slice computation by adapting a previous slice with explicit derivation of their differences by taking model changes into account. We apply incremental slicing to determine the impact of applied model changes and to reason about their potential retest. Based on our novel retest coverage criterion, each slice change specifies a retest test goal to be covered by existing test cases selected for retesting. We prototypically implemented our approach and evaluated its applicability and effectiveness by means of four SPLs.

Sascha Lity, Thomas Morbach, Thomas Thüm, Ina Schaefer

Automated Composition of Service Mashups Through Software Product Line Engineering

Abstract

The growing number of online resources, including data and services, has motivated both researchers and practitioners to provide methods and tools for non-expert end-users to create desirable applications by putting these resources together leading to the so called mashups. In this paper, we focus on a class of mashups referred to as service mashups. A service mashup is built from existing services such that the developed service mashup offers added-value through new functionalities. We propose an approach which adopts concepts from software product line engineering and automated AI planning to support the automated composition of service mashups. One of the advantages of our work is that it allows non-experts to build and optimize desired mashups with little knowledge of service composition. We report on the results of the experimentation that we have performed which support the practicality and scalability of our proposed work.

Mahdi Bashari, Ebrahim Bagheri, Weichang Du

Feature Location in Model-Based Software Product Lines Through a Genetic Algorithm

Abstract

When following an extractive approach to build a model-based Software Product Line (SPL) from a set of existing products, features have to be located across the product models. The approaches that produce best results combine model comparisons with the knowledge from the domain experts to locate the features. However, when the domain expert fails to provide accurate information, the semi-automated approach faces challenges. To cope with this issue we propose a genetic algorithm to feature location in model-based SPLs. We have an oracle from an industrial environment that makes it possible to evaluate the results of the approaches. As a result, the proposed approach is able to provide solutions upon inaccurate information on part of the domain expert while the compared approach fails to provide a solution when the information provided by the domain expert is not accurate enough.

Jaime Font, Lorena Arcega, Øystein Haugen, Carlos Cetina

Carrying Ideas from Knowledge-Based Configuration to Software Product Lines

Abstract

Software variability modelling (SVM) has become a central concern in software product lines – especially configurable software product lines (CSPL) require rigorous SVM. Dynamic SPLs, service oriented SPLs, and autonomous or pervasive systems are examples where CSPLs are applied. Knowledge-based configuration (KBC) is an established way to address variability modelling aiming for the automatic product configuration of physical products. Our aim was to study what major ideas from KBC can be applied to SVM, particularly in the context of CSPLs. Our main contribution is the identification of major ideas from KBC that could be applied to SVM. First, we call for the separation of types and instances. Second, conceptual clarity of modelling concepts, e.g., having both taxonomical and compositional relations would be useful. Third, we argue for the importance of a conceptual basis that provides a foundation for multiple representations, e.g., graphical and textual. Applying the insights and experiences embedded in these ideas may help in the development of modelling support for software product lines, particularly in terms of conceptual clarity and as a basis for tool support with a high level of automation.

Juha Tiihonen, Mikko Raatikainen, Varvana Myllärniemi, Tomi Männistö

Tax-PLEASE—Towards Taxonomy-Based Software Product Line Engineering

Abstract

Modern software systems, in particular in mobile and cloud-based applications, exist in many different variants in order to adapt to changing user requirements or application contexts. Software product line engineering allows developing these software systems by managed large-scale reuse in order to achieve shorter time to market. Traditional software product line engineering approaches use a domain variability model which only captures the configuration options of the product variants, but does not provide any guideline for designing and implementing reusable artifacts. In contrast, software taxonomies structure software domains from an abstract specification of the functionality to concrete implementable variants by successive correctness-preserving refinements. In this paper, we propose a novel software product line engineering process based on a taxonomy-based domain analysis. The taxonomy’s hierarchy provides guidelines for designing and implementing the product line’s reusable artifacts while at the same time specifying possible configuration options. By deriving reusable product line artifacts from a software taxonomy, the well-defined structuring of the reusable artifacts yields improved maintainability and evolvability of the product line.

Ina Schaefer, Christoph Seidl, Loek Cleophas, Bruce W. Watson

Business Aspects of Software Reuse

Frontmatter

A Method to Support the Adoption of Reuse Technology in Large Software Organizations

Abstract

The process of adopting a software technology in a large organization is significantly influenced by organizational culture and behavioral aspects of the practitioners involved in the process. The adoption of software reuse technology in particular significantly alters the software process of the organization as well as the modus operandi of the practitioners involved. The identification of factors that will facilitate or hinder this process is strongly correlated with the existing system of beliefs and represents a key element to the planning of this process. Our aim is to propose an action model based on classes of beliefs that will support the process of adoption of software reuse technology. An industrial case study was conducted in a large organization to validate and refine the proposed method. As a result, we propose a method based on the identification of classes of beliefs and re-signification of those that hinders the adoption of software reuse technologies.

Luiz Amorim, Manoel Mendonça

A Practical Use Case Modeling Approach to Specify Crosscutting Concerns

Abstract

Use case diagrams together with use case specifications are commonly used to specify system requirements. To reduce imprecision, ambiguity, and incompleteness in use case specifications, an approach with template and restriction rules is often recommended to achieve better understandability of use cases and improves the quality of derived analysis models. However, when crosscutting concerns are modeled together with non-crosscutting concerns as use case models, resulting use case models often result in cluttered diagrams and redundant information in use case specifications. Therefore, the overall reusability of the use case models is usually low. To tackle this, we extend a general use case approach, named as RUCM, for modeling crosscutting concerns, along with a weaver to automatically weave aspect use case models into their corresponding base model to facilitate, e.g., automated requirements analysis. The extended approach has been evaluated with three real-world applications from communication, maritime and energy domains and aviation. We compared the modeling effort required to model three sets of crosscutting concerns from the real-world applications, when using and not using the extended RUCM approach. Results show that more than 80 % of modeling effort can be saved.

Tao Yue, Huihui Zhang, Shaukat Ali, Chao Liu

An Approach for Prioritizing Software Features Based on Node Centrality in Probability Network

Abstract

Due to the increasing complexity of software products as well as the restriction of the development budget and time, requirements prioritization, i.e., selecting more crucial requirements to be designed and developed firstly, has become increasingly important in the software development lifetime. Considering the fact that a feature in a feature model can be viewed as a set of closely related requirements, feature prioritization will contribute to requirements prioritization to a large extent. Therefore, how to measure the priority of features within a feature model becomes an important issue in requirements analysis. In this paper, a software feature prioritization approach is proposed, which utilizes the dependencies between features to build a feature probability network and measures feature prioritization through the nodes centrality in the network. Experiments conducted on real world feature models show that the proposed approach can accurately prioritize features in feature models.

Zhenlian Peng, Jian Wang, Keqing He, Hongtao Li

VCU: The Three Dimensions of Reuse

Abstract

Reuse, enabled by modularity and interfaces, is one of the most important concepts in software engineering. This is evidenced by an increasingly large number of reusable artifacts, ranging from small units such as classes to larger, more sophisticated units such as components, services, frameworks, software product lines, and concerns. This paper presents evidence that a canonical set of reuse interfaces has emerged over time: the variation, customization, and usage interfaces (VCU). A reusable artifact that provides all three interfaces reaches the highest potential of reuse, as it explicitly exposes how the artifact can be manipulated during the reuse process along these three dimensions. We demonstrate the wide applicability of the VCU interfaces along two axes: across abstraction layers of a system specification and across existing reuse techniques. The former is shown with the help of a comprehensive case study including reusable requirements, software, and hardware models for the authorization domain. The latter is shown with a discussion on how the VCU interfaces relate to existing reuse techniques.

Jörg Kienzle, Gunter Mussbacher, Omar Alam, Matthias Schöttle, Nicolas Belloir, Philippe Collet, Benoit Combemale, Julien DeAntoni, Jacques Klein, Bernhard Rumpe

Reuse vs. Reusability of Software Supporting Business Processes

Abstract

Reusing software is desirable, and so is reusing business processes. For reusing both in the course of developing software supporting business processes, an integration of related reuse approaches is necessary. Of course, such reuse is not for free and requires reusability of related artefacts, i.e., business process models and software parts supporting them. For successful reuse, of course, trade-offs with making artefacts reusable (or acquiring them) have to be beneficial.

In this paper, we present an integration of business process and software reuse and reusability (R&R). Based on it, we compare trade-offs between making reusable and reusing in the context of developing software supporting business processes. As a consequence, it should become easier to make rational judgments on whether and how to engage in R&R of such software.

Hermann Kaindl, Roman Popp, Ralph Hoch, Christian Zeidler

Component-Based Reuse

Frontmatter

A Case Study on the Availability of Open-Source Components for Game Development

Abstract

Nowadays the amount of source code that is freely available inside open-source software repositories offers great reuse opportunities to software developers. Therefore, it is expected that the implementation of several requirements can be facilitated by reusing open source software components. In this paper, we focus on the reuse opportunities that can be offered in one specific application domain, i.e., game development. In particular, we performed an embedded multiple case study on approximately 110 open-source games, exploiting a large-scale repository of OSS components, and investigated: (a) which game genres can benefit from open source reuse, and (b) what types of requirements can the available open-source components map to. The results of the case study suggest that: (a) game genres with complex game logic, e.g., First Person Shooter, Strategy, Role-Playing, and Sport games offer the most reuse opportunities, and (b) the most common requirement types that can be developed by reusing OSS components are related to scenarios and characters.

Maria-Eleni Paschali, Apostolos Ampatzoglou, Stamatia Bibi, Alexander Chatzigeorgiou, Ioannis Stamelos

RAGE Reusable Game Software Components and Their Integration into Serious Game Engines

Abstract

This paper presents and validates a methodology for integrating reusable software components in diverse game engines. While conforming to the RAGE component-based architecture described elsewhere, the paper explains how the interactions and data exchange processes between a reusable software component and a game engine should be implemented for procuring seamless integration. To this end, a RAGE-compliant C# software component providing a difficulty adaptation routine was integrated with an exemplary strategic tile-based game “TileZero”. Implementations in MonoGame, Unity and Xamarin, respectively, have demonstrated successful portability of the adaptation component. Also, portability across various delivery platforms (Windows desktop, iOS, Android, Windows Phone) was established. Thereby this study has established the validity of the RAGE architecture and its underlying interaction processes for the cross-platform and cross-game engine reuse of software components. The RAGE architecture thereby accommodates the large scale development and application of reusable software components for serious gaming.

Wim van der Vegt, Enkhbold Nyamsuren, Wim Westera

Reusable Secure Connectors for Secure Software Architecture

Abstract

This paper describes the design of reusable secure connectors that are used in the design of secure software architectures for distributed software applications. The secure connectors are designed separately from application components by reusing the appropriate communication pattern between components as well as the security services required by these components. Each secure connector is designed as a composite component that encapsulates both security service components and communication pattern components. Integration of security services and communication patterns within a secure connector is provided by a security coordinator. The main advantage is that secure connectors can be reused in different applications. In this paper, secure connectors are reused in electronic commerce and automated teller machine applications.

Michael Shin, Hassan Gomaa, Don Pathirage

Reuse-Based Software Engineering

Frontmatter

Concept-Based Engineering of Situation-Specific Migration Methods

Abstract

Software migration methods enable to reuse legacy systems by transferring them into new environments. Thereby, the method used needs to fit to the project’s situation by considering conceptual differences between the source and target environment and automating parts of the migration whenever suitable. Using an inappropriate migration method may lead to a decreased software quality or increased effort. Various method engineering approaches have been proposed to support the development of situation-specific migration methods. However, most do not provide a sufficient degree of flexibility when developing a method or fall short in guiding the endeavor. To address this problem, we introduce a situational method engineering framework to guide the development of model-driven migration methods by assembling predefined buildings blocks. The development is centered around the identification of concepts within a legacy system and the selection of suitable migration strategies. We evaluate the framework by an industrial project in which we migrated a legacy system from the domain of real estates to a new environment.

Marvin Grieger, Masud Fazal-Baqaie, Gregor Engels, Markus Klenke

Leveraging Feature Location to Extract the Clone-and-Own Relationships of a Family of Software Products

Abstract

Feature location is concerned with identifying software artifacts associated with a program functionality (features). This paper presents a novel approach that combines feature location at the model level with code comparison at the code level to extract Clone-and-Own Relationships from a family of software products. The aim of our work is to understand the different Clone-and-Own Relationships and to take advantage of them in order to improve the way features are reused. We have evaluated our work by applying our approach to two families of software products of industrial dimensions. The code of one of the families is implemented manually by software engineers from the models that specify the software, while the code of the other family is implemented automatically by a code generation tool. The results show that our approach is able to extract relationships between features such as Reimplemented, Modificated, Adapted, Unaltered, and Ghost Features, thus providing insight into understanding the Clone-and-Own relationships of a family of software products. Furthermore, we suggest how to use these relationships to improve the way features are reused.

Manuel Ballarin, Raúl Lapeña, Carlos Cetina

AIRES: An Architecture to Improve Software Reuse

Abstract

Among the several challenges still faced by Software Engineering, software reuse can be listed as a potential solution towards improving productivity and quality, through the utilization of previously produced artifacts that can leverage development activities. Among these artifacts we can mention not only code, but also requirements’ documents, analysis and design models, test cases, documentation, and even development processes that achieved success in the past and could be reused again and again. However, the diversity of methods, processes and tools for software engineering make it difficult to turn reuse into a systematic activity. Considering this context, the present paper aims at presenting an architectural model that encompasses the main elements needed to support software reuse in a large scale. This model, named AIRES, allows reuse to be realized intrinsically to the development process life cycle, providing mechanisms to facilitate a variety of processes and artifacts representation and a Service-Oriented Architecture (SOA) to make assets available to other software engineering environments or tools. The AIRES model is being implemented using open source platforms and will be available within the cloud.

Rosana T. Vaccare Braga, Daniel Feloni, Karen Pacini, Domenico Schettini Filho, Thiago Gottardi

Pragmatic Software Reuse in Bioinformatics: How Can Social Network Information Help?

Abstract

Little is known about the specific kinds of questions that bioinformatics programmers ask during pragmatic software reuse tasks and how well development online social networks help answer those questions. To fill the gap, we report an empirical study involving 20 biomedical software developers performing reuse tasks. A key contribution of our study is the discovery of 31 questions needed to be addressed, which we further classify into 5 categories along a software-architecture-centric and problem-domain-centric spectrum. Our study further provides evidence for the positive effect of social network information on pragmatic reuse tasks. Our work can lead to enhanced tool support so as to improve biomedical software reuse in practice.

Xiaoyu Jin, Charu Khatwani, Nan Niu, Michael Wagner, Juha Savolainen

Software Reuse Tools

Frontmatter

Feature Location Benchmark for Software Families Using Eclipse Community Releases

Abstract

It is common belief that high impact research in software reuse requires assessment in realistic, non-trivial, comparable, and reproducible settings. However, real software artefacts and common representations are usually unavailable. Also, establishing a representative ground truth is a challenging and debatable subject. Feature location in the context of software families is a research field that is becoming more mature with a high proliferation of techniques. We present EFLBench, a benchmark and a framework to provide a common ground for this field. EFLBench leverages the efforts made by the Eclipse Community which provides real feature-based family artefacts and their implementations. Eclipse is an active and non-trivial project and thus, it establishes an unbiased ground truth. EFLBench is publicly available and supports all tasks for feature location techniques integration, benchmark construction and benchmark usage. We demonstrate its usage and its simplicity and reproducibility by comparing four techniques.

Jabier Martinez, Tewfik Ziadi, Mike Papadakis, Tegawendé F. Bissyandé, Jacques Klein, Yves Le Traon

Java Extensions for Design Pattern Instantiation

Abstract

Design patterns are not easily traceable in source code, leading to maintainability and comprehension issues, while the instantiation of certain patterns involves generalizable boiler-plate code. We provide high-level language constructs addressing design patterns that transform source code by injecting a substantial part of their implementation at compile time. We developed proof of concept extensions addressing widely used design patterns, namely Singleton, Visitor, Decorator, and Observer, using annotations as the means to extend Java. We describe our Java annotations to support these design patterns and the associated source code transformations, demonstrating that it is possible to significantly reduce the necessary code to instantiate a pattern through the use of high-level constructs.

André L. Santos, Duarte Coelho

Towards a Semantic Search Engine for Open Source Software

Abstract

To be able to use or reuse an open source software, we must be aware of its existence and find it first. Existing search engines on the Web do not allow finding open source software satisfying given requirements while taking into account special semantics. In this paper, we propose a semantic search system for open source software allowing to identify and localize them. It relies on an ontology providing a mechanism to describe knowledge about open source software. Moreover, it can infer knowledge for semantic identification through some defined rules. Preliminary results are encouraging. The evaluation results compared to a non-semantic version of the same search engine confirm the added value of the consideration of the semantic aspect in search.

Sihem Ben Sassi

Detecting Similar Programs via The Weisfeiler-Leman Graph Kernel

Abstract

With the increasing availability of source code on the Internet, many new approaches to retrieve, repair, and reuse code have emerged that rely on the ability to efficiently compute the similarity of two pieces of code. The meaning of similarity, however, heavily depends on the application domain. For predicting API calls, for example, programs can be considered similar if they call a specific set of functions in a similar way, while for automated bug fixing, it is important that similar programs share a similar data-flow.

In this paper, we propose an algorithm to compute program similarity based on the Weisfeiler-Leman graph kernel. Our algorithm is able to operate on different graph-based representations of programs and thus can be applied in different domains. We show the usefulness of our approach in two experiments using data-flow similarity and API-call similarity.

Wenchao Li, Hassen Saidi, Huascar Sanchez, Martin Schäf, Pascal Schweitzer

Domain Analysis and Modelling

Frontmatter

Metamodel and Constraints Co-evolution: A Semi Automatic Maintenance of OCL Constraints

Abstract

Metamodels are core components of modeling languages to define structural aspects of a business domain. As a complement, OCL constraints are used to specify detailed aspects of the business domain, e.g. more than 750 constraints come with the UML metamodel. As the metamodel evolves, its OCL constraints may need to be co-evolved too. Our systematic analysis shows that semantically different resolutions can be applied depending not only on the metamodel changes, but also on the user intent and on the structure of the impacted constraints. In this paper, we investigate the reasons that lead to apply different resolutions. We then propose a co-evolution approach that offers alternative resolutions while allowing the user to choose the best applicable one. We evaluated our approach on the evolution of the UML case study. The results confirm the need of alternative resolutions along with user decision to cope with real co-evolution scenarios. The results show that our approach reaches 80 % of semantically correct co-evolution.

Djamel Eddine Khelladi, Regina Hebig, Reda Bendraou, Jacques Robin, Marie-Pierre Gervais

A Model Repository Description Language - MRDL

Abstract

Repository-based development of software systems has gained more attention recently by addressing new challenges such as security and dependability. However, there are still gaps in existing modeling languages and/or formalisms dedicated to define model repositories and the way how to reuse them in the automation of software development. Thus, there is a strong requirement for defining a model repository description language not only as a modeling approach, but also as a suitable instrument to support system and software engineers in the activity of search and retrieval of appropriate models beyond keyword-based search. Moreover, modeling approaches allow using tools for the specification and the exploitation of the designed artifacts (e.g. analysis and evaluation). The goal of this paper is to advance the state of the art in model repository description for software and systems engineering. In particular, we have designed a flexible and extensible modeling language, by means of an OMG style metamodel, to specify model repositories for modeling artifacts, and we have defined an operational architecture for development tools. In particular, we show the feasibility of our own approach by reporting some preliminary prototype providing a model-based repository of security and dependability (S&D) pattern models.

Brahim Hamid

Reverse-Engineering Reusable Language Modules from Legacy Domain-Specific Languages

Abstract

The use of domain-specific languages (DSLs) has become a successful technique in the development of complex systems. Nevertheless, the construction of this type of languages is time-consuming and requires highly-specialized knowledge and skills. An emerging practice to facilitate this task is to enable reuse through the definition of language modules which can be later put together to build up new DSLs. Still, the identification and definition of language modules are complex and error-prone activities, thus hindering the reuse exploitation when developing DSLs. In this paper, we propose a computer-aided approach to (i) identify potential reuse in a set of legacy DSLs; and (ii) capitalize such potential reuse by extracting a set of reusable language modules with well defined interfaces that facilitate their assembly. We validate our approach by using realistic DSLs coming out from industrial case studies and obtained from public GitHub repositories.

David Méndez-Acuña, José A. Galindo, Benoit Combemale, Arnaud Blouin, Benoit Baudry, Gurvan Le Guernic

A Framework for Enhancing the Retrieval of UML Diagrams

Abstract

Software design is one of the demanding task that requires a lot of experience, expertise, and knowledge in many different design alternatives. Experience software designer’s knowledge is considers as a vital asset to the software development company, especially in current competitive market environment. In order to benefit from the knowledge of experienced software designers, Software Company needs a tool to store these design knowledge for future use and retrieved those design from repository when needed, especially before developing a new system. This tool should complement the effort required to design a new system from scratch and be able to compare the requirement of a new project with the requirements of the old projects in the repository. This paper proposes a framework for reusing UML diagrams.

Alhassan Adamu, Wan Mohd Nazmee Wan Zainoon

Tool Demonstrations

Frontmatter

Puzzle: A Tool for Analyzing and Extracting Specification Clones in DSLs

Abstract

The use of domain-specific languages (DSLs) is a successful technique in the development of complex systems. Indeed, the construction of new DSLs addressing the particular needs of software projects has become a recurrent activity. In this context, the phenomenon of specification cloning has started to appear. Language designers often copy&paste some parts of the specification from legacy DSLs to “reuse” formerly defined language constructs. As well known, this type of practices introduce problems such as bugs propagation, thus increasing of maintenance costs. In this paper, we present Puzzle, a tool that uses static analysis to facilitate the detection of specification clones in DSLs implemented under the executable metamodeling paradigm. Puzzle also enables the extraction specification clones as reusable language modules that can be later used to build up new DSLs.

David Méndez-Acuña, José A. Galindo, Benoit Combemale, Arnaud Blouin, Benoit Baudry

FeatureIDE: Scalable Product Configuration of Variable Systems

Abstract

In the last decades, variability management for similar products is one of the main challenges in software systems. In this context, feature models are used to describe the dependencies between reusable common and variable artifacts, called features. However, for large feature models it is a complex task to find a valid feature combination as product configuration. Our Eclipse plug-in FeatureIDE provides several mechanisms, such as information hiding and decision propagation, which support the configuration process to combine the reusable artifacts in various manners. We illustrate the applications of these mechanisms from a user’s point of view.

Juliana Alves Pereira, Sebastian Krieter, Jens Meinicke, Reimar Schröter, Gunter Saake, Thomas Leich

Recalot.com: Towards a Reusable, Modular, and RESTFul Social Recommender System

Abstract

Many different recommender system (RS) frameworks have been developed by the research community. Most of these RS frameworks are designed only for research purposes and offline evaluation of different algorithms. A reuse of such frameworks in a productive environment is only possible with high effort. In this paper, we present a concept of a generic reusable RESTful recommender web service framework, designed to perform directly offline and online analysis for research and to use the recommender algorithms in production.

Matthäus Schmedding, Michael Fuchs, Claus-Peter Klas, Felix Engel, Holger Brock, Dominic Heutelbeck, Matthias Hemmje

CORPO-DS: A Tool to Support Decision Making for Component Reuse Through Profiling with Ontologies

Abstract

This paper introduces a software tool that supports the activities of a novel, reuse-based development framework, which focuses on assessing the suitability level of candidate components. The tool enables the creation of a specifications profile using a semi-formal natural language, which describes the desired functional and non-functional properties of the component(s) sought. It also offers the means to parse the profile automatically and translate it into instance values of a dedicated CBSE ontology. Finally, the tool performs matching between required and offered component properties at the level of ontology items and suggests the most suitable components to consider for integration based on a suitability ratio calculated.

Savvas Loumakos, Andreas S. Andreou

Springer Professional

Über dieses Buch

Inhaltsverzeichnis

Frontmatter

Software Product Lines

Frontmatter

Applying Incremental Model Slicing to Product-Line Regression Testing

Automated Composition of Service Mashups Through Software Product Line Engineering

Feature Location in Model-Based Software Product Lines Through a Genetic Algorithm

Carrying Ideas from Knowledge-Based Configuration to Software Product Lines

Tax-PLEASE—Towards Taxonomy-Based Software Product Line Engineering

Business Aspects of Software Reuse

Frontmatter

A Method to Support the Adoption of Reuse Technology in Large Software Organizations

A Practical Use Case Modeling Approach to Specify Crosscutting Concerns

An Approach for Prioritizing Software Features Based on Node Centrality in Probability Network

VCU: The Three Dimensions of Reuse

Reuse vs. Reusability of Software Supporting Business Processes

Component-Based Reuse

Frontmatter

A Case Study on the Availability of Open-Source Components for Game Development

RAGE Reusable Game Software Components and Their Integration into Serious Game Engines

Reusable Secure Connectors for Secure Software Architecture

Reuse-Based Software Engineering

Frontmatter

Concept-Based Engineering of Situation-Specific Migration Methods

Leveraging Feature Location to Extract the Clone-and-Own Relationships of a Family of Software Products

AIRES: An Architecture to Improve Software Reuse

Pragmatic Software Reuse in Bioinformatics: How Can Social Network Information Help?

Software Reuse Tools

Frontmatter

Feature Location Benchmark for Software Families Using Eclipse Community Releases

Java Extensions for Design Pattern Instantiation

Towards a Semantic Search Engine for Open Source Software

Detecting Similar Programs via The Weisfeiler-Leman Graph Kernel

Domain Analysis and Modelling

Frontmatter

Metamodel and Constraints Co-evolution: A Semi Automatic Maintenance of OCL Constraints

A Model Repository Description Language - MRDL

Reverse-Engineering Reusable Language Modules from Legacy Domain-Specific Languages

A Framework for Enhancing the Retrieval of UML Diagrams

Tool Demonstrations

Frontmatter

Puzzle: A Tool for Analyzing and Extracting Specification Clones in DSLs

FeatureIDE: Scalable Product Configuration of Variable Systems

Recalot.com: Towards a Reusable, Modular, and RESTFul Social Recommender System

CORPO-DS: A Tool to Support Decision Making for Component Reuse Through Profiling with Ontologies

Backmatter

Premium Partner