A widely used Agile practice for requirements is to produce a set of user stories (also called ``agile product backlog''), which roughly includes a list of pairs (role, feature), where the role handles the feature for a certain purpose. In the context of Software Product Lines, the requirements for a family of similar systems is thus a family of user-story sets, one per system, leading to a 3-dimensional dataset composed of sets of triples (system, role, feature). In this paper, we combine Triadic Concept Analysis (TCA) and Large Language Model (LLM) prompting to suggest the user-story set required to develop a new system relying on the variability logic of an existing system family. This process consists in 1) computing 3-dimensional variability expressed as a set of TCA implications, 2) providing the designer with intelligible design options, 3) capturing the designer's selection of options, 4) proposing a first user-story set corresponding to this selection, 5) consolidating its validity according to the implications identified in step 1, while completing it if necessary, and 6) leveraging LLM to have a more comprehensive website. This process is evaluated with a dataset comprising the user-story sets of 67 similar-purpose websites.

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.

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.

The conceptual structures built with Formal Concept Analysis (FCA) and its extensions are appropriate constructs for supporting Exploratory Search (ES). FCA indeed classifies a set of objects described by Boolean attributes in a concept lattice which is prone to (intra-lattice) navigation. Relational Concept Analysis (RCA), for its part, classifies several sets of objects connected through multiple binary relationships by using logical operators (quantifiers) which can be approximate. The output is a set of interconnected concept lattices, thus adding inter-lattice navigation opportunities. In this paper, we describe the web platform RCAviz, which aims to support such intra- and inter-lattice navigation. The user can select a subset of objects and attributes as a starting point for navigation. Then RCAviz shows the associated concept and its close intra- and inter-lattice neighbors. The user can access to the objects and attributes introduced and inherited in a concept. They then can navigate, i.e. zoom and pan the current view, and move from one concept to another. Additional views show the previous and the next conceptual structures, as well as an history which allows the user to browse its navigation. A navigation example is shown on a real dataset to illustrate the potential of RCAviz for ES.

Formal Concept Analysis (FCA) has been introduced for almost a decade as a suitable method for Feature Location (FL) on a collection of product variants. Even though FCA-based FL techniques allow to locate the core of a feature implementation, they do not propose a solution to trace feature interactions to their implementation. Thus, the extracted traceability links (traces) are too inaccurate, and, in the context of SPL extraction, cannot be used to generate complete products.

International audience

[Departement_IRSTEA]Territoires [TR1_IRSTEA]SYNERGIE [Axe_IRSTEA]TETIS-SISO

An important issue of software architecture evolution is the capability for architects to keep a trace of the evolution of their work.This paper states that existing research on versioning does not cope well with software architectures.Indeed, it does not propose any adapted solutions to manage the co-evolution of the different architecture representations produced during the development process.We base our work on a three-level architecture description language (ADL) named Dedal, which represents architectures at three abstraction levels.Moreover, Dedal provides a formal base for managing version propagation.It is based on component substitutability that generalizes Liskov's substitutability principle.We propose a set of rules to support the prediction of version compatibility in terms of impact on the different architecture levels.

Product line engineering aims to reduce the cost and effort to develop new related softwares, while increasing the software quality and the software scope.Variability analysis and modeling is a key issue in this approach.Several representations were proposed, including feature models (FMs) and product comparison matrices (PCMs).While PCMs are useful for presenting products in a tabular form, for their understanding and manipulation, it helps to switch to a graphical view.FMs are graphical views, but they are not canonical (i.e., several equivalent FMs can represent a same PCM) and user intervention is necessary to ensure the extraction of a meaningful FM from PCMs.In this paper, we investigate the benefits of a new structure, which captures variability in a canonical graphical representation.We outline its construction and we give insights about its shape and use when it is used as an alternative representation of wikipedia PCMs in the domain of software.

Handling evolution in component-based software architectures is a non trivial task.Indeed, a series of changes applied on software may alter its architecture leading to several inconsistencies.In turn, architecture inconsistencies lead to software erosion and shorten its lifetime.To avoid architectural inconsistencies and increase software reliability, architecture evolution must be handled at all steps of the software lifecycle.Moreover, changes must be treated as first class entities.In this paper, we propose an evolution management model that takes these criteria into account.The model is a support for our three-level Dedal architectural model.It captures and handles change at any of the Dedal abstraction levels: specification, implementation and deployment.It generates evolution plans using evolution rules proposed in previous work.The generation process is implemented using the ProB model checker and evaluated through three evolution scenarios of a Home Automation Software.

Identifier names (e.g., packages, classes, methods, variables) are one of most important software comprehension sources. Identifier names need to be analyzed in order to support collaborative software engineering and to reuse source codes. Indeed, they convey domain concept of softwares. For instan ce, ``getMinimumSupport'' would be associated with association rule concept in data mining softwares, while some are difficult to recognize such as the case of mixing parts of words (e.g., ``initFeatSet''). We thus propose methods for assisting automatic software understanding by classifying identifier names into domain concept categories. An innovative solution based on data mining algorithms is proposed. Our approach aims to learn character patterns of identifier names. The main challenges are (1) to automatically split identifier names into relevant constituent subnames (2) to build a model associating such a set of subnames to predefined domain concepts. For this purpose, we propose a novel manner for splitting such identifiers into their constituent words and use N-grams based text classification to predict the related domain concept. In this article, we report the theoretical method and the algorithms we propose, together with the experiments run on real software source codes that show the interest of our approach.

International audience

Companies often develop a set of software variants that share some features and differ in others to meet specific requirements. To exploit the existing software variants as a Software Product Line (SPL), a Feature Model of this SPL must be built as a first step. To do so, it is necessary to define and document the optional and mandatory features that compose the variants. In our previous work, we mined a set of feature implementations as identified sets of source code elements. In this paper, we propose a complementary approach, which aims to document the mined feature implementations by giving them names and descriptions, based on the source code elements that form feature implementations and the use-case diagrams that specify software variants. The novelty of our approach is its use of commonality and variability across software variants, at feature implementation and use-case levels, to run Information Retrieval methods in an efficient way. Experiments on several real case studies (Mobile media and ArgoUML-SPL) validate our approach and show promising results.

The design of class models for information systems, databases or programming is a delicate process in which experts of the domain and designers have to identify and agree on the domain concepts. Formal Concept Analysis (FCA) has been proposed for supporting this collaborative work and fostering the emergence of higher level entities and the factorization of descriptions and behaviors. More recently, an extension of FCA, Relational Concept Analysis (RCA), has been designed to extend the scope of FCA to the emergence of higher level domain associations. FCA and RCA build a kind of normal form for models, in which the factorization is exhaustive, and the specialization order is adequate. The counterpart of these strong properties is a worst-case exponential theoretical complexity. In this paper, we study a practical application of RCA on several versions of a real class model in order to give precise figures about RCA and to detect which configurations are tractable.

Model Driven Engineering (MDE) is based on a large set of models that are used and manipulated throughout the development cycle. These models are manually or automatically produced and/or exploited using model transformations. To allow engineers to maintain the models and track their changes, recovering transformation traces is essential. In this paper, we propose an automated approach, based on multi-objective optimization, to recover transformation traces between models. Our approach takes as input a source model in the form of a set of fragments (fragments are defined using the source meta-model cardinalities and OCL constraints), and a target model. The recovered transformation traces take the form of many-to-many mappings between the constructs of the two models.

Component-based development promotes a software development process that focuses on component reuse. How to describe a desired component before searching in the repository? How to find an existing component that fulfills the required functionalities? How to capture the system personalization based on its constitutive components' customization? To answer these questions, this paper claims that components should be described using three different forms at three development stages: architecture specification, configuration and assembly. However, no architecture description language proposes such a detailed description for components that supports such a three step component-based development. This paper proposes a three-level Adl, named Dedal, that enables the explicit and separate definitions of component roles, component classes, and component instances.

The real value of Web services under the SOA paradigm lies in their ability to be assembled to obtain a new functionality. Assembling Web services can be achieved through a standard called BPEL, which creates executable processes by orchestrating Web service invocations. The problem with BPEL is the inability to separate the process description from its realization. In other words, it requires a prior retrieval of concrete Web services, which can be very challenging regarding the issues surrounding service discovery and selection. In this paper, we propose to separate a BPEL process description from its realization. We extend the notion of abstract BPEL processes, in order to enable developers to describe their desired orchestrations abstractly without identifying concrete services, according to three levels: the needed functionality, the expected QoS levels, and the composition flow. Then, the abstract BPEL process is realized by a selection framework that automatically discovers, classifies, and selects suitable services to render the process executable. Backup services are also discovered to assure the continuity of the realized process.

Use case diagrams appear early within a UML-based development, structured over the concepts of actors and use cases to capture user requirements of an application. Good modeling practices suggest that use case diagrams should be simple and easy-to-re

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.

A large part of the time allocated to software maintenance is dedicated to the program comprehension. Many approaches that uses the program structure or the external documentation have been created to assist program comprehension. However, the identifiers of the program are an important source of information that is still not widely used for this purpose. In this article, we propose an approach, based upon Natural Language Processing techniques, that automatically extracts and organizes concepts from software identifiers in a WordNet-like structure that we call lexical views. These lexical views give useful insight on an overall software architecture and can be used to improve results of many software engineering tasks. The proposal is evaluated against a corpus of 24 open source programs.

Shadows are well known as a programming language feature in the application area of MUDs (a certain type of multi-player online game). We argue that agile methodologies can be enhanced by the use of shadows as this feature because of its inherent ability to dynamically change the behavior of classes and objects, provides mechanisms to ease common tasks such as prototyping, deprecating, dynamic classification and interclassing at run-time. Therefore shadows should be considered a notion beyond any specific programming languages in order to facilitate its use in model-driven software engineering. For this we introduce Shadows-UML, an UML extension, that would help to push forward the convergence between model-driven and agile methodologies.

Designing and maintaining a huge class model is a very complex task. When an object oriented software or model grows, duplicated elements start to appear, decreasing the readability and the maintainability. In this paper, we present an approach, implemented in a tool and validated by a case study, that helps software architects designing and improving their class models, discarding redundancy and adding relevant abstractions. Since many different languages allow to express class models, this approach has been made generic i.e. capable of dealing with any language described by a meta-model.

Abstract In this paper, we present a search‐based automatic many‐to‐one component substitution mechanism. When a component is removed from an assembly to overcome component obsolescence, failure or unavailability, most existing systems perform component‐to‐component (one‐to‐one) substitution. Thus, they only handle situations where a specific candidate component is available. As this is not the most frequent case, it would be more flexible to allow a single component to be replaced by a whole component assembly (many‐to‐one component substitution). We propose such an automatic substitution mechanism, which does not require the possible changes to be anticipated and which preserves the quality of the assembly. This mechanism requires components to be enhanced with ports, which provide synthetic information on components' assembling capabilities. Such port‐enhanced components then constitute input data for a search‐based mechanism that looks for possible assemblies using various heuristics to tame complexity. Copyright © 2008 John Wiley & Sons, Ltd.

Encapsulation and modularity are supported by various static access control mechanisms that manage implementation hiding and define interfaces adapted to different client profiles. Programming languages use numerous and very different mechanisms, the cumulative application of which is sometimes confusing and hard to predict. Furthermore, understanding and reasoning about access control independently from the programming languages is quite difficult. Tools based on a language-independent model of access control are presented to address these issues. These tools support access control handling via visualisation of access, checking of design requirements on access and source code generation. We believe in the contribution of such tools for improving understanding and enhancing use of access control from design to implementation.

Investigates the separation between types and classes by putting to use a special feature of Java regarding classes, interfaces and inheritance. We propose an original method which, from a single inheritance class hierarchy, extracts a multiple inheritance interface hierarchy, which contains all the types of the original hierarchy, each class being linked to the interface representing its type. In the resulting structure, interfaces are well-organized and follow a natural multiple specialization, which would not have been possible using only the single inheritance which comes with Java. Our method is based on the use of a Galois lattice, which is a reference for the elaboration of hierarchies. We introduce and justify the need for a new algorithm that efficiently builds an essential part of the Galois lattice.

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.

Previous studies concerning multiple inheritance convinced us that a better analysis of conflict resolution mechanisms was necessary. In [DHHM92], we stated properties that a sound mechanism has to respect. Among them, a monotonicity principle plays a critical role, ensuring that the inheritance mechanism behaves “naturally” relative to the incremental design of the inheritance hierarchy. We focus here on linearizations and present an intrinsically monotonic linearization, whereas currently used linearizations are not. This paper describes the algorithm in detail, explains the design choices, and compares it to other linearizations, with LOOPS and CLOS taken as references. In particular, this new linearization extends CLOS and LOOPS linearizations, producing the same results when these linearizations are sound.

The main topic of this paper is multiple inheritance and conflict resolution methods in Object Oriented Programming. Our aim is to develop sound mechanisms easily understandable to any user. For this purpose, coherent behaviors of conflict resolution methods for multiple inheritance (such as supporting incrementality-monotonicity and stability under link subdivision) are introduced. We present interesting examples in which multiple inheritance known linearization algorithms (such as in CLOS [2] and LOOPS [19]) behave badly. Then we carefully study the conditions (on the inheritance graph) which assure good linearizations. We end with some suggestions for an incremental inheritance algorithm.