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

Software metric for Java and C++ practices (Workpackage 1.1)

The objective of this deliverable is to define a catalog of software met- rics. In particular we analyze the metrics used in the Squale Model and tool. In addition it offers a coherent set of software metrics for object-oriented languages on top of which Squale practices will be based. There is a plethora of software metrics and a large amount of research articles. Still there is a lack for a serious and practically-oriented evaluation of metrics. Often metrics lacks the property that the software reengineer or quality expert can easily understand the situation summa- rized by the metrics. In particular since the exact notion of coupling and cohesion is complex, a particular focus on such point is important

Package Fingerprint: a visual summary of package interfaces and relationships

International audienceContext: Object-oriented languages such as Java, Smalltalk, and C++ structure their programs using packages. Maintainers of large systems need to understand how packages relate to each other, but this task is complex because packages often have multiple clients and play different roles (class container, code ownership. . . ). Several approaches have been proposed, among which the use of cohesion and coupling metrics. Such metrics help identify candidate packages for restructuring; however, they do not help maintainers actually understand the structure and interrelation- ships between packages. Objectives: In this paper, we use pre-attentive processing as the basis for package visualization and see to what extent it could be used in package understanding. Method: We present the package fingerprint, a 2D visualization of the references made to and from a package. The proposed visualization offers a semantically rich, but compact and zoomable views centered on packages. We focus on two views (incoming and outgoing references) that help users understand how the package under analysis is used by the system and how it uses the system. Results: We applied these views on four large systems: Squeak, JBoss, Azureus, and ArgoUML. We obtained several interesting results, among which, the identification of a set of recurring visual patterns that help maintainers: (a) more easily identify the role of and the way a package is used within the system (e.g., the package under analysis provides a set of layered services), and, (b) detect either problematic situations (e.g., a single package that groups together a large number of basic services) or opportunities for better package restructuring (e.g., removing cyclic dependencies among packages). The visualization generally scaled well and the detection of different patterns was always possible. Conclusion: The proposed visualizations and patterns proved to be useful in understanding and maintaining the different systems we addressed. To generalize to other contexts and systems, a real user study is required

Project-Team RMoD (Analyses and Language Constructs for Object-Oriented Application Evolution) 2009 Activity Report

This is the yearly report of the RMOD team. A good way to understand what we are doing

Visualizing, Assessing and Re-Modularizing Object-Oriented Architectural Elements

TheseTo cope with the complexity of large object-oriented software systems, developers organize classes into subsystems using the concepts of module or package. Such modular structure helps software systems to evolve when facing new requirements. The organization of classes into packages and/or subsystems represents the software modularization. the software modularization usually follows interrelationships between classes. Ideally, packages should to be loosely coupled and cohesive to a certain extent. However, Studies show that as software evolves to meet requirements and environment changes, the software modularization gradually drifts and looses quality. As a consequence, the software modularization must be maintained. It is thus important to understand, to assess and to optimize the organization of packages and their relationships. Our claim is that the maintenance of large and complex software modularizations needs approaches that help in: (1) understanding package shapes and relationships; (2) assessing the quality of a modularization, as well as the quality of a single package within a given modularization; (3) optimizing the quality of an existing modulariza- tion. In this thesis, we concentrate on three research fields: software visualizations, metrics and algorithms. At first, we define two visualizations that help maintainers: (1) to understand packages structure, usage and relationships; (2) to spot patterns; and (3) to identify misplaced classes and structural anomalies. In addition to visual- izations, we define a suite of metrics that help in assessing the package design quality (i.e., package cohesion and coupling). We also define metrics that assess the quality of a collection of inter-dependent packages from different view points, such as the degree of package coupling and cycles. Finally, we define a search-based algorithm that automatically reduces package coupling and cycles only by moving classes over existing packages. Our optimization approach takes explicitly into account the origi- nal class organization and package structure. It also allows maintainers to control the optimization process by specifying: (1) the maximal number of classes that may change their packages; (2) the classes that are candidate for moving and the classes that should not; (3) the packages that are candidate for restructuring and the packages that should not; and (4) the maximal number of classes that a given package can entail. The approaches presented in this thesis have been applied to real large object- oriented software systems. The results we obtained demonstrate the usefulness of our visualizations and metrics; and the effectiveness of our optimization algorithm.Pour faire face à la complexité des grands systèmes logiciels orientés objets, les programmeurs organisent les classes en sous-systèmes en utilisant les concepts de module ou de package. Une telle structure modulaire permet aux systèmes logiciels d'évoluer face aux nouvelles exigences. L'organisation des classes dans des pack- ages et / ou sous-systèmes, que nous appelons la modularisation du logiciel, suit habituellement les relations entre les classes. Il est de usage de vouloir les packages faiblement couplés et assez cohésifs. Cependant, les études montrent que quand les systèmes logiciels s'adaptent aux exigences et aux modifications de l'environnement, leurs modularisations dérivent et perdent progressivement leur qualité. En con- séquence, la modularisation des systèmes logiciels doit être maintenue. Il est donc important de comprendre, d'évaluer et d'optimiser l'organisation des packages et de leurs relations. Le point défendu dans la thèse est que le maintien des modularisations logiciels de grande taille et complexes requiert des approches qui contribuent à: (1) la com- préhension des packages et de leurs relations; (2) l'évaluation de la qualité d'une modularisation, ainsi que la qualité d'un package dans le contexte d'une modularisa- tion donnée; (3) l'optimisation de la qualité d'une modularisation existante. Dans cette thèse, nous nous concentrons sur trois domaines de recherche: visu- alisations de programmes, métriques et algorithmes. Dans un premier temps, nous définissons deux visualisations qui aident les mainteneurs à: (1) la compréhension de la structure des packages, et de leurs utilisations et leurs relations; (2) l'identification des modèles; et (3) l'identification des anomalies structurelles. En plus de visualisa- tions, nous définissons un ensemble de métriques qui aident à évaluer la qualité d'un package (i.e., la cohésion et le couplage). Nous définissons également des métriques qui permettent d'évaluer la qualité d'une collection des packages inter-dépendants. Ceci en prenant en compte le degré de couplage et de cycles entre les packages. Enfin, nous définissons une algorithme de recherche qui réduit automatiquement le couplage et les cycles entre les packages, en déplaçant seulement les classes sur les packages existants. Notre approche d'optimisation prend explicitement en compte l'organisation des classes et la structure originale des packages. Il permet également aux mainteneurs de contrôler le processus d'optimisation en spécifiant: (1) le nombre maximal des classes qui peuvent changer leurs packages; (2) les classes qui sont candidates pour se déplacer et celles qui ne doivent pas changer leurs packages; (3) les packages qui sont candidates pour la restructuration et ceux qui ne doivent pas se changer; et (4) le nombre maximal des classes qu'un package donné peut contenir. Les approches présentées dans cette thèse ont été appliquées à des systèmes logi- ciels orienté objets, réels et de grand taille. Les résultats obtenus démontrent l'utilité de nos visualisations et métriques, et l'efficacité de notre algorithme d'optimisation