@phdthesis{Lava11b,

  author = {Jannik Laval},

  title = {Package Dependencies Analysis and Remediation in Object-Oriented Systems},

  school = {Universit\'e de Lille},

  year = {2011},

  institution = {INRIA},

  type_rapport = {PhD},

  abstract = {Software evolves over time with the modification, addition and removal of new classes, methods, functions, dependencies. A consequence is that behavior may not be placed in the right packages and the software modularization is broken. A good organization of classes into identifiable and collaborating packages eases the understanding, maintenance, test and evolution of software systems. We argue that maintainers lack tool support for understanding the concrete organization and for structuring packages within their context.

Our claim is that the maintenance of large software modularizations needs approaches that help (i) understanding the structure at package level and assessing its quality; (ii) identifying modularity problems; and (iii) take decisions and verify the impact of these decisions.

In this thesis, we propose ECOO, an approach to help reengineers identify and understand structural problems in software architectures and to support the remodularization activity. It concerns the three following research fields:

- Understanding package dependency problems. We propose visualizations to highlight cyclic dependencies problems at package level.

- Proposing dependencies to be changed for remodularization. The approach proposes dependencies to break to make the system more modular.

- Analyzing impact of change. The approach proposes a change impact analysis to try modifications before applying them on the real system.

The approaches presented in this thesis have been qualitatively and quantitatively validated and results have been taken into account in the reengineering of analyzed systems. The results we obtained demonstrate the usefulness of our approach.},

url = {http://rmod.lille.inria.fr/archives/phd/PhD-2011-Laval.pdf},

hal-id = {tel-00601546}

}

@inproceedings{Fall11a,

  author = {Jean R\'emi Falleri and Simon Denier and Jannik Laval and Philipe Vismara and St\'ephane Ducasse},

  booktitle = {Proceedings of the 49th International Conference on Objects, Models, Components, Patterns (TOOLS-Europe'11)},

  year = {2011},

  month = jun,

  inriareport = {2011},

  x-country = {FR},

  title = {Efficient Retrieval and Ranking of Undesired Package Cycles in Large Software Systems},

  address = {Zurich, Switzerland},

  abstract = {Many design guidelines state that a software system architecture should avoid cycles between its packages. Yet such cycles appear again and again in many programs. We believe that the existing approaches for cycle detection are too coarse to assist the developers to remove cycles from their programs. In this paper, we describe an efficient algorithm that performs a fine-grained analysis of the cycles among the packages of an application. In addition, we define a metric to rank cycles by their level of undesirability, prioritizing the cycles that seems the more undesired by the developers. Our approach is validated on two large and mature software systems in Java and Smalltalk.},

url = {http://rmod.lille.inria.fr/archives/papers/Fall11a-Tools2011-UndesirableCycles.pdf},

keywords = {lse-pub},

  annote = {internationalconference},

  aeres = {ACT},

  aeresstatus = {aeres12},

  inria = {RMOD},

  labo = {dans},

  x-pays = {FR},

  selectif = {oui},

  x-editorial-board = {yes},

  x-proceedings = {yes},

  x-international-audience = {yes},

  x-country = {FR},

  x-language = {EN},

  hal-id = {inria-00614770}

}

@inproceedings{Roth11a,

  author = {David Rothlisberger and Oscar Nierstrasz and St\'ephane Ducasse},

  title = {SmartGroups: Focusing on Task-Relevant Source Artifacts in IDEs},

  booktitle = {International Conference on Program Comprehension (ICPC)},

  annote = {internationalconference},

  keywords = {lse-pub},

  misc = {Acceptance rate: 18/76 = 23\%},

  aeresstatus = {aeres12},

  aeres = {ACT},

  rate = {23%},

  misc = {Acceptance rate: 18/76 = 23\%},

  selectif = {oui},

  inria = {RMOD},

  publisher = {IEEE Computer Society Press},

  year = {2011},

  abstract = {Navigating large software systems, even when using a modern IDE is difficult, since conceptually related software artifacts are distributed in a huge software space.

For most software maintenance tasks, only a small fraction of the entire software space is actually relevant. The IDE, however, does not reveal the task relevancy of source artifacts, thus developers cannot easily focus on the artifacts required to accomplish their tasks. 

Smart Groups help developers to perform software maintenance tasks by representing groups of source artifacts that are relevant for the current task. Relevancy is determined by analyzing historical navigation and modification activities, evolutionary information, and runtime information. 

The prediction quality of Smart Groups is validated with a benchmark evaluation using recorded development activities and evolutionary information from versioning systems.},

  labo = {dans},

  x-pays = {FR},

  selectif = {oui},

  x-editorial-board = {yes},

  x-proceedings = {yes},

  x-international-audience = {yes},

  x-country = {FR},

  x-language = {EN},

url = {http://rmod.lille.inria.fr/archives/papers/Roet11a-ICPC2011-smartGroups.pdf},

  hal-id = {inria-00614779}

}

@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%},

  pages  = {121-130},

  selectif = {oui},

  inria = {RMOD},

  urldoi    = {http://dx.doi.org/10.1109/ICPC.2011.11},

  publisher = {IEEE Computer Society Press},

  url = {http://rmod.lille.inria.fr/archives/papers/Fabr11a-ICPC2011-AspectMaps.pdf},

  year = {2011},

  aeresstatus = {aeres12},

  inria = {RMOD},

  labo = {dans},

  x-pays = {FR},

  selectif = {non},

  x-editorial-board = {yes},

  x-proceedings = {yes},

  x-international-audience = {yes},

  x-country = {FR},

  x-language = {EN},

  abstract = {When using Aspect-Oriented Programming, it is sometimes difficult to determine at which join point an aspect executes. Similarly, when considering one join point, knowing which aspects will execute there and in what order is non- trivial. This makes it difficult to understand how the application will behave. A number of visualizations have been proposed that attempt to provide support for such program understanding. However, they neither scale up to large code bases nor scale down to understanding what happens at a single join point. In this paper, we present AspectMaps - a visualization that scales in both directions, thanks to a multi-level selective structural zoom. We show how the use of AspectMaps allows for program understanding of code with aspects, revealing both a wealth of information of what can happen at one particular join point as well as allowing to see the “big picture” on a larger code base. We demonstrate the usefulness of AspectMaps on an example and present the results of a small user study that shows that AspectMaps outperforms other aspect visualization tools.},

  hal-id = {inria-00614773}

}

@inproceedings{Abde07a,

  annote = {internationalworkshop},

  author = {Hani Abdeen and Ilham Alloui and St\'ephane Ducasse and Damien Pollet and Mathieu Suen},

  booktitle = {FAMOOSr, 1st Workshop on FAMIX and Moose in Reengineering},

  keywords = {moose-pub stefPub},

  title = {Package References Distribution Fingerprint},

  year = {2007}

}

@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{Anqu97a,

 author = {Anquetil, Nicolas and Lethbridge, Timothy C.},

 title = {File clustering using naming conventions for legacy systems},

 abstract = {Decomposing complex software systems into conceptually independent subsystems represents a significant software engineering activity that receives considerable research attention. Most of the research in this domain deals with the source code; trying to cluster together files which are conceptually related. In this paper we propose using a more informal source of information: file names. We present an experiment which shows that file naming convention is the best file clustering criteria for the software system we are studying.Based on the experiment results, we also sketch a method to build a conceptual browser on a software system.},

 booktitle = {Proceedings of the 1997 conference of the Centre for Advanced Studies on Collaborative research},

 series = {CASCON '97},

 year = {1997},

 location = {Toronto, Ontario, Canada},

 url = {http://portal.acm.org/citation.cfm?id=782010.782012},

 publisher = {IBM Press},

  annote = {internationalconference},

  keywords = {clustering},

  month = nov,

  pages = {184--195},

 aeres = {ACT},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes},

 x-pays = {CA}

}

@inproceedings{Anqu98a,

  author = {Nicolas Anquetil and Timothy C. Lethbridge},

  title = {Assessing the relevance of identifier names in a legacy software system},

  abstract = {Reverse engineering is a difficult task even for humans. When trying to provide tools to assist in this task, one should try to take advantage of all possible sources of information.Informal sources, like naming conventions, are more abstract than the code, thus helping to bridge the gap between code and design. On the other hand, there is no certainty that they actually represent the current state of the system.Some researchers have used these informal sources of information, relying on an assumption that if types (or variables, or functions) have the same name then they represent the same thing.However none of these researchers have actually tried to establish to what extent this assumption is valid. This paper provides a framework to study this issue. We will define what it means to have a "reliable naming convention", how this can be tested and under what conditions. We present examples from the particular legacy software system we are studying as well as from the literature.},

  annote = {internationalconference},

  pages = {213--222},

  publisher = {IBM Press},

  year = {1998},

 booktitle = {Proceedings of the 1998 conference of the Centre for Advanced Studies on Collaborative research},

 series = {CASCON '98},

 location = {Toronto, Ontario, Canada},

 url = {http://portal.acm.org/citation.cfm?id=783160.783164},

 aeres = {ACT},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes},

 x-pays = {CA}

}

@inproceedings{Anqu98b,

  author = {Nicolas Anquetil and Timothy C. Lethbridge},

  annote = {internationalconference},

  pages = {84--93},

  title = {Extracting Concepts from File Names: a New File Clustering Criterion},

  abstract = {Decomposing complex software systems into conceptually independent subsystems is a significant software engineering activity which received considerable research attention. Most of the research in this domain considers the body of the source code; trying to cluster together files which are conceptually related. This paper discusses techniques for extracting concepts (we call them “abbreviations”) from a more informal source of information: file names. The task is difficult because nothing indicates where to split the file names into substrings. In general, finding abbreviations would require domain knowledge to identify the concepts that are referred to in a name and intuition to recognize such concepts in abbreviated forms. We show by experiment that the techniques we propose allow about 90\% of the abbreviations to be found automatically. },

  year = {1998},

 booktitle = {Proceedings of the 20th international conference on Software engineering},

 series = {ICSE '98},

 isbn = {0-8186-8368-6},

 location = {Kyoto, Japan},

 url = {http://portal.acm.org/citation.cfm?id=302163.302172},

 publisher = {IEEE Computer Society},

 address = {Washington, DC, USA},

 aeres = {ACT},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes},

 x-pays = {CA}

}

@article{Anqu98c,

 author = {Anquetil, Nicolas and Vaucher, Jean},

 title = {Expressing opposition in the object model, first step towards negation},

 abstract = {Although seemingly simple and intuitive, the object model still contains ambiguous notions. For example, inheritance has been proved to convey two different meanings depending on whether it is behavior or implementation that is inherited. Another conceptually simple notion, multiple inheritance, has not yet been clearly formalized. In this paper, we start by looking at relationships between sibling classes (two immediate subclasses of a common parent). Siblings can be combined through multiple inheritance, or on the contrary, they can be mutually exclusive. We call the relation between incompatible siblings "opposition", and show how it could help in formalizing object models. We then consider widening the explicit use of negation in object models. We argue that negative assertions could be used to validate the creation of new classes to ensure they are compatible with the intended uses of existing classes. Negation leads us to consider the implicit assumption behind object models, we propose to shift from the closed world assumption to the open world assumption.},

 journal = {SIGPLAN Notices},

 volume = {33},

 issue = {1},

 year = {1998},

 issn = {0362-1340},

 pages = {48--55},

 doi = {10.1145/609742.609749},

 publisher = {ACM},

 address = {New York, NY, USA},

 month = {jan},

 keywords = {multiple inheritance, negation, object model, reflection, theoretical foundations},

 annote = {internationaljournal},

 aeres = {ASCL},

 selectif = {non},

 labo = {non},

 x-editorial-board = {no},

 x-international-audience = {yes},

 x-pays = {CA}

}

@inproceedings{Anqu99a,

  author = {Nicolas Anquetil and Timothy Lethbridge},

  title = {Experiments with {Clustering} as a {Software} {Remodularization} {Method}},

  abstract = {As valuable software systems get old, reverse engineering becomes more and more important to the companies that have to maintain the code. Clustering is a key activity in reverse engineering to discover a better design of the systems or to extract significant concepts from the code. Clustering is an old activity, highly sophisticated, offering many methods to answer different needs. Although these methods have been well documented in the past, these discussions may not apply entirely to the reverse engineering domain. We study some clustering algorithms and other parameters to establish whether and why they could be used for software remodularization. We study three aspects of the clustering activity: abstract descriptions chosen for the entities to cluster; metrics computing coupling between the entities; and clustering algorithms. The experiments were conducted on three public domain systems (gcc, Linux and Mosaic) and a real world legacy system (2 million LOC). Among other things, we confirm the importance of a proper description scheme of the entities being clustered, we list a few good coupling metrics to use and characterize the quality of different clustering algorithms. We also propose novel description schemes not directly based on the source code and we advocate better formal evaluation methods for the clustering results},

  booktitle = {Proceedings of WCRE '99 (6th Working Conference on Reverse Engineering)},

  isbn = {0-7695-0303-9},

  doi = {10.1109/WCRE.1999.806964},

   annote = {internationalconference},

  keywords = {clustering},

  pages = {235--255},

  year = {1999},

 aeres = {ACT},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes},

 x-pays = {CA}

}

@article{Anqu99b,

  author = {Nicolas Anquetil and Timothy C. Lethbridge},

  title = {Recovering Software Architecture from the Names of Source Files},

  abstract = {We discuss how to extract a useful set of subsystems from a set of existing source-code file names. This problem is challenging because many legacy systems use thousands of files names, including some that are very short and cryptic. At the same time the problem is important because software maintainers often find it difficult to understand such systems. We propose a general algorithm to cluster files based on their names, and a set of alternative methods for implementing the algorithm. One of the key tasks is picking candidate words to try to identify in file names. We do this by (a) iteratively decomposing file names, (b) finding common substrings, and (c) choosing words in routine names, in an English dictionary or in source-code comments. In addition, we investigate generating abbreviations from the candidate words in order to find matches in file names, as well as how to split file names into components given no word markers. To compare and evaluate our five approaches, we present two experiments. The first compares the "concepts" found in each file name by each method with the results of manually decomposing file names. The second experiment compares automatically generated subsystems with subsystem examples proposed by experts. We conclude that two methods are most effective: extracting concepts using common substrings and extracting those concepts that relate to the names of routines in the files.},

  journal = {Journal of Software Maintenance: Research and Practice},

  pages = {201--21},

  doi = {10.1002/(SICI)1096-908X(199905/06)11:3<201::AID-SMR192>3.0.CO;2-1},

  annote = {internationaljournal},

  misc = {5 Year ISI impact factor 1.523 (2010)},

  impactfactor = {5 Year ISI impact factor 1.523 (2010)},

  volume = {11},

  year = {1999},

 aeres = {ACT},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes},

 x-pays = {CA}

}

@inproceedings{Anqu00a,

 author = {Anquetil, Nicolas},

 title = {Concepts + Relations = 'Abstract Constructs'},

 year = {2000},

 booktitle = {WCRE'00: Proceedings of the Seventh Working Conference on Reverse Engineering (WCRE'00)},

 address = {Los Alamitos, CA, USA},

publisher = {IEEE Computer Society},

 note = {Due to an error of the editor, the paper does not appear in the proceedings},

 url = {http://rmod.lille.inria.fr/archives/papers/Anqu00a-WCRE-Concepts+Relations.pdf},

 annote = {internationalconference},

 aeres = {ACT},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes}

}

@inproceedings{Anqu00b,

 author = {Anquetil, Nicolas},

 title = {A Comparison of Graphs of Concept for Reverse Engineering},

 abstract = {To group related things together (for example to form subsystems); researchers in Reverse Engineering are looking for algorithms that create meaningful groups. One such algorithm, Concept Analysis, received a lot of interest recently. It creates a lattice of concepts, which have some advantages over the more traditional tree of clusters from clustering algorithms.We will argue that the main interest of Concept Analysis lies in the concepts themselves and can be disconnected from the particular structure (the lattice of concepts) in which the concepts are usually arranged. We will compare Concept Analysis to various other algorithms trying to select the most important concepts contained in a set of entities.Our main conclusion is that although it have advantages, the lattice of concepts suffer from a major drawback that other constructs do not have: it returns much more information (concepts) than what it was given in input (a set of entities describing some software system).},

 booktitle = {Proceedings of the 8th International Workshop on Program Comprehension},

 series = {IWPC '00},

 year = {2000},

 isbn = {0-7695-0656-9},

 pages = {231--},

 url = {http://rmod.lille.inria.fr/archives/papers/Anqu00b-ICSM-GraphsConcepts.pdf},

 publisher = {IEEE Computer Society},

 address = {Washington, DC, USA},

 keywords = {Reverse Engineering, Concept Analysis, Clustering},

  annote = {internationalconference},

 aeres = {ACT},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes}

}

@inproceedings{Anqu01a,

 author = {Anquetil, Nicolas},

 title = {Characterizing the Informal Knowledge Contained in Systems},

 abstract = {Program comprehension of legacy systems is a highly knowledge-intensive task. One of the goals of reverse engineering is to propose automated help to relate application domain concepts to all their implementation instances. It is generally accepted that to do so would require analyzing such documentation as identifiers or comments. However, before attempting to perform this difficult analysis, it would be useful to know precisely what information the documentation contains and if it is worth trying. In this paper, we present the results of a study of the knowledge contained in two sources of documentation for the Mosaic system. This knowledge is categorized into various domains, and the relative proportions of these domains are discussed. Among other things, the results highlight the high frequency with which application domain concepts are used, which could provide the means to identify them.},

 booktitle = {WCRE '01: Proceedings of the Eighth Working Conference on Reverse Engineering (WCRE'01)},

 year = {2001},

 isbn = {0-7695-1303-4},

 pages = {166--175},

 doi = {10.1109/WCRE.2001.957821},

 url = {http://rmod.lille.inria.fr/archives/papers/Anqu01a-WCRE-InformalKnowledge.pdf},

 publisher = {IEEE Computer Society},

 address = {Washington, DC, USA},

 annote = {internationalconference},

 aeres = {ACT},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes}

}

@inbook{Anqu02a,

 author = {Lethbridge, Timothy C. and Anquetil, Nicolas},

 title = {Approaches to clustering for program comprehension and remodularization},

 book = {Advances in software engineering},

 year = {2002},

 isbn = {0-387-95109-1},

 pages = {137--157},

 url = {http://portal.acm.org/citation.cfm?id=505630.505637},

 publisher = {Springer-Verlag New York, Inc.},

 address = {New York, NY, USA},

  aeres	       = {OS},

  impactfactor = {},

  labo         = {hors},

  inria	       = {hors},

  selectif     = {oui},

  x-editorial-board = {no},

  x-proceedings = {no},

  x-international-audience = {yes},

  x-language = {EN}

}

@article{Anqu03a,

  author = {Nicolas Anquetil and Timothy Lethbridge},

  title = {Comparative study of clustering algorithms and abstract representations for software remodularization},

  abstract = {As valuable software systems become older, reverse engineering becomes increasingly important to companies that have to maintain the code. Clustering is a key activity in reverse engineering that is used to discover improved designs of systems or to extract significant concepts from code. Clustering is an old, highly sophisticated, activity which offers many methods to meet different needs. The various methods have been well documented in the past; however, conclusions from general clustering literature may not apply entirely to the reverse engineering domain. In the paper, the authors study three decisions that need to be made when clustering: the choice of (i) abstract descriptions of the entities to be clustered, (ii) metrics to compute coupling between the entities, and (iii) clustering algorithms. For each decision, our objective is to understand which choices are best when performing software remodularisation. The experiments were conducted on three public domain systems (gcc, Linux and Mosaic) and a real world legacy system (2 million LOC). Among other things, the authors confirm the importance of a proper description scheme for the entities being clustered, list a few effective coupling metrics and characterise the quality of different clustering algorithms. They also propose description schemes not directly based on the source code, and advocate better formal evaluation methods for the clustering results.},

  annote = {internationaljournal},

  journal = {IEE Proceedings - Software},

  volume = {150},

  number = {3},

  year = {2003},

  pages = {185-201},

 url = {http://rmod.lille.inria.fr/archives/papers/Anqu03a-IEESoft-ComparativeStudy.pdf},

  doi = {10.1049/ip-sen:20030581},

  annote = {internationaljournal},

 aeres = {ACL},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes},

 x-pays = {CA}

}

@inproceedings{Anqu03b,

  author    = {Nicolas Anquetil and

               K{\'a}thia Mar\c{c}al de Oliveira and

               M{\'a}rcio Greyck Batista Dias and

               Marcelo Ramal and

               Ricardo de Moura Meneses},

  title     = {Knowledge for Software Maintenance},

  abstract = {Knowledge management is emerging as a promising area to support software engineering activities. The general idea is to use knowledge gained in previous projects to help future ones. We believe this approach is even more relevant when considering software maintenance where maintainers often have to modify a system that they did not develop, that has no documentation, and that nobody knows intimately. Contrasting with this lack of information on the system, maintainers need a lot of knowledge: about the application domain, the organization software maintenance procedures, the system itself, the language used, past development methods, etc. Although one can readily agree with the information needs listed above, there is no clear, exhaustive definition of which knowledge would be useful to perform software maintenance. In this paper we describe our research to identify these needs. This research is part of a long term project that aims at building a knowledge management system for software maintenance.},

  booktitle = {Proceedings of the Fifteenth International Conference on

               Software Engineering {\&} Knowledge Engineering (SEKE'2003)},

  year      = {2003},

  pages     = {61-68},

  annote = {internationalconference},

 aeres = {ACT},

 selectif = {oui},

 labo = {non},

 x-editorial-board = {yes},

 x-international-audience = {yes},

 x-pays = {BR}

}

@inbook{Anqu06a,

author = {Nicolas Anquetil and K\'athia M. de Oliveira and M\'arcio G. B. Dias},

title = {Software Maintenance Ontology},

chapter = {5},

book = {Ontologies for Software Engineering and Software Technology},

publisher = {Springer-Verlag New York, Inc.},

year = {2006},

doi = {10.1007/3-540-34518-3_5},

isbn = {978-3-540-34517-6},

pages = {153--173},

  aeres	       = {OS},

  impactfactor = {},

  labo         = {hors},

  inria	       = {hors},

  selectif     = {oui},

  x-editorial-board = {no},

  x-proceedings = {no},

  x-international-audience = {yes},

  x-language = {EN}

}

@inproceedings{Anqu06c,

author = {Alexandre H. Torres, Nicolas Anquetil, K\'athia M. de Oliveira},

title = {Pro-active dissemination of knowledge with learning histories},

booktitle = {Proceedings of the Eighth International Workshop on Learning Software Organizations},

abstract = {Because they routinely work with intangible goods, software organizations need to be aware of the importance of knowledge. Different knowledge management approaches exist in the literature to help them manage this fundamental asset. However, the current approaches suffer from different problems, like dealing only with explicit knowledge (e.g. in the form of best practices), or focusing on "on demand" knowledge access. In this paper we present a richer, pro-active, knowledge management approach suitable for small or medium organizations. We report on an experiment we conducted with our model.},

pages = {19--27},

year = {2006},

 url = {http://rmod.lille.inria.fr/archives/papers/Anqu06c-LSO-ProactiveKnowldge.pdf},

 aeres = {ACT},

 selectif = {oui},

  labo         = {hors},

  inria	       = {hors},

 x-editorial-board = {yes},

 x-proceedings = {yes},

 x-international-audience = {yes},

 x-language = {EN},

 x-pays = {BR}

}

@article{Anqu07a,

 author = {Anquetil, Nicolas and de Oliveira, K\'{a}thia M. and de Sousa, Kleiber D. and Batista Dias, M\'{a}rcio G.},

 title = {Software maintenance seen as a knowledge management issue},

 abstract = {Creating and maintaining software systems is a knowledge intensive task. One needs to have a good understanding of the application domain, the problem to solve and all its requirements, the software process used, technical details of the programming language(s), the system's architecture and how the different parts fit together, how the system interacts with its environment, etc. All this knowledge is difficult and costly to gather. It is also difficult to store and usually lives only in the mind of the software engineers who worked on a particular project. If this is a problem for development of new software, it is even more for maintenance, when one must rediscover lost information of an abstract nature from legacy source code among a swarm of unrelated details. In this paper, we submit that this lack of knowledge is one of the prominent problems in software maintenance. To try to solve this problem, we adapted a knowledge extraction technique to the knowledge needs specific to software maintenance. We explain how we explicit the knowledge discovered on a legacy software during maintenance so that it may be recorded for future use. Some applications on industry maintenance projects are reported.},