Assessing the Quality of your Software with MoQam

International audienceOver the last decade, the need for quality in software has increased. Several quality models have been proposed [4, 6, 11]. These mod- els emphasize the need to have quality checks while developing a software program. As far as we are aware of, no model to assess quality of existing software have reached a significant acceptance. This paper describes the Qualixo quality model. Qualixo is an open-source quality model developed by several companies and pushed further in the context of the Squale research project. Ac- cording to Marinescu and Ratiu [9], Qualixo can be classified as a Factor-Criteria-Metrics quality model. Qualixo is being applied in large companies such as AirFrance or PSA. It uses measurements to assess software quality. These measurements cover a number of different aspects of a software, including specification accuracy, programming rules, and test coverage. Qualixo has been origi- nally implemented on top of Eclipse. In this paper we present Mo- Qam (Moose Quality Assessment Model), the implementation of the Qualixo quality model in the Moose open-source reengineering environment

Cycles Assessment with CycleTable

Understanding the package organization of a large application is a challenging and critical task since it allows developers to better maintain the application. Several ap- proaches show in different ways software structure. Fewer show modularity issues at the package level. We focus on modularity issues due to cyclic dependencies between packages. Most approaches detect Strongly Connected Components (SCC) in a graph of dependencies. However, SCC detection does not allow one to easily understand and remove cyclic dependencies in legacy software displaying dozens of packages all dependent on each other. This paper presents i) a heuristic to focus on shared dependencies between cycles in SCC and ii) CycleTable, a visualization showing interesting dependencies to efficiently remove cycles in the system. This visualization is completed with enriched cells, small views displaying the internals of a dependency [LDDB09]. We performed i) a case study which shows that the shared dependency heuristic highlights dependencies to be removed, and ii) a comparative study which shows that CycleTable is useful for the task of breaking cycles in a SCC compared to a normal node-link representation

Visualisations pour la remodularisation à large échelle des systèmes à objets

National audienceDans ce chapitre, nous abordons deux points critiques de la remodularisa- tion : comment visualiser la structure d'un logiciel pour aider à la rendre mod- ulaire et comment aider le développeur à prendre les bonnes décisions. D'abord nous décrivons certains outils pour visualiser la structure des logiciels et comment nous les adaptons à la remodularisation. Ensuite nous présentons des visualisations adaptées à l'identification des problèmes de modularité. Enfin, nous proposons un outil, nommé Orion, permettant de simuler les changements de structure d'un logi- ciel. Il permet d'analyser l'impact des changements dans la structure et d'évaluer les coûts associés

Modèles de mesure de la qualité des logiciels

National audienceDe manière générale, un logiciel de qualité s'entend comme un logiciel capable de répondre parfaitement aux attentes du client, le tout sans défaut d'exécution. Ainsi, on détermine la qualité logicielle comme un ensemble de règles et de principes à suivre au cours du développement d'une application afin de concevoir un logiciel répondant à ces attentes1 [ABDT04]. La NASA par exemple, a déterminé un ensemble de procédures, d'instructions de travail et de règles pour s'assurer que chaque étape du développement s'effectue de manière adéquate2 [EBM06]. La qualité d'un logiciel se reflète non seule- ment dans les processus de développement mais aussi dans la qualité des éléments qui le constituent, la documentation, la présence de tests..... Mesurer la qualité d'un logiciel consiste alors à déterminer son adéquation par rapport aux objectifs de départ et aux standards de programmation. Il faut donc définir précisément ce que l'application doit faire et comment elle doit le faire, tant d'un point de vue fonctionnel que d'un point de vue technique. Une fois ces objectifs fixés, on peut alors appliquer un ensemble de règles et de mesures afin de calculer la différence entre objectifs attendus et réalisation obtenue. Obtenir une mesure de la qualité permet à la fois d'avoir une image précise du logiciel mesuré mais aussi de déterminer le comportement de celui-ci dans le temps : quels sont les risques de bogues, les éventuelles failles sécuritaires, les difficultés de maintenance, les freins à l'évolution, la viabilité à long terme, etc. Un des objectifs de la mesure de la qualité logicielle consiste à sensibiliser les équipes de développement sur leur méthodes de programmation. En effet, mesurer la qualité a également pour objectif de fournir des bonnes pratiques de travail et des indicateurs permettant d'augmenter la qualité des futurs développements. Pour obtenir une image complète de la qualité d'un logiciel on fait appel à un modèle de qualité. Celui-ci regroupe des règles qui décrivent ce que doit être un logiciel de qualité et le répertorie en différents groupes. Le modèle est ensuite évalué à partir de mesures obtenues grâce au code source, à la documentation, aux annexes techniques, aux règles de conception ou tout autre information disponible pour le projet. Un modèle de qualité comporte souvent plusieurs niveaux de lecture. Il se compose d'une couche de haut niveau qui décrit la qualité selon un point de vue très généraliste. Ce premier niveau est ensuite décrit plus spécifiquement, le tout pour atteindre ensuite le plus bas niveau, détaillé et technique. Dans ce chapitre nous présentons quelques modèles de qualité standards pour en- suite détailler le modèle Squale. Il s'agit d'un modèle de qualité open source développé depuis plusieurs années dans un contexte industriel avec Air France-KLM et PSA Peugeot- Citroen3. Ce modèle de qualité offre à la fois une vue générale de la qualité du projet mesuré mais également une vue détaillée orientée développeur. Il propose une manière d'agréger les données issues du projet de façon à ne perdre aucune information. Il per- met également de passer d'une vue détaillée à une vue globale et vice et versa. Squale est un modèle qui détermine la qualité d'une application mais il propose également un plan de remédiation conçu comme une aide à la décision

Identifying cycle causes with Enriched Dependency Structural Matrix

International audienceDependency Structure Matrix (DSM) has been successfully applied to identify software dependencies among packages and subsystems. A number of algorithms were proposed to compute the matrix so that it highlights patterns and problematic dependencies between subsystems. However, existing DSM implementations often miss important informa- tion to fully support reengineering effort. For example, they do not clearly qualify and quantify problematic relationships, information which is crucial to support remediation tasks. In this paper we present enriched DSM (eDSM) where cells are enriched with contextual information about (i) the type of dependencies (inheritance, class reference . . . ), (ii) the proportion of referencing entities, (iii) the proportion of ref- erenced entities. We distinguish independent cycles and stress potentially simple fixes for cycles using coloring information. This work is language independent and has been implemented on top of the Moose reengineering environment. It has been applied to non-trivial case studies among which ArgoUML, and Morphic the UI framework available in two open-source Smalltalks, Squeak and Pharo. Solution to problems identified by eDSM have been performed and retrofitted in Pharo main distribution

Deep into Pharo

International audienceThis is a book on Pharo a programming language available at http://www.pharo.or

BLOC: a Trait-Based Collections Library – a Preliminary Experience Report

International audienceA trait is a programming construct which provides code reusability. Traits are groups of methods that can be reused orthogonally from inheritance. Traits offer a solution to the problems of multiple inheritance by providing a behavior-centric modularity. Since traits offer an alternative to traditional inheritance-based code reuse, a couple of questions arise. For example, what is a good granularity for a Trait enabling reuse as well as plug ease? How much reuse can we expect on large existing inheritance-based hierarchies? In this paper we take as case study the Smalltalk Collection hierarchy and we start rewriting it from scratch using traits from the beginning. We show how such library can be built using traits and we report such a preliminary experience. Since the Collection library is large, we focused and built the main classes of the library with Traits and report problems we encountered and how we solved them. Results of this experience are positive and show that we can build new collections based on the traits used to define the new library kernel

Supporting Incremental Change in Large System Models

International audienceWhen reengineering large systems, software developers would like to assess and compare the impact of multiple change scenarios without actually performing these changes. A change can be ef- fected by applying a tool to the source code, or by a manual refac- toring. In addition, tools run over a model are costly to redevelop. It raises an interesting challenge for tools implementors: how to support modification of large source code models to enable com- parison of multiple versions. One naive approach is to copy the entire model after each modification. However, such an approach is too expensive in memory and execution time. In this paper we ex- plore different implementations that source code metamodels sup- port multiple versions of a system. We propose a solution based on dynamic binding of entities between multiple versions, providing good access performance while minimizing memory consumption

Technical and Economical Model (Workpackage 2.1)

The objective of this workpackage is to define a model for (i) assessing the effort of software modification, (ii) identifying healing actions following practices from the Squale quality model defined in the previous workpackage (WP1.3). It defines the input for the next workpackage which is about planning actions once their effort is characterized. The key constraints of this work are: • The remediation effort should be expressed in the context of a quality model. It should act as a quantification of the work to obtain a better (or good) quality of the entity under analysis. • The remediation should be based on practices as described in the workpackage 1.3

Enhanced Dependency Structure Matrix for Moose

International audienceDependency Structure Matrix (DSM), an approach de- veloped in the context of process optimization, has been suc- cessfully applied to identify software dependencies among packages and subsystems. It exists a couple of algorithms to help organizing the matrix in a form that reflects the ar- chitecture and highlights patterns and problematic depen- dencies between subsystems. However, the existing DSM implementations often miss some important information in their visualization to fully support a reengineering effort. In this paper we enhanced DSM with enriched cell contextual information by showing information (i) about the kinds of references made (inheritance, class accesses..), (ii) the pro- portion of entities (classes/methods) doing references, (iii) the proportion of entities been the target of the references. We distinguish independent cycles and stress the cycles us- ing coloring information. This work has been implemented on top of the Moose open-source reengineering environment and Mondrian. It has been applied to non-trivial case stud- ies such as the Morphic UI frameworks available in Squeak an open-source Smalltalk