Context: Microservice-based architecture has emerged as a robust architectural style for developing software systems as loosely coupled modules with several high-quality characteristics. Given characteristics like maintainability, independent deployability, and scalability, many practitioners embrace this architectural style while developing new applications or migrating existing monolithic ones. Objective: In this paper, we address the migration process, which is an exhausting task that requires splitting the monolithic software system into a set of highly internally-cohesive and loosely externally-coupled services. Our objective is to design and empirically evaluate an automated microservice decomposition approach driven by the database model of a monolithic system, aiming to maximize modularity and cohesion while minimizing inter-service coupling. Method: Our proposed process takes a data model-centric perspective. We argue that microservice identification cannot rely on source code analysis only, because the source code of the monolith was not originally written with a microservice-based architecture style in mind. Later in the migration process, this code must be modified to match the new architecture. The identification of microservice candidates is divided into two stages. In the first stage, topic modeling is performed to decompose the monolithic system’s database model into sub-models. Each derived sub-model refers to a potential microservice’s independent database. In the second stage, the monolith’s source code is analyzed and distributed to the identified sub-models based on semantic similarity and structural relationships among source code elements. Results: We evaluated our approach on two open-source applications with available microservice versions and obtained promising results. We also compared it with existing methods using four state-of-the-art modularity and cohesion metrics on three common open-source projects. The findings show that our approach effectively identifies modular and cohesive microservices. Conclusion: In this paper, we demonstrate that considering data models as the preliminary drivers for microservices identification provides an effective approach for defining microservice boundaries.

Context: Throughout the software lifecycle, a significant amount of knowledge is accumulated around the source code. In our work, we focus on agile software requirements, particularly user stories, and on issues and merge requests in version control systems, that have been opened for implementing user stories. Objective: The objective of this paper is to present a method that leverages this knowledge to guide an SPL migration. Methods: We consider merge requests in version control systems as the link between user stories (requirements) and the source code (implementation). The method combines Natural Language Processing (NLP) and clustering to identify features from user stories and hierarchically organize them. Relational Concept Analysis (RCA) is then used to compute logical rules from the hierarchy of features, using their links with the products and the source code. The logical rules are finally transformed into constraints in the produced feature model. Results: The method was implemented and evaluated on a dataset from an industrial partner. The results showed the efficiency of our method in synthesizing feature models for an SPL migration of the partner’s code base. Conclusion: The proposed method synthesizes feature models to guide an SPL migration based on agile software development practices and demonstrates its effectiveness on a real industrial dataset.

The microservice architecture (MSA) emerged as an evolution of existing architectural styles with the promise of improving software quality by decomposing an app into modules that can be maintained, deployed, and scaled independently. However, the transition from a monolithic to a microservice architecture is fraught with difficulties, especially when it comes to assessing qualitative aspects, as controversial results can arise. In this paper, we present an experience report on the migration of a monolithic web application and use performance, availability and energy efficiency as quality attributes to shed light on such an architectural transition. Horizontal scaling, i.e., distributing the workload across several service instances, is applied and we study its impact.Our main findings are: i) when no app component is replicated, MSA outperforms the monolithic architecture; ii) the monolithic architecture shows performance and availability improvement when replicating the entire app; iii) the replicated MSA version reaches a ceiling when not replicating its routing part (i.e., the API gateway), showing worse response times compared to the replicated monolith; iv) when replicating the API gateway, the MSA version reaches optimal performance with fewer replicates than the monolith; v) when not replicating services, MSA consumes more CPU resources than the monolithic architecture; vi) when scaling up, the MSA version is more efficient than the replicated monolith in terms of memory usage, and it can better exploit CPU resources; vii) when not replicating services, MSA consumes more energy than the monolithic architecture, whereas when scaling up, the MSA version is more efficient than the replicated monolith; MSA version reaches a good balance between CPU and memory usage.

Configurable software systems and families of similar software systems are increasingly being considered by industry to provide software tailored to each customer's needs. Their development requires managing software variability, i.e. commonalities, differences and constraints. A primary step is properly analyzing the variability of software, which can be done at various levels, from specification to deployment. In this paper, we focus on the software variability expressed through user-stories, viz. short formatted sentences indicating which user role can perform which action at the specification level. At this level, variability is usually analyzed in a two dimension view, i.e. software described by features, and considering the roles apart. The novelty of this work is to model the three dimensions of the variability (i.e. software, roles, features) and explore it using Triadic Concept Analysis (TCA), an extension of Formal Concept Analysis. The variability exploration is based on the extraction of 3-dimensional implication rules. The adopted methodology is applied to a case study made of 65 commercial web sites in four domains, i.e. manga, martial arts sports equipment, board games including trading cards, and video-games. This work highlights the diversity of information provided by such methodology to draw directions for the development of a new product or for building software variability models.

We present ShellOnYou, a new Computer Science education tool, and analyze its use with four successive student cohorts. Developed to help instructors manage numerous students, this web application offers auto-graded exercises to acquire practical knowledge of Unix-like operating systems from the command line. For each answer, and almost instantly, students receive a score and detailed feedback. This reactive and iterative process encourages students to resubmit answers and progressively expand their procedural knowledge. The tool can also deliver individualized statements, thereby allowing students to improve their skills by combining personal research and peer learning. As an online tool, ShellOnYou affords students access flexibility, and also easily fits in distance learning programs. We found it particularly useful when teaching students with heterogeneous Unix backgrounds. The tool is available on request. We placed four successive student cohorts in a learning situation involving this tool, and asked them to fill a survey at the end of the learning period. We combine qualitative and quantitative methods to analyze their answers to the survey. We attempt to characterize their acquisition of procedural knowledge and the building of group dynamics. Several dimensions emerge: the benefits of using the tool in a learning situation, the learning process iteration as a catalyst for renewed commitment, the tool's entertaining format and its scoring system as a motivation for regular studying, and the inherent customization of the learning pace.

Metamodels are subject to evolution over their lifetime. UML metamodel for instance evolved through different versions, ranging from 0.8 to 2.5 minors. These metamodels are sometimes accompanied with constraints defined using OCL (Object Constraint Language). Many works in the literature developed methods for managing and assisting the co-evolution of metamodels and their constraints. These methods enable a developer to update, in an automated (or semi-automated) way, the constraints associated to a metamodel starting from the deltas identified between versions of this metamodel. In this work we complement this assistance by notifying the developer with potential inaccurate structures in the metamodel that may be introduced during evolution. We introduce in this paper an original evolution assistance method which focuses rather on the problem (notifying metamodel inaccurate structures) than on the solution (generating OCL constraints using patterns of them). The ultimate goal of this assistance is not only to enable the developer to complete existing/updated constraints with new ones, but also to accompany her/him to further check existing constraints and to test whether they still hold. A case study is presented to show the relevance of the method.

A large component and service-based software system exists in different forms, as different variants targeting different business needs and users. This kind of systems is provided as a set of "independent" products and not as a "single whole". Developers use ad hoc mechanisms to manage variability. However, for deriving new product variants that are built upon existing ones, the presence of a single model describing the architecture of the whole system with an explicit specification of commonality and variability is of great interest. Indeed, this enables them to see the invariant part of the whole, on top of which new functionality can be built, in addition to the different options they can use. We investigate in this work the use of software product line reverse engineering approaches, and in particular the framework named But4Reuse, for recovering an architecture model that enables us to build a Software Architecture Product Line (SAPL), from a set of software variants. We propose a generic process for recovering an architecture model of such a product line. We have instantiated this process for the OSGi Java framework and experimented it for building the architecture model of Eclipse IDE SPL. The results of this experimentation showed that this process can effectively reconstruct such an architecture model.

The reputation of web services is calculated by aggregating user feedback ratings. Though reputation is a subjective metric, it can be considered as a good indicator about service's Quality of Experience, and henceforth, it can be used for recommending services in an open ecosystem. In this work, we propose a three-phase process for evaluating web service reputation by aggregating user feedback ratings. The relationship between users and services is modeled as a bi-partite graph where an adapted HITS (Hypertext Induced Topic Search) algorithm is employed to distinguish between honest and malicious users in Phase I. Then, this model is used to evaluate, in Phase III, the reputation of web services from user ratings after punishing malicious users in Phase II. An experiment on a dataset of real Web services was conducted to validate the effectiveness of the proposed model in evaluating Web service reputation.

International audience

Modularity in Object-Oriented (OO) applications has been a major concern since the early years of OO programming languages.Migrating existing OO applications to Component-Based (CB) ones can contribute to improve modularity, and therefore maintainability and reuse.In this paper, we propose a method for source code transformation (refactoring) in order to perform this migration.This method enhances decoupling by considering that some dependencies between classes should be set through abstract types (interfaces) like in CB applications.In addition, some anticipated instantiations of these classes "buried" in the source code are extracted and replaced by declarative statements (like connectors in CB applications) which are processed by a dependency injection mechanism.For doing so, a set of "Bad Smells", i.e., modularity-violating symptoms, has been defined.These are first detected in the source code.Then, some refactoring operations are applied for their elimination.An implementation of the method was successfully experimented on a set of open source Java projects.The results of this experimentation are reported in this paper.

Large object-oriented applications have complex and numerous dependencies, and usually do not have explicit software architectures. Therefore they are hard to maintain, and parts of them are difficult to reuse. Component-based development paradigm emerged for improving these aspects and for supporting effective maintainability and reuse. It provides better understandability through a high-level architecture view of the application. Thereby migrating object-oriented applications to component-based ones will contribute to improve these characteristics (maintainability and reuse). In this paper, we propose an approach to automatically transform object-oriented applications to component-based ones. More particularly, the input of the approach is the result provided by software architecture recovery: a component-based architecture description. Then, our approach transforms the object-oriented source code in order to produce deployable components. We focus in this paper on the transformation of source code related to instantiation and inheritance dependencies between classes that are in different components. We experimented the proposed solution in the transformation of a collection of Java applications into the OSGi framework. The experimental results are discussed in this paper.

In the literature, many solutions for measuring the reputation of web services have been proposed. These solutions help in building service recommendation systems. Nonetheless, there are still many challenges that need to be addressed in this context, such as the "cold start" problem, and the lack of estimation of the initial reputation values of newcomer web services. As reputation measurement depends on the previous reputation values, the lack of initial values can subvert the performance of the whole service recommendation system, making it vulnerable to different threats, like the Sybil attack. In this paper, we propose a new bootstrapping mechanism for evaluating the reputation of newcomer web services based on their initial Quality of Service (QoS) attributes, and their similarity with "long-standing" web services. Basically, the technique uses regression models for estimating the unknown reputation values of newcomer services from their known values of QoS attributes. The technique has been experimented on a large set of services, and its performance has been measured using some statistical metrics, such as the coefficient of determination (R2), Mean Absolute Error (MSE), and Percentage Error (PE).

Web service business processes are a kind of service compositions considered as one of the most frequent form of service-oriented software architectures. In this paper, we present a method that helps software architects in the design of such service architectures. This method assists the architects in answering them by proposing some patterns achieving quality requirements. We consider in our work that quality can be achieved through patterns, which are specified with checkable/process able languages. Besides this, the method that we propose simulates the application of these patterns and notifies the architect with its consequences on the other implemented qualities.

Currently Web services remain one of the leading technologies for implementing components of distributed service oriented software architectures. One of the most frequent form of compositions of these entities is Web service orchestration. As any other software artifact, such service compositions are subject to an unescapable evolution (Lehman's first law of software evolution). Either for answering new user requirements, for adapting, for correcting or for enhancing the provided functionality or quality, an architect has to conduct some evolutions on the design of these artifacts. In this paper, we present a method which aims at helping software architects of Web service orchestrations in processing an evolution of quality requirements. This method introduces a template for describing quality evolution "intents". It then analyzes these intents and assists the architects in answering them by proposing some patterns. We consider in our work the postulate stating that quality can be implemented through patterns, which are specified with checkable/process able languages. Besides this, the method that we propose simulates the application of these patterns and notifies the architect with its consequences on the other implemented qualities.

In the context of Component-based Programming, which addresses the implementation stage of a component-based software engineering development process, this paper describes a specification and an operational integration of an inheritance system into a self-contained new component-based programming language named Compo. Our proposal completes and extends related works by making it possible to apply inheritance to the full description of components, i.e. both to structural (description of provisions and requirements, of component architecture) and behavioral (full implementations of services) parts in component descriptions. Inheritance in Compo is designed to be used in conjunction with composition to maximize reuse capabilities and expressive power. Compo implementation proposes a clear operational solution for inheritance and for achieving and testing substitutions.

Web component-based development is a challenging development paradigm, whose attraction to practitioners is increasing more and more. One of the main advantages of this paradigm is the ability to build customizable and composable web application modules as independent units of development, and to share them with other developers by publishing them in libraries as COTS (Commercial Off The Shelf) or free components. In parallel, since many years, Web services confirmed their status of one of the most pertinent solutions for a service provider, like Google or Amazon, to open its solutions for third party development. In this paper, we present an approach to migrate existing web component-based applications to a set of primitive and composite Web services and deploy them on a web service provider. This transformation helps server-side web application developers in transforming their "user interface"-based web components into a set of web services intended for remote code extensions. We implemented our solution on a collection of Java-related technologies. Java EE components are the input of the proposed implementation, and a set of Java Web services with their WSDL interfaces, choreographies and orchestrations of these services are provided at output.

Building a composite application based on Web services has become a real challenge regarding the large and diverse service space nowadays. Especially when considering the various functional and non-functional capabilities that Web services may afford and users may require. In this paper, we propose an approach for facilitating Web service selection according to user requirements. These requirements specify the needed functionality and expected QoS, as well as the composability between each pair of services. The originality of our approach is embodied in the use of Relational Concept Analysis (RCA), an extension of Formal Concept Analysis (FCA). Using RCA, we classify services by their calculated QoS levels and composability modes. We use a real case study of 901 services to show how to accomplish an efficient selection of services satisfying a specified set of functional and non-functional requirements.

During software maintenance, some non-functional properties may be lost. This is due to the lack of an explicit definition of their links with the corresponding architectural choices. In this paper, we present a solution that automates the checking of non-functional properties after the evolution of a component-based software. Our approach emphasizes the interest of formally documenting the links binding non-functional requirements to architectural choices. The proposed formalism is based on the Object Constraint Language (OCL) applied to a software component metamodel. We also present a prototype tool which uses this documentation to warn the developer of possible effects of an architectural change on non-functional requirements.

It is argued that architecture comprehension and regression testing of a software system are the most expensive maintenance activities. This is mainly due to the fact that architectural choices are either not explicit, at every stage of the software development process, or not preserved from one stage to another. In this paper, we present an Architectural Constraint Language (ACL) as a means to formally describe architectural choices at all the stages. This language is based on the UML’s Object Constraint Language and on a set of MOF-compliant metamodels. We also present a prototype which validates the proposed approach. It allows the evaluation of ACL expressions at two stages and ensures, by using a transformation mechanism, that the constraints stated at one stage are subsequently preserved.