OZONE: Layer Identification in the presence of Cyclic Dependencies

International audienceA layered software architecture helps understanding the role of software entities (e.g., packages or classes) in a system and hence, the impact of changes on these entities. However, the computation of an optimal layered organization in the presence of cyclic dependencies is difficult. In this paper, we present an approach that (i) provides a strategy supporting the automated detection of cyclic dependencies, (ii) proposes heuristics to break cyclic dependencies, and (iii) computes an organization of software entities in multiple layers even in presence of cyclic dependencies. Our approach performs better than the other existing approaches in terms of accuracy and interactivity, it supports human inputs and constraints. In this paper, we present this approach and compare it to existing solutions. We applied our approach on two large software systems to identify package layers and the results are manually validated by software engineers of the two systems

Matrice de dépendances enrichie

National audienceLes matrices de dépendance (DSM - Dependency Structure Matrix), développées dans le cadre de l'optimisation de processus, ont fait leurs preuves pour identifier les dépendances logicielles entre des packages ou des sous-systè- mes. Il existe plusieurs algorithmes pour structurer une matrice de façon à ce qu'elle reflète l'architecture des éléments analysés et mette en évidence des cycles entre les sous-systèmes. Cependant, les implémentations de matrices de dépendance existantes manquent d'informations importantes pour apporter une réelle aide au travail de réingénierie. Par exemple, le poids des relations qui posent problème ainsi que leur type ne sont pas clairement présentés. Ou en- core, des cycles indépendants sont fusionnés. Il est également difficile d'obtenir une visualisation centrée sur un package. Dans ce papier, nous améliorons les matrices de dépendance en ajoutant des informations sur (i) le type de réfé- rences, (ii) le nombre d'entités référençantes, (iii) le nombre d'entités référen- cées. Nous distinguons également les cycles indépendants. Ce travail a été im- plémenté dans l'environnement de réingénierie open-source Moose. Il a été ap- pliqué à des études de cas complexes comme le framework Morphic UI contenu dans les environnements Smalltalk open-source Squeak et Pharo. Les résultats obtenus ont été appliqués dans l'environnement de programmation Pharo et ont mené à des améliorations

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

System-level Usage Dependency Analysis of Object-Oriented Systems

Uncovering, modelling, and understanding architectural level dependencies of software systems is a key task for software maintainers. However, current dependency analysis techniques for object-oriented software are targeted at the class or method level; this is because most dependencies — such as instantiates, references, and calls — must be interpreted in the context of one or more class hierarchies. In this paper, we propose an approach, called the Highlevel Object Dependency Graph (HODG), that captures all possible usage dependencies among coarse-grained entities. Based on the new model, we further propose a set of dependency analysis methods. Finally, we present an exploratory case study using HODGs — supported by an automated analysis tool — of the Apache Ant build system; we show how HODG analysis can help maintainers capture external properties of coarse-grained entities, and better understand the nature of their interdependencies.