Due to its tremendous advantages, microservice architectural style has become an essential element for the development of applications deployed on the cloud and for those adopting the DevOps practices. Nevertheless, while microservices can be used to develop new applications, there are monolithic ones, that are not well adapted neither to the cloud nor to DevOps. Migrating these applications towards microservices appears as a solution to adapt them to both. In this context, we propose an approach aiming to achieve this objective by focusing on the step of microservices identification. The proposed identification, in this paper, is based on an analysis of the relationships between source code elements, their relationships with the persistent data manipulated in this code and finally the knowledge, often partial, of the architect concerning the system to migrate. A function that measures the quality of a microservice based on its ability to provide consistent service and its interdependence with others microservice in the resulting architecture was defined. Moreover, the architect recommendations are used, when available, to guide the identification process. The conducted experiment shows the relevance of the obtained microservices by our approach.

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.

International audience

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.

Software Product Line Engineering (SPLE) is a systematic reuse approach to develop a short time-to-market and quality products, called Software Product Line (SPL). Usually, a SPL is not developed from scratch but it is developed by reusing features (resp. their implementing source code elements) of existing similar systems previously developed by ad-hoc reuse techniques. The features implementations that are reused may be changed for developing new products (SPL) using SPLE. Any code element can be a part of (shared by) different features implementations; modifying one feature's implementation can thus impact others. Therefore, feature-level Change Impact Analysis (CIA) is important to predict affected features for change management purpose. In this paper, we propose a feature-level CIA approach using Formal Concept Analysis (FCA) applied to SPL evolution. In our experimental evaluation using three case studies of different domains and sizes, we show the effectiveness of our technique in terms of the most commonly used metrics on the subject.

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.

The APE (Adaptive Programming Environment) project focuses on applying Machine Learning techniques to embed a software assistant into the VisualWorks Smalltalk interactive programming environment. The assistant is able to learn user's habits and to automatically suggest to perform repetitive tasks on his behalf. This paper describes our assistant and focuses more particularly on the learning issue. It explains why state-of-the-art Machine Learning algorithms fail to provide an efficient solution for learning user's habits, and shows, through experiments on real data that a new algorithm we have designed for this learning task, achieves better results than related algorithms.

This paper's primary aim is to improve the understanding of the delegation mechanism as defined in [18]. We propose a new characterization of delegation based on the notions of name sharing, property sharing and value sharing. It allows us (1) to clearly differentiate delegation from class-inheritance in particular and more generally from other inheritance mechanisms and (2) to explain how a founded use of delegation relies on a correct semantics of variable property sharing between objects connected by a delegation link. We then describe a model of split objects which is proposed as an example of a disciplined and semantically founded use of delegation, where property sharing expresses viewpoints within objects.

Several algorithms [Cas92, MS89, Run92, DDHL94a, DDHL95, GMM95] have been proposed to automatically insert a class into an inheritance hierarchy. But actual hierarchies all include overriden and overloaded properties that these algorithms handle either very partially or not at all. Partially handled means handled provided there is a separate given function f able to compare overloaded properties [DDHL95, GMM95].In this paper, we describe a new version of our algorithm (named Ares) which handles automatic class insertion more efficiently using such a function f. Although impossible to fully define, this function can be computed for a number of well defined cases of overloading and overriding. We give a classification of such cases and describe the computation process for a well-defined set of nontrivial cases.The algorithm preserves these important properties:- preservation of the maximal factorization of properties- preservation of the underlying structure (Galois lattice) of the input hierarchy- conservation of relevant classes of the input hierarchy with their properties.

Prototype-based languages are currently proposed as a substitute to class-based languages for a higher flexibility in manipulating objects.These languages are all based on a similar set of basic principles: object-centered representation, dynamic addition (deletion) of slots, cloning and message delegation.But they all differ in the precise interpretation of these principles and nobody has yet considered the semantic issues raised by their combination.In this paper, we propose a new taxonomy of prototypebased languages, enhancing the Treaty of Orlando by now discussing issues associated with the different semantics of the identified prototype-based languages.From this taxonomy, we extract a constructive proposal for the design of a new prototype-based language.This proposal is the chief result of this paper; it suggests one set of primitives which is regarded as the best to provide a clean, useful and coherent prototype-based computational model.We finally describe an implementation of most interesting language alternatives in the form of a Smalltalk-platform.This platform establishes an operational semantics for the basic primitives andmore interesting -validates our previous taxonomy by implementing it as a class hierarchy.Obviously, this platform has been used to relate in the same formalism the semantics of different languages with each others.For instance, the programming models of existing languages, such as Self, ObjectLisp and Actra's examplars, are faithfully derived as subclasses in this hierarchy.

An attempt is made to explain how the object-oriented formalism can improve the expressive power of an exception handling system and how it can simplify its implementation and its utilization. Using the proposed approach, a user-friendly, powerful, extensible and reusable exception handling system has been implemented. A specification of such a system using an 00L is described. Several classical exception handling requirements have been easily implemented and new functionalities have been proposed, among which the most important may be the ability for users to reuse and customize the existing system in order to provide specific exception handling in application programs. The system has been implemented in the Lore object-oriented language and in Smalltalk.>