[Moose-dev] Re: papers

not sure everything is there but probably some @inproceedings{Fabr11a, author = {Johan Fabry and Andy Kellens and Simon Denier and St\'ephane Ducasse}, title = {AspectMaps: A Scalable Visualization of Join Point Shadows}, booktitle = {International Conference on Program Comprehension (ICPC)}, annote = {internationalconference}, keywords = {lse-pub}, misc = {Acceptance rate: 18/76 = 23\%}, aeresstatus = {aeres12}, aeres = {ACT}, rate = {23%}, selectif = {oui}, inria = {RMOD}, publisher = {IEEE Computer Society Press}, year = {2011} } @inproceedings{Abde08b, author = {Hani Abdeen and Ilham Alloui and St\'ephane Ducasse and Damien Pollet and Mathieu Suen}, title = {Package Reference Fingerprint: a Rich and Compact Visualization to Understand Package Relationships}, booktitle = {European Conference on Software Maintenance and Reengineering (CSMR)}, annote = {internationalconference}, pages = {213--222}, keywords = {moose-pub cook-pub lse-pub}, misc = {Acceptance rate: 24/87 = 27\%}, aeresstatus = {aeres08}, aeres = {ACT}, rate = {27%}, selectif = {oui}, inria = {ADAM}, publisher = {IEEE Computer Society Press}, url = {http://rmod.lille.inria.fr/archives/papers/Abde08b-CSMR2008-Fingerprint.pdf}, location = {Athens, Greece}, year = {2008}, abstract = {Object-oriented languages such as Java, Smalltalk, and C++ structure their programs using packages, allowing classes to be organized into named abstractions. Maintainers of large applications need to understand how packages are structured and how they relate to each other, but this task is very complex because packages often have multiple clients and different roles (class container, code ownership...). Cohesion and coupling are still among the most used metrics, because they help identify candidate packages for restructuring; however, they do not help maintainers understand the structure and interrelationships between packages. In this paper, 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 visualization 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. We applied these views on three large case studies: JBoss, Azureus, and ArgoUML.}, hal = {http://hal.inria.fr/inria-00200869}, hal-id = {inria-00200869} } @inproceedings{Abde09b, author = {Hani Abdeen and St\'ephane Ducasse and Houari A. Sahraoui and Ilham Alloui}, title = {Automatic Package Coupling and Cycle Minimization}, booktitle = {International Working Conference on Reverse Engineering (WCRE)}, publisher = {IEEE Computer Society Press}, address = {Washington, DC, USA}, misc = {acceptance rate: 20/79 = 25\%}, pages = {103--112}, annote = {internationalconference}, aeres = {ACT}, x-pays = {CA}, x-country = {FR}, x-editorial-board = {yes}, inriareport = {2009}, x-proceedings = {yes}, x-international-audience = {yes}, aeresstatus = {aeres12}, rate = {25\%}, selectif = {oui}, inria = {RMOD}, keywords = {moose remoose2 lse-pub cook}, year = {2009}, hal = {http://hal.inria.fr/inria-00425417}, hal-id = {inria-00425417 to recover as lse}, url = {http://rmod.lille.inria.fr/archives/papers/Abde09b-WCRE2009-AutomaticPackageCoupling.pdf}, abstract = {Object-oriented (OO) software is usually organized into subsystems using the concepts of package or module. Such modular structure helps applications to evolve when facing new requirements. However, studies show that as soft- ware evolves to meet requirements and environment changes, modularization quality degrades. To help maintainers improve the quality of software modularization we have designed and implemented a heuristic search-based approach for automatically optimizing inter-package connectivity (i.e., dependencies). In this paper, we present our approach and its underlying techniques and algorithm. We show through a case study how it enables maintainers to optimize OO package structure of source code. Our optimization approach is based on Simulated Annealing technique.}, x-language = {EN} } @phdthesis{Abde09c, author = {Hani Abdeen}, title = {Visualizing, Assessing and Re-Modularizing Object-Oriented Architectural Elements}, school = {Universit\'e de Lille}, year = {2009}, annote = {PhD}, institution = {INRIA}, inria = {RMOD}, keywords = {moose remoose2 lse-pub cook}, aeres = {AP}, type_rapport = {PhD}, abstract = {To 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 modularization. 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 visualizations, 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 original 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.}, url = {http://rmod.lille.inria.fr/archives/phd/PhD-2009-Abdeen.pdf}, hal-id = {tel-00498389 / zi#3ow#h}, x-language = {EN} } @article{Abde10a, title = {Package Fingerprint: a visual summary of package interfaces and relationships}, author = {Hani Abdeen and St\'ephane Ducasse and Damien Pollet and Ilham Alloui}, journal = {Information and Software Technology Journal}, annote = {internationaljournal}, inriareport = {2010}, inria = {RMOD}, pages = {1312-1330}, keywords = {moose remoose2 lse-pub cook}, doi = {10.1016/j.infsof.2010.07.005}, x-editorial-board = {yes}, impactfactor = {ISI impact factor 1.821 (2010)}, x-proceedings = {yes}, volume = {52}, x-international-audience = {yes}, aeres = {ACL}, aeresstatus = {aeres12}, year = {2010}, abstract = {Context: 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.}, url = {http://rmod.lille.inria.fr/archives/papers/Abde10a-IST-Official-packageFingerprints.pdf}, secondurl = {http://rmod.lille.inria.fr/archives/papers/Abde10a-IST-packageFingerprints.pdf}, hal-id = {inria-00531496} } @inproceedings{Anqu11a, title = {Legacy Software Restructuring: Analyzing a Concrete Case}, author = {Nicolas Anquetil and Jannik Laval}, booktitle = {CSMR 2011: Proceedings of the 15th European Conference on Software Maintenance and Reengineering}, year = {2011}, address = {Oldenburg, Germany}, keywords = {moose-pub lse-pub}, abstract = {Software re-modularization is an old preoccupation of reverse engineering research. The advantages of a well structured or modularized system are well known. Yet after so much time and efforts, the field seems unable to come up with solutions that make a clear difference in practice. Recently, some researchers started to question whether some basic assumptions of the field were not overrated. The main one consists in evaluating the high-cohesion/low-coupling dogma with metrics of unknown relevance. In this paper, we study a real structuring case (on the Eclipse platform) to try to better understand if (some) existing metrics would have helped the software engineers in the task. Results show that the cohesion and coupling metrics used in the experiment did not behave as expected and would probably not have helped the maintainers reach there goal. We also measured another possible restructuring which is to decrease the number of cyclic dependencies between modules. Again, the results did not meet expectations.}, misc = {acceptance rate: 29/82 = 35\%}, aeres = {ACT}, annote = {internationalconference}, aeresstatus = {aeres12}, labo = {dans}, inria = {RMOD}, inriareport = {2011}, selectif = {oui}, x-editorial-board = {yes}, x-proceedings = {yes}, x-international-audience = {yes}, x-language = {EN}, x-country = {GE} } @article{Arev10a, author = {Gabriela Ar\'evalo and St\'ephane Ducasse and Silvia Gordillo and Oscar Nierstrasz}, month = dec, annote = {internationaljournal}, title = {Generating a catalog of unanticipated schemas in class hierarchies using Formal Concept Analysis}, journal = {Information and Software Technology}, volume = {52}, pages = {1167-1187}, aeres = {ACL}, impactfactor = {ISI impact factor 1.821 (2010)}, misc = {ISI impact factor 1.821 (2010)}, inriareport = {2010}, inria = {RMOD}, x-editorial-board = {yes}, x-proceedings = {yes}, x-international-audience = {yes}, keywords = {moose lse-pub cook}, aeresstatus = {aeres12}, issn = {0950-5849}, doi = {10.1016/j.infsof.2010.05.010}, hal-id = {inria-00531498}, year = {2010}, x-pays = {AR,CH}, url = {http://rmod.lille.inria.fr/archives/papers/Arev10a-IST-generating_a_catalog.pdf}, secondurl = {http://rmod.lille.inria.fr/archives/papers/Arev10a-IST-Official-generating_a_catalog.pdf} } @inproceedings{Uqui10a, title = {Visually Supporting Source Code Changes Integration: the Torch Dashboard}, author = {Uquillas G\'omez, Ver\'onica and St\'ephane Ducasse and Theo D'Hondt}, booktitle = {Working Conference on Reverse Engineering (WCRE 2010)}, year = {2010}, annote = {internationalconference}, keywords = {lse-pub}, month = oct, inria = {RMOD}, labo = {dans}, inriareport = {2010}, x-editorial-board = {yes}, x-proceedings = {yes}, x-international-audience = {yes}, x-country = {BE}, x-language = {EN}, url = {http://rmod.lille.inria.fr/archives/papers/Uqui10a-Torch-WCRE10.pdf}, abstract = {Automatic and advanced merging algorithms help programmers to merge their modifications in main development repositories. However, there is little support to help release masters (integrators) to take decisions about the integration of published merged changes into the system release. Most of the time, the release master has to read all the changed code, check the diffs to build an idea of a change, and read unchanged code to understand the context of some changes. Such a task can be overwhelming. In this paper we present a dashboard to support integrators getting an overview of proposed changes in the context of object-oriented programming. Our approach named Torch characterizes changes based on structural information, authors and symbolic information. It mixes text-based diff information with visual representation and metrics characterizing the changes. We describe our experiment applying it to Pharo, a large open-source system, and report on the evaluation of our approach by release masters of several open-source projects.}, hal-id = {inria-00531508} } @inproceedings{Uqui10b, annote = {internationalworkshop}, author = {Uquillas G\'omez, Ver\'onica and St\'ephane Ducasse and Theo D'Hondt}, booktitle = {Smalltalks'2010}, keywords = {moose-pub stefPub lse-pub}, title = {Meta-models and Infrastructure for Smalltalk Omnipresent History}, year = {2010}, abstract = {Source code management systems record different versions of code. Tool support can then com- pute deltas between versions. However there is little support to be able to perform history-wide queries and analysis: for example building slices of changes and identifying their differences since the beginning of the project. We believe that this is due to the lack of a powerful code meta- model as well as an infrastructure. For example, in Smalltalk often several source code meta- models coexist: the Smalltalk reflective API coexists with the one of the Refactoring engine or distributed versioning system. While having specific meta-models is an engineered solution, it hampers meta-models manipulation as it requires more maintenance efforts (e.g., duplication of tests, transformation between models), and more importantly navigation tool reuse. As a first step to solve this problem, this article presents several source code models that could be used to support several activities and proposes an unified and layered approach to be the foundation for building an infrastructure for omnipresent version browsing.}, aeresstatus = {aeres12}, aeres = {COM}, inria = {RMOD}, x-editorial-board = {yes}, x-proceedings = {yes}, inriareport = {2010}, x-international-audience = {yes}, url = {http://rmod.lille.inria.fr/archives/workshops/Uqui10b-Smalltalk2010-Metamodels.pdf}, hal-id = {inria-00531613} } On Mar 14, 2011, at 9:08 PM, Tudor Girba wrote: