1396
|
1 |
@phdthesis{Lava11b,
|
|
2 |
author = {Jannik Laval},
|
|
3 |
title = {Package Dependencies Analysis and Remediation in Object-Oriented Systems},
|
|
4 |
school = {Universit\'e de Lille},
|
|
5 |
year = {2011},
|
|
6 |
institution = {INRIA},
|
|
7 |
type_rapport = {PhD},
|
|
8 |
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.
|
|
9 |
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.
|
|
10 |
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:
|
|
11 |
- Understanding package dependency problems. We propose visualizations to highlight cyclic dependencies problems at package level.
|
|
12 |
- Proposing dependencies to be changed for remodularization. The approach proposes dependencies to break to make the system more modular.
|
|
13 |
- Analyzing impact of change. The approach proposes a change impact analysis to try modifications before applying them on the real system.
|
|
14 |
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.},
|
|
15 |
url = {http://rmod.lille.inria.fr/archives/phd/PhD-2011-Laval.pdf},
|
|
16 |
hal-id = {tel-00601546}
|
|
17 |
}
|
|
18 |
|
|
19 |
@inproceedings{Fall11a,
|
|
20 |
author = {Jean R\'emi Falleri and Simon Denier and Jannik Laval and Philipe Vismara and St\'ephane Ducasse},
|
|
21 |
booktitle = {Proceedings of the 49th International Conference on Objects, Models, Components, Patterns (TOOLS-Europe'11)},
|
|
22 |
year = {2011},
|
|
23 |
month = jun,
|
|
24 |
inriareport = {2011},
|
|
25 |
x-country = {FR},
|
|
26 |
title = {Efficient Retrieval and Ranking of Undesired Package Cycles in Large Software Systems},
|
|
27 |
address = {Zurich, Switzerland},
|
|
28 |
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.},
|
|
29 |
url = {http://rmod.lille.inria.fr/archives/papers/Fall11a-Tools2011-UndesirableCycles.pdf},
|
|
30 |
keywords = {lse-pub},
|
|
31 |
annote = {internationalconference},
|
|
32 |
aeres = {ACT},
|
|
33 |
aeresstatus = {aeres12},
|
|
34 |
inria = {RMOD},
|
|
35 |
labo = {dans},
|
|
36 |
x-pays = {FR},
|
|
37 |
selectif = {oui},
|
|
38 |
x-editorial-board = {yes},
|
|
39 |
x-proceedings = {yes},
|
|
40 |
x-international-audience = {yes},
|
|
41 |
x-country = {FR},
|
|
42 |
x-language = {EN},
|
|
43 |
hal-id = {inria-00614770}
|
|
44 |
}
|
|
45 |
|
|
46 |
@inproceedings{Roth11a,
|
|
47 |
author = {David Rothlisberger and Oscar Nierstrasz and St\'ephane Ducasse},
|
|
48 |
title = {SmartGroups: Focusing on Task-Relevant Source Artifacts in IDEs},
|
|
49 |
booktitle = {International Conference on Program Comprehension (ICPC)},
|
|
50 |
annote = {internationalconference},
|
|
51 |
keywords = {lse-pub},
|
|
52 |
misc = {Acceptance rate: 18/76 = 23\%},
|
|
53 |
aeresstatus = {aeres12},
|
|
54 |
aeres = {ACT},
|
|
55 |
rate = {23%},
|
|
56 |
misc = {Acceptance rate: 18/76 = 23\%},
|
|
57 |
selectif = {oui},
|
|
58 |
inria = {RMOD},
|
|
59 |
publisher = {IEEE Computer Society Press},
|
|
60 |
year = {2011},
|
|
61 |
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.
|
|
62 |
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.
|
|
63 |
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.
|
|
64 |
The prediction quality of Smart Groups is validated with a benchmark evaluation using recorded development activities and evolutionary information from versioning systems.},
|
|
65 |
labo = {dans},
|
|
66 |
x-pays = {FR},
|
|
67 |
selectif = {oui},
|
|
68 |
x-editorial-board = {yes},
|
|
69 |
x-proceedings = {yes},
|
|
70 |
x-international-audience = {yes},
|
|
71 |
x-country = {FR},
|
|
72 |
x-language = {EN},
|
|
73 |
url = {http://rmod.lille.inria.fr/archives/papers/Roet11a-ICPC2011-smartGroups.pdf},
|
|
74 |
hal-id = {inria-00614779}
|
|
75 |
}
|
|
76 |
|
|
77 |
@inproceedings{Fabr11a,
|
|
78 |
author = {Johan Fabry and Andy Kellens and Simon Denier and St\'ephane Ducasse},
|
|
79 |
title = {AspectMaps: A Scalable Visualization of Join Point Shadows},
|
|
80 |
booktitle = {International Conference on Program Comprehension (ICPC)},
|
|
81 |
annote = {internationalconference},
|
|
82 |
keywords = {lse-pub},
|
|
83 |
misc = {Acceptance rate: 18/76 = 23\%},
|
|
84 |
aeresstatus = {aeres12},
|
|
85 |
aeres = {ACT},
|
|
86 |
rate = {23%},
|
|
87 |
pages = {121-130},
|
|
88 |
selectif = {oui},
|
|
89 |
inria = {RMOD},
|
|
90 |
urldoi = {http://dx.doi.org/10.1109/ICPC.2011.11},
|
|
91 |
publisher = {IEEE Computer Society Press},
|
|
92 |
url = {http://rmod.lille.inria.fr/archives/papers/Fabr11a-ICPC2011-AspectMaps.pdf},
|
|
93 |
year = {2011},
|
|
94 |
aeresstatus = {aeres12},
|
|
95 |
inria = {RMOD},
|
|
96 |
labo = {dans},
|
|
97 |
x-pays = {FR},
|
|
98 |
selectif = {non},
|
|
99 |
x-editorial-board = {yes},
|
|
100 |
x-proceedings = {yes},
|
|
101 |
x-international-audience = {yes},
|
|
102 |
x-country = {FR},
|
|
103 |
x-language = {EN},
|
|
104 |
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.},
|
|
105 |
hal-id = {inria-00614773}
|
|
106 |
}
|
|
107 |
|
|
108 |
|
|
109 |
@inproceedings{Abde07a,
|
|
110 |
annote = {internationalworkshop},
|
|
111 |
author = {Hani Abdeen and Ilham Alloui and St\'ephane Ducasse and Damien Pollet and Mathieu Suen},
|
|
112 |
booktitle = {FAMOOSr, 1st Workshop on FAMIX and Moose in Reengineering},
|
|
113 |
keywords = {moose-pub stefPub},
|
|
114 |
title = {Package References Distribution Fingerprint},
|
|
115 |
year = {2007}
|
|
116 |
}
|
|
117 |
|
|
118 |
|
|
119 |
|
|
120 |
@inproceedings{Abde08b,
|
|
121 |
author = {Hani Abdeen and Ilham Alloui and St\'ephane Ducasse and Damien Pollet and Mathieu Suen},
|
|
122 |
title = {Package Reference Fingerprint: a Rich and Compact Visualization to Understand Package Relationships},
|
|
123 |
booktitle = {European Conference on Software Maintenance and Reengineering (CSMR)},
|
|
124 |
annote = {internationalconference},
|
|
125 |
pages = {213--222},
|
|
126 |
keywords = {moose-pub cook-pub lse-pub},
|
|
127 |
misc = {Acceptance rate: 24/87 = 27\%},
|
|
128 |
aeresstatus = {aeres08},
|
|
129 |
aeres = {ACT},
|
|
130 |
rate = {27%},
|
|
131 |
selectif = {oui},
|
|
132 |
inria = {ADAM},
|
|
133 |
publisher = {IEEE Computer Society Press},
|
|
134 |
url = {http://rmod.lille.inria.fr/archives/papers/Abde08b-CSMR2008-Fingerprint.pdf},
|
|
135 |
location = {Athens, Greece},
|
|
136 |
year = {2008},
|
|
137 |
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.},
|
|
138 |
hal = {http://hal.inria.fr/inria-00200869},
|
|
139 |
hal-id = {inria-00200869}
|
|
140 |
}
|
|
141 |
|
|
142 |
@inproceedings{Abde09b,
|
|
143 |
author = {Hani Abdeen and St\'ephane Ducasse and Houari A. Sahraoui and Ilham Alloui},
|
|
144 |
title = {Automatic Package Coupling and Cycle Minimization},
|
|
145 |
booktitle = {International Working Conference on Reverse Engineering (WCRE)},
|
|
146 |
publisher = {IEEE Computer Society Press},
|
|
147 |
address = {Washington, DC, USA},
|
|
148 |
misc = {acceptance rate: 20/79 = 25\%},
|
|
149 |
pages = {103--112},
|
|
150 |
annote = {internationalconference},
|
|
151 |
aeres = {ACT},
|
|
152 |
x-pays = {CA},
|
|
153 |
x-country = {FR},
|
|
154 |
x-editorial-board = {yes},
|
|
155 |
inriareport = {2009},
|
|
156 |
x-proceedings = {yes},
|
|
157 |
x-international-audience = {yes},
|
|
158 |
aeresstatus = {aeres12},
|
|
159 |
rate = {25\%},
|
|
160 |
selectif = {oui},
|
|
161 |
inria = {RMOD},
|
|
162 |
keywords = {moose remoose2 lse-pub cook},
|
|
163 |
year = {2009},
|
|
164 |
hal = {http://hal.inria.fr/inria-00425417},
|
|
165 |
hal-id = {inria-00425417 to recover as lse},
|
|
166 |
url = {http://rmod.lille.inria.fr/archives/papers/Abde09b-WCRE2009-AutomaticPackageCoupling.pdf},
|
|
167 |
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.},
|
|
168 |
x-language = {EN}
|
|
169 |
}
|
|
170 |
|
|
171 |
@phdthesis{Abde09c,
|
|
172 |
author = {Hani Abdeen},
|
|
173 |
title = {Visualizing, Assessing and Re-Modularizing Object-Oriented Architectural Elements},
|
|
174 |
school = {Universit\'e de Lille},
|
|
175 |
year = {2009},
|
|
176 |
annote = {PhD},
|
|
177 |
institution = {INRIA},
|
|
178 |
inria = {RMOD},
|
|
179 |
keywords = {moose remoose2 lse-pub cook},
|
|
180 |
aeres = {AP},
|
|
181 |
type_rapport = {PhD},
|
|
182 |
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
|
|
183 |
software evolves to meet requirements and environment changes, the software modularization gradually drifts
|
|
184 |
and looses quality. As a consequence, the software modularization must be maintained. It is thus important to
|
|
185 |
understand, to assess and to optimize the organization of packages and their relationships.
|
|
186 |
Our claim is that the maintenance of large and complex software modularizations needs approaches that help in:
|
|
187 |
(1) understanding package shapes and relationships; (2) assessing the quality of a modularization, as well as
|
|
188 |
the quality of a single package within a given modularization; (3) optimizing the quality of an existing
|
|
189 |
modularization.
|
|
190 |
In this thesis, we concentrate on three research fields: software visualizations, metrics and algorithms. At
|
|
191 |
first, we define two visualizations that help maintainers: (1) to understand packages structure, usage and
|
|
192 |
relationships; (2) to spot patterns; and (3) to identify misplaced classes and structural anomalies. In
|
|
193 |
addition to visualizations, we define a suite of metrics that help in assessing the package design quality
|
|
194 |
(i.e., package cohesion and coupling). We also define metrics that assess the quality of a collection of
|
|
195 |
inter-dependent packages from different view points, such as the degree of package coupling and cycles.
|
|
196 |
Finally, we define a search-based algorithm that automatically reduces package coupling and cycles only by
|
|
197 |
moving classes over existing packages. Our optimization approach takes explicitly into account the original
|
|
198 |
class organization and package structure. It also allows maintainers to control the optimization process by
|
|
199 |
specifying: (1) the maximal number of classes that may change their packages; (2) the classes that are
|
|
200 |
candidate for moving and the classes that should not; (3) the packages that are candidate for restructuring
|
|
201 |
and the packages that should not; and (4) the maximal number of classes that a given package can entail.
|
|
202 |
The approaches presented in this thesis have been applied to real large object-oriented software systems. The
|
|
203 |
results we obtained demonstrate the usefulness of our visualizations and metrics; and the effectiveness of our
|
|
204 |
optimization algorithm.},
|
|
205 |
url = {http://rmod.lille.inria.fr/archives/phd/PhD-2009-Abdeen.pdf},
|
|
206 |
hal-id = {tel-00498389 / zi#3ow#h},
|
|
207 |
x-language = {EN}
|
|
208 |
}
|
|
209 |
|
|
210 |
@article{Abde10a,
|
|
211 |
title = {Package Fingerprint: a visual summary of package interfaces and relationships},
|
|
212 |
author = {Hani Abdeen and St\'ephane Ducasse and Damien Pollet and Ilham Alloui},
|
|
213 |
journal = {Information and Software Technology Journal},
|
|
214 |
annote = {internationaljournal},
|
|
215 |
inriareport = {2010},
|
|
216 |
inria = {RMOD},
|
|
217 |
pages = {1312-1330},
|
|
218 |
keywords = {moose remoose2 lse-pub cook},
|
|
219 |
doi = {10.1016/j.infsof.2010.07.005},
|
|
220 |
x-editorial-board = {yes},
|
|
221 |
impactfactor = {ISI impact factor 1.821 (2010)},
|
|
222 |
x-proceedings = {yes},
|
|
223 |
volume = {52},
|
|
224 |
x-international-audience = {yes},
|
|
225 |
aeres = {ACL},
|
|
226 |
aeresstatus = {aeres12},
|
|
227 |
year = {2010},
|
|
228 |
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.
|
|
229 |
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.
|
|
230 |
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.
|
|
231 |
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.
|
|
232 |
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.},
|
|
233 |
url = {http://rmod.lille.inria.fr/archives/papers/Abde10a-IST-Official-packageFingerprints.pdf},
|
|
234 |
secondurl = {http://rmod.lille.inria.fr/archives/papers/Abde10a-IST-packageFingerprints.pdf},
|
|
235 |
hal-id = {inria-00531496}
|
|
236 |
}
|
|
237 |
|
|
238 |
@inproceedings{Anqu97a,
|
|
239 |
author = {Anquetil, Nicolas and Lethbridge, Timothy C.},
|
|
240 |
title = {File clustering using naming conventions for legacy systems},
|
|
241 |
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.},
|
|
242 |
booktitle = {Proceedings of the 1997 conference of the Centre for Advanced Studies on Collaborative research},
|
|
243 |
series = {CASCON '97},
|
|
244 |
year = {1997},
|
|
245 |
location = {Toronto, Ontario, Canada},
|
|
246 |
url = {http://portal.acm.org/citation.cfm?id=782010.782012},
|
|
247 |
publisher = {IBM Press},
|
|
248 |
annote = {internationalconference},
|
|
249 |
keywords = {clustering},
|
|
250 |
month = nov,
|
|
251 |
pages = {184--195},
|
|
252 |
aeres = {ACT},
|
|
253 |
selectif = {oui},
|
|
254 |
labo = {non},
|
|
255 |
x-editorial-board = {yes},
|
|
256 |
x-international-audience = {yes},
|
|
257 |
x-pays = {CA}
|
|
258 |
}
|
|
259 |
|
|
260 |
@inproceedings{Anqu98a,
|
|
261 |
author = {Nicolas Anquetil and Timothy C. Lethbridge},
|
|
262 |
title = {Assessing the relevance of identifier names in a legacy software system},
|
|
263 |
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.},
|
|
264 |
annote = {internationalconference},
|
|
265 |
pages = {213--222},
|
|
266 |
publisher = {IBM Press},
|
|
267 |
year = {1998},
|
|
268 |
booktitle = {Proceedings of the 1998 conference of the Centre for Advanced Studies on Collaborative research},
|
|
269 |
series = {CASCON '98},
|
|
270 |
location = {Toronto, Ontario, Canada},
|
|
271 |
url = {http://portal.acm.org/citation.cfm?id=783160.783164},
|
|
272 |
aeres = {ACT},
|
|
273 |
selectif = {oui},
|
|
274 |
labo = {non},
|
|
275 |
x-editorial-board = {yes},
|
|
276 |
x-international-audience = {yes},
|
|
277 |
x-pays = {CA}
|
|
278 |
}
|
|
279 |
|
|
280 |
@inproceedings{Anqu98b,
|
|
281 |
author = {Nicolas Anquetil and Timothy C. Lethbridge},
|
|
282 |
annote = {internationalconference},
|
|
283 |
pages = {84--93},
|
|
284 |
title = {Extracting Concepts from File Names: a New File Clustering Criterion},
|
|
285 |
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. },
|
|
286 |
year = {1998},
|
|
287 |
booktitle = {Proceedings of the 20th international conference on Software engineering},
|
|
288 |
series = {ICSE '98},
|
|
289 |
isbn = {0-8186-8368-6},
|
|
290 |
location = {Kyoto, Japan},
|
|
291 |
url = {http://portal.acm.org/citation.cfm?id=302163.302172},
|
|
292 |
publisher = {IEEE Computer Society},
|
|
293 |
address = {Washington, DC, USA},
|
|
294 |
aeres = {ACT},
|
|
295 |
selectif = {oui},
|
|
296 |
labo = {non},
|
|
297 |
x-editorial-board = {yes},
|
|
298 |
x-international-audience = {yes},
|
|
299 |
x-pays = {CA}
|
|
300 |
}
|
|
301 |
|
|
302 |
@article{Anqu98c,
|
|
303 |
author = {Anquetil, Nicolas and Vaucher, Jean},
|
|
304 |
title = {Expressing opposition in the object model, first step towards negation},
|
|
305 |
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.},
|
|
306 |
journal = {SIGPLAN Notices},
|
|
307 |
volume = {33},
|
|
308 |
issue = {1},
|
|
309 |
year = {1998},
|
|
310 |
issn = {0362-1340},
|
|
311 |
pages = {48--55},
|
|
312 |
doi = {10.1145/609742.609749},
|
|
313 |
publisher = {ACM},
|
|
314 |
address = {New York, NY, USA},
|
|
315 |
month = {jan},
|
|
316 |
keywords = {multiple inheritance, negation, object model, reflection, theoretical foundations},
|
|
317 |
annote = {internationaljournal},
|
|
318 |
aeres = {ASCL},
|
|
319 |
selectif = {non},
|
|
320 |
labo = {non},
|
|
321 |
x-editorial-board = {no},
|
|
322 |
x-international-audience = {yes},
|
|
323 |
x-pays = {CA}
|
|
324 |
}
|
|
325 |
|
|
326 |
@inproceedings{Anqu99a,
|
|
327 |
author = {Nicolas Anquetil and Timothy Lethbridge},
|
|
328 |
title = {Experiments with {Clustering} as a {Software} {Remodularization} {Method}},
|
|
329 |
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},
|
|
330 |
booktitle = {Proceedings of WCRE '99 (6th Working Conference on Reverse Engineering)},
|
|
331 |
isbn = {0-7695-0303-9},
|
|
332 |
doi = {10.1109/WCRE.1999.806964},
|
|
333 |
annote = {internationalconference},
|
|
334 |
keywords = {clustering},
|
|
335 |
pages = {235--255},
|
|
336 |
year = {1999},
|
|
337 |
aeres = {ACT},
|
|
338 |
selectif = {oui},
|
|
339 |
labo = {non},
|
|
340 |
x-editorial-board = {yes},
|
|
341 |
x-international-audience = {yes},
|
|
342 |
x-pays = {CA}
|
|
343 |
}
|
|
344 |
|
|
345 |
@article{Anqu99b,
|
|
346 |
author = {Nicolas Anquetil and Timothy C. Lethbridge},
|
|
347 |
title = {Recovering Software Architecture from the Names of Source Files},
|
|
348 |
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.},
|
|
349 |
journal = {Journal of Software Maintenance: Research and Practice},
|
|
350 |
pages = {201--21},
|
|
351 |
doi = {10.1002/(SICI)1096-908X(199905/06)11:3<201::AID-SMR192>3.0.CO;2-1},
|
|
352 |
annote = {internationaljournal},
|
|
353 |
misc = {5 Year ISI impact factor 1.523 (2010)},
|
|
354 |
impactfactor = {5 Year ISI impact factor 1.523 (2010)},
|
|
355 |
volume = {11},
|
|
356 |
year = {1999},
|
|
357 |
aeres = {ACT},
|
|
358 |
selectif = {oui},
|
|
359 |
labo = {non},
|
|
360 |
x-editorial-board = {yes},
|
|
361 |
x-international-audience = {yes},
|
|
362 |
x-pays = {CA}
|
|
363 |
}
|
|
364 |
|
|
365 |
@inproceedings{Anqu00a,
|
|
366 |
author = {Anquetil, Nicolas},
|
|
367 |
title = {Concepts + Relations = 'Abstract Constructs'},
|
|
368 |
year = {2000},
|
|
369 |
booktitle = {WCRE'00: Proceedings of the Seventh Working Conference on Reverse Engineering (WCRE'00)},
|
|
370 |
address = {Los Alamitos, CA, USA},
|
|
371 |
publisher = {IEEE Computer Society},
|
|
372 |
note = {Due to an error of the editor, the paper does not appear in the proceedings},
|
|
373 |
url = {http://rmod.lille.inria.fr/archives/papers/Anqu00a-WCRE-Concepts+Relations.pdf},
|
|
374 |
annote = {internationalconference},
|
|
375 |
aeres = {ACT},
|
|
376 |
selectif = {oui},
|
|
377 |
labo = {non},
|
|
378 |
x-editorial-board = {yes},
|
|
379 |
x-international-audience = {yes}
|
|
380 |
}
|
|
381 |
|
|
382 |
@inproceedings{Anqu00b,
|
|
383 |
author = {Anquetil, Nicolas},
|
|
384 |
title = {A Comparison of Graphs of Concept for Reverse Engineering},
|
|
385 |
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).},
|
|
386 |
booktitle = {Proceedings of the 8th International Workshop on Program Comprehension},
|
|
387 |
series = {IWPC '00},
|
|
388 |
year = {2000},
|
|
389 |
isbn = {0-7695-0656-9},
|
|
390 |
pages = {231--},
|
|
391 |
url = {http://rmod.lille.inria.fr/archives/papers/Anqu00b-ICSM-GraphsConcepts.pdf},
|
|
392 |
publisher = {IEEE Computer Society},
|
|
393 |
address = {Washington, DC, USA},
|
|
394 |
keywords = {Reverse Engineering, Concept Analysis, Clustering},
|
|
395 |
annote = {internationalconference},
|
|
396 |
aeres = {ACT},
|
|
397 |
selectif = {oui},
|
|
398 |
labo = {non},
|
|
399 |
x-editorial-board = {yes},
|
|
400 |
x-international-audience = {yes}
|
|
401 |
}
|
|
402 |
|
|
403 |
@inproceedings{Anqu01a,
|
|
404 |
author = {Anquetil, Nicolas},
|
|
405 |
title = {Characterizing the Informal Knowledge Contained in Systems},
|
|
406 |
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.},
|
|
407 |
booktitle = {WCRE '01: Proceedings of the Eighth Working Conference on Reverse Engineering (WCRE'01)},
|
|
408 |
year = {2001},
|
|
409 |
isbn = {0-7695-1303-4},
|
|
410 |
pages = {166--175},
|
|
411 |
doi = {10.1109/WCRE.2001.957821},
|
|
412 |
url = {http://rmod.lille.inria.fr/archives/papers/Anqu01a-WCRE-InformalKnowledge.pdf},
|
|
413 |
publisher = {IEEE Computer Society},
|
|
414 |
address = {Washington, DC, USA},
|
|
415 |
annote = {internationalconference},
|
|
416 |
aeres = {ACT},
|
|
417 |
selectif = {oui},
|
|
418 |
labo = {non},
|
|
419 |
x-editorial-board = {yes},
|
|
420 |
x-international-audience = {yes}
|
|
421 |
}
|
|
422 |
|
|
423 |
@inbook{Anqu02a,
|
|
424 |
author = {Lethbridge, Timothy C. and Anquetil, Nicolas},
|
|
425 |
title = {Approaches to clustering for program comprehension and remodularization},
|
|
426 |
book = {Advances in software engineering},
|
|
427 |
year = {2002},
|
|
428 |
isbn = {0-387-95109-1},
|
|
429 |
pages = {137--157},
|
|
430 |
url = {http://portal.acm.org/citation.cfm?id=505630.505637},
|
|
431 |
publisher = {Springer-Verlag New York, Inc.},
|
|
432 |
address = {New York, NY, USA},
|
|
433 |
aeres = {OS},
|
|
434 |
impactfactor = {},
|
|
435 |
labo = {hors},
|
|
436 |
inria = {hors},
|
|
437 |
selectif = {oui},
|
|
438 |
x-editorial-board = {no},
|
|
439 |
x-proceedings = {no},
|
|
440 |
x-international-audience = {yes},
|
|
441 |
x-language = {EN}
|
|
442 |
}
|
|
443 |
|
|
444 |
@article{Anqu03a,
|
|
445 |
author = {Nicolas Anquetil and Timothy Lethbridge},
|
|
446 |
title = {Comparative study of clustering algorithms and abstract representations for software remodularization},
|
|
447 |
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.},
|
|
448 |
annote = {internationaljournal},
|
|
449 |
journal = {IEE Proceedings - Software},
|
|
450 |
volume = {150},
|
|
451 |
number = {3},
|
|
452 |
year = {2003},
|
|
453 |
pages = {185-201},
|
|
454 |
url = {http://rmod.lille.inria.fr/archives/papers/Anqu03a-IEESoft-ComparativeStudy.pdf},
|
|
455 |
doi = {10.1049/ip-sen:20030581},
|
|
456 |
annote = {internationaljournal},
|
|
457 |
aeres = {ACL},
|
|
458 |
selectif = {oui},
|
|
459 |
labo = {non},
|
|
460 |
x-editorial-board = {yes},
|
|
461 |
x-international-audience = {yes},
|
|
462 |
x-pays = {CA}
|
|
463 |
}
|
|
464 |
|
|
465 |
@inproceedings{Anqu03b,
|
|
466 |
author = {Nicolas Anquetil and
|
|
467 |
K{\'a}thia Mar\c{c}al de Oliveira and
|
|
468 |
M{\'a}rcio Greyck Batista Dias and
|
|
469 |
Marcelo Ramal and
|
|
470 |
Ricardo de Moura Meneses},
|
|
471 |
title = {Knowledge for Software Maintenance},
|
|
472 |
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.},
|
|
473 |
booktitle = {Proceedings of the Fifteenth International Conference on
|
|
474 |
Software Engineering {\&} Knowledge Engineering (SEKE'2003)},
|
|
475 |
year = {2003},
|
|
476 |
pages = {61-68},
|
|
477 |
annote = {internationalconference},
|
|
478 |
aeres = {ACT},
|
|
479 |
selectif = {oui},
|
|
480 |
labo = {non},
|
|
481 |
x-editorial-board = {yes},
|
|
482 |
x-international-audience = {yes},
|
|
483 |
x-pays = {BR}
|
|
484 |
}
|
|
485 |
|
|
486 |
@inbook{Anqu06a,
|
|
487 |
author = {Nicolas Anquetil and K\'athia M. de Oliveira and M\'arcio G. B. Dias},
|
|
488 |
title = {Software Maintenance Ontology},
|
|
489 |
chapter = {5},
|
|
490 |
book = {Ontologies for Software Engineering and Software Technology},
|
|
491 |
publisher = {Springer-Verlag New York, Inc.},
|
|
492 |
year = {2006},
|
|
493 |
doi = {10.1007/3-540-34518-3_5},
|
|
494 |
isbn = {978-3-540-34517-6},
|
|
495 |
pages = {153--173},
|
|
496 |
aeres = {OS},
|
|
497 |
impactfactor = {},
|
|
498 |
labo = {hors},
|
|
499 |
inria = {hors},
|
|
500 |
selectif = {oui},
|
|
501 |
x-editorial-board = {no},
|
|
502 |
x-proceedings = {no},
|
|
503 |
x-international-audience = {yes},
|
|
504 |
x-language = {EN}
|
|
505 |
}
|
|
506 |
|
|
507 |
@inproceedings{Anqu06c,
|
|
508 |
author = {Alexandre H. Torres, Nicolas Anquetil, K\'athia M. de Oliveira},
|
|
509 |
title = {Pro-active dissemination of knowledge with learning histories},
|
|
510 |
booktitle = {Proceedings of the Eighth International Workshop on Learning Software Organizations},
|
|
511 |
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.},
|
|
512 |
pages = {19--27},
|
|
513 |
year = {2006},
|
|
514 |
url = {http://rmod.lille.inria.fr/archives/papers/Anqu06c-LSO-ProactiveKnowldge.pdf},
|
|
515 |
aeres = {ACT},
|
|
516 |
selectif = {oui},
|
|
517 |
labo = {hors},
|
|
518 |
inria = {hors},
|
|
519 |
x-editorial-board = {yes},
|
|
520 |
x-proceedings = {yes},
|
|
521 |
x-international-audience = {yes},
|
|
522 |
x-language = {EN},
|
|
523 |
x-pays = {BR}
|
|
524 |
}
|
|
525 |
|
|
526 |
@article{Anqu07a,
|
|
527 |
author = {Anquetil, Nicolas and de Oliveira, K\'{a}thia M. and de Sousa, Kleiber D. and Batista Dias, M\'{a}rcio G.},
|
|
528 |
title = {Software maintenance seen as a knowledge management issue},
|
|
529 |
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.},
|
|
530 |
journal = {Inf. Softw. Technol.},
|
|
531 |
volume = {49},
|
|
532 |
number = {5},
|
|
533 |
year = {2007},
|
|
534 |
issn = {0950-5849},
|
|
535 |
pages = {515--529},
|
|
536 |
url = {http://rmod.lille.inria.fr/archives/papers/Anqu07a-IST-MaintenanceKnowledge.pdf},
|
|
537 |
doi = {10.1016/j.infsof.2006.07.007},
|
|
538 |
publisher = {Butterworth-Heinemann},
|
|
539 |
address = {Newton, MA, USA},
|
|
540 |
annote = {internationaljournal},
|
|
541 |
aeres = {ACL},
|
|
542 |
selectif = {oui},
|
|
543 |
labo = {non},
|
|
544 |
x-editorial-board = {yes},
|
|
545 |
x-international-audience = {yes},
|
|
546 |
x-pays = {BR}
|
|
547 |
}
|
|
548 |
|
|
549 |
@inproceedings{Anqu08a,
|
|
550 |
author = {N. {Anquetil} and B. {Grammel} and I. {Galvao Lourenco da Silva} and J.A.R. {Noppen} and S. {Shakil Khan} and H. {Arboleda} and A. {Rashid} and A. {Garcia}},
|
|
551 |
title = {Traceability for Model Driven, Software Product Line Engineering},
|
|
552 |
abstract = {Traceability is an important challenge for software organizations. This is true for traditional software development and even more so in new approaches that introduce more variety of artefacts such as Model Driven development or Software Product Lines. In this paper we look at some aspect of the interaction of Traceability, Model Driven development and Software Product Line.},
|
|
553 |
booktitle = {ECMDA Traceability Workshop Proceedings},
|
|
554 |
address = {Norway},
|
|
555 |
publisher = {SINTEF ICT},
|
|
556 |
pages = {77--86},
|
|
557 |
year = {2008},
|
|
558 |
month = {jun},
|
|
559 |
url = {http://doc.utwente.nl/64994/},
|
|
560 |
annote = {internationalconference},
|
|
561 |
aeres = {ACL},
|
|
562 |
selectif = {non},
|
|
563 |
labo = {non},
|
|
564 |
x-editorial-board = {yes},
|
|
565 |
x-international-audience = {yes}
|
|
566 |
}
|
|
567 |
|
|
568 |
@inproceedings{Anqu08b,
|
|
569 |
author = {Andr\'e Sousa and Uir\'a Kulesza and Andreas Rummler and Nicolas Anquetil, Ralf Mitschke and Ana Moreira and Vasco Amaral and Jo\~{a}o Ara\'ujo},
|
|
570 |
title = {A Model-Driven Traceability Framework to Software Product Line Development},
|
|
571 |
abstract = {In this paper, we present a model-driven traceability framework to software product line (SPL) development. Model-driven techniques are adopted with the aim to support the flexible specification of trace links between different kinds of SPL artefacts. A traceability metamodel is defined to support the flexible creation and storage of the SPL trace links. The framework is organized as a set of extensible plug-ins that can be instantiated to create customized trace queries and views. It is implemented based on the Eclipse platform and EMF technology. We illustrate a concrete instantiation of the framework to support the tracing between feature and use cases models.},
|
|
572 |
booktitle = {ECMDA Traceability Workshop Proceedings},
|
|
573 |
address = {Norway},
|
|
574 |
publisher = {SINTEF ICT},
|
|
575 |
year = {2008},
|
|
576 |
month = {jun},
|
|
577 |
annote = {internationalconference},
|
|
578 |
aeres = {ACL},
|
|
579 |
selectif = {non},
|
|
580 |
labo = {non},
|
|
581 |
x-editorial-board = {yes},
|
|
582 |
x-international-audience = {yes}
|
|
583 |
}
|
|
584 |
|
|
585 |
@article{Anqu10a,
|
|
586 |
author = {Anquetil, Nicolas and Kulesza, Uir\'{a} and Mitschke, Ralf and Moreira, Ana and Royer, Jean-Claude and Rummler, Andreas and Sousa, Andr\'{e}},
|
|
587 |
title = {A model-driven traceability framework for software product lines},
|
|
588 |
abstract = {Software product line (SPL) engineering is a recent approach to software development where a set of software products are derived for a well defined target application domain, from a common set of core assets using analogous means of production (for instance, through Model Driven Engineering). Therefore, such family of products are built from reuse, instead of developed individually from scratch. SPL promise to lower the costs of development, increase the quality of software, give clients more flexibility and reduce time to market. These benefits come with a set of new problems and turn some older problems possibly more complex. One of these problems is traceability management. In the European AMPLE project we are creating a common traceability framework across the various activities of the SPL development. We identified four orthogonal traceability dimensions in SPL development, one of which is an extension of what is often considered as "traceability of variability". This constitutes one of the two contributions of this paper. The second contribution is the specification of a metamodel for a repository of traceability links in the context of SPL and the implementation of a respective traceability framework. This framework enables fundamental traceability management operations, such as trace import and export, modification, query and visualization. The power of our framework is highlighted with an example scenario.},
|
|
589 |
journal = {Softw. Syst. Model.},
|
|
590 |
volume = {9},
|
|
591 |
number = {4},
|
|
592 |
year = {2010},
|
|
593 |
issn = {1619-1366},
|
|
594 |
pages = {427--451},
|
|
595 |
url = {http://rmod.lille.inria.fr/archives/papers/Anqu10a-SOSYM-TraceabilitySPL.pdf},
|
|
596 |
doi = {10.1007/s10270-009-0120-9},
|
|
597 |
publisher = {Springer-Verlag New York, Inc.},
|
|
598 |
address = {Secaucus, NJ, USA},
|
|
599 |
annote = {internationaljournal},
|
|
600 |
aeresstatus= {aeres12},
|
|
601 |
aeres = {ACL},
|
|
602 |
selectif = {oui},
|
|
603 |
labo = {non},
|
|
604 |
x-editorial-board = {yes},
|
|
605 |
x-international-audience = {yes},
|
|
606 |
x-pays = {DE,PT,BR},
|
|
607 |
hal-id = {tobedone2010}
|
|
608 |
}
|
|
609 |
|
|
610 |
@inproceedings{Anqu11a,
|
|
611 |
title = {Legacy Software Restructuring: Analyzing a Concrete Case},
|
|
612 |
author = {Nicolas Anquetil and Jannik Laval},
|
|
613 |
booktitle = {CSMR 2011: Proceedings of the 15th European Conference on Software Maintenance and Reengineering},
|
|
614 |
year = {2011},
|
|
615 |
address = {Oldenburg, Germany},
|
|
616 |
keywords = {moose-pub lse-pub},
|
|
617 |
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.
|
|
618 |
We also measured another possible restructuring which is to decrease the number of cyclic dependencies between modules.
|
|
619 |
Again, the results did not meet expectations.},
|
|
620 |
misc = {acceptance rate: 29/82 = 35\%},
|
|
621 |
aeres = {ACT},
|
|
622 |
annote = {internationalconference},
|
|
623 |
aeresstatus = {aeres12},
|
|
624 |
labo = {dans},
|
|
625 |
inria = {RMOD},
|
|
626 |
inriareport = {2011},
|
|
627 |
selectif = {oui},
|
|
628 |
x-editorial-board = {yes},
|
|
629 |
x-proceedings = {yes},
|
|
630 |
x-international-audience = {yes},
|
|
631 |
x-language = {EN},
|
|
632 |
x-country = {GE},
|
|
633 |
url = {http://rmod.lille.inria.fr/archives/phd/Anqu11a-CSMR2011-Coupling.pdf}
|
|
634 |
}
|
|
635 |
|
|
636 |
@booklet{Ardi95b,
|
|
637 |
annote = {lectures},
|
|
638 |
author = {Laurent Arditi and St\'ephane Ducasse},
|
|
639 |
keywords = {stefPub},
|
|
640 |
note = {support de cours de Deug SM-PE et Mass, 120 pages},
|
|
641 |
title = {Une premi\`ere approche fonctionnelle et r\'ecursive de la programmation},
|
|
642 |
year = {1995}
|
|
643 |
}
|
|
644 |
|
|
645 |
@book{Ardi96a,
|
|
646 |
address = {Paris},
|
|
647 |
annote = {book},
|
|
648 |
author = {Laurent Arditi and St\'ephane Ducasse},
|
|
649 |
keywords = {stefPub scglib},
|
|
650 |
month = apr,
|
|
651 |
note = {238 pages, Pr\'eface de G\'erard Huet},
|
|
652 |
publisher = {Eyrolles},
|
|
653 |
title = {La programmation: une approche fonctionelle et r\'ecursive avec Scheme},
|
|
654 |
isbn = {2-212-08915-5},
|
|
655 |
year = {1996}
|
|
656 |
}
|
|
657 |
|
|
658 |
@inproceedings{Ardi97a,
|
|
659 |
abstract = {Dans cet article, nous pr\'esentons une exp\'erience d'enseignement de l'informatique en milieu aride: volume horaire faible, faible coefficient, \'etudiants peu motiv\'es. Dans ce contexte d\'efavorable, nous avons choisi de privil\`egier un concept, la r\'ecursivit\'e dans le cadre de la programmation fonctionnelle, plut\^ot qu'un langage. Ce choix nous a conduit \`a consid\`erer le langage Scheme pour sa simplicit\'e. Nous d\'ecrivons ici notre cours, les probl\`emes que nous avons rencontr\'es et les solutions que nous avons choisies.},
|
|
660 |
annote = {nationalconference},
|
|
661 |
author = {Laurent Arditi and St\'ephane Ducasse},
|
|
662 |
booktitle = {Actes des Journ\'ees Fran\c{c}aises des Langages Applicatifs (JFLA '97)},
|
|
663 |
keywords = {stefPub snf97},
|
|
664 |
pages = {209--228},
|
|
665 |
title = {Scheme: un langage applicatif pour l'enseignement de l'informatique en milieu aride},
|
|
666 |
url = {http://rmod.lille.inria.fr/archives/papers/Ardi97a-JFLA07-SchemeTeaching.pdf},
|
|
667 |
url = {http://scg.unibe.ch/archive/papers/Ardi97aSchemeTeaching.pdf},
|
|
668 |
hal-id = {inria-00533051},
|
|
669 |
year = {1997}
|
|
670 |
}
|
|
671 |
|
|
672 |
@inproceedings{Arev03c,
|
|
673 |
abstract = {Understanding the internal workings of classes is a key prerequisite to maintaining an object-oriented software system. Unfortunately, classical editing and browsing tools offer mainly linear and textual views of classes and their implementation. These views fail to expose the semantic relationships between the internal parts of a class. We propose XRay views --a technique based on Concept Analysis-- which reveal the internal relationships between groups of methods and attributes of a class. XRay views are composed out of elementary collaborations between attributes and methods, and help the engineer to build a mental model of how a class works internally. In this paper we present XRay views, and illustrate the approach by applying it on the Smalltalk class UIBuilder.},
|
|
674 |
annote = {internationalconference},
|
|
675 |
author = {Gabriela Ar{\'e}valo and St\'ephane Ducasse and Oscar Nierstrasz},
|
|
676 |
booktitle = {Proceedings of 18th Conference on Automated Software Engineering (ASE'03)},
|
|
677 |
cvs = {ConAnASE03XRayViews},
|
|
678 |
doi = {10.1109/ASE.2003.1240318},
|
|
679 |
keywords = {recast03 scg-pub stefPub moose-pub arevalo jb04},
|
|
680 |
month = oct,
|
|
681 |
note = {Short paper},
|
|
682 |
pages = {267--270},
|
|
683 |
publisher = {IEEE Computer Society},
|
|
684 |
title = {{X-Ray} Views: Understanding the Internals of Classes},
|
|
685 |
url = {http://rmod.lille.inria.fr/archives/papers/Arev03c-ASE03-XRayViews.pdf},
|
|
686 |
secondurl = {http://scg.unibe.ch/archive/papers/Arev03cASE03XRayViews.pdf},
|
|
687 |
abstract = {Understanding the internal workings of classes is a key prerequisite to maintaining an object-oriented software system. Unfortunately, classical editing and browsing tools offer mainly linear and textual views of classes and their implementation. These views fail to expose the semantic relationships between the internal parts of a class. We propose XRay views -- a technique based on Concept Analysis -- which reveal the internal relationships between groups of methods and attributes of a class. XRay views are com- posed out of elementary collaborations between attributes and methods, and help the engineer to build a mental model of how a class works internally. In this paper we present XRay views, and illustrate the approach by applying it on the Smalltalk class UIBuilder.},
|
|
688 |
hal-id={inria-00533054},
|
|
689 |
year = {2003}
|
|
690 |
}
|
|
691 |
|
|
692 |
@inproceedings{Arev03d,
|
|
693 |
abstract = {Understanding the internal workings of classes is a key prerequisite to maintaining an object-oriented software system. Unfortunately, classical editing and browsing tools offer mainly linear and textual views of classes and their implementation. These views fail to expose the semantic relationships between the internal parts of a class. We propose XRay views --a technique based on Concept Analysis-- which reveal the internal relationships between groups of methods and attributes of a class. XRay views are composed out of elementary collaborations between attributes and methods and help the engineer to build a mental model of how a class works internally. In this paper we present XRay views, and illustrate the approach by applying it to three Smalltalk classes: OrderedCollection, Scanner, and UIBuilder.},
|
|
694 |
annote = {internationalworkshop},
|
|
695 |
author = {Gabriela Ar{\'e}valo and St\'ephane Ducasse and Oscar Nierstrasz},
|
|
696 |
booktitle = {Proceedings of 2nd International Workshop on MASPEGHI 2003 (ASE 2003)},
|
|
697 |
cvs = {ConAnMASPEGHI03XRayViews},
|
|
698 |
keywords = {snf04 scg-pub skip-doi stefPub arevalo jb04 moose-pub},
|
|
699 |
month = oct,
|
|
700 |
pages = {9--18},
|
|
701 |
publisher = {CRIM --- University of Montreal (Canada)},
|
|
702 |
title = {Understanding Classes using {X-Ray} Views},
|
|
703 |
url = {http://scg.unibe.ch/archive/papers/Arev03dMASPEGHI03XRayViews.pdf},
|
|
704 |
year = {2003}
|
|
705 |
}
|
|
706 |
|
|
707 |
@inproceedings{Arev05b,
|
|
708 |
abstract = {Object-oriented applications are difficult to extend and maintain, due to the presence of implicit dependencies in the inheritance hierarchy. Although these dependencies often correspond to well-known schemas, such as hook and template methods, new unanticipated dependency schemas occur in practice, and can consequently be hard to recognize and detect. To tackle this problem, we have applied Concept Analysis to automatically detect recurring dependency schemas in class hierarchies used in object-oriented applications. In this paper we describe our mapping of OO dependencies to the formal framework of Concept Analysis, we apply our approach to a non-trivial case study, and we report on the kinds of dependencies that are uncovered with this technique. As a result, we show how the discovered dependency schemas correspond not only to good design practices, but also to bad smells in design.},
|
|
709 |
aeres = {ACT},
|
|
710 |
aeresstatus = {aeres08},
|
|
711 |
annote = {internationalconference},
|
|
712 |
author = {Gabriela Ar{\'e}valo and St\'ephane Ducasse and Oscar Nierstrasz},
|
|
713 |
booktitle = {Proceedings of 9th European Conference on Software Maintenance and Reengineering (CSMR'05)},
|
|
714 |
cvs = {ConAnCSMR05ClassHierarchies},
|
|
715 |
doi = {10.1109/CSMR.2005.24},
|
|
716 |
impactfactor = {hors},
|
|
717 |
keywords = {scg-pub arevalo jb05 recast05 stefPub moose-pub},
|
|
718 |
location = {Manchester, United Kingdom},
|
|
719 |
misc = {acceptance rate: 33/81 = 41\%},
|
|
720 |
accepttotal = {81},
|
|
721 |
acceptnum = {33},
|
|
722 |
month = mar,
|
|
723 |
pages = {62--71},
|
|
724 |
publisher = {IEEE Computer Society},
|
|
725 |
rate = {41%},
|
|
726 |
selectif = {non},
|
|
727 |
title = {Discovering Unanticipated Dependency Schemas in Class Hierarchies},
|
|
728 |
abstract = {Object-oriented applications are difficult to extend and maintain, due to the presence of implicit dependencies in the inheritance hierarchy. Although these dependencies of- ten correspond to well-known schemas, such as hook and template methods, new unanticipated dependency schemas occur in practice, and can consequently be hard to recognize and detect. To tackle this problem, we have applied Concept Analysis to automatically detect recurring dependency schemas in class hierarchies used in object-oriented applications. In this paper we describe our mapping of OO dependencies to the formal framework of Concept Analysis, we apply our approach to a non-trivial case study, and we report on the kinds of dependencies that are uncovered with this technique. As a result, we show how the discovered dependency schemas correspond not only to good design practices, but also to "bad smells" in design.},
|
|
729 |
hal-id = {inria-00533057},
|
|
730 |
url = {http://rmod.lille.inria.fr/archives/papers/Arev05b-CSMR05-ClassHierarchies.pdf},
|
|
731 |
secondurl = {http://scg.unibe.ch/archive/papers/Arev05bCSMR05ClassHierarchies.pdf},
|
|
732 |
year = {2005}
|
|
733 |
}
|
|
734 |
|
|
735 |
@inproceedings{Arev05c,
|
|
736 |
abstract = {A key difficulty in the maintenance and evolution of complex software systems is to recognize and understand the implicit dependencies that define contracts that must be respected by changes to the software. Formal Concept Analysis is a well-established technique for identifying groups of elements with common sets of properties. We have successfully applied FCA to complex software systems in order to automatically discover a variety of different kinds of implicit, recurring sets of dependencies amongst design artifacts. In this paper we describe our approach, outline three case studies, and draw various lessons from our experiences. In particular, we discuss how our approach is applied iteratively in order to draw the maximum benefit offered by FCA.},
|
|
737 |
aeres = {ACT},
|
|
738 |
aeresstatus = {aeres08},
|
|
739 |
annote = {internationalconference},
|
|
740 |
author = {Gabriela Ar{\'e}valo and St\'ephane Ducasse and Oscar Nierstrasz},
|
|
741 |
booktitle = {Proceedings of 3rd International Conference on Formal Concept Analysis (ICFCA '05)},
|
|
742 |
cvs = {ConAnICFCA05LessonsLearned},
|
|
743 |
doi = {10.1007/b105806},
|
|
744 |
impactfactor = {hors},
|
|
745 |
keywords = {scg-pub jb05 recast05 arevalo stefPub},
|
|
746 |
location = {Lens, France},
|
|
747 |
month = feb,
|
|
748 |
pages = {95--112},
|
|
749 |
publisher = {Springer Verlag},
|
|
750 |
selectif = {non},
|
|
751 |
series = {LNAI (Lecture Notes in Artificial Intelligence)},
|
|
752 |
title = {Lessons Learned in Applying Formal Concept Analysis},
|
|
753 |
url = {http://rmod.lille.inria.fr/archives/papers/Arev05c-ICFCA05-LessonsLearned.pdf},
|
|
754 |
secondurl = {http://scg.unibe.ch/archive/papers/Arev05cICFCA05LessonsLearned.pdf},
|
|
755 |
volume = {3403},
|
|
756 |
hal-id = {inria-00533445},
|
|
757 |
year = {2005}
|
|
758 |
}
|
|
759 |
|
|
760 |
@inproceedings{Arev06a,
|
|
761 |
abstract = {Designing class models is usually an iterative process to detect how to express, for a specific domain, the adequate concepts and their relationships. During those iterations, the abstraction of concepts and relationships is an important step. In this paper, we propose to automate this abstraction process using techniques based on Formal Concept Analysis in a model-driven context. Using UML 2.0 class diagrams as modeling language for class models, in this proposal we show how our model-driven approach enables parameterization, tracing and generalization to any metamodel to express class models.},
|
|
762 |
author = {Gabriela Ar\'evalo and Jean-R\'emy Falleri and Marianne Huchard and Cl\'ementine Nebut},
|
|
763 |
booktitle = {{MoDELS} 2006},
|
|
764 |
editor = {Oscar Nierstrasz; Jhon Whittle; David Harel; Gianna Reggio},
|
|
765 |
isbn = {978-3-540-45772-5},
|
|
766 |
keywords = {UML, model transformation, refactoring, formal concept analysis, relational concept analysis},
|
|
767 |
month = oct,
|
|
768 |
pages = {513-527},
|
|
769 |
publisher = {Springer Verlag},
|
|
770 |
series = {{LNCS} ({L}ecture {N}otes in {C}omputer {S}cience)},
|
|
771 |
title = {Building Abstractions in Class Models: Formal Concept Analysis in a Model-Driven Approach},
|
|
772 |
volume = {4199},
|
|
773 |
year = {2006}
|
|
774 |
}
|
|
775 |
|
|
776 |
@article{Arev10a,
|
|
777 |
author = {Gabriela Ar\'evalo and St\'ephane Ducasse and Silvia Gordillo and Oscar Nierstrasz},
|
|
778 |
month = dec,
|
|
779 |
annote = {internationaljournal},
|
|
780 |
title = {Generating a catalog of unanticipated schemas in class hierarchies using Formal Concept Analysis},
|
|
781 |
journal = {Information and Software Technology},
|
|
782 |
volume = {52},
|
|
783 |
pages = {1167-1187},
|
|
784 |
aeres = {ACL},
|
|
785 |
impactfactor = {ISI impact factor 1.821 (2010)},
|
|
786 |
misc = {ISI impact factor 1.821 (2010)},
|
|
787 |
inriareport = {2010},
|
|
788 |
inria = {RMOD},
|
|
789 |
x-editorial-board = {yes},
|
|
790 |
x-proceedings = {yes},
|
|
791 |
x-international-audience = {yes},
|
|
792 |
keywords = {moose lse-pub cook},
|
|
793 |
aeresstatus = {aeres12},
|
|
794 |
issn = {0950-5849},
|
|
795 |
doi = {10.1016/j.infsof.2010.05.010},
|
|
796 |
hal-id = {inria-00531498},
|
|
797 |
year = {2010},
|
|
798 |
x-pays = {AR,CH},
|
|
799 |
url = {http://rmod.lille.inria.fr/archives/papers/Arev10a-IST-generating_a_catalog.pdf},
|
|
800 |
secondurl = {http://rmod.lille.inria.fr/archives/papers/Arev10a-IST-Official-generating_a_catalog.pdf}
|
|
801 |
}
|
|
802 |
|
|
803 |
@inproceedings{Arna10a,
|
|
804 |
title = {Read-Only Execution for Dynamic Languages},
|
|
805 |
author = {Jean-Baptiste Arnaud and Marcus Denker and St\'ephane Ducasse and Damien Pollet and Alexandre Bergel and Mathieu Suen},
|
|
806 |
booktitle = {Proceedings of the 48th International Conference Objects, Models, Components, Patterns (TOOLS-Europe'10)},
|
|
807 |
year = {2010},
|
|
808 |
annote = {internationalconference},
|
|
809 |
keywords = {tools10 lse-pub marcusdenker},
|
|
810 |
month = jun,
|
|
811 |
inria = {RMOD},
|
|
812 |
inriareport = {2010},
|
|
813 |
x-editorial-board = {yes},
|
|
814 |
x-proceedings = {yes},
|
|
815 |
x-international-audience = {yes},
|
|
816 |
x-country = {FR},
|
|
817 |
x-language = {EN},
|
|
818 |
address = {Malaga, Spain},
|
|
819 |
url = {http://rmod.lille.inria.fr/archives/papers/Arna10a-Tools2010-ReadOnlyExecutionForDynamicLanguages.pdf},
|
|
820 |
abstract = {Supporting read-only and side effect free execution has been the focus of a large body of work in the area of statically typed programming languages. Read-onlyness in dynamically typed languages is difficult to achieve because of the absence of a type checking phase and the support of an open-world assumption in which code can be constantly added and modified. To address this issue, we propose Dynamic Read-Only references (DRO) that provide a view on an object where this object and its object graph are protected from modification. The read- only view dynamically propagates to aggregated objects, without changing the object graph itself; it acts as a read-only view of complex data structures, without making them read-only globally. We implement dynamic read-only references by using smart object proxies that lazily propagate the read-only view, following the object graph and driven by control flow and applied them to realize side-effect free assertions.},
|
|
821 |
hal-id = {inria-00498377 / 7a#ndah},
|
|
822 |
misc = {25%},
|
|
823 |
rate = {25%},
|
|
824 |
hal = {http://hal.archives-ouvertes.fr/inria-00498377/fr/}
|
|
825 |
}
|
|
826 |
|
|
827 |
@techreport{Balm09a,
|
|
828 |
author = {Fran{\c c}oise Balmas and Alexandre Bergel and Simon Denier and St\'ephane Ducasse and Jannik Laval and Karine Mordal-Manet and Hani Abdeen and Fabrice Bellingard},
|
|
829 |
title = {Software metric for Java and C++ practices},
|
|
830 |
keywords = {squale-pub lse-pub deliverable11},
|
|
831 |
annote = {technicalReport},
|
|
832 |
institution = {INRIA Lille Nord Europe},
|
|
833 |
type_rapport = {Rapport technique},
|
|
834 |
abstract = {No abstract},
|
|
835 |
year = {2009},
|
|
836 |
inria = {RMOD},
|
|
837 |
inriareport = {2009},
|
|
838 |
hal-id = {inria-00533617}
|
|
839 |
}
|
|
840 |
|
|
841 |
@techreport{Balm09c,
|
|
842 |
author = {Fran{\c c}oise Balmas and Fabrice Bellingard and Simon Denier and St\'ephane Ducasse and Jannik Laval and Karine Mordal-Manet},
|
|
843 |
title = {Practices in the Squale Quality Model (Squale Deliverable 1.3)},
|
|
844 |
keywords = {squale-pub lse-pub deliverable13},
|
|
845 |
institution = {INRIA},
|
|
846 |
inria = {RMOD},
|
|
847 |
inriareport = {2009},
|
|
848 |
year = {2009},
|
|
849 |
aeres = {AP},
|
|
850 |
type_rapport = {Rapport technique},
|
|
851 |
abstract = {No abstract},
|
|
852 |
x-language = {EN},
|
|
853 |
hal-id = {inria-00533654}
|
|
854 |
}
|
|
855 |
|
|
856 |
@inproceedings{Berg03a,
|
|
857 |
abstract = {Classical module systems support well the modular development of applications but do not offer the ability to add or replace a method in a class that is not defined in that module. On the other hand, languages that support method addition and replacement do not provide a modular view of applications, and their changes have a global impact. The result is a gap between module systems for object-oriented languages on one hand, and the very desirable feature of method addition and replacement on the other hand. To solve these problems we present classboxes, a module system for object-oriented languages that provides method addition and replacement. Moreover, the changes made by a classbox are only visible to that classbox (or classboxes that import it), a feature we call local rebinding. To validate the model, we have implemented it in the Squeak Smalltalk environment, and performed experiments modularising code.},
|
|
858 |
aeres = {ACT},
|
|
859 |
aeresstatus = {aeres08},
|
|
860 |
annote = {internationalconference},
|
|
861 |
author = {Alexandre Bergel and St\'ephane Ducasse and Roel Wuyts},
|
|
862 |
booktitle = {Proceedings of Joint Modular Languages Conference (JMLC'03)},
|
|
863 |
doi = {10.1007/b12023},
|
|
864 |
inria = {hors},
|
|
865 |
isbn = {978-3-540-40796-6},
|
|
866 |
keywords = {module classbox},
|
|
867 |
misc = {Best Paper Award},
|
|
868 |
pages = {122--131},
|
|
869 |
publisher = {Springer-Verlag},
|
|
870 |
selectif = {non},
|
|
871 |
series = {LNCS},
|
|
872 |
title = {Classboxes: A Minimal Module Model Supporting Local Rebinding},
|
|
873 |
secondurl = {http://scg.unibe.ch/archive/papers/Berg03aClassboxes.pdf},
|
|
874 |
url = {http://rmod.lille.inria.fr/archives/papers/Berg03a-JLMC03-Classboxes.pdf},
|
|
875 |
volume = {2789},
|
|
876 |
hal-id = {inria-00533446},
|
|
877 |
year = {2003}
|
|
878 |
}
|
|
879 |
|
|
880 |
@inproceedings{Berg03b,
|
|
881 |
abstract = {Classical module systems support well the modular development of applications but do not offer the ability to add or replace a method in a class that is not defined in that module. On the other hand, languages that support method addition and replacement do not provide a modular view of applications, and their changes have a global impact. The result is a gap between module systems for object-oriented languages on one hand, and the very desirable feature of method addition and replacement on the other hand. To solve these problems we present classboxes, a module system for object-oriented languages that provides method addition and replacement. Moreover, the changes made by a classbox are only visible to that classbox (or classboxes that import it), a feature we call local rebinding. To validate the model, we have implemented it in the Squeak Smalltalk environment, and performed experiments modularising code.},
|
|
882 |
aeres = {ACT},
|
|
883 |
aeresstatus = {aeres05},
|
|
884 |
annote = {internationalworkshop},
|
|
885 |
author = {Alexandre Bergel and St\'ephane Ducasse and Roel Wuyts},
|
|
886 |
booktitle = {Proceedings of the ECOOP '03 Workshop on Object-oriented Language Engineering for the Post-Java Era},
|
|
887 |
inria = {hors},
|
|
888 |
keywords = {snf03 scg-pub skip-doi jb03 stefPub alexandrePub module classbox alexPub},
|
|
889 |
month = jul,
|
|
890 |
selectif = {non},
|
|
891 |
title = {The {Classbox} Module System},
|
|
892 |
url = {http://scg.unibe.ch/archive/papers/Berg03bClassboxes.pdf},
|
|
893 |
year = {2003}
|
|
894 |
}
|
|
895 |
|
|
896 |
@techreport{Berg04a,
|
|
897 |
abstract = {A class extension is a method that is defined in a module, but whose class is defined elsewhere. Class extensions offer a convenient way to incrementally modify existing classes when subclassing is inappropriate. Unfortunately existing approaches suffer from various limitations. Either class extensions have a global impact, with possibly negative effects for unexpected clients, or they have a purely local impact, with negative results for collaborating clients. Furthermore, conflicting class extensions are either disallowed, or resolved by linearization, with consequent negative effects. To solve these problems we present classboxes, a module system for object-oriented languages that provides for method addition and replacement. Moreover, the changes made by a classbox are only visible to that classbox (or classboxes that import it), a feature we call local rebinding. To validate the model we have implemented it in the Squeak Smalltalk environment, and performed benchmarks.},
|
|
898 |
address = {Universit\"at Bern, Switzerland},
|
|
899 |
aeres = {AP},
|
|
900 |
aeresstatus = {aeres05},
|
|
901 |
annote = {report notrefereed technicalReport},
|
|
902 |
author = {Alexandre Bergel and St\'ephane Ducasse and Oscar Nierstrasz and Roel Wuyts},
|
|
903 |
classification = {D.1.5 Object-oriented Programming; D.3.3 Language Constructs and Features},
|
|
904 |
general_terms = {Inheritance, Mixins, Multiple Inheritance, Traits, Reuse, Smalltalk},
|
|
905 |
inria = {hors},
|
|
906 |
institution = {Institut f\"ur Informatik},
|
|
907 |
keywords = {snf-redundant scg-pub skip-doi jb04 snf04 stefPub alexPub alexandrePub},
|
|
908 |
misc = {ClassboxTR04},
|
|
909 |
month = jun,
|
|
910 |
number = {IAM-04-003},
|
|
911 |
selectif = {non},
|
|
912 |
title = {Classboxes: Controlling Visibility of Class Extensions},
|
|
913 |
type = {Technical Report},
|
|
914 |
url = {http://scg.unibe.ch/archive/papers/Berg04aIAM-04-003.pdf},
|
|
915 |
year = {2004},
|
|
916 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Berg04aIAM-04-003.pdf}
|
|
917 |
}
|
|
918 |
|
|
919 |
@inproceedings{Berg04c,
|
|
920 |
abstract = {With prototype-based languages, concretization and abstraction are unified into a single concept a prototype. Prototype-based languages are based on a simple set of principles: object-centered representation, dynamic reshape of objects, cloning and possibly message delegation. However, they all differ in the interpretation and combination of these principles. Therefore there is a need to compare and understand. In this paper we present Prototalk, a research and teaching vehicle to understand, implement and compare prototype-based languages. Prototalk is a framework that offers a predefined set of language data structures and mechanisms that can be composed and extended to generate various prototype-based language interpreters. It presents a classification of languages based on different mechanisms in an operational manner.},
|
|
921 |
aeres = {ACT},
|
|
922 |
aeresstatus = {aeres05},
|
|
923 |
annote = {internationalconference},
|
|
924 |
author = {Alexandre Bergel and Christophe Dony and St\'ephane Ducasse},
|
|
925 |
booktitle = {Proceedings of 12th International Smalltalk Conference (ISC'04)},
|
|
926 |
cvs = {PrototalkESUG04},
|
|
927 |
inria = {hors},
|
|
928 |
keywords = {scg-pub skip-doi jb05 snf04 stefPub alexPub alexandrePub noWorkshop},
|
|
929 |
month = sep,
|
|
930 |
pages = {107--130},
|
|
931 |
selectif = {non},
|
|
932 |
title = {Prototalk: an Environment for Teaching, Understanding, Designing and Prototyping Object-Oriented Languages},
|
|
933 |
url = {http://rmod.lille.inria.fr/archives/papers/Berg04c-ISC04-prototalk.pdf},
|
|
934 |
secondurl = {http://scg.unibe.ch/archive/papers/Berg04cprototalk.pdf},
|
|
935 |
hal-id = {inria-00533452},
|
|
936 |
year = {2004}
|
|
937 |
}
|
|
938 |
|
|
939 |
@article{Berg05a,
|
|
940 |
abstract = {A class extension is a method that is defined in a module, but whose class is
|
|
941 |
defined elsewhere. Class extensions offer a convenient way to incrementally modify existing
|
|
942 |
classes when subclassing is inappropriate. Unfortunately existing approaches suffer from
|
|
943 |
various limitations. Either class extensions have a global impact, with possibly negative
|
|
944 |
effects for unexpected clients, or they have a purely local impact, with negative results
|
|
945 |
for collaborating clients. Furthermore, conflicting class extensions are either disallowed,
|
|
946 |
or resolved by linearization, with consequent negative effects. To solve these problems we
|
|
947 |
present classboxes, a module system for object-oriented languages that provides for method
|
|
948 |
addition and replacement. Moreover, the changes made by a classbox are only visible to that
|
|
949 |
classbox (or classboxes that import it), a feature we call local rebinding. To validate the
|
|
950 |
model we have implemented it in the Squeak Smalltalk environment, and performed
|
|
951 |
benchmarks.},
|
|
952 |
aeres = {ACL},
|
|
953 |
aeresstatus = {aeres08},
|
|
954 |
annote = {internationaljournal},
|
|
955 |
author = {Alexandre Bergel and St\'ephane Ducasse and Oscar Nierstrasz and Roel Wuyts},
|
|
956 |
cvs = {ClassboxESUG04},
|
|
957 |
doi = {10.1016/j.cl.2004.11.002},
|
|
958 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
959 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
960 |
inria = {hors},
|
|
961 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
962 |
keywords = {scg-pub snf-actsc jb05 classbox snf05 stefPub},
|
|
963 |
month = dec,
|
|
964 |
number = {3-4},
|
|
965 |
pages = {107--126},
|
|
966 |
publisher = {Elsevier},
|
|
967 |
selectif = {non},
|
|
968 |
title = {Classboxes: Controlling Visibility of Class Extensions},
|
|
969 |
url = {http://rmod.lille.inria.fr/archives/papers/Berg05a-CompLangESUG04-classboxesJournal.pdf},
|
|
970 |
secondurl = {http://scg.unibe.ch/archive/papers/Berg05aclassboxesJournal.pdf},
|
|
971 |
volume = {31},
|
|
972 |
hal-id = {inria-00533458},
|
|
973 |
year = {2005}
|
|
974 |
}
|
|
975 |
|
|
976 |
@inproceedings{Berg05b,
|
|
977 |
abstract = {Unanticipated changes to complex software systems can introduce anomalies such as duplicated code, suboptimal inheritance relationships and a proliferation of run-time downcasts. Refactoring to eliminate these anomalies may not be an option, at least in certain stages of software evolution. Classboxes are modules that restrict the visibility of changes to selected clients only, thereby offering more freedom in the way unanticipated changes may be implemented, and thus reducing the need for convoluted design anomalies. In this paper we demonstrate how classboxes can be implemented in statically-typed languages like {Java}. We also present an extended case study of Swing, a {Java} GUI package built on top of AWT, and we document the ensuing anomalies that Swing introduces. We show how Classbox/J, a prototype implementation of classboxes for {Java}, is used to provide a cleaner implementation of Swing using local refinement rather than subclassing.},
|
|
978 |
address = {New York, NY, USA},
|
|
979 |
aeres = {ACT},
|
|
980 |
aeresstatus = {aeres08},
|
|
981 |
annote = {internationalconference topconference},
|
|
982 |
author = {Alexandre Bergel and St\'ephane Ducasse and Oscar Nierstrasz},
|
|
983 |
booktitle = {Proceedings of 20th International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA'05)},
|
|
984 |
doi = {10.1145/1094811.1094826},
|
|
985 |
inria = {hors},
|
|
986 |
keywords = {snf05 stefPub alexPub snf06 jb06 scg-pub},
|
|
987 |
misc = {acceptance rate: 25/142 = 17\%},
|
|
988 |
accepttotal = {142},
|
|
989 |
acceptnum = {25},
|
|
990 |
pages = {177--189},
|
|
991 |
publisher = {ACM Press},
|
|
992 |
rate = {17%},
|
|
993 |
selectif = {oui},
|
|
994 |
hal-id = {inria-00533461},
|
|
995 |
title = {Classbox/{J}: Controlling the Scope of Change in {Java}},
|
|
996 |
url = {http://rmod.lille.inria.fr/archives/papers/Berg05b-OOSPLA05-classboxJ},
|
|
997 |
secondurl = {http://scg.unibe.ch/archive/papers/Berg05bclassboxjOOPSLA.pdf},
|
|
998 |
year = {2005}
|
|
999 |
}
|
|
1000 |
|
|
1001 |
@article{Berg05c,
|
|
1002 |
abstract = {Each object-oriented programming language proposes various grouping
|
|
1003 |
mechanisms to bundle interacting classes (i.e., packages, modules, selector namespaces,
|
|
1004 |
etc). To understand such diversity and to compare the different approaches, a common
|
|
1005 |
foundation is needed. As far as we are aware of, no major attempt that would go in that
|
|
1006 |
direction has been realized. In this paper we present a simple module calculus together
|
|
1007 |
with a set of operators for modeling the composition semantics of different grouping
|
|
1008 |
mechanisms. Using this module calculus we are able to express the semantics of {Java}
|
|
1009 |
packages, C# namespaces, Ruby modules, selector namespaces, gbeta classes, classboxes,
|
|
1010 |
MZScheme units, and MixJuice modules. This calculus supports the identification of system
|
|
1011 |
families sharing similar characteristics. In addition it provides a uniform way to
|
|
1012 |
represent and analyze fine-grained module semantics.},
|
|
1013 |
aeres = {ACL},
|
|
1014 |
aeresstatus = {aeres08},
|
|
1015 |
annote = {internationaljournal},
|
|
1016 |
author = {Alexandre Bergel and St\'ephane Ducasse and Oscar Nierstrasz},
|
|
1017 |
cvs = {ModuleAnalysisJUCS05},
|
|
1018 |
impactfactor = {0.337, SCI},
|
|
1019 |
inria = {hors},
|
|
1020 |
journal = {Journal of Universal Computer Science},
|
|
1021 |
keywords = {scg-pub skip-doi jb06 classbox snf06 stefPub alexPub listic},
|
|
1022 |
misc = {SCI impact factor 0.337},
|
|
1023 |
month = nov,
|
|
1024 |
number = {10},
|
|
1025 |
pages = {1613--1644},
|
|
1026 |
selectif = {non},
|
|
1027 |
title = {Analyzing Module Diversity},
|
|
1028 |
url = {http://www.jucs.org/jucs_11_10/analyzing_module_diversity
|
|
1029 |
http://scg.unibe.ch/archive/papers/Berg05cModuleDiversity.pdf},
|
|
1030 |
volume = {11},
|
|
1031 |
year = {2005}
|
|
1032 |
}
|
|
1033 |
|
|
1034 |
@inproceedings{Berg05d,
|
|
1035 |
abstract = {On the one hand, traits are a powerful way of structuring classes. Traits
|
|
1036 |
support the reuse of method collections over several classes. However, traits cannot be
|
|
1037 |
used when specifying unanticipated changes to an application. On the other hand, classboxes
|
|
1038 |
are a new module system that supports the local redefinition of classes: a collection of
|
|
1039 |
classes can be locally extended with variables and/or methods and the existing clients do
|
|
1040 |
not get impacted by changes. However, an extension applied to a class by a classbox cannot
|
|
1041 |
be reused for other classes. This paper describes how combining Traits and Classboxes
|
|
1042 |
supports the safe introduction of crosscutting collaborations: safe because the existing
|
|
1043 |
clients of the classes do not get impacted, crosscutting because collaborations between
|
|
1044 |
several classes can be put in place in a unanticipated manner. In the resulting system, a
|
|
1045 |
collaboration is represented by a classbox and a role by a trait.},
|
|
1046 |
address = {Erfurt, Germany},
|
|
1047 |
aeres = {ACT},
|
|
1048 |
aeresstatus = {aeres08},
|
|
1049 |
annote = {nationalconference},
|
|
1050 |
author = {Alexandre Bergel and St\'ephane Ducasse},
|
|
1051 |
booktitle = {{Net}.{ObjectDays} (NODE'05)},
|
|
1052 |
inria = {hors},
|
|
1053 |
keywords = {snf05 jb06 scg-pub skip-doi alexPub stefPub listic},
|
|
1054 |
month = sep,
|
|
1055 |
pages = {61--75},
|
|
1056 |
selectif = {non},
|
|
1057 |
title = {Supporting Unanticipated Changes with {Traits} and {Classboxes}},
|
|
1058 |
url = {http://scg.unibe.ch/archive/papers/Berg05dTraitsClassbox.pdf},
|
|
1059 |
year = {2005}
|
|
1060 |
}
|
|
1061 |
|
|
1062 |
@article{Berg05e,
|
|
1063 |
abstract = {Atomically introducing changes to a group of classes is a challenging task.
|
|
1064 |
In addition, certain applications require that changes be applied dynamically without
|
|
1065 |
shutting down and restarting the application. In this paper we present an extension of
|
|
1066 |
classboxes to make them dynamic. A classbox is a kind of module that supports class
|
|
1067 |
extension and instance variable addition. Class extensions and definitions defined in a
|
|
1068 |
classbox represent an aspect. In addition, with classboxes, aspects are dynamically applied
|
|
1069 |
to, removed from hot- in a system. Such aspects may crosscut a large number of classes
|
|
1070 |
which are extended by adding or redefining existing methods and adding new instance
|
|
1071 |
variables. Finally the aspects are scoped i.e., they are local to the classboxes that
|
|
1072 |
define them.},
|
|
1073 |
aeres = {ACT},
|
|
1074 |
annote = {nationaljournal},
|
|
1075 |
author = {Alexandre Bergel and St\'ephane Ducasse},
|
|
1076 |
cvs = {ClassboxJFDLPA04},
|
|
1077 |
inria = {hors},
|
|
1078 |
journal = {Revue des Sciences et Technologies de l'Information (RSTI) --- L'Objet
|
|
1079 |
(Num\'ero sp\'ecial : Programmation par aspects)},
|
|
1080 |
keywords = {scg-pub skip-doi jb05 classboxes snf05 stefPub alexandrePub alexPub listic},
|
|
1081 |
month = nov,
|
|
1082 |
number = {3},
|
|
1083 |
pages = {53--68},
|
|
1084 |
publisher = {Hermes, Paris},
|
|
1085 |
selectif = {non},
|
|
1086 |
title = {Scoped and Dynamic Aspects with {Classboxes}},
|
|
1087 |
url = {http://scg.unibe.ch/archive/papers/Berg05eDynamicClassboxes.pdf},
|
|
1088 |
volume = {11},
|
|
1089 |
year = {2005}
|
|
1090 |
}
|
|
1091 |
|
|
1092 |
@inproceedings{Berg06b,
|
|
1093 |
abstract = {Prototyping new programming languages is often assimilated as a task
|
|
1094 |
requiring heavy expertise in parsing and compilation. This paper argues that choosing as a
|
|
1095 |
host platform a language having advanced reflective capabilities helps in reducing the
|
|
1096 |
effort and time spent on developing new language related constructs and tools. The Squeak
|
|
1097 |
Smalltalk implementation provides very expressive reflective facilities. In this paper we
|
|
1098 |
focus on having methods as first class entities, enabling methods manipulation as plain
|
|
1099 |
standard objects and reification of method execution. Powerful language related tools and
|
|
1100 |
efficient new programming constructs can be quickly implemented. ByteSurgeon, a bytecode
|
|
1101 |
manipulation library, and FacetS, an aspect mechanism, serve as illustrations.},
|
|
1102 |
aeres = {ACT},
|
|
1103 |
annote = {internationalworkshop},
|
|
1104 |
author = {Alexandre Bergel and Marcus Denker},
|
|
1105 |
booktitle = {Proceedings of the ECOOP'06 Workshop on Revival of Dynamic Languages},
|
|
1106 |
cvs = {SqueakRSP06},
|
|
1107 |
inria = {hors},
|
|
1108 |
keywords = {snf06 scg-pub skip-doi jb06 fb06 alexpub fromscgbib marcusdenker},
|
|
1109 |
medium = {4},
|
|
1110 |
month = jul,
|
|
1111 |
peerreview = {yes},
|
|
1112 |
selectif = {non},
|
|
1113 |
title = {Prototyping Languages, Related Constructs and Tools with {Squeak}},
|
|
1114 |
url = {http://rmod.lille.inria.fr/archives/workshops/Bergel06b-RDL06-Prototyping.pdf},
|
|
1115 |
year = {2006}
|
|
1116 |
}
|
|
1117 |
|
|
1118 |
@inproceedings{Berg07a,
|
|
1119 |
abstract = {Traits offer a fine-grained mechanism to compose classes from reusable
|
|
1120 |
components while avoiding problems of fragility brought by multiple inheritance and mixins.
|
|
1121 |
Traits as originally proposed are \emph{stateless}, that is, they contain only methods, but
|
|
1122 |
no instance variables. State can only be accessed within traits by accessors, which become
|
|
1123 |
\emph{required methods} of the trait. Although this approach works reasonably well in
|
|
1124 |
practice, it means that many traits, viewed as software components, are artificially
|
|
1125 |
\emph{incomplete}, and classes that use such traits may contain significant amounts of
|
|
1126 |
boilerplate glue code. Although these limitations are largely mitigated by proper tool
|
|
1127 |
support, we seek a cleaner solution that supports \emph{stateful traits}. The key
|
|
1128 |
difficulty is how to handle conflicts that arise when composed traits contribute instance
|
|
1129 |
variables whose names clash. We present a solution that is faithful to the guiding
|
|
1130 |
principle of stateless traits: \emph{the client retains control of the composition}.
|
|
1131 |
Stateful traits consist of a minimal extension to stateless traits in which instance
|
|
1132 |
variables are purely local to the scope of a trait, unless they are explicitly made
|
|
1133 |
accessible by the composing client of a trait. Naming conflicts are avoided, and variables
|
|
1134 |
of disjoint traits can be explicitly merged by clients. We discuss and compare two
|
|
1135 |
implementation strategies, and briefly present a case study in which stateful traits have
|
|
1136 |
been used to refactor the trait-based version of the Smalltalk collection hierarchy.},
|
|
1137 |
aeres = {ACL},
|
|
1138 |
aeresstatus = {aeres08},
|
|
1139 |
annote = {internationalconference},
|
|
1140 |
author = {Alexandre Bergel and St\'ephane Ducasse and Oscar Nierstrasz and Roel Wuyts},
|
|
1141 |
booktitle = {Advances in Smalltalk --- Proceedings of 14th International Smalltalk Conference (ISC 2006)},
|
|
1142 |
doi = {10.1007/978-3-540-71836-9\_3},
|
|
1143 |
inria = {hors},
|
|
1144 |
isbn = {978-3-540-71835-2},
|
|
1145 |
issn = {0302-9743},
|
|
1146 |
keywords = {scg07 stefPub scg-pub jb07 snf06 traits},
|
|
1147 |
medium = {2},
|
|
1148 |
month = aug,
|
|
1149 |
pages = {66--90},
|
|
1150 |
peerreview = {yes},
|
|
1151 |
publisher = {Springer},
|
|
1152 |
selectif = {non},
|
|
1153 |
series = {LNCS},
|
|
1154 |
title = {Stateful Traits},
|
|
1155 |
url = {http://rmod.lille.inria.fr/archives/papers/Berg07a-InternationalSmalltalkConference07-StatefulTraits.pdf},
|
|
1156 |
volume = {4406},
|
|
1157 |
year = {2007}
|
|
1158 |
}
|
|
1159 |
|
|
1160 |
@inproceedings{Berg07c,
|
|
1161 |
abstract = {Smalltalk is not only an object-oriented programming language; it is also known for its extensive integrated development environment supporting interactive and dynamic programming. While the default tools are adequate for browsing the code and developing applications, it is often cumbersome to extend the environment to support new language constructs or to build additional tools supporting new ways of navigating and presenting source code. In this paper, we present the OmniBrowser, a browser framework that supports the definition of browsers based on an explicit metamodel. With OmniBrowser a domain model is described in a graph and the navigation in this graph is specified in its associated metagraph. We present how new browsers are built from predefined parts and how new tools are easily described. The browser framework is implemented in the Squeak Smalltalk environment. This paper shows several concrete instantiations of the framework: a remake of the ubiquitous Smalltalk System Browser, and a coverage browser.},
|
|
1162 |
aeres = {ACT},
|
|
1163 |
aeresstatus = {aeres08},
|
|
1164 |
annote = {internationalconference},
|
|
1165 |
author = {Alexandre Bergel and St\'ephane Ducasse and Colin Putney and Roel Wuyts},
|
|
1166 |
booktitle = {Advances in Smalltalk --- Proceedings of 14th International Smalltalk Conference (ISC 2006)},
|
|
1167 |
doi = {10.1007/978-3-540-71836-9\_3},
|
|
1168 |
inria = {hors},
|
|
1169 |
isbn = {978-3-540-71835-2},
|
|
1170 |
issn = {0302-9743},
|
|
1171 |
keywords = {scg07 stefPub scg-pub jb07 snf06},
|
|
1172 |
medium = {2},
|
|
1173 |
month = aug,
|
|
1174 |
pages = {134--156},
|
|
1175 |
peerreview = {yes},
|
|
1176 |
publisher = {Springer},
|
|
1177 |
selectif = {non},
|
|
1178 |
series = {LNCS},
|
|
1179 |
title = {Meta-Driven Browsers},
|
|
1180 |
url = {http://scg.unibe.ch/archive/papers/Berg07cOmnibrowser.pdf},
|
|
1181 |
volume = {4406},
|
|
1182 |
year = {2007}
|
|
1183 |
}
|
|
1184 |
|
|
1185 |
@article{Berg08a,
|
|
1186 |
abstract = {Page-centric Web application frameworks fail to offer adequate solutions to
|
|
1187 |
model composition and control flow. Seaside allows Web applications to be developed in the
|
|
1188 |
same way as desktop applications. Control flow is modelled as a continuous piece of code,
|
|
1189 |
and components may be composed, configured and nested as one would expect from traditional
|
|
1190 |
user interface frameworks.},
|
|
1191 |
aeres = {AP},
|
|
1192 |
aeresstatus = {aeres08},
|
|
1193 |
annote = {notrefereed},
|
|
1194 |
author = {Alexandre Bergel and St\'ephane Ducasse and Lukas Renggli},
|
|
1195 |
inria = {hors},
|
|
1196 |
journal = {ERCIM News},
|
|
1197 |
keywords = {scg-pub snf-none skip-doi alexPub stefPub jb08 remoose},
|
|
1198 |
month = jan,
|
|
1199 |
selectif = {non},
|
|
1200 |
title = {Seaside -- Advanced Composition and Control Flow for Dynamic Web Applications},
|
|
1201 |
url = {http://ercim-news.ercim.org/content/view/325/536/},
|
|
1202 |
volume = 72,
|
|
1203 |
year = {2008}
|
|
1204 |
}
|
|
1205 |
|
|
1206 |
@inproceedings{Berg08b,
|
|
1207 |
abstract = {Following last two years' workshop on dynamic languages at the ECOOP
|
|
1208 |
conference, the Dyla 2007 workshop was a successful and popular event. As its name implies,
|
|
1209 |
the workshop's focus was on dynamic languages and their applications. Topics and
|
|
1210 |
discussions at the workshop included macro expansion mechanisms, extension of the method
|
|
1211 |
lookup algorithm, language interpretation, reflexivity and languages for mobile ad hoc
|
|
1212 |
networks. The main goal of this workshop was to bring together different dynamic language
|
|
1213 |
communities and favouring cross communities interaction. Dyla 2007 was organised as a full
|
|
1214 |
day meeting, partly devoted to presentation of submitted position papers and partly devoted
|
|
1215 |
to tool demonstration. All accepted papers can be downloaded from the workshop's web site.
|
|
1216 |
In this report, we provide an overview of the presentations and a summary of discussions.},
|
|
1217 |
aeres = {DO},
|
|
1218 |
aeresstatus = {aeres08},
|
|
1219 |
annote = {workshopproceedings},
|
|
1220 |
author = {Alexandre Bergel and Wolfgang De Meuter and St\'ephane Ducasse and Oscar Nierstrasz and Roel Wuyts},
|
|
1221 |
booktitle = {Object-Oriented Technology. ECOOP 2007 Workshop Reader},
|
|
1222 |
doi = {10.1007/978-3-540-78195-0},
|
|
1223 |
inria = {hors},
|
|
1224 |
isbn = {978-3-540-78194-3},
|
|
1225 |
keywords = {scg07 scg-pub stefPub jb08 snf-none},
|
|
1226 |
medium = {2},
|
|
1227 |
pages = {7--12},
|
|
1228 |
peerreview = {yes},
|
|
1229 |
publisher = {Springer-Verlag},
|
|
1230 |
selectif = {non},
|
|
1231 |
series = {LNCS},
|
|
1232 |
title = {Dynamic Languages and Applications, Report on the Workshop {Dyla}'07 at {ECOOP}
|
|
1233 |
2007},
|
|
1234 |
url = {http://dyla2007.unibe.ch/
|
|
1235 |
http://scg.unibe.ch/archive/papers/Berg08bDyla07Report.pdf
|
|
1236 |
http://www.springer.com/computer/programming/book/978-3-540-78194-3},
|
|
1237 |
volume = {4906},
|
|
1238 |
year = {2008}
|
|
1239 |
}
|
|
1240 |
|
|
1241 |
@inproceedings{Berg08c,
|
|
1242 |
author = {Alexandre Bergel and St\'ephane Ducasse and Jannik Laval and Romain Peirs},
|
|
1243 |
title = {Enhanced Dependency Structure Matrix for Moose},
|
|
1244 |
annote = {internationalworkshop},
|
|
1245 |
keywords = {moose},
|
|
1246 |
aeres = {missing},
|
|
1247 |
booktitle = {FAMOOSr, 2nd Workshop on FAMIX and Moose in Reengineering},
|
|
1248 |
year = {2008},
|
|
1249 |
x-editorial-board = {yes},
|
|
1250 |
x-proceedings = {no},
|
|
1251 |
x-international-audience = {yes},
|
|
1252 |
aeres = {COM},
|
|
1253 |
aeresstatus = {aeres12},
|
|
1254 |
selectif = {non},
|
|
1255 |
labo = {dans},
|
|
1256 |
inria = {RMOD},
|
|
1257 |
url = {http://rmod.lille.inria.fr/archives/workshops/Berg08c-Famoosr2008-DSM.pdf},
|
|
1258 |
hal-id = {inria-00498484}
|
|
1259 |
}
|
|
1260 |
|
|
1261 |
@article{Berg08d,
|
|
1262 |
abstract = {Smalltalk is not only an object-oriented programming language; it is also
|
|
1263 |
known for its extensive integrated development environment supporting interactive and
|
|
1264 |
dynamic programming. While the default tools are adequate for browsing the code and
|
|
1265 |
developing applications, it is often cumbersome to extend the environment to support new
|
|
1266 |
language constructs or to build additional tools supporting new ways of navigating and
|
|
1267 |
presenting source code. In this paper, we present the OmniBrowser, a browser framework that
|
|
1268 |
supports the definition of browsers based on an explicit metamodel. With OmniBrowser a
|
|
1269 |
domain model is described in a graph and the navigation in this graph is specified in its
|
|
1270 |
associated metagraph. We present how new browsers are built from predefined parts and how
|
|
1271 |
new tools are easily described. The browser framework is implemented in the Squeak
|
|
1272 |
Smalltalk environment. This paper shows several concrete instantiations of the framework: a
|
|
1273 |
remake of the ubiquitous Smalltalk System Browser, a coverage browser, the Duo Browser and
|
|
1274 |
the Dynamic Protocols browser.},
|
|
1275 |
aeres = {ACL},
|
|
1276 |
aeresstatus = {aeres08},
|
|
1277 |
annote = {internationaljournal},
|
|
1278 |
author = {Alexandre Bergel and St\'ephane Ducasse and Colin Putney and Roel Wuyts},
|
|
1279 |
doi = {10.1016/j.cl.2007.05.005},
|
|
1280 |
inria = {hors},
|
|
1281 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
1282 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
1283 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
1284 |
keywords = {stefPub snf06},
|
|
1285 |
number = {2-3},
|
|
1286 |
pages = {109--129},
|
|
1287 |
publisher = {Elsevier},
|
|
1288 |
selectif = {non},
|
|
1289 |
title = {Creating Sophisticated Development Tools with {OmniBrowser}},
|
|
1290 |
volume = {34},
|
|
1291 |
year = {2005},
|
|
1292 |
bdsk-url-1 = {http://dx.doi.org/10.1016/j.cl.2007.05.005}
|
|
1293 |
}
|
|
1294 |
|
|
1295 |
@article{Berg08e,
|
|
1296 |
abstract = {Traits offer a fine-grained mechanism to compose classes from reusable components while avoiding problems of fragility brought by multiple inheritance and mixins. Traits as originally proposed are stateless, that is, they contain only methods, but no instance variables. State can only be accessed within stateless traits by accessors, which become required methods of the trait. Although this approach works reasonably well in practice, it means that many traits, viewed as software components, are artificially \emph{incomplete}, and classes that use such traits may contain significant amounts of boilerplate glue code. We present an approach to stateful traits that is faithful to the guiding principle of stateless traits: the client retains control of the composition. Stateful traits consist of a minimal extension to stateless traits in which instance variables are purely local to the scope of a trait, unless they are explicitly made accessible by the composing client of a trait. We demonstrate by means of a formal object calculus that adding state to traits preserves the flattening property: traits contained in a program can be compiled away. We discuss and compare two implementation strategies, and briefly present a case study in which stateful traits have been used to refactor the trait-based version of the Smalltalk collection hierarchy.},
|
|
1297 |
aeres = {ACL},
|
|
1298 |
aeresstatus = {aeres08},
|
|
1299 |
annote = {internationaljournal},
|
|
1300 |
author = {Alexandre Bergel and St\'ephane Ducasse and Oscar Nierstrasz and Roel Wuyts},
|
|
1301 |
doi = {10.1016/j.cl.2007.05.003},
|
|
1302 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
1303 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
1304 |
inria = {hors},
|
|
1305 |
issn = {1477-8424},
|
|
1306 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
1307 |
keywords = {scg07 stefPub scg-pub jb08 snf06},
|
|
1308 |
medium = {2},
|
|
1309 |
number = {2-3},
|
|
1310 |
pages = {83--108},
|
|
1311 |
peerreview = {yes},
|
|
1312 |
publisher = {Elsevier},
|
|
1313 |
selectif = {non},
|
|
1314 |
title = {Stateful Traits and their Formalization},
|
|
1315 |
url = {http://rmod.lille.inria.fr/archives/papers/Berg07e-JournalComputerLnaguages-StatefulTraitsFormalization.pdf},
|
|
1316 |
volume = {34},
|
|
1317 |
year = {2008}
|
|
1318 |
}
|
|
1319 |
|
|
1320 |
@inproceedings{Berg09a,
|
|
1321 |
title = {SQUALE -- Software QUALity Enhancement},
|
|
1322 |
author = {Alexandre Bergel and Simon Denier and St\'ephane Ducasse and Jannik Laval and Fabrice Bellingard and Philippe Vaillergues and Fran{\c c}oise Balmas and Karine Mordal-Manet},
|
|
1323 |
booktitle = {Proceedings of the 13th European Conference on Software Maintenance and Reengineering (CSMR 2009), European Projects Track},
|
|
1324 |
annote = {internationalconference},
|
|
1325 |
year = {2009},
|
|
1326 |
month = {mar},
|
|
1327 |
institution = {INRIA},
|
|
1328 |
aeres = {COM},
|
|
1329 |
note = {Presentation},
|
|
1330 |
keywords = {squale-pub lse-pub},
|
|
1331 |
aeres = {ACT},
|
|
1332 |
aeresstatus = {aeres12},
|
|
1333 |
selectif = {non},
|
|
1334 |
labo = {dans},
|
|
1335 |
inria = {RMOD},
|
|
1336 |
x-editorial-board = {yes},
|
|
1337 |
x-proceedings = {yes},
|
|
1338 |
x-international-audience = {yes},
|
|
1339 |
abstract = {No abstract},
|
|
1340 |
x-language = {EN},
|
|
1341 |
url = {http://rmod.lille.inria.fr/archives/workshops/Berg09c-CSMR2009-Squale.pdf},
|
|
1342 |
hal-id = {tobedone}
|
|
1343 |
}
|
|
1344 |
|
|
1345 |
@inproceedings{Bert03a,
|
|
1346 |
abstract = {Understanding object-oriented legacy systems is a complex task exacerbated by the presence of late binding and polymorphism. Moreover, the metaphor of message sending and the anthropomorphism promoted by object-oriented languages makes it difficult to statically identify the precise role the objects play at run-time. We propose a lightweight visualization approach enriched with run-time information which allows us to identify precise aspects of the objects lifetime such as the role played in the creation of other objects and the communication architecture they support. Our approach not only supports the run-time understanding of an application but also allows one to evaluate test understanding and test coverage.},
|
|
1347 |
annote = {internationalworkshop},
|
|
1348 |
author = {Roland Bertuli and St\'ephane Ducasse and Michele Lanza},
|
|
1349 |
booktitle = {Proceedings of WOOR 2003 (4th International Workshop on Object-Oriented Reengineering)},
|
|
1350 |
keywords = {snf03 scg-pub skip-doi jb03 stefPub moose-pub},
|
|
1351 |
pages = {10--19},
|
|
1352 |
publisher = {University of Antwerp},
|
|
1353 |
title = {Run-Time Information Visualization for Understanding Object-Oriented Systems},
|
|
1354 |
url = {http://scg.unibe.ch/archive/papers/Bert03aEcoopWorkshop.pdf},
|
|
1355 |
year = {2003}
|
|
1356 |
}
|
|
1357 |
|
|
1358 |
@inproceedings{Bezi03a,
|
|
1359 |
annote = {internationalconference},
|
|
1360 |
author = {B\'ezivin, Jean and Farcet, Nicolas and J\'ez\'equel, Jean-Marc and Langlois, Beno\^\it and Pollet, Damien},
|
|
1361 |
booktitle = {UML~2003 --- The Unified Modeling Language --- Modeling Languages and Applications},
|
|
1362 |
editor = {Stevens, Perdita and Whittle, Jon and Booch, Grady},
|
|
1363 |
isbn = {3-540-20243-9},
|
|
1364 |
month = oct,
|
|
1365 |
pages = {175--189},
|
|
1366 |
publisher = {Springer Verlag},
|
|
1367 |
series = {LNCS},
|
|
1368 |
title = {Reflective Model Driven Engineering},
|
|
1369 |
url = {http://www.irisa.fr/triskell/publis/2003/Bezivin03.pdf},
|
|
1370 |
volume = {2863},
|
|
1371 |
year = {2003}
|
|
1372 |
}
|
|
1373 |
|
|
1374 |
|
|
1375 |
@inproceedings{Bhat07a,
|
|
1376 |
author = {Bhatti, Muhammad Usman and St\'ephane Ducasse},
|
|
1377 |
title = {Surgical Information to Detect Design Problems with MOOSE},
|
|
1378 |
annote = {internationalworkshop},
|
|
1379 |
keywords = {moose-pub},
|
|
1380 |
booktitle = {FAMOOSr, 1st Workshop on FAMIX and Moose in Reengineering},
|
|
1381 |
url = {http://scg.unibe.ch/archive/papers/Bhat07aFamoosRWorkshop.pdf},
|
|
1382 |
year = {2007},
|
|
1383 |
hal-id = {tobedone}
|
|
1384 |
}
|
|
1385 |
|
|
1386 |
@inproceedings{Bhat08a,
|
|
1387 |
author = {Bhatti, Muhammad Usman and St\'ephane Ducasse and Awais Rashid},
|
|
1388 |
title = {Aspect Mining in Procedural Object-Oriented Code},
|
|
1389 |
annote = {internationalconference shortpaper},
|
|
1390 |
keywords = {moose-pub},
|
|
1391 |
aeres = {ACT},
|
|
1392 |
aeresstatus = {aeres08},
|
|
1393 |
selectif = {non},
|
|
1394 |
inria = {RMOD},
|
|
1395 |
booktitle = {International Conference on Program Comprehension (ICPC 2008)},
|
|
1396 |
url = {http://rmod.lille.inria.fr/archives/papers/Bhat08a-ICPC2008-AspectMining.pdf},
|
|
1397 |
year = {2008},
|
|
1398 |
x-editorial-board = {yes},
|
|
1399 |
x-proceedings = {yes},
|
|
1400 |
x-international-audience = {yes},
|
|
1401 |
x-pays = {UK},
|
|
1402 |
hal-id = {tobedone}
|
|
1403 |
}
|
|
1404 |
|
|
1405 |
@inproceedings{Bhat08b,
|
|
1406 |
author = {Bhatti, Muhammad Usman and St\'ephane Ducasse and Marianne Huchard},
|
|
1407 |
title = {Reconsidering Classes in Procedural Object-Oriented Code},
|
|
1408 |
annote = {internationalconference stefPub},
|
|
1409 |
keywords = {moose-pub},
|
|
1410 |
aeres = {ACT},
|
|
1411 |
aeresstatus = {aeres08},
|
|
1412 |
selectif = {non},
|
|
1413 |
inria = {RMOD},
|
|
1414 |
booktitle = {International Conference on Reverse Engineering (WCRE)},
|
|
1415 |
url = {http://rmod.lille.inria.fr/archives/papers/Bhat08b-WCRE2008-ObjectIdentification.pdf},
|
|
1416 |
year = {2008},
|
|
1417 |
x-editorial-board = {yes},
|
|
1418 |
x-proceedings = {yes},
|
|
1419 |
x-international-audience = {yes},
|
|
1420 |
hal-id = {tobedone}
|
|
1421 |
}
|
|
1422 |
|
|
1423 |
|
|
1424 |
|
|
1425 |
@techreport{Bhat08c,
|
|
1426 |
author = {Bhatti, Muhammad Usman and St\'ephane Ducasse and
|
|
1427 |
Awais Rashid},
|
|
1428 |
title = {Aspect Mining in Procedural Object-Oriented Code},
|
|
1429 |
url = {http://rmod.lille.inria.fr/archives/papers/Bhat08c-TechReport-AspectMining.pdf},
|
|
1430 |
annote = {technicalreport},
|
|
1431 |
institution = {INRIA Lille Nord Europe},
|
|
1432 |
year = {2008},
|
|
1433 |
x-pays = {UK}
|
|
1434 |
}
|
|
1435 |
|
|
1436 |
@phdthesis{Bhat08d,
|
|
1437 |
author = {Muhammad Usman Bhatti},
|
|
1438 |
title = {Object Identification and Aspect Mining in Procedural Object-Oriented Code},
|
|
1439 |
school = {UNIVERSITE PARIS I -- PANTHEON -- SORBONNE},
|
|
1440 |
abstract = {In this dissertation, we present Procedural Object-Oriented Code (POC). POC is the aftermath of the software development activity that involves state of the art object-oriented languages, without employing object-oriented analysis and design. Huge classes, absence of abstractions for domain entities, and shallow inheritance hierarchies are hallmark design defects of procedural object-oriented code. POC also consists of scattered code appearing not only due to the absence of aspects, but it also manifests scattered code appearing due to the non-abstracted domain entities i.e., domain entities that do not have their proper object-oriented classes. The non-abstracted domain logic hinders mining useful crosscutting concerns related to aspects in POC. Confronted with the absence of object-oriented design and the difficulty of mining aspects in POC, we studied it from two perspectives.
|
|
1441 |
First, we improve aspect mining techniques by classifying various crosscutting concerns identified in POC with a two-pronged approach: Firstly, the approach identifies and groups crosscutting concerns present in a software system: aspects as well as non-abstracted domain logic. Crosscutting concerns pertaining to non- abstracted domain entities are identified and extracted through their usage of application domain entity data. Secondly, a new metric called spread-out is introduced to quantify the divulgence of diverse crosscutting concerns.
|
|
1442 |
Second, we studied the problem of object identification in procedural object- oriented code. We present a semi-automatic, tool-assisted approach for restructuring POC into an improved object-oriented design. The approach identifies principal classes in POC. These principal classes are then used to extract object-oriented abstractions using Formal Concept Analysis lattices. This is achieved by providing three different concept lattices, namely fundamental, association, and interactions views.
|
|
1443 |
We developed tools to validate the approaches presented in the thesis. The approaches are validated on a recently developed industrial application. The application is used to run blood plasma analysis automatons. The results of our approach are promising.},
|
|
1444 |
year = {2008},
|
|
1445 |
hal = {tel-00498436 /}
|
|
1446 |
}
|
|
1447 |
|
|
1448 |
@techreport{Blac02a,
|
|
1449 |
abstract = {Traits are a programming language technology modeled after mixins but
|
|
1450 |
avoiding their problems. In this paper we refactor the Smalltalk collections hierarchy
|
|
1451 |
using traits. We observed that the original hierarchy contained much duplication of code;
|
|
1452 |
traits let us remove all of it. Traits also make possible much more general reuse of
|
|
1453 |
collection code outside of the existing hierarchy; for example, they make it easy to
|
|
1454 |
convert other collection-like things into true collections. Our refactoring reduced the
|
|
1455 |
size of the collection hierarchy by approximately 12 per cent, with no measurable impact on
|
|
1456 |
execution efficiency. More importantly, understandability and reusability of the code was
|
|
1457 |
significantly improved, and the path was paved for a more intensive refactoring.},
|
|
1458 |
address = {Universit\"at Bern, Switzerland},
|
|
1459 |
annote = {report notrefereed},
|
|
1460 |
author = {Andrew P. Black and Nathanael Sch\"arli and St\'ephane Ducasse},
|
|
1461 |
classification = {D.2.6 Programming Environments D.2.10 Design D.1.5 Object-oriented
|
|
1462 |
Programming; D.3.3 Language Constructs and Features},
|
|
1463 |
general_terms = {Inheritance, Mixins, Multiple Inheritance, Traits, Reuse, Smalltalk},
|
|
1464 |
institution = {Institut f\"ur Informatik},
|
|
1465 |
month = nov,
|
|
1466 |
note = {Also available as Technical Report CSE-02-014, OGI School of Science \& Engineering, Beaverton, Oregon, USA},
|
|
1467 |
number = {IAM-02-007},
|
|
1468 |
title = {Applying Traits to the {Smalltalk} Collection Hierarchy},
|
|
1469 |
type = {Technical Report},
|
|
1470 |
url = {http://scg.unibe.ch/archive/papers/Blac02aTraitsHierarchy.pdf},
|
|
1471 |
year = {2002},
|
|
1472 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Blac02aTraitsHierarchy.pdf}
|
|
1473 |
}
|
|
1474 |
|
|
1475 |
@inproceedings{Blac03a,
|
|
1476 |
abstract = {Traits are a programming language technology that promote the reuse of
|
|
1477 |
methods between unrelated classes. This paper reports on a refactoring of the Smalltalk
|
|
1478 |
collections classes using traits. The original collection classes contained much
|
|
1479 |
duplication of code; traits let us remove all of it. We also found places where the
|
|
1480 |
protocols of the collections lacked uniformity; traits allowed us to correct these
|
|
1481 |
non-uniformities without code duplication. Traits also make it possible to reuse fragments
|
|
1482 |
of collection code outside of the existing hierarchy; for example, they make it easy to
|
|
1483 |
convert other collection-like things into true collections. Our refactoring reduced the
|
|
1484 |
number of methods in the collection classes by approximately 10 per cent. More importantly,
|
|
1485 |
understandability maintainability and reusability of the code were significantly improved.},
|
|
1486 |
annote = {internationalconference topconference},
|
|
1487 |
author = {Andrew P. Black and Nathanael Sch\"arli and St\'ephane Ducasse},
|
|
1488 |
booktitle = {Proceedings of 17th International Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA'03)},
|
|
1489 |
cvs = {TraitsRefactoringOOPSLA2003},
|
|
1490 |
doi = {10.1145/949305.949311},
|
|
1491 |
misc = {acceptance rate: 26/142 = 18\%},
|
|
1492 |
accepttotal = {142},
|
|
1493 |
acceptnum = {26},
|
|
1494 |
month = oct,
|
|
1495 |
pages = {47--64},
|
|
1496 |
title = {Applying Traits to the {Smalltalk} Collection Hierarchy},
|
|
1497 |
url = {http://scg.unibe.ch/archive/papers/Blac03aTraitsHierarchy.pdf},
|
|
1498 |
volume = {38},
|
|
1499 |
year = {2003}
|
|
1500 |
}
|
|
1501 |
|
|
1502 |
@book{Blac07a,
|
|
1503 |
title = {Squeak by Example},
|
|
1504 |
author = {Andrew Black and St\'ephane Ducasse and Oscar Nierstrasz and Damien Pollet and Damien Cassou and Marcus Denker},
|
|
1505 |
publisher = {Square Bracket Associates},
|
|
1506 |
year = {2007},
|
|
1507 |
aeres = {OV},
|
|
1508 |
aeresstatus = {2008},
|
|
1509 |
inria = {RMOD},
|
|
1510 |
abstract = {Squeak by Example, intended for both students and developers, will guide you gently through the Squeak language and environment by means of a series of examples and exercises. This book is made available under the Creative Commons Attribution-ShareAlike 3.0 license.},
|
|
1511 |
isbn = {978-3-9523341-0-2},
|
|
1512 |
annote = {book},
|
|
1513 |
url = {http://SqueakByExample.org/index.html},
|
|
1514 |
keywords = {skipdoi remoose1-pub marcusdenker}
|
|
1515 |
}
|
|
1516 |
|
|
1517 |
|
|
1518 |
@book{Blac09a,
|
|
1519 |
title = {Pharo by Example},
|
|
1520 |
author = {Andrew P. Black and St\'ephane Ducasse and Oscar Nierstrasz and Damien Pollet and Damien Cassou and Marcus Denker},
|
|
1521 |
publisher = {Square Bracket Associates},
|
|
1522 |
year = {2009},
|
|
1523 |
aeres = {OV},
|
|
1524 |
aeresstatus = {2012},
|
|
1525 |
annote = {book},
|
|
1526 |
inria = {RMOD},
|
|
1527 |
inriareport = {2009},
|
|
1528 |
keywords = {skipdoi remoose2-pub pharo-pub marcusdenker},
|
|
1529 |
abstract = {Pharo by Example, intended for both students and developers, will guide you gently through the Pharo open-source Smalltalk language and environment by means of a series of examples and exercises. This book is made available under the Creative Commons Attribution-ShareAlike 3.0 license.},
|
|
1530 |
isbn = {978-3-9523341-4-0},
|
|
1531 |
url = {http://pharobyexample.org/},
|
|
1532 |
x-pays = {CH,US},
|
|
1533 |
x-scientific-popularization = {yes},
|
|
1534 |
x-international-audience = {yes},
|
|
1535 |
pages = 333,
|
|
1536 |
x-language = {EN}
|
|
1537 |
}
|
|
1538 |
|
|
1539 |
|
|
1540 |
@inproceedings{Bour10a,
|
|
1541 |
title = {BLOC: a Trait-Based Collections Library - a Preliminary Experience Report},
|
|
1542 |
author = {Tristan Bourgois and Jannik Laval and St\'ephane Ducasse and Damien Pollet},
|
|
1543 |
booktitle = {Proceedings of ESUG International Workshop on Smalltalk Technologies (IWST 2010)},
|
|
1544 |
year = {2010},
|
|
1545 |
keywords = {pharo-pub lse-pub},
|
|
1546 |
annote = {internationalworkshop},
|
|
1547 |
aeres = {ACT},
|
|
1548 |
aeresstatus = {aeres12},
|
|
1549 |
selectif = {oui},
|
|
1550 |
inria = {RMOD},
|
|
1551 |
labo = {dans},
|
|
1552 |
x-pays = {FR},
|
|
1553 |
x-editorial-board = {yes},
|
|
1554 |
x-proceedings = {yes},
|
|
1555 |
x-international-audience = {yes},
|
|
1556 |
x-country = {FR},
|
|
1557 |
x-language = {EN},
|
|
1558 |
address = {Barcelona, Spain},
|
|
1559 |
url = {http://rmod.lille.inria.fr/archives/workshops/Bour10a-IWST10-bloc.pdf},
|
|
1560 |
abstract = {A 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?
|
|
1561 |
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.},
|
|
1562 |
hal-id = {inria-00511902/}
|
|
1563 |
}
|
|
1564 |
|
|
1565 |
@book{Brif01a,
|
|
1566 |
annote = {book},
|
|
1567 |
author = {Xavier Briffault and St\'ephane Ducasse},
|
|
1568 |
keywords = {smalltalk squeak scglib},
|
|
1569 |
month = nov,
|
|
1570 |
publisher = {Eyrolles, Paris},
|
|
1571 |
title = {Squeak},
|
|
1572 |
year = {2001}
|
|
1573 |
}
|
|
1574 |
|
|
1575 |
@techreport{Brun09a,
|
|
1576 |
abstract = {Virtual machines emulating hardware devices are generally implemented in low-level languages and using a low-level style for performance reasons. This trend results in largely difficult to understand, difficult to extend and unmaintainable systems. As new general techniques for virtual machines arise, it gets harder to incorporate or test these techniques because of early design and optimization decisions. In this paper we show how such decisions can be postponed to later phases by separating virtual machine implementation issues from the high-level machine-specific model. We construct compact models of whole-system VMs in a high-level language, which exclude all low-level implementation details. We use the pluggable translation toolchain PyPy to translate those models to executables. During the translation process, the toolchain reintroduces the VM implementation and optimization details for specific target platforms. As a case study we implement an executable model of a hardware gaming device. We show that our approach to VM building increases understandability, maintainability and extendability while preserving performance.},
|
|
1577 |
annote = {report notrefereed},
|
|
1578 |
author = {Camillo Bruni and Toon Verwaest and Marcus Denker},
|
|
1579 |
institution = {University of Bern, Institute of Applied Mathematics
|
|
1580 |
and Computer Sciences},
|
|
1581 |
keywords = {scg09 scg-pub jb09 snf09 skip-doi tverwaes marcusdenker fromscgbib},
|
|
1582 |
medium = {2},
|
|
1583 |
number = {IAM-09-002},
|
|
1584 |
peerreview = {yes},
|
|
1585 |
title = {{PyGirl}: Generating Whole-System {VM}s from
|
|
1586 |
high-level models using {PyPy}},
|
|
1587 |
type = {Technical Report},
|
|
1588 |
url = {http://rmod.lille.inria.fr/archives/reports/Brun09a-TechReport-PyGirl.pdf},
|
|
1589 |
year = {2009}
|
|
1590 |
}
|
|
1591 |
|
|
1592 |
@inproceedings{Casa09a,
|
|
1593 |
title = {Object Spaces for Safe Image Surgery},
|
|
1594 |
author = {Gwena{\"e}l Casaccio and Damien Pollet and Marcus Denker and St{\'e}phane Ducasse},
|
|
1595 |
booktitle = {Proceedings of ESUG International Workshop on Smalltalk Technologies (IWST 2009)},
|
|
1596 |
year = {2009},
|
|
1597 |
aeres = {ACT},
|
|
1598 |
aeresstatus = {aeres12},
|
|
1599 |
selectif = {non},
|
|
1600 |
labo = {dans},
|
|
1601 |
publisher = {ACM digital library},
|
|
1602 |
inria = {RMOD},
|
|
1603 |
inriareport = {2009},
|
|
1604 |
keywords = {remoose2-pub marcusdenker lse-pub},
|
|
1605 |
x-editorial-board = {yes},
|
|
1606 |
x-proceedings = {yes},
|
|
1607 |
x-international-audience = {yes},
|
|
1608 |
x-pays = {CL},
|
|
1609 |
url = {http://rmod.lille.inria.fr/archives/workshops/Casa09a-IWST09-ObjectSpaces.pdf},
|
|
1610 |
x-country = {FR},
|
|
1611 |
x-language = {EN},
|
|
1612 |
address = {New York, USA},
|
|
1613 |
abstract = {Long-lived systems rely on reflective self-modification to evolve. Unfortunately, since such a system is at both ends of a causal loop, this means modifications that impact the reflective layer itself can be overly difficult to apply. This paper introduces ObjectSpaces, a reification of the familiar Smalltalk image as a first-class entity. By confining the system inside an ObjectSpace, we isolate the evolution tools from it, while still giving them reflective access to the confined system. We describe the ObjectSpaces idea, the interface to communicate, inspect, and debug objects contained inside and ObjectSpace, based on a prototype implementation in GNU Smalltalk.},
|
|
1614 |
pages = {77-81}
|
|
1615 |
}
|
|
1616 |
|
|
1617 |
@inproceedings{Cass07a,
|
|
1618 |
abstract = {Recently, traits have been proposed as a single inheritance backward compatible solution in which the composing entity has the control over the trait composition. Traits are fine-grained units used to compose classes, while avoiding many of the problems of multiple inheritance and mixin-based approaches. To evaluate the expressiveness of traits, some hierarchies were refactored, showing code reuse. However, such large refactorings, while valuable, may not be facing all the problems, since the hierarchies were previously expressed within single inheritance and following certain patterns. We wanted to evaluate how traits enable reuse, and what problems could be encountered when building a library using traits from scratch, taking into account that traits are units of reuse. This paper presents our work on designing a new stream library named Nile. We present the reuse that we attained using traits, and the problems we encountered.},
|
|
1619 |
aeres = {ACT},
|
|
1620 |
aeresstatus = {aeres08},
|
|
1621 |
annote = {internationalconference},
|
|
1622 |
author = {Damien Cassou and St\'ephane Ducasse and Roel Wuyts},
|
|
1623 |
booktitle = {ICDL'07: Proceedings of the 15th International Conference on Dynamic Languages},
|
|
1624 |
doi = {10.1145/1352678.1352682},
|
|
1625 |
inria = {hors},
|
|
1626 |
isbn = {978-1-60558-084-5},
|
|
1627 |
keywords = {nile cook},
|
|
1628 |
pages = {50--75},
|
|
1629 |
publisher = {ACM Digital Library},
|
|
1630 |
selectif = {non},
|
|
1631 |
title = {Redesigning with Traits: the {Nile} Stream trait-based Library},
|
|
1632 |
url = {http://scg.unibe.ch/archive/papers/Cass07aTraitsStreamRedesign-ICDL.pdf},
|
|
1633 |
year = {2007}
|
|
1634 |
}
|
|
1635 |
|
|
1636 |
@article{Cass09a,
|
|
1637 |
abstract = {Recent years saw the development of a composition mechanism called Traits. Traits are pure units of behavior that can be composed to form classes or other traits. The trait composition mechanism is an alternative to multiple or mixin inheritance in which the composer has full control over the trait composition. To evaluate the expressiveness of traits, some hierarchies were refactored, showing code reuse. However, such large refactorings, while valuable, may not exhibit all possible composition problems, since the hierarchies were previously expressed using single inheritance and following certain patterns. This paper presents our work on designing and implementing a new trait-based stream library named Nile. It evaluates how far traits enable reuse, what problems can be encountered when building a library using traits from scratch and compares the traits solution to alternative composition mechanisms. Nile's core allows the definition of compact collection and file streaming libraries as well as the implementation of a backward-compatible new stream library. Nile method size shows a reduction of 40% compared to the Squeak equivalent. The possibility to reuse the same set of traits to implement two distinct libraries is a concrete illustration of trait reuse capability.},
|
|
1638 |
aeres = {ACL},
|
|
1639 |
aeresstatus = {aeres12},
|
|
1640 |
annote = {internationaljournal},
|
|
1641 |
author = {Damien Cassou and St\'ephane Ducasse and Roel Wuyts},
|
|
1642 |
doi = {10.1016/j.cl.2008.05.004},
|
|
1643 |
halt = {inria-00216108,celwz9},
|
|
1644 |
inria = {RMOD},
|
|
1645 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
1646 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
1647 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
1648 |
keywords = {cook nile stlit-traits},
|
|
1649 |
number = {1},
|
|
1650 |
pages = {2--20},
|
|
1651 |
publisher = {Elsevier},
|
|
1652 |
selectif = {non},
|
|
1653 |
title = {Traits at Work: the design of a new trait-based stream library},
|
|
1654 |
url = {http://scg.unibe.ch/archive/papers/Cass08a-NileNewKernel-ComputerLanguages.pdf},
|
|
1655 |
volume = {35},
|
|
1656 |
year = {2009}
|
|
1657 |
}
|
|
1658 |
|
|
1659 |
@inproceedings{Cruz99a,
|
|
1660 |
abstract = {Although coordination of concurrent objects is a fundamental as-pect of object-oriented concurrent programming, there is only little support for its specification and abstraction at the language level. This is a problem because coordination is often buried in the code of the coordinated objects, leading to a lack of abstraction and reuse. Here we present CoLaS, a coordination model and its implementation based on the notion of Coordination Groups. By clearly identifying and separating the coordination from the co-ordinated objects CoLaS provides a better abstraction and reuse of the coordination and the coordinated objects. Moreover CoLaS's high dynamicity provides better support for coordination of active objects.},
|
|
1661 |
annote = {internationalconference},
|
|
1662 |
author = {Juan-Carlos Cruz and St\'ephane Ducasse},
|
|
1663 |
booktitle = {Proceedings of Coordination '99},
|
|
1664 |
pages = {355--371},
|
|
1665 |
publisher = {Springer-Verlag},
|
|
1666 |
series = {LNCS},
|
|
1667 |
misc = {Core A},
|
|
1668 |
title = {A Group Based Approach for Coordinating Active Objects},
|
|
1669 |
url = {http://scg.unibe.ch/archive/papers/Cruz99aGroupBasedApproach.pdf},
|
|
1670 |
volume = {1594},
|
|
1671 |
year = {1999}
|
|
1672 |
}
|
|
1673 |
|
|
1674 |
@inproceedings{Cruz99b,
|
|
1675 |
abstract = {Open Distributed Systems are the dominating intellectual issue of the end of this century. Figuring out how to build those systems will become a central issue in distributed system research in the next future. Although CORBA seems to provide all the necessary support to construct those systems. It provides a very limited support to the evolution of requirements in those systems. The main problem is that the description of the elements from which systems are built, and the way in which they are composed are mixed into the application code. Making them difficult to understand, modify and customize. We think that a solution to this problem goes through the introduction of the so called coordination models and languages into the CORBA model. We propose in this paper the introduction of our object coordination model called CoLaS into the CORBA model.},
|
|
1676 |
annote = {internationalworkshop},
|
|
1677 |
author = {Juan-Carlos Cruz and St\'ephane Ducasse},
|
|
1678 |
booktitle = {Proceedings of International Workshop in Future Trends in Distributed Computing Systems '99},
|
|
1679 |
doi = {10.1109/FTDCS.1999.818794},
|
|
1680 |
keywords = {olit scg-pub scg-coord-99 snf99 jb99 stefPub},
|
|
1681 |
title = {Coordinating Open Distributed Systems},
|
|
1682 |
url = {http://scg.unibe.ch/archive/papers/Cruz99FTDCS.pdf},
|
|
1683 |
year = {1999}
|
|
1684 |
}
|
|
1685 |
|
|
1686 |
|
|
1687 |
@inproceedings{Cuts09a,
|
|
1688 |
author = {van Cutsem, Tom and Alexandre Bergel and St\'ephane Ducasse and De Meuter, Wolfgang},
|
|
1689 |
booktitle = {Proceedings of ECOOP 2009},
|
|
1690 |
keywords = {traits alexPub stefPub},
|
|
1691 |
editor = {Sophia Drossopoulou},
|
|
1692 |
publisher = {Springer},
|
|
1693 |
annote = {internationalconference topconference},
|
|
1694 |
series = {Lecture Notes in Computer Science},
|
|
1695 |
title = {Adding State and Visibility Control to Traits using Lexical Nesting},
|
|
1696 |
year = {2009},
|
|
1697 |
url = {http://rmod.lille.inria.fr/archives/papers/Cuts09a-ECOOP09-Traits.pdf},
|
|
1698 |
aeres = {ACT},
|
|
1699 |
aeresstatus = {aeres12},
|
|
1700 |
selectif = {oui},
|
|
1701 |
rate = {21%},
|
|
1702 |
misc = {21%},
|
|
1703 |
labo = {dans},
|
|
1704 |
inria = {RMOD},
|
|
1705 |
inriareport = {2009},
|
|
1706 |
x-editorial-board = {yes},
|
|
1707 |
x-proceedings = {yes},
|
|
1708 |
x-international-audience = {yes},
|
|
1709 |
x-pays = {BE},
|
|
1710 |
x-country = {BE},
|
|
1711 |
x-language = {EN},
|
|
1712 |
address = {London, UK},
|
|
1713 |
abstract = {Traits are reusable building blocks that can be composed to share methods across unrelated class hierarchies. Original traits are stateless and cannot express visibility control for methods. Two extensions, stateful traits and freezable traits, have been proposed to overcome these limitations. However, these extensions introduce complexity and have not yet been combined to simultaneously add both state and visibility control to traits.
|
|
1714 |
This paper revisits the addition of state and visibility control to traits. Rather than extending the original traits model with additional operations, we allow traits to be lexically nested within other modules. Traits can then have (shared) state and visibility control by hiding variables or methods in their lexical scope. Although the Traits' flattening property has to be revisited, the combination of traits with lexical nesting results in a simple and expressive trait model. We discuss an implementation of the model in AmbientTalk and specify its operational semantics.},
|
|
1715 |
hal-id = {inria-00498397 / v?f3e59}
|
|
1716 |
}
|
|
1717 |
|
|
1718 |
@inproceedings{Deme00a,
|
|
1719 |
abstract = {Reverse engineering is the process of uncovering the design and the design rationale from a functioning software system. Reverse engineering is an integral part of any successful software system, because changing requirements lead to implementations that drift from their original design. In contrast to traditional reverse engineering techniques -which analyse a single snapshot of a system- we focus the reverse engineering effort by determining where the implementation has changed. Since changes of object-oriented software are often phrased in terms of refactorings, we propose a set of heuristics for detecting refactorings by applying lightweight, object-oriented metrics to successive versions of a software system. We validate our approach with three separate case studies of mature object-oriented software systems for which multiple versions are available. The case studies suggest that the heuristics support the reverse engineering process by focusing attention on the relevant parts of a software system.},
|
|
1720 |
address = {New York NY},
|
|
1721 |
annote = {internationalconference topconference},
|
|
1722 |
author = {Serge Demeyer and St\'ephane Ducasse and Oscar
|
|
1723 |
Nierstrasz},
|
|
1724 |
booktitle = {Proceedings of 15th International Conference on
|
|
1725 |
Object-Oriented Programming, Systems, Languages, and
|
|
1726 |
Applications (OOPSLA '00)},
|
|
1727 |
doi = {10.1145/353171.353183},
|
|
1728 |
keywords = {olit scg-pub jb00 snf00 oorp stefPub moose-pub},
|
|
1729 |
misc = {acceptance rate: 26/142 = 18\%, SCI impact factor
|
|
1730 |
0.190, ranked 66/77},
|
|
1731 |
accepttotal = {142},
|
|
1732 |
acceptnum = {26},
|
|
1733 |
note = {Also in ACM SIGPLAN Notices 35 (10)},
|
|
1734 |
pages = {166--178},
|
|
1735 |
publisher = {ACM Press},
|
|
1736 |
title = {Finding Refactorings via Change Metrics},
|
|
1737 |
url = {http://scg.unibe.ch/archive/papers/Deme00aFindingRefactoring.pdf},
|
|
1738 |
year = {2000}
|
|
1739 |
}
|
|
1740 |
|
|
1741 |
@inproceedings{Deme00d,
|
|
1742 |
abstract = {Since object-oriented programming is usually associated with iterative development, reverse engineering must be considered an essential facet of the object-oriented paradigm. The reverse engineering pattern language presented here summarises the reverse engineering experience gathered as part of the FAMOOS project, a project with the explicit goal of investigating reverse and reengineering techniques in an object-oriented context. Due to limitations on EuroPLOP submissions, only part of the full pattern language is presented, namely the patterns describing how to gain an initial understanding of a software system.},
|
|
1743 |
annote = {internationalworkshop},
|
|
1744 |
author = {Serge Demeyer and St\'ephane Ducasse and Oscar Nierstrasz},
|
|
1745 |
booktitle = {Proceedings of EuroPLoP '2000},
|
|
1746 |
isbn = {3-87940-775-4},
|
|
1747 |
keywords = {snf-none stefPub olit scg-pub skip-doi jb00},
|
|
1748 |
pages = {189--208},
|
|
1749 |
publisher = {UVK GmbH},
|
|
1750 |
title = {A Pattern Language for Reverse Engineering},
|
|
1751 |
url = {http://scg.unibe.ch/archive/papers/Deme00dRevEng.pdf},
|
|
1752 |
year = {2000}
|
|
1753 |
}
|
|
1754 |
|
|
1755 |
@techreport{Deme01y,
|
|
1756 |
annote = {report notrefereed},
|
|
1757 |
author = {Serge Demeyer and Sander Tichelaar and St\'ephane Ducasse},
|
|
1758 |
institution = {University of Bern},
|
|
1759 |
title = {{FAMIX} 2.1 --- {The} {FAMOOS} {Information} {Exchange} {Model}},
|
|
1760 |
year = {2001}
|
|
1761 |
}
|
|
1762 |
|
|
1763 |
@book{Deme02a,
|
|
1764 |
abstract = {The rapid growth of object-oriented development over the past twenty years has given rise to many object-oriented systems that are large, complex and hard to maintain. Object-Oriented Reengineering Patterns addresses the problem of understanding and reengineering such object-oriented legacy systems. This book collects and distills successful techniques in planning a reengineering project, reverse-engineering, problem detection, migration strategies and software redesign. The material in this book is presented as a set of "reengineering patterns" --- recurring solutions that experts apply while reengineering and maintaining object-oriented systems. The principles and techniques described in this book have been observed and validated in a number of industrial projects, and reflect best practice in object-oriented reengineering.},
|
|
1765 |
annote = {book},
|
|
1766 |
author = {Serge Demeyer and St{\'e}phane Ducasse and Oscar Nierstrasz},
|
|
1767 |
isbn = {1-55860-639-4},
|
|
1768 |
publisher = {Morgan Kaufmann},
|
|
1769 |
title = {Object-Oriented Reengineering Patterns},
|
|
1770 |
url = {http://www.iam.unibe.ch/~scg/OORP},
|
|
1771 |
year = {2002}
|
|
1772 |
}
|
|
1773 |
|
|
1774 |
@inproceedings{Deme03a,
|
|
1775 |
annote = {workshopproceedings},
|
|
1776 |
author = {Serge Demeyer and St\'ephane Ducasse and Kim Mens and Adrian Trifu and Rajesh Vasa},
|
|
1777 |
booktitle = {Object-Oriented Technology (ECOOP'03 Workshop Reader)},
|
|
1778 |
publisher = {Springer-Verlag},
|
|
1779 |
pages = {72-85},
|
|
1780 |
series = {LNCS},
|
|
1781 |
title = {Report of the {ECOOP}'03 Workshop on Object-Oriented Reengineering},
|
|
1782 |
year = {2003}
|
|
1783 |
}
|
|
1784 |
|
|
1785 |
@misc{Deme03b,
|
|
1786 |
annote = {workshopproceedings},
|
|
1787 |
author = {Wolfgang Demeuter and St\'ephane Ducasse and Theo D'hondt and Ole Lehrmann Madsen},
|
|
1788 |
booktitle = {Object-Oriented Technology (ECOOP'03 Workshop Reader)},
|
|
1789 |
publisher = {Springer-Verlag},
|
|
1790 |
series = {LNCS},
|
|
1791 |
title = {Report of the {ECOOP}'03 Workshop on Object-Oriented Language Engineering in Post-Java Era},
|
|
1792 |
year = {2003}
|
|
1793 |
}
|
|
1794 |
|
|
1795 |
@inproceedings{Deme05a,
|
|
1796 |
abstract = {The notion of refactoring --- transforming the source-code of an object-oriented program without changing its external behaviour --- has been studied intensively within the last decade. This diversity has created a plethora of toy-examples, cases and code snippets, which make it hard to assess the current state-of-the-art. Moreover, due to this diversity, there is currently no accepted way of teaching good refactoring practices, despite the acknowledgment in the software engineering body of knowledge. Therefore, this paper presents a common example --- the LAN simulation --- which has been used by a number of European Universities for both research and teaching purposes.},
|
|
1797 |
address = {Los Alamitos CA},
|
|
1798 |
aeres = {ACT},
|
|
1799 |
aeresstatus = {aeres08},
|
|
1800 |
annote = {internationalworkshop},
|
|
1801 |
author = {Serge Demeyer and Filip Van Rysselberghe and Tudor G\^irba and Jacek Ratzinger and Radu Marinescu and Tom Mens and Bart Du Bois and Dirk Janssens and St\'ephane Ducasse and Michele Lanza and Matthias Rieger and Harald Gall and Michel Wermelinger and Mohammad El-Ramly},
|
|
1802 |
booktitle = {Proceedings of IWPSE 2005 (8th International
|
|
1803 |
Workshop on Principles of Software Evolution)},
|
|
1804 |
doi = {10.1109/IWPSE.2005.30},
|
|
1805 |
inri = {hors},
|
|
1806 |
location = {Lisbon, Portugal},
|
|
1807 |
misc = {acceptance rate: 13/54=24\%},
|
|
1808 |
accepttotal = {54},
|
|
1809 |
acceptnum = {13},
|
|
1810 |
pages = {123--131},
|
|
1811 |
publisher = {IEEE Computer Society Press},
|
|
1812 |
rate = {24%},
|
|
1813 |
selectif = {oui},
|
|
1814 |
title = {The {LAN}-simulation: A Research and Teaching Example for Refactoring},
|
|
1815 |
url = {http://scg.unibe.ch/archive/papers/Deme05aLANRefactoring.pdf},
|
|
1816 |
year = {2005}
|
|
1817 |
}
|
|
1818 |
|
|
1819 |
@misc{Deme05b,
|
|
1820 |
abstract = {Surprising as it may seem, many of the early adopters of the object-oriented paradigm already face a number of problems typically encountered in large-scale legacy systems. Software engineers are now confronted with millions of lines of industrial source code, developed using object-oriented design methods and languages of the late 80s and early 90s. These systems exhibit a range of problems, effectively preventing them from satisfying the evolving requirements imposed by their customers. This paper shares our knowledge concerning the reengineering of object-oriented legacy systems. We draw upon our experiences, to show you techniques and tools we have applied on real industrial OO systems to detect and repair problems. In particular, we discuss issues like reverse engineering, design extraction, metrics, refactoring and program visualisation.},
|
|
1821 |
address = {Washington, DC, USA},
|
|
1822 |
annote = {tutorial},
|
|
1823 |
author = {Serge Demeyer and St\'{e}phane Ducasse and Oscar
|
|
1824 |
Nierstrasz},
|
|
1825 |
booktitle = {ICSM '05: Proceedings of the 21st IEEE International
|
|
1826 |
Conference on Software Maintenance},
|
|
1827 |
doi = {10.1109/ICSM.2005.67},
|
|
1828 |
isbn = {0-7695-2368-4},
|
|
1829 |
keywords = {scg-misc jb-none tutorial},
|
|
1830 |
note = {tutorial},
|
|
1831 |
pages = {723--724},
|
|
1832 |
publisher = {IEEE Computer Society},
|
|
1833 |
title = {Object-Oriented Reengineering: Patterns and
|
|
1834 |
Techniques},
|
|
1835 |
url = {http://scg.unibe.ch/archive/papers/Deme05bOORP-Tutorial.pdf},
|
|
1836 |
year = {2005},
|
|
1837 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Deme05bOORP-Tutorial.pdf},
|
|
1838 |
bdsk-url-2 = {http://dx.doi.org/10.1109/ICSM.2005.67}
|
|
1839 |
}
|
|
1840 |
|
|
1841 |
@inproceedings{Deme06a,
|
|
1842 |
annote = {workshopproceedings},
|
|
1843 |
author = {Serge Demeyer and Kim Mens and Roel Wuyts and
|
|
1844 |
Yann-Ga\"el Gu\'e{e}h\'{e}neuc and Andy Zaidman and
|
|
1845 |
Neil Walkinshaw and Ademar Aguiar and St\'ephane
|
|
1846 |
Ducasse},
|
|
1847 |
booktitle = {Object-Oriented Technology. ECOOP'05 Workshop
|
|
1848 |
Reader},
|
|
1849 |
keywords = {scg-pub skip-abstract skip-doi jb-none stefPub},
|
|
1850 |
title = {Report of the 6th ECOOP'05 Workshop on
|
|
1851 |
Object-Oriented Reengineering},
|
|
1852 |
url = {http://www.info.ucl.ac.be/~km/MyResearchPages/publications/workshop_report/WR_2006_ECOOP2005_WOOR.pdf},
|
|
1853 |
year = {2006},
|
|
1854 |
bdsk-url-1 = {http://www.info.ucl.ac.be/~km/MyResearchPages/publications/workshop_report/WR_2006_ECOOP2005_WOOR.pdf}
|
|
1855 |
}
|
|
1856 |
|
|
1857 |
@book{Deme08a,
|
|
1858 |
abstract = {The rapid growth of object-oriented development over the past twenty years has given rise to many object-oriented systems that are large, complex and hard to maintain. Object-Oriented Reengineering Patterns addresses the problem of understanding and reengineering such object-oriented legacy systems. This book collects and distills successful techniques in planning a reengineering project, reverse-engineering, problem detection, migration strategies and software redesign. The material in this book is presented as a set of "reengineering patterns" --- recurring solutions that experts apply while reengineering and maintaining object-oriented systems. The principles and techniques described in this book have been observed and validated in a number of industrial projects, and reflect best practice in object-oriented reengineering.},
|
|
1859 |
annote = {book},
|
|
1860 |
author = {Serge Demeyer and St{\'e}phane Ducasse and Oscar Nierstrasz},
|
|
1861 |
isbn = {978-3-9523341-2-6},
|
|
1862 |
keywords = {olit scg08 scg-pub snf-none jb09 skip-doi stefPub mooseCincom moose-pub},
|
|
1863 |
medium = {2},
|
|
1864 |
peerreview = {no},
|
|
1865 |
publisher = {Square Bracket Associates},
|
|
1866 |
title = {Object-Oriented Reengineering Patterns},
|
|
1867 |
url = {http://scg.unibe.ch/download/oorp/},
|
|
1868 |
year = {2008}
|
|
1869 |
}
|
|
1870 |
|
|
1871 |
@unpublished{Deme97z,
|
|
1872 |
abstract = {Applying object-oriented design methods and languages does not guarantee that the resulting software systems will be flexible and adaptable. The industrial partners in the FAMOOS project have learned this lesson the hard way: they are now faced with large and rigid software systems that hamper them in meeting a diverse and evolving set of customer requirements. Object-oriented frameworks are touted as a promising solution, but it is unclear how to transform object-oriented legacy systems into frameworks. This paper proposes an approach --i.e, a methodology and tools-- for re-engineering object-oriented systems towards frameworks by means of high-level and low-level restructuring transformations that detect and resolve architectural and detailed design anomalies, and improve application flexibility and adaptability.},
|
|
1873 |
author = {Serge Demeyer and St\'ephane Ducasse and Robb Nebbe
|
|
1874 |
and Oscar Nierstrasz and Tamar Richner},
|
|
1875 |
keywords = {olit famoos-techrep scg-wp skip-doi snf97
|
|
1876 |
sergedem-techrep},
|
|
1877 |
month = may,
|
|
1878 |
note = {technical report},
|
|
1879 |
title = {Using Restructuring Transformations to Reengineer
|
|
1880 |
Object-Oriented Systems},
|
|
1881 |
url = {http://www.iam.unibe.ch/~demeyer/Deme97z/index.html
|
|
1882 |
http://scg.unibe.ch/archive/papers/Deme97zWCRE.pdf},
|
|
1883 |
year = {1997}
|
|
1884 |
}
|
|
1885 |
|
|
1886 |
@inproceedings{Deme98n,
|
|
1887 |
annote = {internationalworkshop},
|
|
1888 |
author = {Serge Demeyer and St\'ephane Ducasse},
|
|
1889 |
booktitle = {Object-Oriented Technology (ECOOP '98 Workshop
|
|
1890 |
Reader)},
|
|
1891 |
editor = {Serge Demeyer and Jan Bosch},
|
|
1892 |
keywords = {olit famoos-papunr scg-pub skip-pdf skip-abstract
|
|
1893 |
skip-doi snf98 metrics jb98 stefPub},
|
|
1894 |
pages = {247--249},
|
|
1895 |
publisher = {Springer-Verlag},
|
|
1896 |
series = {LNCS},
|
|
1897 |
title = {Do Metrics Support Framework Development?},
|
|
1898 |
volume = {1543},
|
|
1899 |
year = {1998}
|
|
1900 |
}
|
|
1901 |
|
|
1902 |
@inproceedings{Deme99a,
|
|
1903 |
abstract = {Maturing a well designed framework requires a set of software metrics to steer the iterative development process. Based on a case study of the VisualWorks/Smalltalk framework for user-interface building, we conclude that today's size and inheritance metrics are not reliable to detect problems but are useful in measuring stability. We expect that this work will contribute to the application of metrics as a project management tool.},
|
|
1904 |
annote = {nationalconference},
|
|
1905 |
author = {Serge Demeyer and St\'ephane Ducasse},
|
|
1906 |
booktitle = {Proceedings of Languages et Mod\`eles \`a Objets (LMO'99)},
|
|
1907 |
editor = {Jacques Malenfant},
|
|
1908 |
keywords = {olit famoos-papref scg-pub skip-doi snf99 jb99 oorp
|
|
1909 |
stefPub moose-pub},
|
|
1910 |
pages = {69--82},
|
|
1911 |
publisher = {HERMES Science Publications, Paris},
|
|
1912 |
title = {Metrics, Do They Really Help?},
|
|
1913 |
url = {http://scg.unibe.ch/archive/papers/Deme99aDemeyerDucasseLMO99.pdf},
|
|
1914 |
year = {1999},
|
|
1915 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Deme99aDemeyerDucasseLMO99.pdf}
|
|
1916 |
}
|
|
1917 |
|
|
1918 |
@inproceedings{Deme99c,
|
|
1919 |
abstract = {Surprising as it may seem, many of the early adopters of the object-oriented paradigm already face a number of problems typically encountered in large-scale legacy systems. Consequently, reverse engineering techniques are relevant in an object-oriented context as well. This paper investigates a hybrid approach, combining the immediate appeal of visualisations with the scalability of metrics. We validate such a hybrid approach by showing how CodeCrawler ---the experimental platform we built--- allowed us to understand the program structure of, and identify potential design anomalies in a public domain software system.},
|
|
1920 |
annote = {internationalconference},
|
|
1921 |
author = {Serge Demeyer and St\'ephane Ducasse and Michele
|
|
1922 |
Lanza},
|
|
1923 |
booktitle = {Proceedings of 6th Working Conference on Reverse
|
|
1924 |
Engineering (WCRE '99)},
|
|
1925 |
doi = {10.1109/WCRE.1999.806958},
|
|
1926 |
editor = {Francoise Balmas and Mike Blaha and Spencer Rugaber},
|
|
1927 |
keywords = {olit famoos-papref scg-pub snf99 jb99 oorp stefPub
|
|
1928 |
moose-pub},
|
|
1929 |
month = oct,
|
|
1930 |
publisher = {IEEE Computer Society},
|
|
1931 |
title = {A Hybrid Reverse Engineering Platform Combining
|
|
1932 |
Metrics and Program Visualization},
|
|
1933 |
url = {http://scg.unibe.ch/archive/papers/Deme99cCodeCrawler.pdf},
|
|
1934 |
year = {1999}
|
|
1935 |
}
|
|
1936 |
|
|
1937 |
@inproceedings{Deme99d,
|
|
1938 |
abstract = {UML is currently embraced as "the" standard in object-oriented modeling languages, the recent work of OMG on the Meta Object Faci lity (MOF) being the most noteworthy example. We welcome these standardisation efforts, yet warn against the tendency to use UML as the panacea for all exchange standards. In particular, we argue that UML is not sufficient to serve as a tool-interoperability standard for integrating round-trip engineering tools, because one is forced to rely on UML's built-in extension mechanisms to a dequately model the reality in source-code. Meanwhile, our argumentation includes a number of constructive suggestions that we ho pe will influence future releases of the UML and MOF standards.},
|
|
1939 |
address = {Kaiserslautern, Germany},
|
|
1940 |
annote = {internationalconference},
|
|
1941 |
author = {Serge Demeyer and St\'ephane Ducasse and Sander
|
|
1942 |
Tichelaar},
|
|
1943 |
booktitle = {Proceedings UML '99 (The Second International
|
|
1944 |
Conference on The Unified Modeling Language)},
|
|
1945 |
editor = {Bernhard Rumpe},
|
|
1946 |
keywords = {olit famoos-papref scg-pub skip-doi snf99 jb99
|
|
1947 |
stefPub moose-pub},
|
|
1948 |
misc = {acceptance rate: 44/166 = 26\%, SCI impact 0.515, ranked 39/69},
|
|
1949 |
accepttotal = {166},
|
|
1950 |
acceptnum = {44},
|
|
1951 |
month = oct,
|
|
1952 |
pages = {630--644},
|
|
1953 |
publisher = {Springer-Verlag},
|
|
1954 |
series = {LNCS},
|
|
1955 |
title = {Why Unified is not Universal. {UML} Shortcomings for
|
|
1956 |
Coping with Round-trip Engineering},
|
|
1957 |
url = {http://scg.unibe.ch/archive/papers/Deme99dUML99.pdf},
|
|
1958 |
volume = {1723},
|
|
1959 |
year = {1999},
|
|
1960 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Deme99dUML99.pdf}
|
|
1961 |
}
|
|
1962 |
|
|
1963 |
@inproceedings{Deme99n,
|
|
1964 |
abstract = {This pattern language describes how to reverse engineer an object-oriented software system. Since the only way to achieve a truly reusable object-oriented design is recognised to be iterative development, reverse engineering is indeed an essential facet of any object-oriented development process. The pattern language itself covers the different phases one encounters when reverse engineering a large software system: from being unfamiliar with a software system up untill preparations for actual reengineering. What you read here is a short version of a complete pattern language. We present only five patterns in full detail and include a summary for the remaining patterns.},
|
|
1965 |
address = {Konstanz, Germany},
|
|
1966 |
annote = {internationalworkshop},
|
|
1967 |
author = {Serge Demeyer and St\'ephane Ducasse and Sander Tichelaar},
|
|
1968 |
booktitle = {Proceedings of the 4th European Conference on Pattern Languages of Programming and Computing},
|
|
1969 |
editor = {Paul Dyson},
|
|
1970 |
keywords = {scg-pub skip-doi stefPub},
|
|
1971 |
month = jul,
|
|
1972 |
publisher = {UVK Universit\"atsverlag Konstanz GmbH},
|
|
1973 |
title = {A Pattern Language for Reverse Engineering},
|
|
1974 |
url = {http://scg.unibe.ch/archive/papers/Deme99nEuroplop99.pdf},
|
|
1975 |
year = {1999}
|
|
1976 |
}
|
|
1977 |
|
|
1978 |
@inproceedings{Deni04a,
|
|
1979 |
address = {Paris, France},
|
|
1980 |
author = {Simon Denier},
|
|
1981 |
booktitle = {Actes de la Premi\`ere Journ\'ee Francophone sur le D\'eveloppement du Logiciel par Aspects (JFDLPA'04)},
|
|
1982 |
editor = {Pierre Cointe},
|
|
1983 |
month = sep,
|
|
1984 |
pages = {62--78},
|
|
1985 |
title = {Traits Programming with {AspectJ}},
|
|
1986 |
url = {http://www.emn.fr/x-info/obasco/events/jfdlpa04/},
|
|
1987 |
year = {2004},
|
|
1988 |
bdsk-url-1 = {http://www.emn.fr/x-info/obasco/events/jfdlpa04/}
|
|
1989 |
}
|
|
1990 |
|
|
1991 |
@inproceedings{Deni09a,
|
|
1992 |
title = {Understanding the Use of Inheritance with Visual Patterns},
|
|
1993 |
author = {Simon Denier and Houari A. Sahraoui},
|
|
1994 |
booktitle = {Proceedings of the 3rd International Symposium on Empirical Software Engineering and Measurement (ESEM 2009)},
|
|
1995 |
editor = {James Miller and Rick Selby},
|
|
1996 |
publisher = {IEEE Computer Society Press},
|
|
1997 |
address = {Lake Buena Vista, FL, USA},
|
|
1998 |
year = {2009},
|
|
1999 |
inriareport = {2009},
|
|
2000 |
keywords = {lse-pub remoose},
|
|
2001 |
annote = {internationalconference},
|
|
2002 |
aeres = {ACT},
|
|
2003 |
aeresstatus = {aeres12},
|
|
2004 |
selectif = {non},
|
|
2005 |
labo = {dans},
|
|
2006 |
inria = {RMOD},
|
|
2007 |
rate = {39\%},
|
|
2008 |
x-editorial-board = {yes},
|
|
2009 |
x-proceedings = {yes},
|
|
2010 |
x-international-audience = {yes},
|
|
2011 |
x-language = {EN},
|
|
2012 |
x-country = {FR},
|
|
2013 |
x-pays = {CA},
|
|
2014 |
url = {http://rmod.lille.inria.fr/archives/papers/Deni09a-ESEM09-VisuInheritance.pdf},
|
|
2015 |
abstract = {The goal of this work is to visualize inheritance in object-oriented programs to help its comprehension. We propose a single, compact view of all class hierarchies at once using a custom Sunburst layout. It enables to quickly discover interesting facts across classes while preserving the essential relationship between parent and children classes. We explain how standard inheritance metrics are mapped into our visualization. Additionally, we define a new metric characterizing similar children classes. Using these metrics and the proposed layout, a set of common visual patterns is derived. These patterns allow the programmer to quickly understand how inheritance is used and provide answers to some essential questions when performing program comprehension tasks. Our approach is evaluated through a case study that involves examples from large programs, demonstrating its scalability.}
|
|
2016 |
}
|
|
2017 |
|
|
2018 |
@inproceedings{Deni09b,
|
|
2019 |
title = {Proposals for the Reborn Pharo Developer},
|
|
2020 |
author = {Simon Denier and Damien Pollet and St\'ephane Ducasse},
|
|
2021 |
booktitle = {Proceedings of ESUG International Workshop on Smalltalk Technologies (IWST 2009)},
|
|
2022 |
year = {2009},
|
|
2023 |
keywords = {lse-pub pharo-pub},
|
|
2024 |
annote = {internationalworkshop},
|
|
2025 |
aeres = {ACT},
|
|
2026 |
aeresstatus = {aeres12},
|
|
2027 |
selectif = {non},
|
|
2028 |
labo = {dans},
|
|
2029 |
inria = {RMOD},
|
|
2030 |
inriareport = {2009},
|
|
2031 |
x-editorial-board = {yes},
|
|
2032 |
x-proceedings = {yes},
|
|
2033 |
x-international-audience = {yes},
|
|
2034 |
url = {http://rmod.lille.inria.fr/archives/workshops/Deni09b-IWST09-PharoBrowsers.pdf},
|
|
2035 |
x-country = {FR},
|
|
2036 |
x-language = {EN},
|
|
2037 |
address = {Brest, France},
|
|
2038 |
abstract = {No abstract}
|
|
2039 |
}
|
|
2040 |
|
|
2041 |
@proceedings{Deni09c,
|
|
2042 |
title = {Proceedings of the 3rd Workshop on FAMIX and MOOSE in Software Reengineering (FAMOOSr 2009)},
|
|
2043 |
author = {Simon Denier and Tudor G\^irba},
|
|
2044 |
editor = {Simon Denier and Tudor G\^irba},
|
|
2045 |
pages = {27},
|
|
2046 |
year = {2009},
|
|
2047 |
keywords = {moose-pub lse-pub},
|
|
2048 |
annote = {workshopproceedings},
|
|
2049 |
aeres = {AP},
|
|
2050 |
aeresstatus = {aeres12},
|
|
2051 |
labo = {dans},
|
|
2052 |
inria = {RMOD},
|
|
2053 |
inriareport = {2009},
|
|
2054 |
x-editorial-board = {yes},
|
|
2055 |
x-proceedings = {yes},
|
|
2056 |
x-international-audience = {yes},
|
|
2057 |
x-language = {EN},
|
|
2058 |
x-pays = {CH},
|
|
2059 |
url = {http://rmod.lille.inria.fr/archives/workshops/Deni09c-famoosr09-proceedings.pdf},
|
|
2060 |
abstract = {The increasing amount of data available about software systems poses new challenges for re- and reverse engineering research, as the proposed approaches need to scale. In this context, concerns about meta-modeling and analysis techniques need to be augmented by technical concerns about how to reuse and how to build upon the efforts of previous research. MOOSE is an extensive infrastructure for reverse engineering evolved for over 10 years that promotes the reuse of engineering efforts in research. MOOSE accommodates various types of data modeled in the FAMIX family of meta-models. The goal of this half-day workshop is to strengthen the community of researchers and practitioners who are working in re- and reverse engineering, by providing a forum for building future research starting from MOOSE and FAMIX as shared infrastructure.}
|
|
2061 |
}
|
|
2062 |
|
|
2063 |
@techreport{Deni10a,
|
|
2064 |
author = {Simon Denier and Jannik Laval and St\'ephane Ducasse and Fabrice Bellingard},
|
|
2065 |
title = {Technical and Economical Model (Squale Deliverable 2.1)},
|
|
2066 |
institution = {INRIA},
|
|
2067 |
inriareport = {2010},
|
|
2068 |
year = {2010},
|
|
2069 |
type_rapport = {Rapport technique},
|
|
2070 |
abstract = {No abstract},
|
|
2071 |
hal-id = {inria-00533656}
|
|
2072 |
}
|
|
2073 |
|
|
2074 |
@techreport{Deni10b,
|
|
2075 |
author = {Simon Denier and Jannik Laval and St\'ephane Ducasse and Fabrice Bellingard},
|
|
2076 |
title = {Technical Model for Remediation (Squale Deliverable 2.2)},
|
|
2077 |
institution = {INRIA},
|
|
2078 |
inriareport = {2010},
|
|
2079 |
year = {2010},
|
|
2080 |
type_rapport = {Rapport technique},
|
|
2081 |
abstract = {No abstract},
|
|
2082 |
hal-id = {inria-00533659}
|
|
2083 |
}
|
|
2084 |
|
|
2085 |
@inproceedings{Denk00a,
|
|
2086 |
abstract = {Mittels CORBA k\"onnen verteilte Applikationen einfach \"uber ein Netzwerk miteinander kommunizieren. Doch das von CORBA zur Verf\"ugung gestellte Kommunikationsmodell reicht in manchen F\"allen nicht aus, es wird ein Modell zur asynchronen Kommunikation zwischen lose gekoppelten Objekten ben\"otigt. Der CORBA Event Service ist ein Versuch, ein solches Kommunikationsmodell bereitzustellen. Der Event Service hat sich aber als unzureichend herausgestellt. Daher wurde er um einige Aspekte zum Notiocation Service erweitert.},
|
|
2087 |
author = {Marcus Denker},
|
|
2088 |
booktitle = {Architektur vernetzter Systeme},
|
|
2089 |
issn = {1432-7864},
|
|
2090 |
page = {7--13},
|
|
2091 |
keywords = {marcusdenker fromscgbib},
|
|
2092 |
publisher = {Universit\"at Karlsruhe, Institut fuer Telematik (Interner Bericht)},
|
|
2093 |
title = {Event und Notification Service in CORBA},
|
|
2094 |
url = {http://rmod.lille.inria.fr/archives/reports/Denk00a-TechReport-Corba.pdf},
|
|
2095 |
year = {2000}
|
|
2096 |
}
|
|
2097 |
|
|
2098 |
@article{Denk01a,
|
|
2099 |
author = {Marcus Denker},
|
|
2100 |
journal = {Der Eulenspiegel},
|
|
2101 |
number = {2},
|
|
2102 |
keywords = {Etoys Squeak Education marcusdenker fromscgbib},
|
|
2103 |
annote = {notrefereed},
|
|
2104 |
selectif = {non},
|
|
2105 |
publisher = {Fachschaft Mathematik/Informatik, University of Karlsruhe},
|
|
2106 |
title = {Squeak: Zurück in die Zukunft},
|
|
2107 |
url = {http://rmod.lille.inria.fr/archives/popular/Denk01a-EulenSpiegel-Squeak.pdf},
|
|
2108 |
volume = {2001},
|
|
2109 |
year = {2001}
|
|
2110 |
}
|
|
2111 |
|
|
2112 |
@misc{Denk02a,
|
|
2113 |
abstract = {Das Squeak-System m\"ochte eine flexible Programmierumgebung und ein m\"achtiges multimediales Autorensystem f\"ur Kinder bereitstellen. Die besonderen Eigenschaften eines solchen Systems stellen besondere Anforderungen an die Implementierung. Die Studienarbeit zeigt die Probleme der bestehenden Implementierungen auf und stellt einen verbesserten Entwurf vor.},
|
|
2114 |
author = {Marcus Denker},
|
|
2115 |
keywords = {Squeak marcusdenker fromscgbib},
|
|
2116 |
note = {Studienarbeit, Universit\"at Karlsruhe},
|
|
2117 |
title = {Entwurf von Optimierungen f\"ur Squeak},
|
|
2118 |
url = {http://rmod.lille.inria.fr/archives/reports/Denk02a-Studienarbeit-J3.pdf},
|
|
2119 |
year = {2002}
|
|
2120 |
}
|
|
2121 |
|
|
2122 |
@mastersthesis{Denk04a,
|
|
2123 |
author = {Marcus Denker},
|
|
2124 |
school = {University of Karlsruhe},
|
|
2125 |
title = {Erweiterung eines statischen \"Ubersetzers zu einem
|
|
2126 |
Laufzeit\"ubersetzungssystem},
|
|
2127 |
type = {diploma thesis},
|
|
2128 |
keywords = {marcusdenker fromscgbib},
|
|
2129 |
url = {http://rmod.lille.inria.fr/archives/reports/Denk04a-Thesis-Karlsruhe.pdf},
|
|
2130 |
year = {2004}
|
|
2131 |
}
|
|
2132 |
|
|
2133 |
@inproceedings{Denk04b,
|
|
2134 |
abstract = {This is not a real article. While putting together
|
|
2135 |
the demo image for for 21C3, I decided to not write
|
|
2136 |
an article that is just to be read (mostly because
|
|
2137 |
these are really boring to write...) This text is
|
|
2138 |
just a short user manual for that thing (we call it
|
|
2139 |
Squeak Image) that I will use for the demo at 21C3.
|
|
2140 |
So if you follow the instructions, you will be able
|
|
2141 |
to go through the slides and play with everything
|
|
2142 |
yourself.},
|
|
2143 |
author = {Marcus Denker},
|
|
2144 |
keywords = {fromscgbib marcusdenker},
|
|
2145 |
booktitle = {Proceedings of the 21st Chaos Communication
|
|
2146 |
Congress},
|
|
2147 |
isbn = {3-934636-02-0},
|
|
2148 |
page = {52--59},
|
|
2149 |
publisher = {Chaos Computer Club},
|
|
2150 |
title = {Squeak@21c3},
|
|
2151 |
url = {http://rmod.lille.inria.fr/archives/popular/Denk04b-21C3-Squeak.pdf},
|
|
2152 |
year = {2004}
|
|
2153 |
}
|
|
2154 |
|
|
2155 |
@inproceedings{Denk05a,
|
|
2156 |
abstract = {Squeak allows kids of all ages to be creative with their computer. The goal of the Squeak Project is to build a system without constraints: It is used at schools, universities and in industry. Squeak is an open System: It is implemented in Squeak itself, all parts are available for learning and hacking. The whole source code is available and can be changed while the system is running. Squeak is available on the internet under a free license, it is highly portable and currently used on over 20 different platforms. This talk will give an overview over the Squeak Project: From the eToy kids programming environment up to the Seaside system for professional web development. The eToys make programming fun for children from around age 8. The talk will show how to build simple eToy programs and how Squeak is used at school. But even professional developers are using Squeak; The Seaside framework shows how the openness of Squeak can help to make developers more productive. The last part of the talk will give a glimpse into the future: OpenCroquet. The Croquet project is building a revolutionary collaborative environment based on Squeak. It provides a scalable, peer-to-peer multiuser 3D environment that is completely open for exploration and makes novel ways for communication and interaction possible.},
|
|
2157 |
keywords = {fromscgbib marcusdenker},
|
|
2158 |
author = {Marcus Denker},
|
|
2159 |
booktitle = {Proceedings of LinuxTag 2005},
|
|
2160 |
title = {Squeak and Croquet},
|
|
2161 |
url = {http://rmod.lille.inria.fr/archives/popular/Denk05a-LinuxTag-Squeak.pdf},
|
|
2162 |
year = {2005}
|
|
2163 |
}
|
|
2164 |
|
|
2165 |
@article{Denk06a,
|
|
2166 |
abstract = {Transforming programs to alter their semantics is of
|
|
2167 |
wide interest, for purposes as diverse as
|
|
2168 |
off-the-shelf component adaptation, optimization,
|
|
2169 |
trace generation, and experimentation with new
|
|
2170 |
language features. The current wave of interest in
|
|
2171 |
advanced technologies for better separation of
|
|
2172 |
concerns, such as aspect-oriented programming, is a
|
|
2173 |
solid testimony of this fact. Strangely enough,
|
|
2174 |
almost all proposals are formulated in the context
|
|
2175 |
of {Java}, in which tool providers encounter severe
|
|
2176 |
restrictions due to the rigidity of the environment.
|
|
2177 |
This paper present ByteSurgeon, a library to
|
|
2178 |
transform binary code in Smalltalk. ByteSurgeon
|
|
2179 |
takes full advantage of the flexibility of the
|
|
2180 |
Squeak environment to enable bytecode transformation
|
|
2181 |
at runtime, thereby allowing dynamic, on-the-fly
|
|
2182 |
modification of applications. ByteSurgeon operates
|
|
2183 |
on bytecode in order to cope with situations where
|
|
2184 |
the source code is not available, while providing
|
|
2185 |
appropriate high-level abstractions so that users do
|
|
2186 |
not need to program at the bytecode level. We
|
|
2187 |
illustrate the use of ByteSurgeon via the
|
|
2188 |
implementation of method wrappers and a simple MOP,
|
|
2189 |
and report on its efficiency.},
|
|
2190 |
aeres = {ACL},
|
|
2191 |
aeresstatus = {aeres08},
|
|
2192 |
annote = {internationaljournal},
|
|
2193 |
author = {Marcus Denker and St\'ephane Ducasse and {\'E}ric Tanter},
|
|
2194 |
doi = {10.1016/j.cl.2005.10.002},
|
|
2195 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
2196 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
2197 |
keywords = {scg-pub stefPub jb06 snf-actsc snf06 mdPub fromscgbib marcusdenker},
|
|
2198 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
2199 |
month = jul,
|
|
2200 |
number = {2-3},
|
|
2201 |
pages = {125--139},
|
|
2202 |
publisher = {Elsevier},
|
|
2203 |
selectif = {non},
|
|
2204 |
title = {Runtime Bytecode Transformation for {Smalltalk}},
|
|
2205 |
url = {http://rmod.lille.inria.fr/archives/papers/Denk06a-COMLAN-RuntimeByteCode.pdf},
|
|
2206 |
volume = {32},
|
|
2207 |
year = {2006}
|
|
2208 |
}
|
|
2209 |
|
|
2210 |
|
|
2211 |
@inproceedings{Denk06c,
|
|
2212 |
abstract = {The developers of tools for dynamic analysis are faced with choosing from the many approaches to gathering runtime data. Typically, dynamic analysis involves instrumenting the program under investigation to record its runtime behavior. Current approaches for byte-code based systems like Java and Smalltalk rely often on inserting byte-code into the program under analysis. However, detailed knowledge of the target programming language or virtual machine is required to implement dynamic analysis tools. Obtaining and exploiting this knowledge to build better analysis tools is cumbersome and often distracts the tool builder from the actual goal, which is the analysis of the runtime behavior of a system. In this paper, we argue that we need to adopt a higher level view of a software system when considering the task of abstracting runtime information. We focus on object-oriented virtual machine based languages. We want to be able to deal with the runtime system as a collection of reified first-class entities. We propose to achieve this by introducing a layer of abstraction, i.e., a behavioral middle layer. This has the advantage that the task of collecting dynamic information is not concerned with low level details of a specific language or virtual machine. The positive effect of such a behavioral middle layer is twofold: on the one hand it provides us with a standard API for all dynamic analysis based tools to use, on the other hand it allows the tool developer to abstract from the actual implementation technique.},
|
|
2213 |
annote = {internationalworkshop},
|
|
2214 |
author = {Marcus Denker and Orla Greevy and Michele Lanza},
|
|
2215 |
booktitle = {2nd International Workshop on Program Comprehension
|
|
2216 |
through Dynamic Analysis (PCODA 2006)},
|
|
2217 |
keywords = {scg-pub skip-doi snf07 jb07 fb06 reflectivity fromscgbib marcusdenker},
|
|
2218 |
medium = {2},
|
|
2219 |
pages = {32--38},
|
|
2220 |
peerreview = {yes},
|
|
2221 |
title = {Higher Abstractions for Dynamic Analysis},
|
|
2222 |
url = {http://rmod.lille.inria.fr/archives/workshops/Denk06c-PCODA06-HigherAbstractions.pdf},
|
|
2223 |
year = {2006}
|
|
2224 |
}
|
|
2225 |
|
|
2226 |
|
|
2227 |
|
|
2228 |
@inproceedings{Denk07a,
|
|
2229 |
abstract = {Over the last few years, we actively participated in the maintenance and evolution of Squeak, an open-source Smalltalk. The community is constantly faced with the problem of enabling changes while at the same time preserving compatibility. In this paper we describe the current situation, the problems that faced the community and we outline the solutions that have been put in place. We also identify some areas where problems continue to exist and propose these as potential problems to addressed by the research community.},
|
|
2230 |
aeres = {ACT},
|
|
2231 |
aeresstatus = {aeres08},
|
|
2232 |
annote = {internationalworkshop},
|
|
2233 |
author = {Marcus Denker and St\'ephane Ducasse},
|
|
2234 |
booktitle = {Proceedings of the ERCIM Working Group on Software Evolution (2006)},
|
|
2235 |
doi = {10.1016/j.entcs.2006.08.003},
|
|
2236 |
inria = {hors},
|
|
2237 |
issn = {1571-0661},
|
|
2238 |
keywords = {scg07 stefPub scg-pub snf06 recast06 jb07 marcusdenker fromscgbib},
|
|
2239 |
medium = {2},
|
|
2240 |
month = jan,
|
|
2241 |
pages = {81--91},
|
|
2242 |
peerreview = {yes},
|
|
2243 |
publisher = {Elsevier},
|
|
2244 |
selectif = {non},
|
|
2245 |
series = {Electronic Notes in Theoretical Computer Science},
|
|
2246 |
title = {Software Evolution from the Field: an Experience
|
|
2247 |
Report from the {Squeak} Maintainers},
|
|
2248 |
url = {http://rmod.lille.inria.fr/archives/workshops/Denk07a-Ercim06-EvolutionSqueak.pdf},
|
|
2249 |
volume = {166},
|
|
2250 |
year = {2007}
|
|
2251 |
}
|
|
2252 |
|
|
2253 |
@inproceedings{Denk07b,
|
|
2254 |
abstract = {Reflection has proved to be a powerful feature to support the design of development environments and to extend languages. However, the granularity of structural reflection stops at the method level. This is a problem since without sub-method reflection developers have to duplicate efforts, for example to introduce transparently pluggable type-checkers or fine-grained profilers. In this paper we present Persephone, an efficient implementation of a sub-method meta-object protocol (MOP) based on AST annotations and dual methods (a compiled method and its meta-object) that reconcile AST expressiveness with bytecode execution. We validate the MOP by presenting TreeNurse, a method instrumentation framework and TypePlug, an optional, pluggable type system which is based on Persephone.},
|
|
2255 |
aeres = {ACT},
|
|
2256 |
aeresstatus = {aeres08},
|
|
2257 |
annote = {internationalconference},
|
|
2258 |
author = {Marcus Denker and St\'ephane Ducasse and Adrian Lienhard and Philippe Marschall},
|
|
2259 |
booktitle = {Journal of Object Technology, Special Issue. Proceedings of TOOLS Europe 2007},
|
|
2260 |
inria = {hors},
|
|
2261 |
issn = {1660-1769},
|
|
2262 |
keywords = {scg07 scg-pub jb08 snf07 skip-doi jot snf-bmcc
|
|
2263 |
reflectivity fromscgbib marcusdenker},
|
|
2264 |
medium = {2},
|
|
2265 |
month = oct,
|
|
2266 |
pages = {231--251},
|
|
2267 |
peerreview = {yes},
|
|
2268 |
publisher = {ETH},
|
|
2269 |
selectif = {non},
|
|
2270 |
title = {Sub-Method Reflection},
|
|
2271 |
url = {http://rmod.lille.inria.fr/archives/papers/Denk07b-TOOLS07-Submethod.pdf},
|
|
2272 |
volume = {6/9},
|
|
2273 |
year = {2007}
|
|
2274 |
}
|
|
2275 |
|
|
2276 |
|
|
2277 |
@inproceedings{Denk07c,
|
|
2278 |
abstract = {Real world software systems change continuously to meet new demands. Most programming languages and development environments, however, are more concerned with limiting the effects of change rather than enabling and exploiting change. Various techniques and technologies to exploit change have been developed over the years, but there exists no common support for these approaches. We propose Changeboxes as a general-purpose mechanism for encapsulating change as a first-class entity in a running software system. Changeboxes support multiple, concurrent and possibly inconsistent views of software artifacts within the same running system. Since Changeboxes are first-class, they can be manipulated to control the scope of change in a running system.Furthermore, Changeboxes capture the semantics of change. Changeboxes can be used, for example, to encapsulate refactorings, or to replay or analyze the history of changes. In this paper we introduce Changeboxes by means of a prototype implementation. We illustrate the benefits that Changeboxes offer for evolving software systems, and we present the results of a preliminary performance evaluation that assesses the costs associated with Changeboxes while suggesting possible strategies for improvement.},
|
|
2279 |
annote = {internationalconference},
|
|
2280 |
author = {Marcus Denker and Tudor G\^irba and Adrian Lienhard and Oscar Nierstrasz and Lukas Renggli and Pascal Zumkehr},
|
|
2281 |
booktitle = {Proceedings of the 2007 International Conference on Dynamic Languages (ICDL 2007)},
|
|
2282 |
publisher = {ACM Digital Library},
|
|
2283 |
isbn = {978-1-60558-084-5},
|
|
2284 |
peer = {yes},
|
|
2285 |
keywords = {scg07 scg-pub jb08 snf08 girba cop-lit marcusdenker fromscgbib},
|
|
2286 |
pages = {25--49},
|
|
2287 |
url = {http://rmod.lille.inria.fr/archives/papers/Denk07c-ICDL07-Changeboxes.pdf},
|
|
2288 |
doi = {10.1145/1352678.1352681},
|
|
2289 |
title = {Encapsulating and Exploiting Change with {Changeboxes}},
|
|
2290 |
year = {2007}
|
|
2291 |
}
|
|
2292 |
|
|
2293 |
@inproceedings{Denk07d,
|
|
2294 |
abstract = {The dynamic analysis approach to feature identification describes a technique for capturing feature behavior and mapping it to source code. Major drawbacks of this approach are (1) large amounts of data and (2) lack of support for sub-method elements. In this paper we propose to leverage sub-method reflection to identify and model features. We perform an on-the-fly analysis resulting in annotating the operations participating in a feature's behavior with meta-data.The primary advantage of our annotation approach is that we obtain a fine-grained level of granularity while at the same time eliminating the need to retain and analyze large traces for feature analysis.},
|
|
2295 |
annote = {internationalworkshop},
|
|
2296 |
author = {Marcus Denker and Orla Greevy and Oscar Nierstrasz},
|
|
2297 |
booktitle = {Proceedings of the 3rd International Workshop on Program Comprehension through Dynamic Analysis (PCODA 2007)},
|
|
2298 |
issn = {1872-5392},
|
|
2299 |
keywords = {scg07 scg-pub skip-doi snf08 jb08 reflectivity fromscgbib marcusdenker},
|
|
2300 |
medium = {2},
|
|
2301 |
pages = {29--33},
|
|
2302 |
peerreview = {yes},
|
|
2303 |
publisher = {Technische Universiteit Delft},
|
|
2304 |
title = {Supporting Feature Analysis with Runtime
|
|
2305 |
Annotations},
|
|
2306 |
url = {http://rmod.lille.inria.fr/archives/workshops/Denk07d-PCODA07-FeatureAnnotation.pdf},
|
|
2307 |
year = {2007}
|
|
2308 |
}
|
|
2309 |
|
|
2310 |
@phdthesis{Denk08a,
|
|
2311 |
abstract = {Computational reflection is a fundamental mechanism in object oriented languages. Reflection has proved useful in many contexts, such as in the design of development environments, language extension, and the dynamic, unanticipated adaptation of running systems We identify three problems with the current approach to reflection in object oriented languages: partial behavioral reflection needs to be anticipated, structural reflection is limited to the granularity of a method, and behavioral reflection cannot be applied to the whole system. To address these problems, we extend structural reflection to cover sub-method elements and present how sub-method structural reflection supports unanticipated partial behavioral reflection. We add the concept of context to represent meta-level execution and show how this allows behavioral reflection to be applied even to system classes. We describe an implementation in Smalltalk. Benchmarks validate the practicability of our approach. In addition, we present an experimental evaluation in which we show how the system is used for dynamic analysis. We realize dynamic feature analysis by annotating the sub-method structure of the system directly to denote features instead of recording full execution traces.},
|
|
2312 |
author = {Marcus Denker},
|
|
2313 |
keywords = {scg-phd snf08 jb08 reflectivity marcusdenker fromscgbib},
|
|
2314 |
month = may,
|
|
2315 |
school = {University of Bern},
|
|
2316 |
title = {Sub-method Structural and Behavioral Reflection},
|
|
2317 |
type = {{PhD} thesis},
|
|
2318 |
url = {http://rmod.lille.inria.fr/archives/phd/PhD-2008-Denker.pdf},
|
|
2319 |
year = {2008}
|
|
2320 |
}
|
|
2321 |
|
|
2322 |
@inproceedings{Denk08b,
|
|
2323 |
abstract = {Behavioral reflection is crucial to support for example functional upgrades, on-the-fly debugging, or monitoring critical applications. However the use of reflective features can lead to severe problems due to infinite metacall recursion even in simple cases. This is especially a problem when reflecting on core language features since there is a high chance that such features are used to implement the reflective behavior itself. In this paper we analyze the problem of infinite meta-object call recursion and solve it by providing a first class representation of meta-level execution: at any point in the execution of a system it can be determined if we are operating on a meta-level or base level so that we can prevent infinite recursion. We present how meta-level execution can be represented by a meta-context and how reflection becomes context-aware. Our solution makes it possible to freely apply behavioral reflection even on system classes: the meta-context brings stability to behavioral reflection. We validate the concept with a robust implementation and we present benchmarks.},
|
|
2324 |
annote = {internationalconference},
|
|
2325 |
author = {Marcus Denker and Mathieu Suen and St\'ephane Ducasse},
|
|
2326 |
booktitle = {Proceedings of TOOLS EUROPE 2008},
|
|
2327 |
peer = {yes},
|
|
2328 |
pages = {218--237},
|
|
2329 |
aeres = {ACT},
|
|
2330 |
aeresstatus = {aeres12},
|
|
2331 |
inria = {RMOD},
|
|
2332 |
selectif = {non},
|
|
2333 |
issn = {1865-1348},
|
|
2334 |
keywords = {scg-pub jb08 fb08 snf08 reflectivity marcusdenker remoose},
|
|
2335 |
publisher = {Springer-Verlag},
|
|
2336 |
series = {LNBIP},
|
|
2337 |
volume = 11,
|
|
2338 |
doi = {10.1007/978-3-540-69824-1_13},
|
|
2339 |
url = {http://rmod.lille.inria.fr/archives/papers/Denk08b-Tools08-MetaContext.pdf},
|
|
2340 |
title = {The Meta in Meta-object Architectures},
|
|
2341 |
hal = {inria-00271286,p56w09p},
|
|
2342 |
year = {2008}
|
|
2343 |
}
|
|
2344 |
|
|
2345 |
@inproceedings{Denk10a,
|
|
2346 |
abstract = {A feature represents a functional requirement fulfilled by a system. Since many maintenance tasks are expressed in terms of features, it is important to establish the correspondence between a feature and its implementation in source code. Traditional approaches to establish this correspondence exercise features to generate a trace of runtime events, which is then processed by post-mortem analysis. These approaches typically generate large amounts of data to analyze. Due to their static nature, these approaches do not support incremental and interactive analysis of features. We propose a radically different approach called live feature analysis, which provides a model at runtime of features. Our approach analyzes features on a running system and also makes it possible to grow feature representations by exercising different scenarios of the same feature, and identifies execution elements even to the sub-method level. We describe how live feature analysis is implemented effectively by annotating structural representations of code based on abstract syntax trees. We illustrate our live analysis with a case study where we achieve a more complete feature representation by exercising and merging variants of feature behavior and demonstrate the efficiency or our technique with benchmarks.},
|
|
2347 |
author = {Marcus Denker and Jorge Ressia and Orla Greevy and Oscar Nierstrasz},
|
|
2348 |
keywords = {snf10 jb11 scg-pub lse-pub marcusdenker},
|
|
2349 |
month = oct,
|
|
2350 |
title = {Modeling Features at Runtime},
|
|
2351 |
booktitle = {Proceedings of MODELS 2010 Part II},
|
|
2352 |
publisher = {Springer-Verlag},
|
|
2353 |
series = {LNCS},
|
|
2354 |
volume = 6395,
|
|
2355 |
pages = {138--152},
|
|
2356 |
year = {2010},
|
|
2357 |
inriareport = {2010},
|
|
2358 |
inria = {RMOD},
|
|
2359 |
peer = {yes},
|
|
2360 |
ISBN = {978-3-642-16128-5},
|
|
2361 |
doi = {10.1007/978-3-642-16129-2\_11},
|
|
2362 |
url = {http://rmod.lille.inria.fr/archives/papers/Denk10a-Models10-FeatureModels.pdf},
|
|
2363 |
misc = {Acceptance rate: 20.8\%},
|
|
2364 |
x-proceedings = {yes},
|
|
2365 |
x-international-audience = {yes}
|
|
2366 |
}
|
|
2367 |
|
|
2368 |
|
|
2369 |
@inproceedings{Dery96a,
|
|
2370 |
annote = {nationalconference},
|
|
2371 |
author = {Anne-Marie Dery and St\'ephane Ducasse and Mireille
|
|
2372 |
Fornarino},
|
|
2373 |
booktitle = {Actes d'Interfaces Hommes Machine (IHM'96)},
|
|
2374 |
keywords = {stefPub},
|
|
2375 |
title = {Inhibition et resynchronisation des contr\^oleurs de dialogue},
|
|
2376 |
year = {1996}
|
|
2377 |
}
|
|
2378 |
|
|
2379 |
@incollection{Dery96b,
|
|
2380 |
annote = {articlebook},
|
|
2381 |
author = {Anne-Marie Dery and St\'ephane Ducasse and Mireille Fornarino},
|
|
2382 |
booktitle = {Ing\'eni\`erie Objet},
|
|
2383 |
editor = {O. Mourad},
|
|
2384 |
keywords = {stefPub},
|
|
2385 |
note = {ISBN: 2-7296-0642-4},
|
|
2386 |
pages = {131--155},
|
|
2387 |
publisher = {Inter-Editions},
|
|
2388 |
title = {Objets et D\'ependances},
|
|
2389 |
year = {1996}
|
|
2390 |
}
|
|
2391 |
|
|
2392 |
@techreport{Dery96c,
|
|
2393 |
annote = {report notrefereed},
|
|
2394 |
author = {Anne-Marie Dery and St\'ephane Ducasse and Mireille Fornarino},
|
|
2395 |
institution = {Laboratoire I3S},
|
|
2396 |
keywords = {stefPub},
|
|
2397 |
number = {I3S Lab, RR-96-06},
|
|
2398 |
title = {A New Vision of Control in the {PAC} Model},
|
|
2399 |
year = {1996}
|
|
2400 |
}
|
|
2401 |
|
|
2402 |
@article{Dias03a,
|
|
2403 |
author = {M\'{a}rcio G. B. Dias and Nicolas Anquetil and K\'{a}thia M. de Oliveira},
|
|
2404 |
title = {Organizing the Knowledge Used in Software Maintenance},
|
|
2405 |
abstract = {Knowledge engineering emerged as a very promising area to help improve software engineering practice. One of its possible applications would be to help in solving the numerous problems that affect the software maintenance activity. Maintainers of legacy systems developed years ago with obsolete techniques and tools, and not documented, need all kinds of knowledge (application domain, programming skills, software engineering techniques, etc.) It is generally assumed that formalizing all this knowledge and recording it would be a worthwhile effort. However, research is still in a early stage and numerous questions need to be answered: What knowledge should be targeted first? Where to find this knowledge? etc. To answer these questions, one needs a precise understanding of what knowledge is at stake here. We, therefore, propose an ontology of the knowledge needed to perform software maintenance. This ontology would be most useful as a framework for future research in knowledge engineering for software maintenance.},
|
|
2406 |
journal = {Journal of Universal Computer Science},
|
|
2407 |
year = {2003},
|
|
2408 |
volume = {9},
|
|
2409 |
number = {7},
|
|
2410 |
pages = {641--658},
|
|
2411 |
doi = {10.1049/ip-sen:20030581},
|
|
2412 |
url = {http://www.jucs.org/jucs_9_7/organizing_the_knowledge_used/Dias_M_G_B.pdf},
|
|
2413 |
annote = {internationaljournal},
|
|
2414 |
aeres = {ACLN},
|
|
2415 |
selectif = {non},
|
|
2416 |
labo = {non},
|
|
2417 |
x-editorial-board = {yes},
|
|
2418 |
x-international-audience = {yes},
|
|
2419 |
x-pays = {BR}
|
|
2420 |
}
|
|
2421 |
|
|
2422 |
@inproceedings{Dias03b,
|
|
2423 |
author = {M{\'a}rcio Greyck Batista Dias and
|
|
2424 |
Nicolas Anquetil and
|
|
2425 |
K{\'a}thia Mar\c{c}al de Oliveira},
|
|
2426 |
title = {Organizing the Knowledge Used in Software Maintance},
|
|
2427 |
booktitle = {WM 2003: Professionelles Wissesmanagement - Erfahrungen
|
|
2428 |
und Visionen, Beitr{\"a}ge der 2. Konferenz Professionelles
|
|
2429 |
Wissensmanagement},
|
|
2430 |
year = {2003},
|
|
2431 |
pages = {65-72},
|
|
2432 |
editor = {Ulrich Reimer and
|
|
2433 |
Andreas Abecker and
|
|
2434 |
Steffen Staab and
|
|
2435 |
Gerd Stumme},
|
|
2436 |
volume = {28},
|
|
2437 |
isbn = {3-88579-357-1},
|
|
2438 |
annote = {internationalworkshop},
|
|
2439 |
aeres = {ACT},
|
|
2440 |
selectif = {oui},
|
|
2441 |
labo = {non},
|
|
2442 |
x-editorial-board = {yes},
|
|
2443 |
x-international-audience = {no},
|
|
2444 |
x-pays = {BR}
|
|
2445 |
}
|
|
2446 |
|
|
2447 |
@inproceedings{Duca00a,
|
|
2448 |
abstract = {Reengineering is an inherent aspect of modern software development, with its emphasis on iterative and incremental development. The reengineering pattern presented in this paper shows how you can support your understanding during system reengineering by linking your questions or information about the code in the code itself.},
|
|
2449 |
annote = {internationalworkshop},
|
|
2450 |
author = {St{\'e}phane Ducasse and Serge Demeyer and Oscar Nierstrasz},
|
|
2451 |
booktitle = {Proceedings of EuroPLoP '2000},
|
|
2452 |
keywords = {snf-none olit scg-pub skip-doi jb00 stefPub},
|
|
2453 |
pages = {209--217},
|
|
2454 |
title = {Tie Code And Questions: a Reengineering Pattern},
|
|
2455 |
url = {http://scg.unibe.ch/archive/papers/Duca00aTieCode.pdf},
|
|
2456 |
year = {2000},
|
|
2457 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca00aTieCode.pdf}
|
|
2458 |
}
|
|
2459 |
|
|
2460 |
|
|
2461 |
@inproceedings{Duca00b,
|
|
2462 |
abstract = {Surprising as it may seem, many of the early adopters of the object-oriented paradigm already face a number of problems typically encountered in large-scale legacy systems. The reengineering of those systems often poses problems because of the considerable size and complexity of such systems. In the context of the FAMOOS project we have developed a language independent environment called Moose which can deal with that complexity. This paper describes the architecture of Moose, the tools which have been developed around it and the industrial experiences we have obtained.},
|
|
2463 |
annote = {internationalworkshop},
|
|
2464 |
author = {Ducasse, St\'ephane and Lanza, Michele and Tichelaar, Sander},
|
|
2465 |
booktitle = {Proceedings of CoSET '00 (2nd International Symposium on Constructing Software Engineering Tools)},
|
|
2466 |
keywords = {components scg-pub skip-doi snf00 jb00 repository
|
|
2467 |
abb oorp stefPub moose-pub},
|
|
2468 |
month = jun,
|
|
2469 |
title = {Moose: an {Extensible} {Language}-{Independent} {Environment} for {Reengineering} {Object}-{Oriented} {Systems}},
|
|
2470 |
url = {http://scg.unibe.ch/archive/papers/Duca00bMooseCoset.pdf},
|
|
2471 |
year = {2000},
|
|
2472 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca00bMooseCoset.pdf}
|
|
2473 |
}
|
|
2474 |
|
|
2475 |
|
|
2476 |
@inproceedings{Duca00c,
|
|
2477 |
abstract = {Conditionals -i.e., switch statements, nested ifs- that are used to simulate polymorphism hamper evolution and flexibility of applications. The reengineering patterns presented in this paper show you how to transform conditionals in object-oriented code to improve the flexibility of application.},
|
|
2478 |
annote = {internationalworkshop},
|
|
2479 |
author = {St\'ephane Ducasse and Serge Demeyer and Oscar
|
|
2480 |
Nierstrasz},
|
|
2481 |
booktitle = {Proceedings of EuroPLoP '2000},
|
|
2482 |
keywords = {snf-none skip-doi olit scg-pub jb00 stefPub},
|
|
2483 |
pages = {219--252},
|
|
2484 |
title = {Transform Conditionals to Polymorphism},
|
|
2485 |
url = {http://scg.unibe.ch/archive/papers/Duca00cTransform.pdf},
|
|
2486 |
year = {2000},
|
|
2487 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca00cTransform.pdf}
|
|
2488 |
}
|
|
2489 |
|
|
2490 |
@inproceedings{Duca00d,
|
|
2491 |
abstract = {Tuple spaces have turned out to be one of the most fundamental abstractions for coordinating communicating agents. At the same time, researchers continue to propose new variants of tuple spaces, since no one approach seems to be universally applicable to all problem domains. Some models offer a certain configurability, but existing approaches generally stop at afixed set of configuration options and static configuration at instantiation time. We argue that a more open approach is needed, and present OpenSpaces, an object-oriented framework that supports static configurability through subclassing across several dimensions, as well as dynamic configurability of policies through runtime composition. We introduce OpenSpaces by showing how it can be used to instantiate a typical application, and we present an overview of the framework, implemented in Smalltalk, detailing the various degrees of configurability.},
|
|
2492 |
address = {Limassol, Cyprus},
|
|
2493 |
annote = {internationalconference},
|
|
2494 |
author = {St{\'e}phane Ducasse and Thomas Hofmann and Oscar
|
|
2495 |
Nierstrasz},
|
|
2496 |
booktitle = {Coordination Languages and Models},
|
|
2497 |
doi = {10.1007/3-540-45263-X_1},
|
|
2498 |
editor = {Ant{\'o}nio Porto and Gruia-Catalin Roman},
|
|
2499 |
isbn = {978-3-540-41020-1},
|
|
2500 |
keywords = {olit scg-pub coordination jb00 scg-coord-00 stefPub},
|
|
2501 |
misc = {acceptance rate: 18/52 = 35\%},
|
|
2502 |
accepttotal = {52},
|
|
2503 |
acceptnum = {18},
|
|
2504 |
month = sep,
|
|
2505 |
pages = {1--19},
|
|
2506 |
series = {LNCS},
|
|
2507 |
title = {OpenSpaces: An Object-Oriented Framework For Reconfigurable Coordination Spaces},
|
|
2508 |
url = {http://scg.unibe.ch/archive/papers/Duca00dOpenSpaces.pdf},
|
|
2509 |
volume = {1906},
|
|
2510 |
year = {2000}
|
|
2511 |
}
|
|
2512 |
|
|
2513 |
@inproceedings{Duca00f,
|
|
2514 |
annote = {internationalworkshop},
|
|
2515 |
author = {St{\'e}phane Ducasse and Michele Lanza and Lukas Steiger},
|
|
2516 |
booktitle = {ECOOP 2000 International Workshop of Architecture Evolution},
|
|
2517 |
keywords = {scg-pub skip-abstract skip-pdf skip-doi snf00 jb00
|
|
2518 |
stefPub design-recovery moose-pub},
|
|
2519 |
title = {Supporting Evolution Recovery: a Query-based
|
|
2520 |
Approach},
|
|
2521 |
year = {2000}
|
|
2522 |
}
|
|
2523 |
|
|
2524 |
@techreport{Duca00g,
|
|
2525 |
annote = {report notrefereed},
|
|
2526 |
author = {St\'ephane Ducasse and Michele Lanza and Oscar
|
|
2527 |
Nierstrasz and Matthias Rieger and Sander Tichelaar},
|
|
2528 |
institution = {University of Bern},
|
|
2529 |
keywords = {skip-abstract skip-pdf skip-doi stefPub},
|
|
2530 |
title = {BEOC Analysis Report},
|
|
2531 |
year = {2000}
|
|
2532 |
}
|
|
2533 |
|
|
2534 |
@article{Duca00x,
|
|
2535 |
address = {13 rue du Jura, Paris 13},
|
|
2536 |
annote = {notrefereed},
|
|
2537 |
author = {St\'ephane Ducasse and Florence Ducasse},
|
|
2538 |
journal = {Journal de l'association EPI Enseignement Public et
|
|
2539 |
Informatiques},
|
|
2540 |
keywords = {snf-none scg-pub skip-abstract skip-doi jb00
|
|
2541 |
stefPub},
|
|
2542 |
month = sep,
|
|
2543 |
number = 97,
|
|
2544 |
title = {De l'enseignement de concepts informatiques},
|
|
2545 |
url = {http://scg.unibe.ch/archive/papers/Duca00xExperienceEnseig.pdf},
|
|
2546 |
volume = 4,
|
|
2547 |
year = {2000},
|
|
2548 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca00xExperienceEnseig.pdf}
|
|
2549 |
}
|
|
2550 |
|
|
2551 |
@booklet{Duca00z,
|
|
2552 |
annote = {lectures},
|
|
2553 |
author = {St\'ephane Ducasse and Florence Ducasse},
|
|
2554 |
keywords = {scg-old scg-misc stefPub},
|
|
2555 |
note = {Support de cours de Technologie, 150 pages, http://www.iam.unibe.ch/~ducasse/},
|
|
2556 |
title = {Caro, Dis-moi c'est quoi programmer?},
|
|
2557 |
url = {http://scg.unibe.ch/archive/papers/Duca00zCaroLecturesFr.pdf},
|
|
2558 |
year = {2000},
|
|
2559 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca00zCaroLecturesFr.pdf}
|
|
2560 |
}
|
|
2561 |
|
|
2562 |
@article{Duca01a,
|
|
2563 |
abstract = {The reverse engineering of object-oriented legacy systems presents a number
|
|
2564 |
of problems typically encountered in large-scale legacy systems: the lack of overview and
|
|
2565 |
the need to focus on interesting parts. To help in reverse engineering large
|
|
2566 |
object-oriented legacy systems, we proposed a hybrid approach combining the immediate
|
|
2567 |
appeal of visualisations with the scalability of metrics. However, our approach lacked of a
|
|
2568 |
methodology that guides the reverse engineer. In this paper we present a first methodology
|
|
2569 |
that we developed from our industrial experiments.},
|
|
2570 |
annote = {nationaljournal},
|
|
2571 |
author = {St\'ephane Ducasse and Michele Lanza},
|
|
2572 |
journal = {Technique et science informatiques},
|
|
2573 |
keywords = {scg-pub skip-doi jb01 snf02 stePub},
|
|
2574 |
number = {4},
|
|
2575 |
pages = {539--566},
|
|
2576 |
title = {Towards a Methodology for the Understanding of Object-Oriented Systems},
|
|
2577 |
url = {http://scg.unibe.ch/archive/papers/Duca01aTowardsAMethod.pdf},
|
|
2578 |
volume = {20},
|
|
2579 |
year = {2001},
|
|
2580 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca01aTowardsAMethod.pdf}
|
|
2581 |
}
|
|
2582 |
|
|
2583 |
@article{Duca01b,
|
|
2584 |
abstract = {This article presents the Moose Reengineering
|
|
2585 |
Environment, a language-independent tool environment
|
|
2586 |
to reverse engineer, i.e., understand, and
|
|
2587 |
reengineer software systems, as well as the tools
|
|
2588 |
which have been developed around it and the
|
|
2589 |
experience, both academic and industrial, we have
|
|
2590 |
obtained.},
|
|
2591 |
annote = {notrefereed},
|
|
2592 |
author = {St\'ephane Ducasse and Michele Lanza and Sander Tichelaar},
|
|
2593 |
journal = {Smalltalk Chronicles},
|
|
2594 |
keywords = {scg-pub skip-doi repository reengineering stefPub moose-pub},
|
|
2595 |
month = aug,
|
|
2596 |
title = {The Moose Reengineering Environment},
|
|
2597 |
url = {http://scg.unibe.ch/archive/papers/Duca01bMoose.pdf
|
|
2598 |
http://www.smalltalkchronicles.net/edition3-2/Pages/moose.htm},
|
|
2599 |
year = {2001}
|
|
2600 |
}
|
|
2601 |
|
|
2602 |
@techreport{Duca01c,
|
|
2603 |
abstract = {Reengineering ob ject-oriented applications is becoming a vital activity in today industry where the developer turnover drains the system oral memory out of the systems themselves and where applications should constantly evolve to meet new requirements. This document summarizes the research effort led on reverse engineering and reengineering ob ject-oriented legacy systems. It includes (1) the definition of a suitable meta-model for reengineering, FAMIX. This meta-model, even if flat, supports both reverse engineering and code refac- toring analysis, (2) the presentation of a reengineering platform, MOOSE, (3) the evalution of software metrics for reengineer, (4) the definition of simple visual techniques to support large system understanding or finer grain code element, (5) the identification and cure sup- port for duplicated code, (6) the use of dynamic information to support composable views and collaboration extraction, and (7) the identification of reengineer patterns. Keywords. Meta-Modeling, Language Independence, Reengineering, Reverse Engineering, Code Duplica- tion, Reengineering Patterns, Program Traces, Dynamic Information, Program Visualization, Software Metrics, Refactorings, Interexchange Format, CODECRAWLER, FAMIX, MOOSE, FAMOOS, Smalltalk, Java, C++.},
|
|
2604 |
annote = {habilitation},
|
|
2605 |
author = {Ducasse, St\'ephane},
|
|
2606 |
institution = {Universit\'e Pierre et Marie Curie (Paris 6)},
|
|
2607 |
keywords = {scg-pub skip-doi jb-none reengineering snf02 stefPub
|
|
2608 |
moose-pub},
|
|
2609 |
month = sep,
|
|
2610 |
note = {TR University of Bern, Institute of Computer Science
|
|
2611 |
and Applied Mathematics --- iam-03-008},
|
|
2612 |
title = {Reengineering Object-Oriented Applications},
|
|
2613 |
url = {http://scg.unibe.ch/archive/papers/Duca01cHab.pdf},
|
|
2614 |
year = {2001},
|
|
2615 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca01cHab.pdf}
|
|
2616 |
}
|
|
2617 |
|
|
2618 |
@article{Duca01s,
|
|
2619 |
annote = {vulgarisation},
|
|
2620 |
author = {Ducasse, St\'ephane},
|
|
2621 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2622 |
keywords = {stefPub},
|
|
2623 |
month = nov,
|
|
2624 |
number = 37,
|
|
2625 |
title = {Squeak: Introspection},
|
|
2626 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2627 |
volume = 1,
|
|
2628 |
year = {2001},
|
|
2629 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2630 |
x-scientific-popularization = {oui}
|
|
2631 |
}
|
|
2632 |
|
|
2633 |
@article{Duca01t,
|
|
2634 |
annote = {vulgarisation},
|
|
2635 |
author = {St\'ephane Ducasse},
|
|
2636 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2637 |
keywords = {stefPub},
|
|
2638 |
month = oct,
|
|
2639 |
number = 36,
|
|
2640 |
title = {Squeak: Classes},
|
|
2641 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2642 |
volume = 1,
|
|
2643 |
year = {2001},
|
|
2644 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2645 |
x-scientific-popularization = {oui}
|
|
2646 |
}
|
|
2647 |
|
|
2648 |
@article{Duca01u,
|
|
2649 |
annote = {vulgarisation},
|
|
2650 |
author = {St\'ephane Ducasse},
|
|
2651 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2652 |
keywords = {stefPub},
|
|
2653 |
month = sep,
|
|
2654 |
number = 35,
|
|
2655 |
title = {Squeak: Syntaxe par l'example},
|
|
2656 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2657 |
volume = 1,
|
|
2658 |
year = {2001},
|
|
2659 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2660 |
x-scientific-popularization = {oui}
|
|
2661 |
}
|
|
2662 |
|
|
2663 |
@article{Duca01v,
|
|
2664 |
annote = {vulgarisation},
|
|
2665 |
author = {St\'ephane Ducasse},
|
|
2666 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2667 |
keywords = {stefPub},
|
|
2668 |
month = jul,
|
|
2669 |
number = 34,
|
|
2670 |
title = {Squeak: Une syntaxe minimaliste},
|
|
2671 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2672 |
volume = 1,
|
|
2673 |
year = {2001},
|
|
2674 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2675 |
x-scientific-popularization = {oui}
|
|
2676 |
}
|
|
2677 |
|
|
2678 |
@article{Duca01w,
|
|
2679 |
annote = {vulgarisation},
|
|
2680 |
author = {St\'ephane Ducasse},
|
|
2681 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2682 |
keywords = {stefPub},
|
|
2683 |
month = jun,
|
|
2684 |
number = 33,
|
|
2685 |
title = {Squeak: Un smalltalk open-source d\'etonnant},
|
|
2686 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2687 |
volume = 1,
|
|
2688 |
year = {2001},
|
|
2689 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2690 |
x-scientific-popularization = {oui}
|
|
2691 |
}
|
|
2692 |
|
|
2693 |
@techreport{Duca01x,
|
|
2694 |
author = {St\'ephane Ducasse and Sander Tichelaar},
|
|
2695 |
institution = {University of Bern},
|
|
2696 |
keywords = {moose-pub},
|
|
2697 |
note = {To appear},
|
|
2698 |
title = {{FAMIX} {Smalltalk} language plug-in},
|
|
2699 |
year = {2001}
|
|
2700 |
}
|
|
2701 |
|
|
2702 |
@inproceedings{Duca02a,
|
|
2703 |
abstract = {In this paper we stress the fact that a language and an environment for teaching object-oriented programming should support the anthropomorphic metaphor promoted by the paradigm. We show that all the cultural aspects of Smalltalk, i.e., the vocabulary and the syntax support the object metaphor. In addition, we stress that the programming environment should also support the metaphor. We show that Smalltalk environments offer an important property we named liveness or object proximity that promotes the anthropomorphic perception of objects. By providing excerpt from our forth coming book, we show how Squeak with the Morphic framework reinforces this ability to make object into living entities.},
|
|
2704 |
annote = {internationalworkshop},
|
|
2705 |
author = {St\'ephane Ducasse and Roel Wuyts},
|
|
2706 |
booktitle = {Proceedings of the Ecoop'02 International Educator
|
|
2707 |
Symposium},
|
|
2708 |
keywords = {snf-none stefPub scg-pub skip-doi jb04},
|
|
2709 |
title = {Supporting Objects as An Anthropomorphic View at Computation or Why {Smalltalk} for Teaching Objects?},
|
|
2710 |
url = {http://scg.unibe.ch/archive/papers/Duca02aTeacherWorkshop.pdf},
|
|
2711 |
year = {2002},
|
|
2712 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca02aTeacherWorkshop.pdf}
|
|
2713 |
}
|
|
2714 |
|
|
2715 |
@article{Duca02v,
|
|
2716 |
annote = {vulgarisation},
|
|
2717 |
author = {St\'ephane Ducasse},
|
|
2718 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2719 |
keywords = {stefPub},
|
|
2720 |
month = sep,
|
|
2721 |
number = 46,
|
|
2722 |
title = {Refactoring Browser et SmallLint},
|
|
2723 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2724 |
volume = 1,
|
|
2725 |
year = {2002},
|
|
2726 |
x-scientific-popularization = {oui},
|
|
2727 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html}
|
|
2728 |
}
|
|
2729 |
|
|
2730 |
@article{Duca02w,
|
|
2731 |
annote = {vulgarisation},
|
|
2732 |
author = {St\'ephane Ducasse},
|
|
2733 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2734 |
keywords = {stefPub},
|
|
2735 |
month = jan,
|
|
2736 |
number = 39,
|
|
2737 |
title = {SUnit: Ces tests que souvent l'on deteste},
|
|
2738 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2739 |
volume = 1,
|
|
2740 |
year = {2002},
|
|
2741 |
x-scientific-popularization = {oui},
|
|
2742 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html}
|
|
2743 |
}
|
|
2744 |
|
|
2745 |
@article{Duca03a,
|
|
2746 |
abstract = {Although component-based software development (CBSD) has become mainstream for conventional applications, it has remained elusive for embedded applications due to non-functional constraints. The PECOS project has demonstrated that CBSD can also be applied to severely constrained embedded devices, with timing and memory requirements being taken into account.},
|
|
2747 |
annote = {notrefereed},
|
|
2748 |
author = {St\'ephane Ducasse and Oscar Nierstrasz and Roel Wuyts},
|
|
2749 |
cvs = {ErcimPecos},
|
|
2750 |
journal = {ERCIM News},
|
|
2751 |
keywords = {scg-pub skip-doi pecos jb03 stefPub},
|
|
2752 |
month = jan,
|
|
2753 |
title = {Composing Embedded Real-Time Software Components: the {PECOS} Data-Centric Approach},
|
|
2754 |
url = {http://www.ercim.org/publication/Ercim_News/enw52/nierstrasz.html},
|
|
2755 |
volume = 52,
|
|
2756 |
year = {2003},
|
|
2757 |
bdsk-url-1 = {http://www.ercim.org/publication/Ercim_News/enw52/nierstrasz.html}
|
|
2758 |
}
|
|
2759 |
|
|
2760 |
@inproceedings{Duca03b,
|
|
2761 |
abstract = {Current languages contain visibility mechanisms such as private, protected, or public to control who can see what. However, these visibility mechanisms are fixed once for all. Moreover, they do not solve all problems related to the visibility, and are typically of a static nature. In this position paper we present an open and uniform way of dealing with visibility and introduce surfaces: i.e., list of methods that control the way the behavior of an ob ject is accessible. We introduce two problems that other visibility mechanisms cannot solve, and show how surfaces can.},
|
|
2762 |
annote = {internationalworkshop},
|
|
2763 |
author = {St\'ephane Ducasse and Nathanael Sch{\"a}rli and Roel Wuyts},
|
|
2764 |
booktitle = {Proceedings of the ECOOP '03 Workshop on Object-oriented Language Engineering for the Post-Java Era},
|
|
2765 |
keywords = {snf03 scg-pub skip-doi jb03 stefPub schaerli},
|
|
2766 |
month = jul,
|
|
2767 |
title = {Open Surfaces for Controlled Visibility},
|
|
2768 |
url = {http://scg.unibe.ch/archive/papers/Duca03bSurfaces.pdf},
|
|
2769 |
year = {2003},
|
|
2770 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca03bSurfaces.pdf}
|
|
2771 |
}
|
|
2772 |
|
|
2773 |
@inproceedings{Duca03c,
|
|
2774 |
abstract = {Array programming shines in its ability to express computations at a high-level of abstraction, allowing one to manipulate and query whole sets of data at once. This paper presents the OOPAL model that enhances object-oriented programming with array programming features. The goal of OOPAL is to determine a minimum set of modifications that must be made to the traditional object model in order to take advantage of the possibilities of array programming. It is based on a minimal extension of method invocation and the definition of a kernel of methods implementing the fundamental array programming operations. The model is validated in F-SCRIPT, a new scripting language.},
|
|
2775 |
annote = {internationalworkshop},
|
|
2776 |
author = {St\'ephane Ducasse and Philippe Mougin},
|
|
2777 |
booktitle = {Proceedings of the ECOOP '03 Workshop on Object-oriented Language Engineering for the Post-Java Era},
|
|
2778 |
keywords = {snf03 scg-pub skip-doi jb03 stefPub},
|
|
2779 |
month = jul,
|
|
2780 |
title = {Power to Collections: Generalizing Polymorphism by Unifying Array Programming and Object-Oriented Programming},
|
|
2781 |
url = {http://scg.unibe.ch/archive/papers/Duca03cOOPALEcoop.pdf},
|
|
2782 |
year = {2003},
|
|
2783 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca03cOOPALEcoop.pdf}
|
|
2784 |
}
|
|
2785 |
|
|
2786 |
@article{Duca03d,
|
|
2787 |
abstract = {Over the last decade many research groups and commercial companies have been developing reengineering environments. However, many design decisions such as support for multiple models, incremental loading of information, tool integration, entity grouping, and their impacts on the underlying meta-model and resulting environment have remained implicit. Based on the experience accumulated while developing the Moose reengineering environment and on a survey of reengineering environments, we present a design space defined by a set of criteria that makes explicit the different options and especially their dependencies and trade-offs. Using this design space, developers of future environments should have a better understanding of the problems they face and the impact of design choices.},
|
|
2788 |
annote = {internationaljournal},
|
|
2789 |
author = {St\'ephane Ducasse and Sander Tichelaar},
|
|
2790 |
doi = {10.1002/smr.279},
|
|
2791 |
journal = {Journal of Software Maintenance and Evolution: Research and Practice (JSME)},
|
|
2792 |
keywords = {scg-pub recast04 jb04 stefPub moose-pub},
|
|
2793 |
misc = {5 Year ISI impact factor 1.523 (2010)},
|
|
2794 |
impactfactor = {5 Year ISI impact factor 1.523 (2010)},
|
|
2795 |
month = oct,
|
|
2796 |
number = 5,
|
|
2797 |
pages = {345--373},
|
|
2798 |
title = {Dimensions of Reengineering Environment Infrastructures},
|
|
2799 |
url = {http://scg.unibe.ch/archive/papers/Duca03dInfrastructures.pdf},
|
|
2800 |
volume = 15,
|
|
2801 |
year = {2003},
|
|
2802 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca03dInfrastructures.pdf},
|
|
2803 |
bdsk-url-2 = {http://dx.doi.org/10.1002/smr.279}
|
|
2804 |
}
|
|
2805 |
|
|
2806 |
@misc{Duca03e,
|
|
2807 |
abstract = {SUnit is a minimal yet powerful framework that supports the creation of tests. In this article we start by discussing why we test, then we present an example with SUnit and we go deep into the SUnit implementation.},
|
|
2808 |
author = {St\'ephane Ducasse},
|
|
2809 |
title = {{SUnit} Explained},
|
|
2810 |
url = {http://www.iam.unibe.ch/~ducasse/Programmez/OnTheWeb/SUnitEnglish2.pdf},
|
|
2811 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/Programmez/OnTheWeb/SUnitEnglish2.pdf}
|
|
2812 |
}
|
|
2813 |
|
|
2814 |
@article{Duca03w,
|
|
2815 |
annote = {vulgarisation},
|
|
2816 |
author = {St\'ephane Ducasse},
|
|
2817 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2818 |
keywords = {stefPub},
|
|
2819 |
month = may,
|
|
2820 |
number = 53,
|
|
2821 |
title = {Seaside: Des composants pour le web},
|
|
2822 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2823 |
volume = 1,
|
|
2824 |
year = {2003},
|
|
2825 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html}
|
|
2826 |
}
|
|
2827 |
|
|
2828 |
@article{Duca03x,
|
|
2829 |
annote = {vulgarisation},
|
|
2830 |
author = {St\'ephane Ducasse},
|
|
2831 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2832 |
keywords = {stefPub},
|
|
2833 |
month = apr,
|
|
2834 |
number = 52,
|
|
2835 |
title = {Seaside: Des applications web complexes simplement...},
|
|
2836 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2837 |
volume = 1,
|
|
2838 |
year = {2003},
|
|
2839 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html}
|
|
2840 |
}
|
|
2841 |
|
|
2842 |
@article{Duca03y,
|
|
2843 |
annote = {vulgarisation},
|
|
2844 |
author = {St\'ephane Ducasse},
|
|
2845 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2846 |
keywords = {stefPub},
|
|
2847 |
month = mar,
|
|
2848 |
number = 51,
|
|
2849 |
title = {Squeak: R\'eflexion pour Prototyper},
|
|
2850 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2851 |
volume = 1,
|
|
2852 |
year = {2003},
|
|
2853 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html}
|
|
2854 |
}
|
|
2855 |
|
|
2856 |
@article{Duca03z,
|
|
2857 |
annote = {vulgarisation},
|
|
2858 |
author = {St\'ephane Ducasse},
|
|
2859 |
journal = {Programmez! Le Magazine du D\'eveloppement},
|
|
2860 |
keywords = {stefPub},
|
|
2861 |
month = feb,
|
|
2862 |
number = 50,
|
|
2863 |
title = {Espionnage en Squeak},
|
|
2864 |
url = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html},
|
|
2865 |
volume = 1,
|
|
2866 |
year = {2003},
|
|
2867 |
bdsk-url-1 = {http://www.iam.unibe.ch/~ducasse/WebPages/Books.html}
|
|
2868 |
}
|
|
2869 |
|
|
2870 |
@inproceedings{Duca04a,
|
|
2871 |
abstract = {Understanding the run-time behavior of object-oriented legacy systems is a complex task due to factors such as late binding and polymorphism. Current approaches extract and use information from the complete execution trace of a system. The sheer size and complexity of such traces make their handling, storage, and analysis difficult. Current software systems which run almost non-stop do not permit such a full analysis. In this paper we present a lightweight approach based on the extraction of a condensed amount of information, e.g., measurements, that does not require a full trace. Using this condensed information, we propose a visualization approach which allows us to identify and understand certain aspects of the objects' lifetime such as their role played in the creation of other objects and the communication architecture they support.},
|
|
2872 |
address = {Los Alamitos CA},
|
|
2873 |
annote = {internationalconference},
|
|
2874 |
author = {St\'ephane Ducasse and Michele Lanza and Roland Bertuli},
|
|
2875 |
booktitle = {Proceedings of 8th European Conference on Software Maintenance and Reengineering (CSMR'04)},
|
|
2876 |
doi = {10.1109/CSMR.2004.1281433},
|
|
2877 |
keywords = {recast04 scg-pub stefPub jb04 moose-pub},
|
|
2878 |
misc = {acceptance rate: 33/62 = 52\%},
|
|
2879 |
accepttotal = {62},
|
|
2880 |
acceptnum = {33},
|
|
2881 |
pages = {309--318},
|
|
2882 |
publisher = {IEEE Computer Society Press},
|
|
2883 |
title = {High-Level Polymetric Views of Condensed Run-Time Information},
|
|
2884 |
url = {http://scg.unibe.ch/archive/papers/Duca04aRuntimePolymetricViews.pdf},
|
|
2885 |
year = {2004},
|
|
2886 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca04aRuntimePolymetricViews.pdf},
|
|
2887 |
bdsk-url-2 = {http://dx.doi.org/10.1109/CSMR.2004.1281433}
|
|
2888 |
}
|
|
2889 |
|
|
2890 |
@inproceedings{Duca04b,
|
|
2891 |
abstract = {Due to the size and the extreme complexity of legacy systems, it is nearly impossible to write from scratch tests before refactoring them. In addition object-oriented legacy systems present specific requirements to test them. Indeed late-binding allow subclasses to change fundamental aspects of the superclass code and in particular call flows. Moreover Object-oriented programming promotes a distribution of the responsibilities to multiple entities leading to complex scenario to be tested. In such a context one of the few trustable source of information is the execution of the application itself. Traditional forward engineering approaches such as unit testing do not really provide adequate solution to this problem. Therefore there is a need for a more expressive way of testing the execution of object-oriented applications. We propose to represent the trace of object-oriented applications as logic facts and express tests over the trace. This way complex sequences of message exchanges, sequence matching, or expression of negative information are expressed in compact form. We validated our approach by implementing TestLog a prototype tool and testing the Moose reengineering environment and a meta-interpreter.},
|
|
2892 |
annote = {internationalworkshop},
|
|
2893 |
author = {St\'ephane Ducasse and Michael Freidig and Roel Wuyts},
|
|
2894 |
booktitle = {Fifth International Workshop on Object-Oriented
|
|
2895 |
Reengineering (WOOR 2004)},
|
|
2896 |
keywords = {scg-pub skip-doi recast04 jb04 evolution
|
|
2897 |
visualization test stefPub},
|
|
2898 |
title = {Logic and Trace-based Object-Oriented Application
|
|
2899 |
Testing},
|
|
2900 |
url = {http://scg.unibe.ch/archive/papers/Duca04bTestLogicWoor04.pdf},
|
|
2901 |
year = {2004},
|
|
2902 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca04bTestLogicWoor04.pdf}
|
|
2903 |
}
|
|
2904 |
|
|
2905 |
@techreport{Duca04d,
|
|
2906 |
abstract = {Understanding packages is an important activity in the reengineering of large object-oriented systems. The relationships between packages and their contained classes can affect the cost of modifying the system. The main problem of this task is to quickly grasp the structure of a package and how it interacts with the rest of the system. In this paper we present a top-down program comprehension strategy based on polymetric views, radar charts, and software metrics. We illustrate this approach on two applications and show how we can retrieve the important characteristics of packages.},
|
|
2907 |
annote = {report notrefereed},
|
|
2908 |
author = {St\'ephane Ducasse and Michele Lanza and Laura
|
|
2909 |
Ponisio},
|
|
2910 |
institution = {University of Bern, Institut of Applied Mathematics
|
|
2911 |
and Computer Sciences},
|
|
2912 |
keywords = {jb05 scg-pub skip-doi stefPub snf04 recast05
|
|
2913 |
moose-pub},
|
|
2914 |
number = {IAM-04-007},
|
|
2915 |
title = {A Top-Down Program Comprehension Strategy for
|
|
2916 |
Packages},
|
|
2917 |
type = {Technical Report},
|
|
2918 |
url = {http://scg.unibe.ch/archive/papers/Duca04dPackageVisualization.pdf},
|
|
2919 |
year = {2004},
|
|
2920 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca04dPackageVisualization.pdf}
|
|
2921 |
}
|
|
2922 |
|
|
2923 |
@inproceedings{Duca04e,
|
|
2924 |
abstract = {Developing web applications is difficult since (1) the client-server relationship is asymmetric: the server cannot update clients but only responds to client requests and (2) the navigation facilities of web browsers lead to a situation where servers cannot control the state of the clients. Page-centric web application frameworks fail to offer adequate solutions to model control flow at a high-level of abstraction. Developers have to work manually around the shortcomings of the HTTP protocol. Some approaches offer better abstractions by composing an application out of components, however they still fail to offer modeling control flow at a high level. Continuation-based approaches solve this problem by providing the facilities to model a control flow over several pages with one piece of code. However combining multiple flows inside the same page is difficult. This article presents Seaside. Seaside is a framework which combines an object-oriented approach with a continuation-based one. A Seaside application is built out of components (i.e., objects) and the logic of the application benefits from the continuation-based program flow infrastructure. Seaside offers a unique way to have multiple control flows on a page, one for each component. This enables the developer to write components that are highly reusable and that can be used to compose complex web applications with higher quality in less time.},
|
|
2925 |
annote = {internationalconference},
|
|
2926 |
author = {St\'ephane Ducasse and Adrian Lienhard and Lukas Renggli},
|
|
2927 |
booktitle = {Proceedings of 12th International Smalltalk Conference (ISC'04)},
|
|
2928 |
cvs = {seaside},
|
|
2929 |
keywords = {scg-pub skip-doi jb05 snf05 stefPub seaside-article},
|
|
2930 |
misc = {Also Technical Report IAM-04-008},
|
|
2931 |
month = sep,
|
|
2932 |
pages = {231--257},
|
|
2933 |
title = {Seaside --- a Multiple Control Flow Web Application Framework},
|
|
2934 |
url = {http://scg.unibe.ch/archive/papers/Duca04eSeaside.pdf
|
|
2935 |
http://www.iam.unibe.ch/publikationen/techreports/2004/iam-04-008},
|
|
2936 |
year = {2004},
|
|
2937 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca04eSeaside.pdf%20http://www.iam.unibe.ch/publikationen/techreports/2004/iam-04-008}
|
|
2938 |
}
|
|
2939 |
|
|
2940 |
@inproceedings{Duca04f,
|
|
2941 |
abstract = {The histories of software systems hold useful information when reasoning about the systems at hand or about general laws of software evolution. Yet, the approaches developed so far, do not rely on an explicit meta-model and do not facilitate the comparison of different evolutions. We argue for the need to define history as a first class entity and propose a meta-model centered around the notion of history. We show the usefulness of our a meta-model by discussing the different analysis it enables.},
|
|
2942 |
address = {Amsterdam},
|
|
2943 |
annote = {internationalworkshop},
|
|
2944 |
author = {St\'ephane Ducasse and Tudor G\^irba and Jean-Marie Favre},
|
|
2945 |
booktitle = {Proceedings Workshop on Software Evolution Through Transformation (SETra 2004)},
|
|
2946 |
doi = {10.1016/j.entcs.2004.08.035},
|
|
2947 |
keywords = {scg-pub evolution van stefPub recast05 jointERCIM
|
|
2948 |
girba hismo jb05 moose-pub},
|
|
2949 |
pages = {75--86},
|
|
2950 |
publisher = {Elsevier},
|
|
2951 |
title = {Modeling Software Evolution by Treating History as a First Class Entity},
|
|
2952 |
url = {http://scg.unibe.ch/archive/papers/Duca04fHismo.pdf},
|
|
2953 |
year = {2004},
|
|
2954 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca04fHismo.pdf},
|
|
2955 |
bdsk-url-2 = {http://dx.doi.org/10.1016/j.entcs.2004.08.035}
|
|
2956 |
}
|
|
2957 |
|
|
2958 |
@incollection{Duca05a,
|
|
2959 |
abstract = {Software systems are complex and difficult to analyze. Reverse engineering is a complex analysis that usually involves combining different techniques and tools. Moreover, oftentimes the existing tools are not perfectly suitable for the task, and customization of existing tools, or development of new tools is required. Moose is an extensible reengineering environment designed to provide the necessary infrastructure for tool integration. Moose centers on a language independent meta-model, and offers services like grouping, querying, navigation, and advanced tool integration mechanism.},
|
|
2960 |
address = {Milano},
|
|
2961 |
aeres = {OS},
|
|
2962 |
aeresstatus = {aeres08},
|
|
2963 |
annote = {articlebook},
|
|
2964 |
author = {St\'ephane Ducasse and Tudor G\^irba and Michele
|
|
2965 |
Lanza and Serge Demeyer},
|
|
2966 |
booktitle = {Tools for Software Maintenance and Reengineering},
|
|
2967 |
inria = {hors},
|
|
2968 |
isbn = {88-464-6396-X},
|
|
2969 |
keywords = {moose-pub scg-pub skip-doi jb05 recast05 stefPub
|
|
2970 |
jointERCIM girba},
|
|
2971 |
pages = {55--71},
|
|
2972 |
publisher = {Franco Angeli},
|
|
2973 |
series = {RCOST / Software Technology Series},
|
|
2974 |
title = {Moose: a Collaborative and Extensible Reengineering
|
|
2975 |
Environment},
|
|
2976 |
url = {http://scg.unibe.ch/archive/papers/Duca05aMooseBookChapter.pdf},
|
|
2977 |
year = {2005},
|
|
2978 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca05aMooseBookChapter.pdf}
|
|
2979 |
}
|
|
2980 |
|
|
2981 |
@article{Duca05b,
|
|
2982 |
abstract = {Understanding source code is an important task in the maintenance of software systems. Legacy systems are not only limited to procedural languages, but are also written in object-oriented languages. In such a context, understanding classes is a key activity as they are the cornerstone of the object-oriented paradigm and the primary abstraction from which applications are built. Such an understanding is however difficult to obtain because of reasons such as the presence of late binding and inheritance. A first level of class understanding consists of the understanding of its overall structure, the control flow among its methods, and the accesses on its attributes. We propose a novel xvisualization of classes called class blueprint that is based on a semantically enriched visualization of the internal structure of classes. This visualization allows a software engineer to build a first mental model of a class that he validates via opportunistic code-reading. Furthermore, we have identified visual patterns that represent recurrent situations and as such convey additional information to the viewer. The contributions of this article are the class blueprint, a novel visualization of the internal structure of classes, the identification of visual patterns, and the definition of a vocabulary based on these visual patterns. We have performed several case studies of which one is presented in depth, and validated the usefulness of the approach in a controlled experiment.},
|
|
2983 |
aeres = {ACL},
|
|
2984 |
aeresstatus = {aeres08},
|
|
2985 |
annote = {internationaljournal},
|
|
2986 |
author = {St\'ephane Ducasse and Michele Lanza},
|
|
2987 |
doi = {10.1109/TSE.2005.14},
|
|
2988 |
impactfactor = {5 Year ISI impact factor 4.865 (2010)},
|
|
2989 |
inria = {hors},
|
|
2990 |
journal = {Transactions on Software Engineering (TSE)},
|
|
2991 |
keywords = {hasler07 jb05 scg-pub stefPub recast05 mooseCincom
|
|
2992 |
moose-pub},
|
|
2993 |
misc = {5-year ISI impact factor 4.865 (2010)},
|
|
2994 |
month = jan,
|
|
2995 |
number = {1},
|
|
2996 |
pages = {75--90},
|
|
2997 |
publisher = {IEEE Computer Society},
|
|
2998 |
selectif = {oui},
|
|
2999 |
title = {The {Class} {Blueprint}: Visually Supporting the Understanding of Classes},
|
|
3000 |
url = {http://scg.unibe.ch/archive/papers/Duca05bTSEClassBlueprint.pdf},
|
|
3001 |
volume = {31},
|
|
3002 |
year = {2005},
|
|
3003 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca05bTSEClassBlueprint.pdf},
|
|
3004 |
bdsk-url-2 = {http://dx.doi.org/10.1109/TSE.2005.14}
|
|
3005 |
}
|
|
3006 |
|
|
3007 |
@inproceedings{Duca05d,
|
|
3008 |
annote = {internationalworkshop},
|
|
3009 |
author = {St\'ephane Ducasse and Tudor G\^irba},
|
|
3010 |
booktitle = {Proceedings of CHASE International Workshop 2005},
|
|
3011 |
keywords = {stefPub girba jb05},
|
|
3012 |
title = {Being a Long-Living Software Mayor --- the SimCity Metaphor to Explain the Challenges Behind Software Evolution},
|
|
3013 |
url = {http://scg.unibe.ch/archive/papers/Duca05dChaseSimCity.pdf},
|
|
3014 |
year = {2005},
|
|
3015 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca05dChaseSimCity.pdf}
|
|
3016 |
}
|
|
3017 |
|
|
3018 |
@inproceedings{Duca05e,
|
|
3019 |
abstract = {Understanding sets of classes, or packages, is an important activity in the
|
|
3020 |
development and reengineering of large object-oriented systems. Packages represent the
|
|
3021 |
coarse-grained structure of an application. They are artefacts to deploy and structure
|
|
3022 |
software, and therefore more than a simple generalization of classes. The relationships
|
|
3023 |
between packages and their contained classes are key in the decomposition of an application
|
|
3024 |
and its (re)-modularisation. However, it is difficult to quickly grasp the structure of a
|
|
3025 |
package and to understand how a package interacts with the rest of the system. We tackle
|
|
3026 |
this problem using butterfly visualizations, i.e. dedicated radar charts built from simple
|
|
3027 |
package metrics based on a language-independent meta-model. We illustrate our approach on
|
|
3028 |
two applications and show how we can retrieve the relevant characteristics of packages.},
|
|
3029 |
aeres = {ACT},
|
|
3030 |
aeresstatus = {aeres08},
|
|
3031 |
annote = {internationalconference},
|
|
3032 |
author = {St\'ephane Ducasse and Michele Lanza and Laura Ponisio},
|
|
3033 |
booktitle = {Proceedings of the 11th IEEE International Software Metrics Symposium (METRICS'05)},
|
|
3034 |
cvs = {AlchemistPackageMETRICS05},
|
|
3035 |
doi = {10.1109/METRICS.2005.15},
|
|
3036 |
inria = {hors},
|
|
3037 |
keywords = {jb06 scg-pub stefPub moose-pub recast06},
|
|
3038 |
misc = {acceptance rate: 39/89 = 44\%},
|
|
3039 |
accepttotal = {89},
|
|
3040 |
acceptnum = {39},
|
|
3041 |
pages = {70--77},
|
|
3042 |
publisher = {IEEE Computer Society},
|
|
3043 |
rate = {44%},
|
|
3044 |
selectif = {non},
|
|
3045 |
title = {Butterflies: A Visual Approach to Characterize Packages},
|
|
3046 |
url = {http://rmod.lille.inria.fr/archives/papers/Duca05e-Metrics-Butterflies-Ponisio.pdf},
|
|
3047 |
secondurl = {http://rmod.lille.inria.fr/archive/papers/Duca05ePackageVisualization.pdf},
|
|
3048 |
year = {2005}
|
|
3049 |
}
|
|
3050 |
|
|
3051 |
@inproceedings{Duca05f,
|
|
3052 |
abstract = {Software systems are complex and difficult to analyze. Reengineering is a complex activity that usually involves combining different techniques and tools. Moose is an reengineering environment designed to provide the necessary infrastructure for building new tools and for integrating them. Moose centers on a language independent meta-model, and offers services like grouping, querying, navigation, and meta-descriptions. Several tools have been built on top of Moose dealing with different aspects of reengineering like: visualization, evolution analysis, semantic analysis, concept analysis or dynamic analysis.},
|
|
3053 |
annote = {conference tooldemo},
|
|
3054 |
author = {St\'ephane Ducasse and Tudor G\^irba and Oscar
|
|
3055 |
Nierstrasz},
|
|
3056 |
booktitle = {Proceedings of ESEC/FSE 2005},
|
|
3057 |
cvs = {MooseDemoESEC05},
|
|
3058 |
doi = {10.1145/1081706.1081723},
|
|
3059 |
keywords = {scg-pub moose-pub stefPub jb06 recast06 girba},
|
|
3060 |
month = sep,
|
|
3061 |
note = {Tool demo},
|
|
3062 |
pages = {99--102},
|
|
3063 |
title = {{Moose}: an Agile Reengineering Environment},
|
|
3064 |
url = {http://scg.unibe.ch/archive/papers/Duca05fMooseDemo.pdf},
|
|
3065 |
year = {2005},
|
|
3066 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca05fMooseDemo.pdf},
|
|
3067 |
bdsk-url-2 = {http://dx.doi.org/10.1145/1081706.1081723}
|
|
3068 |
}
|
|
3069 |
|
|
3070 |
@article{Duca05g,
|
|
3071 |
abstract = {In pure object-oriented languages, classes are objects, instances of other classes called metaclasses. In the same way as classes define the properties of their instances, metaclasses define the properties of classes. It is therefore very natural to wish to reuse class properties, utilizing them amongst several classes. However this introduced metaclass composition problems, i.e., code fragments applied to one class may break when used on another class due to the inheritance relationship between their respective metaclasses. Numerous approaches have tried to solve metaclass composition problems, but they always resort to an ad-hoc manner of handling conflicting properties, alienating the meta-programmer. We propose a uniform approach that represents class properties as traits, groups of methods that act as a unit of reuse from which classes are composed. Like all the other classes in the system, metaclasses are composed out of traits. This solution supports the reuse of class properties, and their safe and automatic composition based on explicit conflict resolution. The paper discusses traits and our solution, shows concrete examples implemented in the Smalltalk environment Squeak, and compares our approach with existing models for composing class properties.},
|
|
3072 |
aeres = {ACL},
|
|
3073 |
aeresstastus = {2008},
|
|
3074 |
annote = {internationaljournal},
|
|
3075 |
author = {St\'ephane Ducasse and Nathanael Sch{\"a}rli and
|
|
3076 |
Roel Wuyts},
|
|
3077 |
doi = {10.1016/j.cl.2004.11.003},
|
|
3078 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
3079 |
inria = {hors},
|
|
3080 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
3081 |
keywords = {scg08 scg-pub stefPub schaerli jb05 snf05},
|
|
3082 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
3083 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
3084 |
month = dec,
|
|
3085 |
number = {3-4},
|
|
3086 |
pages = {143--164},
|
|
3087 |
peerreview = {yes},
|
|
3088 |
publisher = {Elsevier},
|
|
3089 |
selectif = {non},
|
|
3090 |
title = {Uniform and Safe Metaclass Composition},
|
|
3091 |
url = {http://scg.unibe.ch/archive/papers/Duca05ySafeMetaclassTrait.pdf},
|
|
3092 |
volume = {31},
|
|
3093 |
year = {2005},
|
|
3094 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca05ySafeMetaclassTrait.pdf}
|
|
3095 |
}
|
|
3096 |
|
|
3097 |
@inproceedings{Duca05h,
|
|
3098 |
abstract = {Wikis are often implemented using string-based approaches to parse and generate their pages. While such approaches work well for simple wikis, they hamper the customization and adaptability of wikis to the variety of end-users when more sophisticated needs are required (i.e., different output formats, user-interfaces, wiki managment, security policies, ...). In this paper we present SmallWiki, the second version of a fully object-oriented implementation of a wiki. SmallWiki is implemented with objects from the top to the bottom and it can be customized easily to accommodate new needs. In addition, SmallWiki is based on a powerful meta-description called Magritte that allows one to create user-interface elements declaratively.},
|
|
3099 |
address = {New York, NY, USA},
|
|
3100 |
aeres = {ACT},
|
|
3101 |
aeresstatus = {aeres08},
|
|
3102 |
annote = {internationalconference},
|
|
3103 |
author = {St\'ephane Ducasse and Lukas Renggli and Roel Wuyts},
|
|
3104 |
booktitle = {Proceedings ACM International Symposium on Wikis
|
|
3105 |
(WikiSym'05)},
|
|
3106 |
cvs = {SmallWikiTwoOOPSLASymp2005},
|
|
3107 |
doi = {10.1145/1104973.1104981},
|
|
3108 |
inria = {hors},
|
|
3109 |
keywords = {jb06 scg-pub snf-none stefPub moose-pub},
|
|
3110 |
pages = {75--82},
|
|
3111 |
publisher = {ACM Computer Society},
|
|
3112 |
selectif = {non},
|
|
3113 |
title = {{SmallWiki} --- A Meta-Described Collaborative
|
|
3114 |
Content Management System},
|
|
3115 |
url = {http://scg.unibe.ch/archive/papers/Duca05hSmallwikiWikiSymp05.pdf},
|
|
3116 |
year = {2005},
|
|
3117 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca05hSmallwikiWikiSymp05.pdf},
|
|
3118 |
bdsk-url-2 = {http://dx.doi.org/10.1145/1104973.1104981}
|
|
3119 |
}
|
|
3120 |
|
|
3121 |
@inproceedings{Duca05i,
|
|
3122 |
abstract = {Understanding classes and methods is a key activity in object-oriented programming, since classes represent the primary abstractions from which applications are built, while methods contain the actual program logic. The main problem of this task is to quickly grasp the purpose and inner structure of a class. To achieve this goal, one must be able to overview multiple methods at once. In this paper, we present microprints, pixel-based representations of methods enriched with semantical information. We present three specialized microprints each dealing with a specific aspect we want to understand of methods: (1) state access, (2) control flow, and (3) invocation relationship.},
|
|
3123 |
annote = {internationalworkshop},
|
|
3124 |
author = {St\'ephane Ducasse and Michele Lanza and Romain
|
|
3125 |
Robbes},
|
|
3126 |
booktitle = {Proceedings of {VISSOFT} 2005 (3th IEEE
|
|
3127 |
International Workshop on Visualizing Software for
|
|
3128 |
Understanding)},
|
|
3129 |
keywords = {scg-pub skip-doi jb06 MISSINGPAGENUMBERS stefPub
|
|
3130 |
recast06},
|
|
3131 |
month = sep,
|
|
3132 |
title = {Multi-level Method Understanding Using
|
|
3133 |
{Microprints}},
|
|
3134 |
url = {http://scg.unibe.ch/archive/papers/Duca05imicroprintsVissoft.pdf},
|
|
3135 |
year = {2005},
|
|
3136 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca05imicroprintsVissoft.pdf}
|
|
3137 |
}
|
|
3138 |
|
|
3139 |
@book{Duca05j,
|
|
3140 |
aeres = {OV},
|
|
3141 |
aeresstatus = {aeres08},
|
|
3142 |
annote = {book},
|
|
3143 |
author = {St\'ephane Ducasse},
|
|
3144 |
keywords = {stefPub jb05 scglib},
|
|
3145 |
note = {ISBN: 1-59059-491-6},
|
|
3146 |
publisher = {APress},
|
|
3147 |
title = {Squeak: Learn Programming with Robots},
|
|
3148 |
year = {2005},
|
|
3149 |
x-scientific-popularization = {yes}
|
|
3150 |
}
|
|
3151 |
|
|
3152 |
@misc{Duca05k,
|
|
3153 |
aeres = {OV},
|
|
3154 |
aeresstastus = {2008},
|
|
3155 |
annote = {vulgarisation},
|
|
3156 |
author = {St\'ephane Ducasse and Hilaire Fernandes},
|
|
3157 |
inria = {hors},
|
|
3158 |
journal = {Linux Pratique},
|
|
3159 |
keywords = {stefPub jb05},
|
|
3160 |
month = mar,
|
|
3161 |
number = 89,
|
|
3162 |
pages = {18--23},
|
|
3163 |
selectif = {non},
|
|
3164 |
title = {Squeak: un Smalltalk libre multim\'edia},
|
|
3165 |
volume = 1,
|
|
3166 |
year = {2005},
|
|
3167 |
x-scientific-popularization = {yes}
|
|
3168 |
}
|
|
3169 |
|
|
3170 |
@inproceedings{Duca06a,
|
|
3171 |
abstract = {When reengineering legacy systems, it is crucial to assess if the legacy behavior has been preserved or how it changed due to the reengineering effort. Ideally if a legacy system is covered by tests, running the tests on the new version can identify potential differences or discrepancies. However, writing tests for an unknown and large system is difficult due to the lack of internal knowledge. It is especially difficult to bring the system to an appropriate state. Our solution is based on the acknowledgment that one of the few trustable piece of information available when approaching a legacy system is the running system itself. Our approach reifies the execution traces and uses logic programming to express tests on them. Thereby it eliminates the need to programatically bring the system in a particular state, and handles the test-writer a high-level abstraction mechanism to query the trace. The resulting system, called TESTLOG, was used on several real-world case studies to validate our claims.},
|
|
3172 |
aeres = {ACT},
|
|
3173 |
aeresstatus = {aeres08},
|
|
3174 |
annote = {internationalconference},
|
|
3175 |
author = {St\'ephane Ducasse and Tudor G\^irba and Roel Wuyts},
|
|
3176 |
booktitle = {Proceedings of 10th European Conference on Software
|
|
3177 |
Maintenance and Reengineering (CSMR'06)},
|
|
3178 |
doi = {10.1109/CSMR.2006.37},
|
|
3179 |
inria = {hors},
|
|
3180 |
keywords = {scg-pub recast06 snf06 jb06 fb06 stefPub girba},
|
|
3181 |
medium = {2},
|
|
3182 |
misc = {acceptance rate: 27/65 = 42 \%},
|
|
3183 |
accepttotal = {65},
|
|
3184 |
acceptnum = {27},
|
|
3185 |
pages = {35--44},
|
|
3186 |
peerreview = {yes},
|
|
3187 |
publisher = {IEEE Computer Society Press},
|
|
3188 |
selectif = {non},
|
|
3189 |
title = {Object-Oriented Legacy System Trace-based Logic
|
|
3190 |
Testing},
|
|
3191 |
url = {http://scg.unibe.ch/archive/papers/Duca06aTestLogtestingCSMR.pdf},
|
|
3192 |
year = {2006},
|
|
3193 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca06aTestLogtestingCSMR.pdf},
|
|
3194 |
bdsk-url-2 = {http://dx.doi.org/10.1109/CSMR.2006.37}
|
|
3195 |
}
|
|
3196 |
|
|
3197 |
@article{Duca06b,
|
|
3198 |
abstract = {Inheritance is well-known and accepted as a mechanism for reuse in object-oriented languages. Unfortunately, due to the coarse granularity of inheritance, it may be difficult to decompose an application into an optimal class hierarchy that maximizes software reuse. Existing schemes based on single inheritance, multiple inheritance, or mixins, all pose numerous problems for reuse. To overcome these problems we propose traits, pure units of reuse consisting only of methods. We develop a formal model of traits that establishes how traits can be composed, either to form other traits, or to form classes. We also outline an experimental validation in which we apply traits to refactor a non-trivial application into composable units.},
|
|
3199 |
aeres = {ACL},
|
|
3200 |
aeresstatus = {aeres08},
|
|
3201 |
annote = {internationaljournal},
|
|
3202 |
author = {St\'ephane Ducasse and Oscar Nierstrasz and Nathanael Sch{\"a}rli and Roel Wuyts and Andrew P. Black},
|
|
3203 |
cvs = {TraitsTOPLAS2005},
|
|
3204 |
doi = {10.1145/1119479.1119483},
|
|
3205 |
inria = {hors},
|
|
3206 |
issn = {0164-0925},
|
|
3207 |
journal = {ACM Transactions on Programming Languages and Systems (TOPLAS)},
|
|
3208 |
keywords = {scg-pub stefPub snf05 snf06 jb06 toplas traits
|
|
3209 |
schaerli toplastraits stlit-traits},
|
|
3210 |
misc = {5-Year ISI impact factor 1.478 (2010), CORE A*},
|
|
3211 |
impactfactor = {5-Year ISI impact factor 1.478 (2010), CORE A*},
|
|
3212 |
miscmisc = {SCI impact factor 1.404 (2005)},
|
|
3213 |
month = mar,
|
|
3214 |
number = {2},
|
|
3215 |
pages = {331--388},
|
|
3216 |
selectif = {oui},
|
|
3217 |
title = {Traits: A Mechanism for fine-grained Reuse},
|
|
3218 |
url = {http://scg.unibe.ch/archive/papers/Duca06bTOPLASTraits.pdf},
|
|
3219 |
secondurl = {http://scg.unibe.ch/archive/papers/Duca06bTOPLASTraits.pdf},
|
|
3220 |
volume = {28},
|
|
3221 |
year = {2006}
|
|
3222 |
}
|
|
3223 |
|
|
3224 |
@inproceedings{Duca06c,
|
|
3225 |
abstract = {Understanding large software systems is a challenging task, and to support it many approaches have been developed. Often, the result of these approaches categorize existing entities into new groups or associates them with mutually exclusive properties. In this paper we present the Distribution Map as a generic technique to visualize and analyze this type of result. Our technique is based on the notion of focus, which shows whether a property is well-encapsulated or cross-cutting, and the notion of spread, which shows whether the property is present in several parts of the system. We present a basic visualization and complement it with measurements that quantify focus and spread. To validate our technique we show evidence of applying it on the result sets of different analysis approaches. As a conclusion we propose that the Distribution Map technique should belong to any reverse engineering toolkit.},
|
|
3226 |
address = {Los Alamitos CA},
|
|
3227 |
aeres = {ACT},
|
|
3228 |
aeresstatus = {aeres08},
|
|
3229 |
annote = {internationalconference},
|
|
3230 |
author = {St\'ephane Ducasse and Tudor G\^irba and Adrian
|
|
3231 |
Kuhn},
|
|
3232 |
booktitle = {Proceedings of 22nd IEEE International Conference on
|
|
3233 |
Software Maintenance (ICSM '06)},
|
|
3234 |
doi = {10.1109/ICSM.2006.22},
|
|
3235 |
inria = {hors},
|
|
3236 |
keywords = {scg-pub jb07 fb06 stefPub moose-pub girba recast07
|
|
3237 |
snf06 akuhn},
|
|
3238 |
medium = {2},
|
|
3239 |
misc = {acceptance rate: 41/147 = 28\%},
|
|
3240 |
accepttotal = {147},
|
|
3241 |
acceptnum = {41},
|
|
3242 |
pages = {203--212},
|
|
3243 |
peerreview = {yes},
|
|
3244 |
publisher = {IEEE Computer Society},
|
|
3245 |
rate = {28%},
|
|
3246 |
selectif = {oui},
|
|
3247 |
title = {Distribution Map},
|
|
3248 |
url = {http://scg.unibe.ch/archive/papers/Duca06cDistributionMap.pdf},
|
|
3249 |
year = {2006},
|
|
3250 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca06cDistributionMap.pdf},
|
|
3251 |
bdsk-url-2 = {http://dx.doi.org/10.1109/ICSM.2006.22}
|
|
3252 |
}
|
|
3253 |
|
|
3254 |
@inproceedings{Duca06d,
|
|
3255 |
abstract = {Object-oriented meta-languages such as MOF or EMOF are often used to specify domain specific languages. However, these meta-languages lack the ability to describe behavior or operational semantics. Several approaches used a subset of Java mixed with OCL as executable meta-languages. In this paper, we report our experience of using Smalltalk as an executable and integrated meta-language. We validated this approach in incrementally building over the last decade, Moose, a meta-described reengineering environment. The reflective capabilities of Smalltalk support a uniform way of letting the base developer focus on his tasks while at the same time allowing him to meta-describe his domain model. The advantage of our this approach is that the developer uses the same tools and environment},
|
|
3256 |
address = {Berlin, Germany},
|
|
3257 |
aeres = {ACT},
|
|
3258 |
annote = {internationalconference},
|
|
3259 |
author = {St\'ephane Ducasse and Tudor G\^irba},
|
|
3260 |
booktitle = {International Conference on Model Driven Engineering
|
|
3261 |
Languages and Systems (Models/UML 2006)},
|
|
3262 |
doi = {10.1007/11880240\_42},
|
|
3263 |
inria = {hors},
|
|
3264 |
isbn = {978-3-540-45772-5},
|
|
3265 |
keywords = {scg-pub jb07 fb06 girba moose-pub stefPub recast07
|
|
3266 |
norex06},
|
|
3267 |
medium = {2},
|
|
3268 |
pages = {604--618},
|
|
3269 |
peerreview = {yes},
|
|
3270 |
publisher = {Springer-Verlag},
|
|
3271 |
rate = {28%},
|
|
3272 |
selectif = {oui},
|
|
3273 |
series = {LNCS},
|
|
3274 |
title = {Using {Smalltalk} as a Reflective Executable
|
|
3275 |
Meta-Language},
|
|
3276 |
url = {http://scg.unibe.ch/archive/papers/Duca06dMOOSEMODELS2006.pdf},
|
|
3277 |
volume = {4199},
|
|
3278 |
year = {2006},
|
|
3279 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca06dMOOSEMODELS2006.pdf},
|
|
3280 |
bdsk-url-2 = {http://dx.doi.org/10.1007/11880240_42}
|
|
3281 |
}
|
|
3282 |
|
|
3283 |
@misc{Duca06e,
|
|
3284 |
aeres = {OV},
|
|
3285 |
annote = {vulgarisation},
|
|
3286 |
author = {St\'ephane Ducasse and Hilaire Fernandes},
|
|
3287 |
inria = {hors},
|
|
3288 |
journal = {Linux Magazine},
|
|
3289 |
keywords = {stefPub},
|
|
3290 |
month = may,
|
|
3291 |
number = 83,
|
|
3292 |
pages = {18--23},
|
|
3293 |
selectif = {non},
|
|
3294 |
title = {La syntaxe Smalltalk par la pratique},
|
|
3295 |
volume = 1,
|
|
3296 |
year = {2006},
|
|
3297 |
x-scientific-popularization = {yes}
|
|
3298 |
}
|
|
3299 |
|
|
3300 |
@misc{Duca06f,
|
|
3301 |
aeres = {OV},
|
|
3302 |
annote = {vulgarisation},
|
|
3303 |
author = {St\'ephane Ducasse and Serge Stinckwich},
|
|
3304 |
inria = {hors},
|
|
3305 |
journal = {Linux Magazine},
|
|
3306 |
keywords = {stefPub},
|
|
3307 |
month = sep,
|
|
3308 |
number = 86,
|
|
3309 |
selectif = {non},
|
|
3310 |
title = {Seaside: d\'eveloppement d'applications web en Smalltalk},
|
|
3311 |
volume = 1,
|
|
3312 |
year = {2006},
|
|
3313 |
x-scientific-popularization = {yes}
|
|
3314 |
}
|
|
3315 |
|
|
3316 |
@misc{Duca06g,
|
|
3317 |
aeres = {OV},
|
|
3318 |
annote = {vulgarisation},
|
|
3319 |
author = {St\'ephane Ducasse and Serge Stinckwich},
|
|
3320 |
inria = {hors},
|
|
3321 |
journal = {Linux Magazine},
|
|
3322 |
keywords = {stefPub},
|
|
3323 |
month = nov,
|
|
3324 |
number = 88,
|
|
3325 |
selectif = {non},
|
|
3326 |
title = {Seaside: d\'evelopper des composants r\'eutilisables},
|
|
3327 |
volume = 1,
|
|
3328 |
year = {2006},
|
|
3329 |
x-scientific-popularization = {yes}
|
|
3330 |
}
|
|
3331 |
|
|
3332 |
@article{Duca06h,
|
|
3333 |
aeres = {OV},
|
|
3334 |
annote = {vulgarisation},
|
|
3335 |
author = {St\'ephane Ducasse and Serge Stinckwich},
|
|
3336 |
inria = {hors},
|
|
3337 |
journal = {Linux Magazine},
|
|
3338 |
keywords = {stefPub},
|
|
3339 |
month = dec,
|
|
3340 |
number = 89,
|
|
3341 |
selectif = {non},
|
|
3342 |
title = {Smalltalk: un mod\`ele pur objet},
|
|
3343 |
volume = 1,
|
|
3344 |
year = {2006},
|
|
3345 |
x-scientific-popularization = {yes}
|
|
3346 |
}
|
|
3347 |
|
|
3348 |
@article{Duca06i,
|
|
3349 |
abstract = {Although duplicated code is known to pose severe problems for software maintenance, it is difficult to identify in large systems. Many different techniques have been developed to detect software clones, some of which are very sophisticated, but are also expensive to implement and adapt. Lightweight techniques based on simple string matching are easy to implement, but how effective are they? We present a simple stringbased approach which we have successfully applied to a number of different languages such COBOL, {Java}, C++, Pascal, Python, Smalltalk, C and PDP-11 assembler. In each case the maximum time to adapt the approach to a new language was less than 45 minutes. In this article we investigate a number of simple variants of string-based clone detection that abstract away from common editing operations, and assess the quality of clone detection for very different case studies. Our results confirm that this inexpensive clone detection technique generally achieves high recall and acceptable precision. Over-zealous normalization of the code before comparison, however, can result in unacceptable numbers of false positives.},
|
|
3350 |
aeres = {ACT},
|
|
3351 |
aeresstatus = {aeres08},
|
|
3352 |
annote = {internationaljournal},
|
|
3353 |
author = {St\'ephane Ducasse and Oscar Nierstrasz and Matthias
|
|
3354 |
Rieger},
|
|
3355 |
cvs = {DuplocJournalPaper},
|
|
3356 |
doi = {10.1002/smr.317},
|
|
3357 |
inria = {hors},
|
|
3358 |
journal = {Journal of Software Maintenance and Evolution: Research and Practice (JSME)},
|
|
3359 |
keywords = {scg-pub recast06 jb06 stefPub duploc},
|
|
3360 |
misc = {5 Year ISI impact factor 1.523 (2010)},
|
|
3361 |
impactfactor = {5 Year ISI impact factor 1.523 (2010)},
|
|
3362 |
month = jan,
|
|
3363 |
number = 1,
|
|
3364 |
pages = {37--58},
|
|
3365 |
selectif = {non},
|
|
3366 |
title = {On the Effectiveness of Clone Detection by String Matching},
|
|
3367 |
url = {http://scg.unibe.ch/archive/papers/Duca06iDuplocJSMEPaper.pdf},
|
|
3368 |
volume = 18,
|
|
3369 |
year = {2006},
|
|
3370 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca06iDuplocJSMEPaper.pdf},
|
|
3371 |
bdsk-url-2 = {http://dx.doi.org/10.1002/smr.317}
|
|
3372 |
}
|
|
3373 |
|
|
3374 |
@article{Duca07a,
|
|
3375 |
abstract = {Nowadays, many complex applications are built with a web browser as their main user interface. However, despite the increasing popularity of the web as an application platform, implementing and maintaining web applications still remains difficult and lags behind conventional desktop application development. The underlying technologies such as HTTP for the interaction and XHTML/CSS for the presentation were originally built to display and link static documents. Unfortunately, most mainstream frameworks provide only little abstraction over the page-oriented structure imposed by those technologies. Inevitably, the goto-like manner of how pages are linked leads to spaghetti code and hampers reuse. In this article we present Seaside, a web application framework that provides an uniform and pure object-oriented view on web applications. In this way, Seaside avoids the unwieldily goto-like style. Exploiting the reflective features of Smalltalk, Seaside reintroduces procedure call abstraction in the client-server context. Seaside's key concepts are: (i) a component architecture supporting multiple, simultaneously active control flows, (ii) a programmatic XHTML generation, and (iii) fully supported on-the-fly debugging, code-editing, and recompilation. In this article we discuss these key features of Seaside and explain how they are made possible by the dynamic nature and the reflective capabilities of Smalltalk.},
|
|
3376 |
address = {Los Alamitos, CA, USA},
|
|
3377 |
aeres = {ACL},
|
|
3378 |
aeresstatus = {aeres08},
|
|
3379 |
annote = {internationaljournal},
|
|
3380 |
author = {St\'ephane Ducasse and Adrian Lienhard and Lukas Renggli},
|
|
3381 |
doi = {10.1109/MS.2007.144},
|
|
3382 |
inria = {hors},
|
|
3383 |
issn = {0740-7459},
|
|
3384 |
journal = {IEEE Software},
|
|
3385 |
keywords = {scg07 scg-pub jb08 snf07 seaside-article},
|
|
3386 |
number = {5},
|
|
3387 |
pages = {56--63},
|
|
3388 |
peerreview = {yes},
|
|
3389 |
publisher = {IEEE Computer Society},
|
|
3390 |
selectif = {oui},
|
|
3391 |
title = {Seaside: A Flexible Environment for Building Dynamic Web Applications},
|
|
3392 |
url = {http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4302687},
|
|
3393 |
volume = {24},
|
|
3394 |
year = {2007},
|
|
3395 |
misc = {5-year ISI impact factor 2.551 (2010)},
|
|
3396 |
impactfactor = {5-year ISI impact factor 2.551 (2010)},
|
|
3397 |
doi = {10.1109/MS.2007.144}
|
|
3398 |
}
|
|
3399 |
|
|
3400 |
@inproceedings{Duca07b,
|
|
3401 |
abstract = {A trait is a unit of behaviour that can be composed with other traits and used by classes. Traits offer an alternative to multiple inheritance. Conflict resolution of traits, while flexible, does not completely handle accidental method name conflicts: if a trait with method m is composed with another trait defining a different method m then resolving the conflict may prove delicate or infeasible in cases where both versions of m are still needed. In this paper we present freezable traits, which provide an expressive composition mechanism to support unanticipated method composition conflicts. Our solution introduces private trait methods and lets the class composer change method visibility at composition time (from public to private and vice versa). Moreover two class composers may use different composition policies for the same trait, something which is not possible in mainstream languages. This approach respects the two main design principles of traits: the class composer is empowered and traits can be flattened away. We present an implementation of freezable traits in Smalltalk. As a side-effect of this implementation we introduced private (early-bound and invisible) methods to Smalltalk by distinguishing object-sends from self-sends. Our implementation uses compile-time bytecode manipulation and, as such, introduces no run-time penalties.},
|
|
3402 |
address = {New York, NY, USA},
|
|
3403 |
aeres = {ACT},
|
|
3404 |
aeresstatus = {aeres08},
|
|
3405 |
annote = {internationalconference topconference},
|
|
3406 |
author = {St\'ephane Ducasse and Roel Wuyts and Alexandre Bergel and Oscar Nierstrasz},
|
|
3407 |
booktitle = {Proceedings of 22nd International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA'07)},
|
|
3408 |
doi = {10.1145/1297027.1297040},
|
|
3409 |
inria = {hors},
|
|
3410 |
isbn = {978-1-59593-786-5},
|
|
3411 |
keywords = {scg07 snf08 stefPub alexPub jb08 scg-pub},
|
|
3412 |
location = {Montreal, Quebec, Canada},
|
|
3413 |
medium = {2},
|
|
3414 |
misc = {Acceptance rate: 33/156:21\%},
|
|
3415 |
accepttotal = {156},
|
|
3416 |
acceptnum = {33},
|
|
3417 |
month = oct,
|
|
3418 |
pages = {171--190},
|
|
3419 |
peerreview = {yes},
|
|
3420 |
publisher = {ACM Press},
|
|
3421 |
rate = {21%},
|
|
3422 |
selectif = {oui},
|
|
3423 |
title = {User-Changeable Visibility: Resolving Unanticipated
|
|
3424 |
Name Clashes in Traits},
|
|
3425 |
url = {http://scg.unibe.ch/archive/papers/Duca07b-FreezableTrait.pdf},
|
|
3426 |
year = {2007},
|
|
3427 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca07b-FreezableTrait.pdf},
|
|
3428 |
bdsk-url-2 = {http://dx.doi.org/10.1145/1297027.1297040}
|
|
3429 |
}
|
|
3430 |
|
|
3431 |
@inproceedings{Duca07c,
|
|
3432 |
abstract = {Large object-oriented applications are structured over large number of packages. Packages are important but complex structural entities that may be difficult to understand since they play different development roles (i.e., class containers, code ownership basic structure, architectural elements...). Maintainers of large applications face the problem of understanding how packages are structured in general and how they relate to each others. In this paper, we present a compact visualization, named Package Surface Blueprint, that qualifies the relationships that a package has with its neighbours. A Package Surface Blueprint represents packages around the notion of package surfaces: groups of relationships according to the packages they refer to. We present two specific views one stressing the references made by a package and another showing the inheritance structure of a package. We applied the visualization on two large case studies: ArgoUML and Squeak.},
|
|
3433 |
aeres = {ACT},
|
|
3434 |
aeresstatus = {aeres08},
|
|
3435 |
annote = {internationalconference stefPub},
|
|
3436 |
author = {St\'ephane Ducasse and Damien Pollet and Mathieu
|
|
3437 |
Suen and Hani Abdeen and Ilham Alloui},
|
|
3438 |
booktitle = {ICSM '07: Proceedings of the IEEE International
|
|
3439 |
Conference on Software Maintenance},
|
|
3440 |
inria = {hors},
|
|
3441 |
keywords = {moose-pub},
|
|
3442 |
misc = {acceptance rate: 46/214 = 21\%},
|
|
3443 |
accepttotal = {214},
|
|
3444 |
acceptnum = {46},
|
|
3445 |
pages = {94--103},
|
|
3446 |
rate = {21%},
|
|
3447 |
selectif = {oui},
|
|
3448 |
title = {Package Surface Blueprints: Visually Supporting the
|
|
3449 |
Understanding of Package Relationships},
|
|
3450 |
url = {http://scg.unibe.ch/archive/papers/Duca07cPackageBlueprintICSM2007.pdf},
|
|
3451 |
year = {2007},
|
|
3452 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca07cPackageBlueprintICSM2007.pdf}
|
|
3453 |
}
|
|
3454 |
|
|
3455 |
@misc{Duca07y,
|
|
3456 |
aeres = {OV},
|
|
3457 |
aeresstatus = {aeres08},
|
|
3458 |
annote = {vulgarisation},
|
|
3459 |
author = {St\'ephane Ducasse and Hilaire Fernandes},
|
|
3460 |
inria = {hors},
|
|
3461 |
journal = {Linux Magazine},
|
|
3462 |
keywords = {stefPub},
|
|
3463 |
month = mar,
|
|
3464 |
number = 92,
|
|
3465 |
pages = {18--23},
|
|
3466 |
selectif = {non},
|
|
3467 |
title = {Smalltalk et design patterns, un couple assorti},
|
|
3468 |
volume = 1,
|
|
3469 |
year = {2007},
|
|
3470 |
x-scientific-popularization = {yes}
|
|
3471 |
}
|
|
3472 |
|
|
3473 |
@misc{Duca07z,
|
|
3474 |
aeres = {OV},
|
|
3475 |
aeresstatus = {aeres08},
|
|
3476 |
annote = {vulgarisation},
|
|
3477 |
author = {St\'ephane Ducasse and Hilaire Fernandes},
|
|
3478 |
inria = {hors},
|
|
3479 |
journal = {Linux Magazine},
|
|
3480 |
keywords = {stefPub},
|
|
3481 |
month = may,
|
|
3482 |
number = 94,
|
|
3483 |
pages = {18--23},
|
|
3484 |
selectif = {non},
|
|
3485 |
title = {Tests unitaires en Smalltalk},
|
|
3486 |
volume = 1,
|
|
3487 |
year = {2007},
|
|
3488 |
x-scientific-popularization = {yes}
|
|
3489 |
}
|
|
3490 |
|
|
3491 |
@article{Duca08a,
|
|
3492 |
annote = {internationaljournal},
|
|
3493 |
author = {St\'ephane Ducasse and Tudor G\^irba and Adrian Kuhn and Lukas Renggli},
|
|
3494 |
journal = {Journal of Software and Systems Modeling (SOSYM)},
|
|
3495 |
publisher = {Springer Verlag},
|
|
3496 |
title = {Meta-Environment and Executable Meta-Language using {Smalltalk}: an Experience Report},
|
|
3497 |
aeres = {ACL},
|
|
3498 |
selectif = {oui},
|
|
3499 |
labo = {dans},
|
|
3500 |
inria = {RMOD},
|
|
3501 |
inriareport = {2009},
|
|
3502 |
annote = {internationaljournal cook-pub remoose1-pub},
|
|
3503 |
url = {http://scg.unibe.ch/archive/drafts/Duca08a-Sosym-ExecutableMetaLanguage.pdf},
|
|
3504 |
doi = {10.1007/s10270-008-0081-4},
|
|
3505 |
month = feb,
|
|
3506 |
number = {1},
|
|
3507 |
pages = {5--19},
|
|
3508 |
volume = {8},
|
|
3509 |
year = {2009},
|
|
3510 |
x-pays = {CH},
|
|
3511 |
x-editorial-board = {yes},
|
|
3512 |
x-proceedings = {yes},
|
|
3513 |
x-international-audience = {yes},
|
|
3514 |
x-language = {EN},
|
|
3515 |
abstract = {No abstract}
|
|
3516 |
}
|
|
3517 |
|
|
3518 |
@inproceedings{Duca08b,
|
|
3519 |
abstract = {The increasing amount of data available about software systems poses new challenges for re- and reverse engineering research, as the proposed approaches need to scale. In this context, concerns about meta-modeling and analysis techniques need to be augmented by technical concerns about how to reuse and how to build upon the efforts of previous research. Moose is an extensive infrastructure for reverse engineering evolved for over 10 years that promotes the reuse of engineering efforts in research. Moose accommodates various types of data modeled in the FAMIX family of meta-models. The goal of this half-day workshop is to strengthen the community of researchers and practitioners who are working in re- and reverse engineering, by providing a forum for building future research starting from Moose and FAMIX as shared infrastructure.},
|
|
3520 |
annote = {workshop},
|
|
3521 |
author = {St\'ephane Ducasse and Tudor G\^irba and Orla Greevy and Michele Lanza and Oscar Nierstrasz},
|
|
3522 |
booktitle = {15th Working Conference on Software Maintenance and Reengineering (WCRE 2008)},
|
|
3523 |
doi = {10.1109/WCRE.2008.51},
|
|
3524 |
keywords = {scg08 scg-pub greevy girba jb09 hasler08 moose-pub
|
|
3525 |
stefPub},
|
|
3526 |
month = oct,
|
|
3527 |
pages = {343--344},
|
|
3528 |
peerreview = {yes},
|
|
3529 |
title = {Workshop on {FAMIX} and {Moose} in Software Reengineering ({FAMOOSr} 2008)},
|
|
3530 |
url = {http://scg.unibe.ch/archive/papers/Duca08bFAMOOSr2008.pdf},
|
|
3531 |
year = {2008},
|
|
3532 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca08bFAMOOSr2008.pdf},
|
|
3533 |
bdsk-url-2 = {http://dx.doi.org/10.1109/WCRE.2008.51}
|
|
3534 |
}
|
|
3535 |
|
|
3536 |
@inproceedings{Duca09a,
|
|
3537 |
author = {Ducasse, St\'ephane and Pollet, Damien and Bergel, Alexandre and Cassou, Damien},
|
|
3538 |
title = {Reusing and Composing Tests with Traits},
|
|
3539 |
booktitle = {Proceedings of the 47th International Conference Objects, Models, Components, Patterns (TOOLS-Europe'09)},
|
|
3540 |
hal = {http://hal.archives-ouvertes.fr/docs/00/40/35/68/PDF/Reusing_Composing.pdf},
|
|
3541 |
hal-id = {inria-00403568 toberecovered for lse},
|
|
3542 |
url = {http://rmod.lille.inria.fr/archives/papers/Duca09a-Tools2009-TraitTests.pdf},
|
|
3543 |
year = {2009},
|
|
3544 |
keywords = {tools09 traits stefPub},
|
|
3545 |
month = {jun},
|
|
3546 |
annote = {internationalconference},
|
|
3547 |
aeres = {ACL},
|
|
3548 |
aeresstatus = {aeres12},
|
|
3549 |
selectif = {oui},
|
|
3550 |
misc = {acceptance rate: 17/67 = 25\%},
|
|
3551 |
rate = {24%},
|
|
3552 |
labo = {dans},
|
|
3553 |
inria = {RMOD},
|
|
3554 |
inriareport = {2009},
|
|
3555 |
pages = {252--271},
|
|
3556 |
x-editorial-board = {yes},
|
|
3557 |
x-proceedings = {yes},
|
|
3558 |
x-international-audience = {yes},
|
|
3559 |
x-country = {FR},
|
|
3560 |
x-language = {EN},
|
|
3561 |
address = {Zurich, Switzerland},
|
|
3562 |
abstract = {Single inheritance often forces developers to duplicate code and logic. This widely recognized situation affects both business code and tests. In a large and complex application whose classes implement many groups of methods (protocols), duplication may also follow the application's idiosyncrasies, making it difficult to specify, maintain, and reuse tests. The research questions we faced are (i) how can we reuse test specifications across and within complex inheritance hierarchies, especially in presence of orthogonal protocols; (ii) how can we test interface behavior in a modular way; (iii) how far can we reuse and parametrize composable tests. In this paper, we compose tests out of separately specified behavioral units of reuse ---traits. We propose test traits, where: (i) specific test cases are composed from independent specifications; (ii) executable behavior specifications may be reused orthogonally to the class hierarchy under test; (iii) test fixtures are external to the test specifications, thus are easier to specialize. Traits have been successfully applied to test two large and critical class libraries in Pharo, a new Smalltalk dialect based on Squeak, but are applicable to other languages with traits.}
|
|
3563 |
}
|
|
3564 |
|
|
3565 |
@inproceedings{Duca09b,
|
|
3566 |
author = {Ducasse, St\'ephane and Denker, Marcus and Lienhard, Adrian},
|
|
3567 |
title = {Evolving a Reflective Language},
|
|
3568 |
abstract = {Traits are method groups that can be used to compose classes. They do not have a runtime existence and are conceptually folded into the classes that use them. Traits have been implemented in different languages. While implementing them in Smalltalk, our first reflex was to take advantage of the fact that traits are not run-time entities: we optimized the implementation for space and hence shared methods between traits and classes. However, by doing so we broke the introspective API of Smalltalk. This paper illustrates a more general problem seen in all reflective systems: the implementation serves both as a model for execution and as the model that is exposed to the programmer. There is a conflict of interests between the information necessary for execution and the information the programmer is interested in. In addition, as soon as the implementation is exposed via reflection, we are not free to optimize. As the complete implementation is visible reflectively, there is no way to hide the optimizations. Few papers report errors and this is one of them. We report our experience facing the initial API mismatch, which has a significant impact on the system because the language is reflective (i.e., written in itself and causally connected). We present the new introspective API we put in place.},
|
|
3569 |
booktitle = {Proceedings of the International Workshop on Smalltalk Technologies (IWST 2009)},
|
|
3570 |
year = {2009},
|
|
3571 |
keywords = {stefPub internationalworkshop lse-pub},
|
|
3572 |
month = {aug},
|
|
3573 |
annote = {internationalworkshop},
|
|
3574 |
aeres = {ACT},
|
|
3575 |
aeresstatus = {aeres12},
|
|
3576 |
selectif = {non},
|
|
3577 |
labo = {dans},
|
|
3578 |
inria = {RMOD},
|
|
3579 |
isbn = {978-1-60558-899-5},
|
|
3580 |
pages = {82--86},
|
|
3581 |
location = {Brest, France},
|
|
3582 |
doi = {10.1145/1735935.1735949},
|
|
3583 |
publisher = {ACM},
|
|
3584 |
x-editorial-board = {yes},
|
|
3585 |
x-proceedings = {yes},
|
|
3586 |
x-international-audience = {yes},
|
|
3587 |
x-pays = {CL,CH},
|
|
3588 |
x-country = {FR},
|
|
3589 |
x-language = {EN},
|
|
3590 |
address = {Brest, France},
|
|
3591 |
url = {http://rmod.lille.inria.fr/archives/workshops/Duca09b-IWST09-TraitMop.pdf}
|
|
3592 |
}
|
|
3593 |
|
|
3594 |
@article{Duca09c,
|
|
3595 |
abstract = {To maintain and understand large applications, it is crucial to know their
|
|
3596 |
architecture. The first problem is that unlike classes and packages, architecture is not
|
|
3597 |
explicitly represented in the code. The second problem is that successful applications
|
|
3598 |
evolve over time, so their architecture inevitably drifts. Reconstructing the architecture
|
|
3599 |
and checking whether it is still valid is therefore an important aid. While there is a
|
|
3600 |
plethora of approaches and techniques supporting architecture reconstruction, there is no
|
|
3601 |
comprehensive state of the art and it is often difficult to compare the approaches. This
|
|
3602 |
article presents a state of the art in software architecture reconstruction approaches.},
|
|
3603 |
annote = {internationaljournal},
|
|
3604 |
author = {Ducasse, St\'ephane and Pollet, Damien},
|
|
3605 |
journal = {IEEE Transactions on Software Engineering},
|
|
3606 |
volume = 35,
|
|
3607 |
number = 4,
|
|
3608 |
aeres = {ACL},
|
|
3609 |
aeresstatus = {aeres12},
|
|
3610 |
selectif = {oui},
|
|
3611 |
inria = {RMOD},
|
|
3612 |
inriareport = {2009},
|
|
3613 |
labo = {dans},
|
|
3614 |
title = {Software Architecture Reconstruction: A Process-Oriented Taxonomy},
|
|
3615 |
url = {http://rmod.lille.inria.fr/archives/papers/Duca09c-TSE-SOAArchitectureExtraction.pdf},
|
|
3616 |
year = {2009},
|
|
3617 |
misc = {5-Year ISI impact factor 4.865 (2010)},
|
|
3618 |
impactfactor = {5-year ISI impact factor 4.865 (2010)},
|
|
3619 |
month = jul,
|
|
3620 |
pages = {573-591},
|
|
3621 |
doi = {10.1109/TSE.2009.19},
|
|
3622 |
x-editorial-board = {yes},
|
|
3623 |
x-proceedings = {yes},
|
|
3624 |
x-international-audience = {yes},
|
|
3625 |
hal-id = {inria-00498407 / @4049m}
|
|
3626 |
}
|
|
3627 |
|
|
3628 |
|
|
3629 |
|
|
3630 |
@techreport{Duca09t,
|
|
3631 |
author = {St\'ephane Ducasse and Simon Denier and Fran{\c c}oise Balmas and Alexandre Bergel and Jannik Laval and Karine Mordal-Manet and Fabrice Bellingard},
|
|
3632 |
title = {Visualization of Practices and Metrics (Squale Deliverable 1.2)},
|
|
3633 |
institution = {INRIA},
|
|
3634 |
keywords = {squale-pub lse-pub deliverable12},
|
|
3635 |
annote = {technicalreport},
|
|
3636 |
inria = {RMOD},
|
|
3637 |
inriareport = {2009},
|
|
3638 |
year = {2009},
|
|
3639 |
aeres = {AP},
|
|
3640 |
type_rapport = {Rapport technique},
|
|
3641 |
abstract = {No abstract},
|
|
3642 |
x-language = {EN},
|
|
3643 |
hal-id = {inria-00533618}
|
|
3644 |
}
|
|
3645 |
|
|
3646 |
|
|
3647 |
@book{Duca10a,
|
|
3648 |
abstract = {Seaside is the open source framework of choice for developing sophisticated and dynamic web applications. Seaside uses the power of objects to master the web. With Seaside web applications is as simple as building desktop applications. Seaside lets you build highly dynamic and interactive web applications. Seaside supports agile development through interactive debugging and unit testing. Seaside is based on Smalltalk, a proven and robust language implemented by different vendors. Seaside is now available for all the major Smalltalk including Pharo, Squeak, GNU Smalltalk, Cincom Smalltalk, GemStone Smalltalk, and VA Smalltalk.},
|
|
3649 |
author = {St\'ephane Ducasse and Lukas Renggli and C. David Shaffer and Rick Zaccone and Michael Davies},
|
|
3650 |
annote = {book},
|
|
3651 |
keywords = {scg-pub skip-doi snf-none jb10},
|
|
3652 |
publisher = {Square Bracket Associates},
|
|
3653 |
title = {Dynamic Web Development with Seaside},
|
|
3654 |
url = {http://book.seaside.st/book},
|
|
3655 |
year = {2010},
|
|
3656 |
isbn = {978-3-9523341-1-9},
|
|
3657 |
aeresstatus = {2012},
|
|
3658 |
x-international-audience = {yes},
|
|
3659 |
annote = {book},
|
|
3660 |
inria = {RMOD},
|
|
3661 |
inriareport = {2010},
|
|
3662 |
keywords = {skipdoi remoose2-pub pharo-pub},
|
|
3663 |
x-scientific-popularization = {yes},
|
|
3664 |
hal-id = {inria-00531503},
|
|
3665 |
aeres = {OS},
|
|
3666 |
aeresstatus = {aeres12},
|
|
3667 |
selectif = {non},
|
|
3668 |
inria = {RMOD},
|
|
3669 |
inriareport = {2010},
|
|
3670 |
labo = {dans},
|
|
3671 |
x-pays = {CH,US,FR},
|
|
3672 |
x-country = {CH,US,FR}
|
|
3673 |
}
|
|
3674 |
|
|
3675 |
@article{Duca10z,
|
|
3676 |
title = {Understanding Packages: The Package Blueprint},
|
|
3677 |
author = {St\'ephane Ducasse and Simon Denier and Damien Pollet and Ilham Alloui and Hani Abdeen and Jean-R\'emy Falleri},
|
|
3678 |
journal = {IEEE Transactions on Software Engineering (TSE) (Accepted with major revisions)},
|
|
3679 |
annote = {internationaljournal},
|
|
3680 |
keywords = {insubmission sub lse-pub},
|
|
3681 |
misc = {5-Year ISI impact factor 4.865 (2010)},
|
|
3682 |
impactfactor = {5-Year ISI impact factor 4.865 (2010)},
|
|
3683 |
year = {2010},
|
|
3684 |
month = aug,
|
|
3685 |
inria = {RMOD},
|
|
3686 |
x-editorial-board = {yes},
|
|
3687 |
x-international-audience = {yes},
|
|
3688 |
x-language = {EN},
|
|
3689 |
aeres = {ACL},
|
|
3690 |
aeresstatus = {aeres12},
|
|
3691 |
selectif = {yes},
|
|
3692 |
inria = {RMOD},
|
|
3693 |
inriareport = {2010},
|
|
3694 |
labo = {dans}
|
|
3695 |
}
|
|
3696 |
|
|
3697 |
@mastersthesis{Duca93a,
|
|
3698 |
annote = {dea},
|
|
3699 |
author = {St\'ephane Ducasse},
|
|
3700 |
keywords = {flo},
|
|
3701 |
month = sep,
|
|
3702 |
note = {Equipe Janus, Supervis\'e par M. Blay-Fornarino et E. Gall\'esio, Team Janus, supervised by M. Blay-Fornarino and E. Gall\'esio},
|
|
3703 |
school = {Laboratoire I3S-Universit\'e de Nice-Sophia Antipolis},
|
|
3704 |
title = {Protocole meta pour l'expression de relations dans un langage \`a objets},
|
|
3705 |
year = {1993}
|
|
3706 |
}
|
|
3707 |
|
|
3708 |
|
|
3709 |
@inproceedings{Duca93b,
|
|
3710 |
annote = {internationalworkshop},
|
|
3711 |
author = {St\'ephane Ducasse and Mireille Fornarino},
|
|
3712 |
booktitle = {OOPSLA '93 International Workshop on Reflection and Metalevel Architectures in Object-Oriented Programming},
|
|
3713 |
keywords = {stefPub flo},
|
|
3714 |
note = {Technical Report, University of Nice-Sophia Antipolis, I3S Lab, RR-94-62},
|
|
3715 |
organization = {ACM},
|
|
3716 |
title = {Protocol for Managing Dependencies between Objects by controlling Generic Function Invocation},
|
|
3717 |
year = {1993}
|
|
3718 |
}
|
|
3719 |
|
|
3720 |
@inproceedings{Duca94a,
|
|
3721 |
annote = {nationalconference},
|
|
3722 |
author = {St\'ephane Ducasse and Mireille Fornarino},
|
|
3723 |
booktitle = {Actes des Journ\'ees Francophones des Langages Applicatifs (JFLA'94)},
|
|
3724 |
editor = {Pierre Cointe, Christian Queinnec et Bernard Serpette},
|
|
3725 |
keywords = {stefPub flo},
|
|
3726 |
pages = {239--258},
|
|
3727 |
title = {Protocole pour la gestion des d\'ependances entre objets gr\^ace au contr\^ole des fonctions g\'en\'eriques},
|
|
3728 |
year = {1994}
|
|
3729 |
}
|
|
3730 |
|
|
3731 |
@techreport{Duca94b,
|
|
3732 |
annote = {report notrefereed},
|
|
3733 |
author = {St\'ephane Ducasse and Mireille Fornarino and Anne-Marie Pinna},
|
|
3734 |
institution = {Laboratoire I3S},
|
|
3735 |
keywords = {stefPub flo},
|
|
3736 |
number = {I3S Lab, RR-94-60},
|
|
3737 |
title = {Embedding behavioral relationships between objects using computational relection},
|
|
3738 |
year = {1994}
|
|
3739 |
}
|
|
3740 |
|
|
3741 |
@inproceedings{Duca95b,
|
|
3742 |
annote = {internationalconference topconference},
|
|
3743 |
author = {St{\'e}phane Ducasse and Mireille Blay-Fornarino and
|
|
3744 |
Anne-Marie Pinna},
|
|
3745 |
booktitle = {Proceedings of 10th International Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA '95)},
|
|
3746 |
keywords = {stefPub flo},
|
|
3747 |
misc = {acceptance rate: 27/167 = 16\%},
|
|
3748 |
accepttotal = {167},
|
|
3749 |
acceptnum = {27},
|
|
3750 |
month = oct,
|
|
3751 |
pages = {265--280},
|
|
3752 |
publisher = {ACM},
|
|
3753 |
title = {A Reflective Model for First Class Dependencies},
|
|
3754 |
url = {http://scg.unibe.ch/archive/papers/Duca95bAReflectiveModel.pdf},
|
|
3755 |
year = {1995}
|
|
3756 |
}
|
|
3757 |
|
|
3758 |
@inproceedings{Duca95c,
|
|
3759 |
annote = {internationalworkshop},
|
|
3760 |
author = {St\'ephane Ducasse},
|
|
3761 |
booktitle = {Proceedings of the International IJCAI'95 Workshop on Reflection and Meta-Level Architectures and their Applications in AI},
|
|
3762 |
institution = {University of Nice-Sophia Antipolis, Laboratoire I3S},
|
|
3763 |
keywords = {flo},
|
|
3764 |
note = {RR-95-12},
|
|
3765 |
pages = {39--49},
|
|
3766 |
title = {Inheritance Mechanism Reification by Means of First Class Object},
|
|
3767 |
year = {1995}
|
|
3768 |
}
|
|
3769 |
|
|
3770 |
@techreport{Duca95d,
|
|
3771 |
annote = {report notrefereed},
|
|
3772 |
author = {St\'ephane Ducasse and Mireille Fornarino and Anne-Marie Pinna-Dery},
|
|
3773 |
institution = {University of Nice-Sophia Antipolis, Laboratoire I3S},
|
|
3774 |
keywords = {stefPub flo},
|
|
3775 |
number = {RR-95-03},
|
|
3776 |
title = {Control et PAC model},
|
|
3777 |
year = {1995}
|
|
3778 |
}
|
|
3779 |
|
|
3780 |
@techreport{Duca96a,
|
|
3781 |
annote = {report notrefereed},
|
|
3782 |
author = {St\'ephane Ducasse},
|
|
3783 |
institution = {University of Nice Sophia-Antipolis, Laboratoire I3S},
|
|
3784 |
note = {I3S Lab, RR-95-28},
|
|
3785 |
title = {Reifying Inheritance in a Reflective Language},
|
|
3786 |
url = {http://scg.unibe.ch/archive/papers/Duca96aInhReify.ps.gz},
|
|
3787 |
year = {1996}
|
|
3788 |
}
|
|
3789 |
|
|
3790 |
@inproceedings{Duca96b,
|
|
3791 |
abstract = {The FLO language integrates management of inter-object dependencies into the object oriented paradigms. In this paper, we focus on the use of reactive dependencies (links) in object-oriented knowledge representation. In particular, we present different meta-links (links between links) and show how the FLO links allow one to design some composition relationships.},
|
|
3792 |
annote = {internationalconference},
|
|
3793 |
author = {St\'ephane Ducasse and Mireille Blay-Fornarino and Anne-Marie Pinna},
|
|
3794 |
booktitle = {Proceedings of International Symposium on Methodologies for Intelligent Systems (ISMIS '96)},
|
|
3795 |
doi = {10.1007/3-540-61286-6_154},
|
|
3796 |
keywords = {flo scg-old scg-pub stefPub},
|
|
3797 |
month = jun,
|
|
3798 |
number = 1079,
|
|
3799 |
pages = {295--304},
|
|
3800 |
publisher = {Springer-Verlag},
|
|
3801 |
series = {LNIA (Lectures Notes in Artificial Intelligence)},
|
|
3802 |
title = {Object and Dependency Oriented Programming in FLO},
|
|
3803 |
url = {http://scg.unibe.ch/archive/papers/Duca96bDependencyOP.pdf},
|
|
3804 |
year = {1996},
|
|
3805 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca96bDependencyOP.pdf},
|
|
3806 |
bdsk-url-2 = {http://dx.doi.org/10.1007/3-540-61286-6_154}
|
|
3807 |
}
|
|
3808 |
|
|
3809 |
@phdthesis{Duca97a,
|
|
3810 |
annote = {phdthesis},
|
|
3811 |
author = {St\'ephane Ducasse},
|
|
3812 |
keywords = {olit scglit oobib snf97 stefPub flo},
|
|
3813 |
month = jan,
|
|
3814 |
note = {Th\`ese de l'Universit\'e de Nice-Sophia Antipolis},
|
|
3815 |
school = {Universit\'e de Nice-Sophia Antipolis},
|
|
3816 |
title = {Int\'egration r\'eflexive de d\'ependances dans un mod\`ele \`a classes},
|
|
3817 |
url = {http://scg.unibe.ch/archive/papers/Duca97aPhD.ps.gz
|
|
3818 |
http://scg.unibe.ch/archive/papers/Duca97aPhD.pdf},
|
|
3819 |
year = {1997},
|
|
3820 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca97aPhD.ps.gz http://scg.unibe.ch/archive/papers/Duca97aPhD.pdf}
|
|
3821 |
}
|
|
3822 |
|
|
3823 |
@inproceedings{Duca97b,
|
|
3824 |
abstract = {The decomposition of a software application into components and connectors at the design stage has been promoted as a way to describe and reason about complex software architectures. There is, however, surprisingly little language support for this decomposition at implementation level. Interaction relationships which are identified at design time are lost as they get spread out into the participating entities at implementation. In this paper, we propose first-class connectors in an object-oriented language as a first step towards making software architecture more explicit at implementation level. Our connectors are run-time entities which control the interaction of components and can express a rich repertoire of interaction relationships. We show how connectors can be reused and how they enhance the reuse of components.},
|
|
3825 |
annote = {internationalconference topconference},
|
|
3826 |
author = {St\'ephane Ducasse and Tamar Richner},
|
|
3827 |
booktitle = {Proceedings of European Software Engineering Conference and Foundations on Software Engineering (ESEC/FSE'97)},
|
|
3828 |
doi = {10.1007/3-540-63531-9_32},
|
|
3829 |
isbn = {978-3-540-63531-4},
|
|
3830 |
keywords = {olit famoos-papref scglit oobib scg-pub flo snf97 jb97 scg-coord-98 stefPub},
|
|
3831 |
misc = {acceptance rate: 19/197 = 9\%},
|
|
3832 |
accepttotal = {197},
|
|
3833 |
acceptnum = {19},
|
|
3834 |
pages = {483--500},
|
|
3835 |
publisher = {Springer-Verlag},
|
|
3836 |
series = {LNCS},
|
|
3837 |
title = {Executable Connectors: Towards Reusable Design Elements},
|
|
3838 |
url = {http://scg.unibe.ch/archive/papers/Duca97bExecutableConnectors.pdf},
|
|
3839 |
volume = {1301},
|
|
3840 |
year = {1997},
|
|
3841 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca97bExecutableConnectors.pdf},
|
|
3842 |
bdsk-url-2 = {http://dx.doi.org/10.1007/3-540-63531-9_32}
|
|
3843 |
}
|
|
3844 |
|
|
3845 |
@inproceedings{Duca97c,
|
|
3846 |
annote = {internationalworkshop},
|
|
3847 |
author = {St\'ephane Ducasse},
|
|
3848 |
booktitle = {Object-Oriented Technology (ECOOP '97 Workshop Reader)},
|
|
3849 |
editor = {Jan Bosch and Stuart Mitchell},
|
|
3850 |
month = jun,
|
|
3851 |
pages = {96--99},
|
|
3852 |
publisher = {Springer-Verlag},
|
|
3853 |
series = {LNCS},
|
|
3854 |
title = {Message Passing Abstractions as Elementary Bricks for Design Pattern Implementation},
|
|
3855 |
volume = 1357,
|
|
3856 |
year = {1997}
|
|
3857 |
}
|
|
3858 |
|
|
3859 |
@inproceedings{Duca97d,
|
|
3860 |
annote = {nationalconference},
|
|
3861 |
author = {St\'ephane Ducasse},
|
|
3862 |
booktitle = {Actes de Langages et Mod\`eles \`a Objets (LMO'97)},
|
|
3863 |
keywords = {olit famoos-papref scglit oobib scg-pub skip-doi
|
|
3864 |
skip-abstract snf97 jb97 stefPub flo},
|
|
3865 |
pages = {95--110},
|
|
3866 |
title = {R\'eification de Sch\'emas de Conception: Une
|
|
3867 |
Exp\'erience},
|
|
3868 |
url = {http://scg.unibe.ch/archive/papers/Duca97dReificationDP.ps.gz},
|
|
3869 |
year = {1997},
|
|
3870 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca97dReificationDP.ps.gz}
|
|
3871 |
}
|
|
3872 |
|
|
3873 |
@article{Duca97e,
|
|
3874 |
annote = {nationaljournal},
|
|
3875 |
author = {St\'ephane Ducasse},
|
|
3876 |
journal = {Revue des Sciences et Technologies de l'Information (RSTI) --- L'Objet},
|
|
3877 |
keywords = {olit famoos-papref scglit oobib scg-pub
|
|
3878 |
skip-abstract skip-doi jb-none snf97 stefPub flo},
|
|
3879 |
number = {4},
|
|
3880 |
pages = {355--377},
|
|
3881 |
publisher = {Hermes, Paris},
|
|
3882 |
title = {Des techniques de contr\^ole de l'envoi de messages en {Smalltalk}},
|
|
3883 |
url = {http://scg.unibe.ch/archive/papers/Duca97eMessagePassing.pdf},
|
|
3884 |
volume = {3},
|
|
3885 |
year = {1997},
|
|
3886 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca97eMessagePassing.pdf}
|
|
3887 |
}
|
|
3888 |
|
|
3889 |
@techreport{Duca97g,
|
|
3890 |
annote = {report notrefereed},
|
|
3891 |
author = {St\'ephane Ducasse},
|
|
3892 |
institution = {University of Bern, Institut of Applied Mathematics and Computer Sciences},
|
|
3893 |
keywords = {scg-pub skip-doi skip-pdf skip-abstract jb-none flo},
|
|
3894 |
note = {Extension version of Duca97e: Des techniques de contr\^ole de l'envoi de messages en Smalltalk},
|
|
3895 |
number = {97-004},
|
|
3896 |
title = {Des techniques de contr\^ole de l'envoi de messages en {Smalltalk}},
|
|
3897 |
year = {1997}
|
|
3898 |
}
|
|
3899 |
|
|
3900 |
@inproceedings{Duca98b,
|
|
3901 |
abstract = {A reengineering pattern describes how to go from an existing legacy solution to a new refactored solution. In this paper we discuss the role of reengineering patterns and contrast them with design patterns and antipatterns. We then highlight the structure of a reengineering pattern and present two simple, related patterns for type-check elimination.},
|
|
3902 |
address = {Konstanz, Germany},
|
|
3903 |
annote = {internationalworkshop},
|
|
3904 |
author = {St\'ephane Ducasse and Robb Nebbe and Tamar Richner},
|
|
3905 |
booktitle = {Proceedings of the 4th European Conference on
|
|
3906 |
Pattern Languages of Programming and Computing,
|
|
3907 |
1999},
|
|
3908 |
editor = {Paul Dyson},
|
|
3909 |
keywords = {scg-pub skip-doi olit famoos-papunr oobib snf98
|
|
3910 |
pattern jb98 stefPub},
|
|
3911 |
month = jul,
|
|
3912 |
publisher = {UVK Universit\"atsverlag Konstanz GmbH},
|
|
3913 |
title = {Two Reengineering Patterns: Eliminating Type
|
|
3914 |
Checking},
|
|
3915 |
url = {http://scg.unibe.ch/archive/papers/Duca98bTwoReengPatterns.pdf},
|
|
3916 |
year = {1998},
|
|
3917 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca98bTwoReengPatterns.pdf}
|
|
3918 |
}
|
|
3919 |
|
|
3920 |
@inproceedings{Duca98c,
|
|
3921 |
abstract = {Although coordination of multiple activities is a fundamental goal of object-oriented concurrent programming languages, there is only limited support for their specification and abstraction at the language level. This leads to a mismatch between conceptional designs, using high-level abstractions, and the implementation, using the low-level coordination constructs. Often coordination is hard-wired into the components they coordinate, which leads to evolution, maintenance and composibility problems. We propose a model called FLO/C that relies on the notion of connectors. A connector is an entity that enforces the coordination of the entities it coordinates. This model supports a clear separation between the coordinated active objects and their coordination. An active object only defines specific domain information and a connector only defines coordination between a group of active objects (its participants). The coordination is abstractly defined refering to components in terms of the object interface. Coordination and coordinated entities are independant and can evolve separately. Coordination can be composed and replaced easily.},
|
|
3922 |
annote = {internationalworkshop},
|
|
3923 |
author = {St\'ephane Ducasse and Manuel G{\"u}nter},
|
|
3924 |
booktitle = {Proceedings of the DEXA workshops},
|
|
3925 |
keywords = {scg-pub skip-doi flo floc olit coordination oobib
|
|
3926 |
snf98 scg-coord-98 jb98 stefPub},
|
|
3927 |
month = aug,
|
|
3928 |
pages = {572--577},
|
|
3929 |
publisher = {IEEE Computer Society Press},
|
|
3930 |
title = {Coordination of Active Objects by Means of Explicit
|
|
3931 |
Connectors},
|
|
3932 |
url = {http://scg.unibe.ch/archive/papers/Duca98cExplicitConnectors.pdf},
|
|
3933 |
year = {1998},
|
|
3934 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca98cExplicitConnectors.pdf}
|
|
3935 |
}
|
|
3936 |
|
|
3937 |
@misc{Duca98z,
|
|
3938 |
annote = {workshopproceedings},
|
|
3939 |
author = {St\'ephane Ducasse and Joachim Weisbrod},
|
|
3940 |
booktitle = {Object-Oriented Technology (ECOOP'98 Workshop
|
|
3941 |
Reader)},
|
|
3942 |
keywords = {skip-pdf scg-pub skip-abstract skip-doi jb-none
|
|
3943 |
stefPub},
|
|
3944 |
number = 1543,
|
|
3945 |
pages = {72--96},
|
|
3946 |
publisher = {Springer-Verlag},
|
|
3947 |
series = {LNCS},
|
|
3948 |
title = {Report of the {ECOOP}'98 Workshop on Experiences in
|
|
3949 |
Object-Oriented Re-Engineering},
|
|
3950 |
year = {1998}
|
|
3951 |
}
|
|
3952 |
|
|
3953 |
@article{Duca99a,
|
|
3954 |
abstract = {In a language like Smalltalk in which objects communicate only via message passing, message passing control is a fundamental tool for the analysis of object behavior (trace, spying) or for the definition of new semantics (asynchronous messages, proxy,...). Different techniques exist, from the well known approach based on the specialization of the doesNotUnderstand: method to the exploitation the method lookup algorithm done by the virtual machine. Until now no comparison between these techniques has been made. In this article we compare the different techniques taking into account the reflective aspects used, the scope, the limit and the cost of the control.},
|
|
3955 |
annote = {internationaljournal},
|
|
3956 |
author = {St\'ephane Ducasse},
|
|
3957 |
journal = {Journal of Object-Oriented Programming (JOOP)},
|
|
3958 |
keywords = {olit famoos-papref snf98 oobib scg-pub skip-doi jb99
|
|
3959 |
stefPub flo},
|
|
3960 |
misc = {SCI impact factor 0.306},
|
|
3961 |
month = jun,
|
|
3962 |
number = {6},
|
|
3963 |
pages = {39--44},
|
|
3964 |
publisher = {SIGS Press},
|
|
3965 |
title = {Evaluating Message Passing Control Techniques in {Smalltalk}},
|
|
3966 |
url = {http://scg.unibe.ch/archive/papers/Duca99aMsgPassingControl.pdf},
|
|
3967 |
volume = {12},
|
|
3968 |
year = {1999},
|
|
3969 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca99aMsgPassingControl.pdf}
|
|
3970 |
}
|
|
3971 |
|
|
3972 |
@inproceedings{Duca99b,
|
|
3973 |
abstract = {Code duplication is one of the factors that severely complicates the maintenance and evolution of large software systems. Good tools for detecting duplicated code are scarce because of the large amount of data to be checked, because duplicated code is not known a priori and because especially it requires parsing technology. In this paper we show that is possible to circumvent these complicating factors by applying a language independent and lightweigth approach, i.e. a tool that requires no parsing and a little learning and configuration time, yet is able to detect a significant amount of code duplication. We validate our approach on a number of case studies, involving five different implementation languages and ranging from 256 K up untill 26Mb of source code.},
|
|
3974 |
annote = {internationalconference},
|
|
3975 |
author = {St\'ephane Ducasse and Matthias Rieger and Serge Demeyer},
|
|
3976 |
booktitle = {Proceedings of 15th IEEE International Conference on Software Maintenance (ICSM'99)},
|
|
3977 |
doi = {10.1109/ICSM.1999.792593},
|
|
3978 |
editor = {Hongji Yang and Lee White},
|
|
3979 |
keywords = {olit famoos-papref scg-pub toBeChecked
|
|
3980 |
sergedem-papref duploc snf99 jb99 oorp stefPub
|
|
3981 |
moose-pub},
|
|
3982 |
misc = {acceptance rate: 49/100 = 49\%},
|
|
3983 |
accepttotal = {100},
|
|
3984 |
acceptnum = {49},
|
|
3985 |
month = sep,
|
|
3986 |
pages = {109--118},
|
|
3987 |
publisher = {IEEE Computer Society},
|
|
3988 |
title = {A Language Independent Approach for Detecting Duplicated Code},
|
|
3989 |
url = {http://scg.unibe.ch/archive/papers/Duca99bCodeDuplication.pdf},
|
|
3990 |
year = {1999},
|
|
3991 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca99bCodeDuplication.pdf},
|
|
3992 |
bdsk-url-2 = {http://dx.doi.org/10.1109/ICSM.1999.792593}
|
|
3993 |
}
|
|
3994 |
|
|
3995 |
@inproceedings{Duca99c,
|
|
3996 |
abstract = {In reengineering an object-oriented system we want to benefit from the expertise developed in earlier efforts. It is therefore essential to have a way to communicate expertise at different levels: from knowledge about how to approach a system to be reengineered, to knowledge about improving code by eliminating 'bad' style. In this paper we propose to use a pattern form to communicate knowledge about reengineering. A reengineering pattern connects an observable problem in the code to a reengineering goal: it describes the process of going from the existing legacy solution causing or aggravating the problem to a new refactored solution which meets the reengineering goal. It thus gives a method appropriate for a specific problem, rather than proposing a general methodology, and makes reference to the appropriate tools or techniques for obtaining the refactored solution. In this paper we discuss the role of reengineering patterns and contrast them with related kinds of patterns. We then highlight the form of reengineering patterns and present two simple patterns for type-check elimination.},
|
|
3997 |
annote = {internationalconference},
|
|
3998 |
author = {St\'ephane Ducasse and Tamar Richner and Robb Nebbe},
|
|
3999 |
booktitle = {Proceedings of 6th Working Conference on Reverse
|
|
4000 |
Engineering (WCRE'99)},
|
|
4001 |
doi = {10.1109/WCRE.1999.806956},
|
|
4002 |
editor = {Francoise Balmas and Mike Blaha and Spencer Rugaber},
|
|
4003 |
keywords = {olit famoos-papref scg-pub jb99 stefPub},
|
|
4004 |
month = oct,
|
|
4005 |
pages = {157--168},
|
|
4006 |
publisher = {IEEE Computer Society},
|
|
4007 |
title = {Type-Check Elimination: Two Object-Oriented
|
|
4008 |
Reengineering Patterns},
|
|
4009 |
url = {http://scg.unibe.ch/archive/papers/Duca99cTypeCheckElim.pdf},
|
|
4010 |
year = {1999},
|
|
4011 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Duca99cTypeCheckElim.pdf},
|
|
4012 |
bdsk-url-2 = {http://dx.doi.org/10.1109/WCRE.1999.806956}
|
|
4013 |
}
|
|
4014 |
|
|
4015 |
@inproceedings{Duca99d,
|
|
4016 |
abstract = {Code duplication is an important problem in application maintenance. Tools exist that support code duplication detection. However, few of them propose a solution for the problem, i.e. refactorings. We propose an approach that uses the information given by code duplication detection to guide the refactorings of OO applications.},
|
|
4017 |
annote = {internationalworkshop},
|
|
4018 |
author = {St\'ephane Ducasse and Matthias Rieger and Georges Golomingi},
|
|
4019 |
booktitle = {Proceedings of the ECOOP '99 Workshop on Experiences in Object-Oriented Re-Engineering},
|
|
4020 |
editor = {St\'ephane Ducasse and Oliver Ciupke},
|
|
4021 |
keywords = {olit famoos-papref scg-pub skip-doi jb99 stefPub},
|
|
4022 |
month = jun,
|
|
4023 |
note = {FZI-Report 2-6-6/99},
|
|
4024 |
publisher = {Forschungszentrum Informatik, Karlsruhe},
|
|
4025 |
title = {Tool Support for Refactoring Duplicated {OO} Code},
|
|
4026 |
url = {http://scg.unibe.ch/archive/papers/Rieg99aToolSuppRefacOOCode.pdf},
|
|
4027 |
year = {1999},
|
|
4028 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Rieg99aToolSuppRefacOOCode.pdf}
|
|
4029 |
}
|
|
4030 |
|
|
4031 |
@inproceedings{Duca99s,
|
|
4032 |
annote = {internationalworkshop},
|
|
4033 |
author = {St\'ephane Ducasse and Michele Lanza and Serge
|
|
4034 |
Demeyer},
|
|
4035 |
booktitle = {Object-Oriented Technology (ECOOP'99 Workshop
|
|
4036 |
Reader)},
|
|
4037 |
keywords = {scg-pub snf-none skip-pdf jb-skip skip-abstract
|
|
4038 |
skip-doi},
|
|
4039 |
number = {1743},
|
|
4040 |
publisher = {Springer-Verlag},
|
|
4041 |
series = {LNCS},
|
|
4042 |
title = {Reverse Engineering based on Metrics and Program
|
|
4043 |
Visualization},
|
|
4044 |
year = {1999}
|
|
4045 |
}
|
|
4046 |
|
|
4047 |
@techreport{Fabr10a,
|
|
4048 |
author = {Johan Fabry and Andy Kellens and St\'ephane Ducasse},
|
|
4049 |
institution = {University of Chile},
|
|
4050 |
month = apr,
|
|
4051 |
title = {AspectMaps: A Scalable Visualization of Join Point Shadows},
|
|
4052 |
year = {2010},
|
|
4053 |
type = {TR/DCC-2010-2}
|
|
4054 |
}
|
|
4055 |
|
|
4056 |
@misc{Fern05a,
|
|
4057 |
aeres = {OV},
|
|
4058 |
aeresstatus = {aeres08},
|
|
4059 |
annote = {vulgarisation},
|
|
4060 |
author = {Hilaire Fernandes and St\'ephane Ducasse},
|
|
4061 |
inria = {hors},
|
|
4062 |
journal = {Linux Pratique},
|
|
4063 |
keywords = {stefPub},
|
|
4064 |
month = oct,
|
|
4065 |
number = 31,
|
|
4066 |
pages = {18--23},
|
|
4067 |
selectif = {non},
|
|
4068 |
title = {Squeak: mon premier programme},
|
|
4069 |
volume = 1,
|
|
4070 |
year = {2005},
|
|
4071 |
x-scientific-popularization = {yes}
|
|
4072 |
}
|
|
4073 |
|
|
4074 |
@misc{Fern06a,
|
|
4075 |
aeres = {OV},
|
|
4076 |
aeresstatus = {aeres08},
|
|
4077 |
annote = {vulgarisation},
|
|
4078 |
author = {Hilaire Fernandes and St\'ephane Ducasse},
|
|
4079 |
inria = {hors},
|
|
4080 |
journal = {Linux Magazine},
|
|
4081 |
keywords = {stefPub},
|
|
4082 |
month = apr,
|
|
4083 |
number = 82,
|
|
4084 |
selectif = {non},
|
|
4085 |
title = {Smalltalk: Le pouvoir et la simplicit\'e du tout objet},
|
|
4086 |
volume = 1,
|
|
4087 |
year = {2006},
|
|
4088 |
x-scientific-popularization = {yes}
|
|
4089 |
}
|
|
4090 |
|
|
4091 |
@misc{Fern06b,
|
|
4092 |
aeres = {OV},
|
|
4093 |
aeresstatus = {aeres08},
|
|
4094 |
annote = {vulgarisation},
|
|
4095 |
author = {Hilaire Fernandes and Serge Stinckwich},
|
|
4096 |
inria = {hors},
|
|
4097 |
journal = {Linux Magazine},
|
|
4098 |
month = jul,
|
|
4099 |
number = 85,
|
|
4100 |
selectif = {non},
|
|
4101 |
title = {Environnement de d\'eveloppement Smalltalk},
|
|
4102 |
volume = 1,
|
|
4103 |
year = {2006},
|
|
4104 |
x-scientific-popularization = {yes}
|
|
4105 |
}
|
|
4106 |
|
|
4107 |
@inproceedings{Fern07a,
|
|
4108 |
aeres = {ACT},
|
|
4109 |
aeresstatus = {aeres08},
|
|
4110 |
annote = {internationalconference},
|
|
4111 |
author = {Hilaire Fernandes and St\'ephane Ducasse and Thibault Caron},
|
|
4112 |
booktitle = {Proceedings of 5th International Conference on Creating, Connecting and Collaborating through Computing (C5 2007)},
|
|
4113 |
inria = {hors},
|
|
4114 |
keywords = {stefPub},
|
|
4115 |
publisher = {IEEE Computer Society},
|
|
4116 |
selectif = {non},
|
|
4117 |
title = {Dr Geo II: Adding Interactivity Planes in Interactive Dynamic Geometry},
|
|
4118 |
year = {2007},
|
|
4119 |
isbn = {0-7695-2806-6},
|
|
4120 |
abstract = {Interactive geometry environments support the creation and exploitation of interactive geometric sketches. However, such environments are often driven in a rigid manner, following a well specified construction path. This rigidity is not always compatible with: i. the internal cognitive representation of the learner about the geometric domain and ii. the way a geometric sketch is used in a paper-pen environment. This rigidity is therefore a source of internal tension for the learner and it can reduce the pedagogical added value of the interactive geometry environments. We think additional interactive planes to manipulate a geometric sketch differently can help the learner. We have developed DR. GEO II, an interactive geometry framework that is able to receive additional interactive planes such as a free sketching and a command-based one. We have experimented it in a junior high school class and we report here our first results.},
|
|
4121 |
pages = {153--162},
|
|
4122 |
url = {http://rmod.lille.inria.fr/archives/papers/Fern07a-C5-DrIIInterfactiveMultimodal.pdf},
|
|
4123 |
doi = {10.1109/C5.2007.12},
|
|
4124 |
hal-id = {inria-00531636}
|
|
4125 |
}
|
|
4126 |
|
|
4127 |
|
|
4128 |
|
|
4129 |
@inproceedings{Fern07b,
|
|
4130 |
aeres = {ACT},
|
|
4131 |
aeresstatus = {aeres08},
|
|
4132 |
author = {Hilaire Fernandes and St\'ephane Ducasse and Thibault Carron},
|
|
4133 |
title = {De l'importance des plans d'interaction dans la g\'eom\'etrie interactive},
|
|
4134 |
booktitle = {Environnements Informatiques pour l'Apprentissage Humain (EIAH 2007)},
|
|
4135 |
inria = {hors},
|
|
4136 |
keywords = {stefPub},
|
|
4137 |
selectif = {non},
|
|
4138 |
pages = {383--388},
|
|
4139 |
year = {2007},
|
|
4140 |
abstract = {Interactive geometry environments support creation and exploitation of geometric sketches. However, such environments are often driven in a rigid manner, following a well specified construction path. This rigidity is not always compatible with the internal cognitive representation of the learner about the geometric domain. This rigidity is therefore a source of internal tension for the learner and it can reduce the pedagogical added value of these environments. We think addi- tional interactive planes to manipulate a geometric sketch differently can help the learner. We have developed an interactive geometry framework that is able to receive additional interactive planes such as a free sketching and a command-based one. We have experimented it in a junior high school class and we report here our results.},
|
|
4141 |
publisher = {\textsc{atief}, \textsc{inrp}},
|
|
4142 |
url = {http://rmod.lille.inria.fr/archives/papers/Fern07b-EIAH-Multimodal.pdf},
|
|
4143 |
month = jun,
|
|
4144 |
hal-id = {inria-00531641}
|
|
4145 |
}
|
|
4146 |
|
|
4147 |
@misc{Fern07y,
|
|
4148 |
aeres = {OV},
|
|
4149 |
aeresstatus = {aeres08},
|
|
4150 |
annote = {vulgarisation},
|
|
4151 |
author = {Hilaire Fernandes and Serge Stinckwich},
|
|
4152 |
inria = {hors},
|
|
4153 |
journal = {Linux Magazine},
|
|
4154 |
month = jan,
|
|
4155 |
number = 90,
|
|
4156 |
selectif = {non},
|
|
4157 |
title = {Morphic, les interfaces utilisateurs selon Squeak},
|
|
4158 |
volume = 1,
|
|
4159 |
year = {2007}
|
|
4160 |
}
|
|
4161 |
|
|
4162 |
|
|
4163 |
|
|
4164 |
@inproceedings{Fern08a,
|
|
4165 |
aeres = {ACT},
|
|
4166 |
aeresstatus = {aeres08},
|
|
4167 |
annote = {internationalconference},
|
|
4168 |
author = {Hilaire Fernandes and Thibault Carron and St\'ephane Ducasse },
|
|
4169 |
booktitle = {Proceedings of 6th International Conference on Creating, Connecting and Collaborating through Computing (C5 2008)},
|
|
4170 |
inria = {RMOD},
|
|
4171 |
keywords = {stefPub},
|
|
4172 |
publisher = {IEEE Computer Society},
|
|
4173 |
isbn = {0-7695-3115-6},
|
|
4174 |
pages = {65--72},
|
|
4175 |
selectif = {non},
|
|
4176 |
url = {http://rmod.lille.inria.fr/archives/papers/Fern08a-C5-istoa-exercises.pdf},
|
|
4177 |
title = {iSTOA: Artefacts for mathematical interactive learning execises},
|
|
4178 |
hal-id = {inria-00531649},
|
|
4179 |
abstract = {In primary schools, mathematics teachers use support tools to introduce new concepts. The objective of these tools is to reinforce a mental representation of the newly introduced concept. Tools can be physical objects or paper- pen based. We call these tools artefacts. In computer assisted environments, such artefacts are not always clearly present, those environments focus on the nature of the exercises (drills, quiz). To realise environments in closer relation to classroom teaching, we propose to analyse and categorise such artefacts: we used pedagogical literature and we extracted artefacts used in teaching multiplication. We present our infrastructure and a list of artefacts in the multiplication realm.},
|
|
4180 |
year = {2008}
|
|
4181 |
}
|
|
4182 |
|
|
4183 |
@inproceedings{Fern09a,
|
|
4184 |
aeres = {ACT},
|
|
4185 |
aeresstatus = {aeres12},
|
|
4186 |
author = {Hilaire Fernandes and Thibault Carron and St\'ephane Ducasse},
|
|
4187 |
title = {Guidage macroscopique de l'apprentissage},
|
|
4188 |
booktitle = {Environnements Informatiques pour l'Apprentissage Humain (EIAH 2009)},
|
|
4189 |
inria = {RMOD},
|
|
4190 |
keywords = {stefPub},
|
|
4191 |
selectif = {non},
|
|
4192 |
year = {2009},
|
|
4193 |
abstract = {Les EIAH sont souvent sp\'ecialis\'es dans un domaine bien pr\'ecis. Cela leur permet d'offrir des mod\'elisations fines du domaine et de l'apprenant. L'analyse alors produite \`a partir des traces est didactiquement tr\`es fine et sp\'ecifique au domaine en question. Elle permet de guider l'apprenant en cas de difficult\'e et de lui proposer des activit\'es de soutien. Cependant cette analyse est \'etroitement li\'ee aux domaines didactiques, et diff\'erente d'un domaine \`a un autre. Face \`a la diversit\'e des domaines enseign\'es, comment proposer un mod\`ele tenant compte de cette multitude et permettant une analyse de l'activit\'e de l'\'el\`eve et son guidage ?
|
|
4194 |
Nous proposons une analyse de l'activit\'e de l'\'el\`eve hors du champ didactique pour un guidage que nous nommons macroscopique, par opposition \`a une analyse didactique fine. Le guidage propos\'e est g\'en\'erique mais param\'etr\'e par un r\'eseau notionnel afin d'\^etre transposable \`a diff\'erents domaines d'enseignement.
|
|
4195 |
Notre approche s'appuie sur les r\'eseaux notionnels, les \'etayages p\'edagogiques, les traces d'objets et l'inf\'erence sur celles-ci. Leur utilisation conjointe permet la description du domaine, la mod\'elisation de l'apprenant et son pilotage par l'EIAH. Nous pr\'esentons cette approche dans iSTOA.net.},
|
|
4196 |
inriaReport = {2009},
|
|
4197 |
publisher = {\textsc{atief}, \textsc{inrp}},
|
|
4198 |
hal-id= { inria-00531658},
|
|
4199 |
url = {http://rmod.lille.inria.fr/archives/papers/Fern09a-EIAH2009-Guidage.pdf},
|
|
4200 |
month = jun
|
|
4201 |
}
|
|
4202 |
|
|
4203 |
|
|
4204 |
@phdthesis{Fern10a,
|
|
4205 |
author = {Hilaire Fernandes},
|
|
4206 |
school = {Universit\'e de Lille},
|
|
4207 |
year = {2010},
|
|
4208 |
annote = {PhD},
|
|
4209 |
title = {iStoa, mod\`ele notionnel de guidage macroscopique de l'apprentissage},
|
|
4210 |
institution = {INRIA},
|
|
4211 |
inria = {RMOD},
|
|
4212 |
aeres = {AP},
|
|
4213 |
type_rapport = {PhD},
|
|
4214 |
hal-id = {tel-00498599},
|
|
4215 |
url = {http://rmod.lille.inria.fr/archives/phd/PhD-2010-Fernandes.pdf},
|
|
4216 |
asbtract = {Les EIAH sont souvent sp\'ecialis\'es \`a un domaine bien pr\'ecis. Cela leur permet d'offrir des mod\'elisations fines du domaine et de l'apprenant. L'analyse alors produite \`a partir des traces est didactiquement tr\`es fine et sp\'ecifique au domaine en question. Elle permet de guider l'apprenant en cas de difficult\'e et de lui proposer des activit\'es de soutien. Cependant cette analyse est \'etroitement li\'ee aux domaines didactiques, et diff\'erente d'un domaine \`a un autre. Dans la diversit\'e des domaines enseign\'es, comment proposer un mod\`ele tenant compte de cette multitude et permettant une analyse de l'activit\'e de l'\'el\`eve et son guidage ?
|
|
4217 |
Nous proposons une analyse de l'activit\'e de l'\'el\`eve hors du champ didactique pour un guidage que nous nommons macroscopique, par opposition \`a une analyse didactique fine. Le guidage propos\'e est param\'etr\'e selon le domaine afin d'\^etre transposable.
|
|
4218 |
Notre approche s'appuie sur les r\'eseaux notionnels, les \'etayages p\'edagogiques, les traces d'objets et l'inf\'erence sur celles-ci. Leur utilisation conjointe permet la description du domaine, la mod\'elisation de l'apprenant et son pilotage par l'EIAH. Nous pr\'esentons cette approche implant\'ee dans iSTOA 1.},
|
|
4219 |
x-language = {FR}
|
|
4220 |
}
|
|
4221 |
|
|
4222 |
@article{Gael02a,
|
|
4223 |
annote = {notrefereed},
|
|
4224 |
author = {Markus Gaelli and Marcus Denker},
|
|
4225 |
comment = {bpb: Bundeszentrale f{\"u}r politische Bildung
|
|
4226 |
Deutschland},
|
|
4227 |
journal = {bpb Online-Publikation: Freie Software im
|
|
4228 |
Unterricht},
|
|
4229 |
keywords = {Squeak gaelli fromscgbib marcusdenker},
|
|
4230 |
misc = {gaelli},
|
|
4231 |
month = oct,
|
|
4232 |
publisher = {bpb: Bundeszentrale f{\"u}r politische Bildung
|
|
4233 |
Deutschland},
|
|
4234 |
title = {Freie Software im Unterricht: Squeak},
|
|
4235 |
url = {http://rmod.lille.inria.fr/archives/popular/Gael02a-BPB-Squeak.pdf},
|
|
4236 |
year = {2002}
|
|
4237 |
}
|
|
4238 |
|
|
4239 |
@article{Gael04b,
|
|
4240 |
abstract = {Es muss keine staubtrockene Angelegenheit von
|
|
4241 |
Informatikstudenten sein, dem Computer neue Dinge
|
|
4242 |
beizubringen. Squeak will Kindern nicht nur den
|
|
4243 |
Umgang mit dem Rechner naeher bringen, sondern ihnen
|
|
4244 |
auch als Mittel zur Entdeckung der realen Welt
|
|
4245 |
dienen. Und fuer Erwachsene stellt es eine
|
|
4246 |
Smalltalk-Umgebung dar, die auch spielerisch
|
|
4247 |
erschlossen werden kann.},
|
|
4248 |
annote = {notrefereed},
|
|
4249 |
author = {Markus Gaelli and Marcus Denker},
|
|
4250 |
journal = {c't magazin f\"ur computer technik},
|
|
4251 |
keywords = {squeak smalltalk snf-none gaelli fromscgbib marcusdenker},
|
|
4252 |
misc = {gaelli},
|
|
4253 |
month = may,
|
|
4254 |
pages = {216--221},
|
|
4255 |
publisher = {Heise Verlag},
|
|
4256 |
title = {Von kleinen und grossen Erfindern --- Squeak:
|
|
4257 |
Lernumgebung und Smalltalk-System f{\"u}r Kinder und
|
|
4258 |
Erwachsene},
|
|
4259 |
url = {http://rmod.lille.inria.fr/archives/popular/Gael04b-Ct-VonKleinenUndGrossenErfindern.pdf},
|
|
4260 |
year = {2004}
|
|
4261 |
}
|
|
4262 |
|
|
4263 |
@inproceedings{Gael04c,
|
|
4264 |
abstract = {Although unit testing is essential for programming, current languages only barely support the developer in composing unit tests into new ones or in navigating between unit tests and their corresponding methods under test. We have taken several Smalltalk programs and analyzed the relationships between unit tests and methods under test, and the re- lationships amongst unit tests. First results indicate that most unit tests can be seen or at least decomposed into commands which focus on single methods, and that large portions of unit tests overlap each other. But these relationships between unit tests and methods under test are not reflected in current languages. We therefore first conceptually extend the meta-model of Smalltalk with one-method commands so that unit tests become both com- posable and navigable. Then we introduce a first lightweight implementation of this meta model using method comments to differentiate between the several test phases of existing XUnit test case methods.},
|
|
4265 |
annote = {internationalworkshop},
|
|
4266 |
author = {Markus Gaelli and Oscar Nierstrasz and St{\'e}phane
|
|
4267 |
Ducasse},
|
|
4268 |
booktitle = {OOPSLA Workshop on Revival of Dynamic Languages},
|
|
4269 |
cvs = {EgRDL2004},
|
|
4270 |
keywords = {snf05 scg-pub skip-doi gaelli jb05},
|
|
4271 |
month = oct,
|
|
4272 |
title = {One-Method Commands: Linking Methods and Their
|
|
4273 |
Tests},
|
|
4274 |
url = {http://scg.unibe.ch/archive/papers/Gael04cLinkingMethodsAndTests.pdf},
|
|
4275 |
year = {2004},
|
|
4276 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Gael04cLinkingMethodsAndTests.pdf}
|
|
4277 |
}
|
|
4278 |
|
|
4279 |
@book{Gens02a,
|
|
4280 |
abstract = {This Handbook presents the PECOS approach for developing field device software. It has been written for the developer who wants to apply the method in a realistic setting. By following this tutorial the reader will get a good understanding of PECOS and will learn how to use PECOS to develop software for embedded real-time systems.},
|
|
4281 |
annote = {notrefereed handbook},
|
|
4282 |
author = {Thomas Genssler and Alexander Christoph and Benedikt Schulz and Michael Winter and Chris M. Stich and Christian Zeidler and Peter M\"uller and Andreas Stelter and Oscar Nierstrasz and St\'ephane Ducasse and Gabriela Ar{\'e}valo and Roel Wuyts and Peng Liang and Bastiaan Sch\"onhage and Reinier van den Born},
|
|
4283 |
keywords = {olit scg-pub skip-doi jb02 pecos arevalo stefPub},
|
|
4284 |
month = sep,
|
|
4285 |
publisher = {The Pecos Consortium},
|
|
4286 |
title = {PECOS in a Nutshell},
|
|
4287 |
url = {http://www.pecos-project.org/public_documents/pecosHandbook.pdf},
|
|
4288 |
year = {2002},
|
|
4289 |
bdsk-url-1 = {http://www.pecos-project.org/public_documents/pecosHandbook.pdf}
|
|
4290 |
}
|
|
4291 |
|
|
4292 |
@inproceedings{Girb04b,
|
|
4293 |
abstract = {Knowing where to start reverse engineering a large software system, when no information other than the system`s source code itself is available, is a daunting task. Having the history of the code (i.e., the versions) could be of help if this would not imply analyzing a huge amount of data. In this paper we present an approach for identifying candidate classes for reverse engineering and reengineering efforts. Our solution is based on summarizing the changes in the evolution of object-oriented software systems by defining history measurements. Our approach, named Yesterday`s Weather, is an analysis based on the retrospective empirical observation that classes which changed the most in the recent past also suffer important changes in the near future. We apply this approach on two case studies and show how we can obtain an overview of the evolution of a system and pinpoint its classes that might change in the next versions.},
|
|
4294 |
address = {Los Alamitos CA},
|
|
4295 |
annote = {internationalconference},
|
|
4296 |
author = {Tudor G\^irba and St\'ephane Ducasse and Michele
|
|
4297 |
Lanza},
|
|
4298 |
booktitle = {Proceedings of 20th IEEE International Conference on
|
|
4299 |
Software Maintenance (ICSM'04)},
|
|
4300 |
doi = {10.1109/ICSM.2004.1357788},
|
|
4301 |
keywords = {scg-pub evolution metrics hismo stefPub van
|
|
4302 |
moose-pub girba recast05 jb05},
|
|
4303 |
location = {Illinois, USA},
|
|
4304 |
misc = {acceptance rate: 38/122 = 31\%},
|
|
4305 |
accepttotal = {122},
|
|
4306 |
acceptnum = {38},
|
|
4307 |
month = sep,
|
|
4308 |
pages = {40--49},
|
|
4309 |
publisher = {IEEE Computer Society},
|
|
4310 |
title = {{Yesterday's} {Weather}: Guiding Early Reverse
|
|
4311 |
Engineering Efforts by Summarizing the Evolution of
|
|
4312 |
Changes},
|
|
4313 |
url = {http://scg.unibe.ch/archive/papers/Girb04bYesterdayWeather.pdf},
|
|
4314 |
year = {2004},
|
|
4315 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Girb04bYesterdayWeather.pdf},
|
|
4316 |
bdsk-url-2 = {http://dx.doi.org/10.1109/ICSM.2004.1357788}
|
|
4317 |
}
|
|
4318 |
|
|
4319 |
@inproceedings{Girb04d,
|
|
4320 |
abstract = {Software system need to change over time to cope
|
|
4321 |
with the new requirements. Furthermore, due to
|
|
4322 |
design decisions, the new requirements happen to
|
|
4323 |
crosscut the system's structure. Understanding how
|
|
4324 |
changes appear in the system can reveal hidden
|
|
4325 |
dependencies between different parts of the system.
|
|
4326 |
We propose to group entities that change together
|
|
4327 |
according to a logical expression that specifies the
|
|
4328 |
change condition. Furthermore, we can group entities
|
|
4329 |
at different levels of abstraction (i.e., method,
|
|
4330 |
class, package). Our approach is based on an
|
|
4331 |
explicit history meta model that centers around the
|
|
4332 |
notion of history and which enables the definition
|
|
4333 |
of historical measurements which summarize the
|
|
4334 |
changes. We apply our approach on two large case
|
|
4335 |
studies and show how we can identify groups of
|
|
4336 |
related entities and detect bad smells.},
|
|
4337 |
annote = {internationalworkshop},
|
|
4338 |
author = {Tudor G\^irba and St\'ephane Ducasse and Radu
|
|
4339 |
Marinescu and Daniel Ra\c{t}iu},
|
|
4340 |
booktitle = {Ninth IEEE Workshop on Empirical Studies of Software
|
|
4341 |
Maintenance},
|
|
4342 |
keywords = {scg-pub skip-doi evolution van metrics smell hismo
|
|
4343 |
stefPub recast05 girba jb05 moose-pub},
|
|
4344 |
title = {Identifying Entities That Change Together},
|
|
4345 |
url = {http://scg.unibe.ch/archive/papers/Girb04dEntitiesChangeTogether.pdf},
|
|
4346 |
year = {2004},
|
|
4347 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Girb04dEntitiesChangeTogether.pdf}
|
|
4348 |
}
|
|
4349 |
|
|
4350 |
@inproceedings{Girb05a,
|
|
4351 |
abstract = {Analyzing historical information can show how a
|
|
4352 |
software system evolved into its current state,
|
|
4353 |
which parts of the system are stable and which have
|
|
4354 |
changed more. However, historical analysis implies
|
|
4355 |
processing a vast amount of information making the
|
|
4356 |
interpretation of the results difficult. To address
|
|
4357 |
this issue, we introduce the notion of the history
|
|
4358 |
of source code artifacts as a first class entity and
|
|
4359 |
define measurements which summarize the evolution of
|
|
4360 |
such entities. We use these measurements to define
|
|
4361 |
rules by which to detect different characteristics
|
|
4362 |
of the evolution of class hierarchies. Furthermore,
|
|
4363 |
we discuss the results we obtained by visualizing
|
|
4364 |
them using a polymetric view. We apply our approach
|
|
4365 |
on two large open source case studies and classify
|
|
4366 |
their class hierarchies based on their history.},
|
|
4367 |
address = {Los Alamitos CA},
|
|
4368 |
aeres = {ACT},
|
|
4369 |
aeresstatus = {aeres08},
|
|
4370 |
annote = {internationalconference},
|
|
4371 |
author = {Tudor G\^irba and Michele Lanza and St\'ephane
|
|
4372 |
Ducasse},
|
|
4373 |
booktitle = {Proceedings of 9th European Conference on Software
|
|
4374 |
Maintenance and Reengineering (CSMR'05)},
|
|
4375 |
doi = {10.1109/CSMR.2005.15},
|
|
4376 |
inria = {hors},
|
|
4377 |
keywords = {scg-pub evolution visualization metrics van recast05
|
|
4378 |
girba stefPub jb05 moose-pub},
|
|
4379 |
misc = {acceptance rate: 33/81 = 41 \%},
|
|
4380 |
accepttotal = {81},
|
|
4381 |
acceptnum = {33},
|
|
4382 |
pages = {2--11},
|
|
4383 |
publisher = {IEEE Computer Society},
|
|
4384 |
rate = {41%},
|
|
4385 |
selectif = {non},
|
|
4386 |
title = {Characterizing the Evolution of Class Hierarchies},
|
|
4387 |
url = {http://scg.unibe.ch/archive/papers/Girb05aHierarchiesEvolution.pdf},
|
|
4388 |
year = {2005},
|
|
4389 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Girb05aHierarchiesEvolution.pdf},
|
|
4390 |
bdsk-url-2 = {http://dx.doi.org/10.1109/CSMR.2005.15}
|
|
4391 |
}
|
|
4392 |
|
|
4393 |
@inproceedings{Girb05b,
|
|
4394 |
abstract = {Understanding how software systems evolve is useful
|
|
4395 |
from different perspectives: reverse engineering,
|
|
4396 |
empirical studies etc.. For an effective
|
|
4397 |
understanding we need an explicit meta-model. We
|
|
4398 |
introduce Hismo, a meta-model which is centered
|
|
4399 |
around the notion of history and we show how we can
|
|
4400 |
obtain it from a snapshot meta-model. Based on our
|
|
4401 |
experience in developing the Hismo reverse
|
|
4402 |
engineering system, we show how we can transform a
|
|
4403 |
snapshot meta-model in a history metamodel.},
|
|
4404 |
annote = {internationalworkshop},
|
|
4405 |
author = {Tudor G\^irba and Jean-Marie Favre and St\'ephane
|
|
4406 |
Ducasse},
|
|
4407 |
booktitle = {Proceedings of 2nd International Workshop on
|
|
4408 |
Meta-Models and Schemas for Reverse Engineering
|
|
4409 |
(ATEM 2004)},
|
|
4410 |
doi = {10.1016/j.entcs.2005.07.005},
|
|
4411 |
keywords = {scg-pub evolution meta-modeling hismo van moose-pub
|
|
4412 |
recast05 jointERCIM girba stefPub jb05},
|
|
4413 |
pages = {57--64},
|
|
4414 |
title = {Using Meta-Model Transformation to Model Software Evolution},
|
|
4415 |
url = {http://scg.unibe.ch/archive/papers/Girb05bMetaModelTransATEM2004.pdf},
|
|
4416 |
year = {2004},
|
|
4417 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Girb05bMetaModelTransATEM2004.pdf},
|
|
4418 |
bdsk-url-2 = {http://dx.doi.org/10.1016/j.entcs.2005.07.005}
|
|
4419 |
}
|
|
4420 |
|
|
4421 |
@inproceedings{Girb05c,
|
|
4422 |
abstract = {As systems evolve their structure change in ways not
|
|
4423 |
expected upfront. As time goes by, the knowledge of
|
|
4424 |
the developers becomes more and more critical for
|
|
4425 |
the process of understanding the system. That is,
|
|
4426 |
when we want to understand a certain issue of the
|
|
4427 |
system we ask the knowledgeable developers. Yet, in
|
|
4428 |
large systems, not every developer is knowledgeable
|
|
4429 |
in all the details of the system. Thus, we would
|
|
4430 |
want to know which developer is knowledgeable in the
|
|
4431 |
issue at hand. In this paper we make use of the
|
|
4432 |
mapping between the changes and the author
|
|
4433 |
identifiers (e.g., user names) provided by
|
|
4434 |
versioning repositories. We first define a
|
|
4435 |
measurement for the notion of code ownership. We use
|
|
4436 |
this measurement to define the Ownership Map
|
|
4437 |
visualization to understand when and how different
|
|
4438 |
developers interacted in which way and in which part
|
|
4439 |
of the system. We report the results we obtained on
|
|
4440 |
several large systems.},
|
|
4441 |
aeres = {ACT},
|
|
4442 |
aeresstatus = {aeres08},
|
|
4443 |
annote = {internationalworkshop},
|
|
4444 |
author = {Tudor G\^irba and Adrian Kuhn and Mauricio Seeberger
|
|
4445 |
and St\'ephane Ducasse},
|
|
4446 |
booktitle = {Proceedings of International Workshop on Principles
|
|
4447 |
of Software Evolution (IWPSE 2005)},
|
|
4448 |
cvs = {ChroniaIWPSE2005},
|
|
4449 |
doi = {10.1109/IWPSE.2005.21},
|
|
4450 |
inria = {hors},
|
|
4451 |
keywords = {scg-pub evolution visualization authors stefPub
|
|
4452 |
girba recast06 jb06 moose-pub chronia akuhn},
|
|
4453 |
location = {Lisbon, Portugal},
|
|
4454 |
misc = {acceptance rate: 13/54 = 24\%},
|
|
4455 |
accepttotal = {54},
|
|
4456 |
acceptnum = {13},
|
|
4457 |
pages = {113--122},
|
|
4458 |
publisher = {IEEE Computer Society Press},
|
|
4459 |
rate = {24%},
|
|
4460 |
selectif = {oui},
|
|
4461 |
title = {How Developers Drive Software Evolution},
|
|
4462 |
url = {http://scg.unibe.ch/archive/papers/Girb05cOwnershipMap.pdf},
|
|
4463 |
year = {2005},
|
|
4464 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Girb05cOwnershipMap.pdf},
|
|
4465 |
bdsk-url-2 = {http://dx.doi.org/10.1109/IWPSE.2005.21}
|
|
4466 |
}
|
|
4467 |
|
|
4468 |
@article{Girb06a,
|
|
4469 |
abstract = {The histories of software systems hold useful
|
|
4470 |
information when reasoning about the systems at hand
|
|
4471 |
or when reasoning about general laws of software
|
|
4472 |
evolution. Over the past 30 years more and more
|
|
4473 |
research has been spent on understanding software
|
|
4474 |
evolution. However, the approaches developed so far
|
|
4475 |
do not rely on an explicit meta-model, and thus,
|
|
4476 |
they make it difficult to reuse or compare their
|
|
4477 |
results. We argue that there is a need for an
|
|
4478 |
explicit meta-model for software evolution analysis.
|
|
4479 |
We present a survey of the evolution analyses and
|
|
4480 |
deduce a set of requirements that an evolution
|
|
4481 |
meta-model should have. We define, Hismo, a
|
|
4482 |
meta-model in which history is modeled as an
|
|
4483 |
explicit entity. Hismo adds a time layer on top of
|
|
4484 |
structural information, and provides a common
|
|
4485 |
infrastructure for expressing and combining
|
|
4486 |
evolution analyses and structural analyses. We
|
|
4487 |
validate the usefulness of our a meta-model by
|
|
4488 |
presenting how different analyses are expressed on
|
|
4489 |
it.},
|
|
4490 |
aeres = {ACL},
|
|
4491 |
aeresstatus = {aeres08},
|
|
4492 |
annote = {internationaljournal},
|
|
4493 |
author = {Tudor G\^irba and St\'ephane Ducasse},
|
|
4494 |
misc = {5 Year ISI impact factor 1.523 (2010)},
|
|
4495 |
impactfactor = {5 Year ISI impact factor 1.523 (2010)},
|
|
4496 |
inria = {hors},
|
|
4497 |
journal = {Journal of Software Maintenance: Research and Practice (JSME)},
|
|
4498 |
keywords = {hasler07 scg-pub skip-doi recast06 jb06 stefPub mooseCincom moose-pub van girba snf-actsc norex06
|
|
4499 |
meta-modeling hismo evolution},
|
|
4500 |
pages = {207--236},
|
|
4501 |
publisher = {John Wiley and Sons, Ltd.},
|
|
4502 |
selectif = {non},
|
|
4503 |
title = {Modeling History to Analyze Software Evolution},
|
|
4504 |
url = {http://scg.unibe.ch/archive/papers/Girb06aHismo.pdf},
|
|
4505 |
volume = {18},
|
|
4506 |
year = {2006}
|
|
4507 |
}
|
|
4508 |
|
|
4509 |
@inproceedings{Girb07a,
|
|
4510 |
abstract = {Software systems need to change over time to cope
|
|
4511 |
with new requirements, and due to design decisions,
|
|
4512 |
the changes happen to crosscut the system's
|
|
4513 |
structure. Understanding how changes appear in the
|
|
4514 |
system can reveal hidden dependencies between
|
|
4515 |
different entities of the system. We propose the
|
|
4516 |
usage of concept analysis to identify groups of
|
|
4517 |
entities that change in the same way and in the same
|
|
4518 |
time. We apply our approach at different levels of
|
|
4519 |
abstraction (i.e., method, class, package) and we
|
|
4520 |
detect fine grained changes (i.e., statements were
|
|
4521 |
added in a class, but no method was added there).
|
|
4522 |
Concept analysis is a technique that identifies
|
|
4523 |
entities that have the same properties, but it
|
|
4524 |
requires manual inspection due to the large number
|
|
4525 |
of candidates it detects. We propose a heuristic
|
|
4526 |
that dramatically eliminate the false positives. We
|
|
4527 |
apply our approach on two case studies and we show
|
|
4528 |
how we can identify hidden dependencies and detect
|
|
4529 |
bad smells.},
|
|
4530 |
aeres = {ACT},
|
|
4531 |
aeresstatus = {aeres08},
|
|
4532 |
annote = {internationalworkshop},
|
|
4533 |
author = {Tudor G\^irba and St\'ephane Ducasse and {A}drian
|
|
4534 |
{K}uhn and Radu Marinescu and Daniel Ra\c{t}iu},
|
|
4535 |
booktitle = {Proceedings of International Workshop on Principles
|
|
4536 |
of Software Evolution (IWPSE 2007)},
|
|
4537 |
doi = {10.1145/1294948.1294970},
|
|
4538 |
inria = {hors},
|
|
4539 |
isbn = {978-1-59593-722-3},
|
|
4540 |
keywords = {scg07 scg-pub evolution fca girba jb08 metrics
|
|
4541 |
moose-pub norex07 stefPub},
|
|
4542 |
medium = {2},
|
|
4543 |
pages = {83--89},
|
|
4544 |
peerreview = {yes},
|
|
4545 |
publisher = {ACM Press},
|
|
4546 |
selectif = {non},
|
|
4547 |
title = {Using Concept Analysis to Detect Co-Change Patterns},
|
|
4548 |
url = {http://scg.unibe.ch/archive/papers/Girb07aCoChangePatterns.pdf},
|
|
4549 |
year = {2007}
|
|
4550 |
}
|
|
4551 |
|
|
4552 |
@misc{Gonz04a,
|
|
4553 |
abstract = {This report covers the activities of the 2nd
|
|
4554 |
workshop on "Object-Oriented Language Engineering
|
|
4555 |
for the Post-Java Era". We describe the motivation
|
|
4556 |
that led to the organisation of a second edition of
|
|
4557 |
the workshop. Relevant organisational aspects are
|
|
4558 |
mentioned. The main part of the report consists of a
|
|
4559 |
summary of Dave Thomas's invited talk, and a recount
|
|
4560 |
of the presentations by the authors of position
|
|
4561 |
papers. Comments given along the way by the
|
|
4562 |
participants are included. Finally, some pointers to
|
|
4563 |
related work and events are given.},
|
|
4564 |
annote = {workshopproceedings},
|
|
4565 |
author = {Sebastian Gonzales and Wolgang Demeuter and Pascal
|
|
4566 |
Costanza and St\'ephane Ducasse and Richard Gabriel
|
|
4567 |
and Theo D'hondt},
|
|
4568 |
booktitle = {Object-Oriented Technology (ECOOP'04 Workshop
|
|
4569 |
Reader)},
|
|
4570 |
keywords = {scg-pub skip-doi jb04 stefPub recast04},
|
|
4571 |
publisher = {Springer-Verlag},
|
|
4572 |
series = {LNCS},
|
|
4573 |
title = {Report of the {ECOOP}'03 Workshop on Object-Oriented
|
|
4574 |
Language Engineering in Post-Java Era},
|
|
4575 |
url = {http://scg.unibe.ch/archive/papers/Gonz04aoolepje04-report.pdf},
|
|
4576 |
year = {2004}
|
|
4577 |
}
|
|
4578 |
|
|
4579 |
@inproceedings{Gonz09a,
|
|
4580 |
abstract = {The emerging field of context-oriented programming
|
|
4581 |
gives a predominant role to the execution context of
|
|
4582 |
applications, and advocates the use of dedicated
|
|
4583 |
mechanisms to allow the elegant expression of
|
|
4584 |
behavioural adaptations to such context. With
|
|
4585 |
suitable reflective facilities, language semantics
|
|
4586 |
can be adapted to context by reusing the same
|
|
4587 |
context-oriented mechanisms that allow base-level
|
|
4588 |
adaptability. This kind of meta-level adaptability,
|
|
4589 |
in which the computation model itself becomes
|
|
4590 |
adaptable to context, gives rise to context-oriented
|
|
4591 |
computational reflection. To explore this idea, we
|
|
4592 |
set out to implement a simple software transactional
|
|
4593 |
memory system that exploits meta-level adaptability
|
|
4594 |
by regarding transactions as contexts, and adapting
|
|
4595 |
fundamental system behaviour to such transactional
|
|
4596 |
contexts. The implementation is succinct and
|
|
4597 |
non-intrusive, giving us an indication of the power
|
|
4598 |
lying at the crossroads of context-oriented
|
|
4599 |
programming and computational reflection.},
|
|
4600 |
address = {New York, NY, USA},
|
|
4601 |
author = {Gonz\'{a}lez, Sebasti\'{a}n and Denker, Marcus and
|
|
4602 |
Mens, Kim},
|
|
4603 |
booktitle = {COP '09: International Workshop on Context-Oriented
|
|
4604 |
Programming},
|
|
4605 |
doi = {10.1145/1562112.1562115},
|
|
4606 |
isbn = {978-1-60558-538-3},
|
|
4607 |
keywords = {cop-lit gonzales ambience fromscgbib},
|
|
4608 |
location = {Genova, Italy},
|
|
4609 |
pages = {1--6},
|
|
4610 |
publisher = {ACM},
|
|
4611 |
title = {Transactional contexts: harnessing the power of context-oriented reflection},
|
|
4612 |
year = {2009},
|
|
4613 |
url = {http://rmod.lille.inria.fr/archives/workshops/Gonz09a-COP09-Context.pdf}
|
|
4614 |
}
|
|
4615 |
|
|
4616 |
@inproceedings{Gree05a,
|
|
4617 |
abstract = {Software developers are constantly required to
|
|
4618 |
modify and adapt features of an application in
|
|
4619 |
response to changing requirements. The problem is
|
|
4620 |
that just by reading the source code, it is
|
|
4621 |
difficult to determine how classes and methods
|
|
4622 |
contribute to the runtime behavior of features.
|
|
4623 |
Moreover, dependencies between system features are
|
|
4624 |
not obvious, consequently software maintenance
|
|
4625 |
operations often result in unintended side effects.
|
|
4626 |
To tackle these problems, we propose a compact
|
|
4627 |
feature-driven approach (\ie summarized trace
|
|
4628 |
information) based on dynamic analysis to
|
|
4629 |
characterize features and computational units of an
|
|
4630 |
application. We extract execution traces to achieve
|
|
4631 |
an explicit mapping between features and classes
|
|
4632 |
using two complementary perspectives. We apply our
|
|
4633 |
approach to two case studies and we report our
|
|
4634 |
findings.},
|
|
4635 |
address = {Los Alamitos CA},
|
|
4636 |
aeres = {ACT},
|
|
4637 |
aeresstatus = {aeres08},
|
|
4638 |
annote = {internationalconference},
|
|
4639 |
author = {Orla Greevy and St\'ephane Ducasse},
|
|
4640 |
booktitle = {Proceedings of 9th European Conference on Software
|
|
4641 |
Maintenance and Reengineering (CSMR'05)},
|
|
4642 |
cvs = {TraceScraperRevEng},
|
|
4643 |
doi = {10.1109/CSMR.2005.21},
|
|
4644 |
inria = {hors},
|
|
4645 |
keywords = {scg-pub greevy jb05 recast05 stefPub Feature
|
|
4646 |
Feature-Traces Dynamic Analysis Evolution moose-pub},
|
|
4647 |
location = {Manchester, United Kingdom},
|
|
4648 |
misc = {acceptance rate: 33/81 = 41\%},
|
|
4649 |
accepttotal = {81},
|
|
4650 |
acceptnum = {33},
|
|
4651 |
pages = {314--323},
|
|
4652 |
publisher = {IEEE Computer Society},
|
|
4653 |
rate = {41%},
|
|
4654 |
selectif = {non},
|
|
4655 |
title = {Correlating Features and Code Using A Compact
|
|
4656 |
Two-Sided Trace Analysis Approach},
|
|
4657 |
url = {http://scg.unibe.ch/archive/papers/Gree05aTraceScraperCSMR2005Features.pdf},
|
|
4658 |
year = {2005},
|
|
4659 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Gree05aTraceScraperCSMR2005Features.pdf},
|
|
4660 |
bdsk-url-2 = {http://dx.doi.org/10.1109/CSMR.2005.21}
|
|
4661 |
}
|
|
4662 |
|
|
4663 |
@inproceedings{Gree05b,
|
|
4664 |
abstract = {Software developers are often faced with the task of
|
|
4665 |
maintaining or extending large and complex
|
|
4666 |
applications, with which they are unfamiliar.
|
|
4667 |
Typically change requests and bug reports are
|
|
4668 |
expressed in terms of system features. Much of the
|
|
4669 |
maintenance effort is spent trying to identify which
|
|
4670 |
classes and methods provide functionality to
|
|
4671 |
individual features. To tackle this problem, we
|
|
4672 |
propose an approach based on dynamic analysis that
|
|
4673 |
exploits the relationship between features and
|
|
4674 |
software entities. Our definition of a feature is a
|
|
4675 |
unit of observable behavior of a software system. We
|
|
4676 |
apply our approach to a large open source
|
|
4677 |
application and identify key classes and methods
|
|
4678 |
which provide functionality to individual features.},
|
|
4679 |
annote = {internationalworkshop},
|
|
4680 |
author = {Orla Greevy and St\'ephane Ducasse},
|
|
4681 |
booktitle = {Proceedings of WOOR 2005 (6th International Workshop
|
|
4682 |
on Object-Oriented Reengineering)},
|
|
4683 |
cvs = {TraceScraperWOOR2005},
|
|
4684 |
keywords = {scg-pub skip-doi greevy jb06 MISSINGPAGENUMBERS
|
|
4685 |
stefPub Feature Feature-Traces Dynamic Analysis
|
|
4686 |
Evolution moose-pub recast05},
|
|
4687 |
month = jul,
|
|
4688 |
title = {Characterizing the Functional Roles of Classes and
|
|
4689 |
Methods by Analyzing Feature Traces},
|
|
4690 |
url = {http://scg.unibe.ch/archive/papers/Gree05bTraceScraperWOOR2005.pdf},
|
|
4691 |
year = {2005},
|
|
4692 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Gree05bTraceScraperWOOR2005.pdf}
|
|
4693 |
}
|
|
4694 |
|
|
4695 |
@inproceedings{Gree05c,
|
|
4696 |
abstract = {Many of the approaches that analyze software
|
|
4697 |
evolution consider a static perspective of a system.
|
|
4698 |
Static analysis approaches focus on the evolution of
|
|
4699 |
static software entities such as packages, classes
|
|
4700 |
and methods. Without knowledge of the roles software
|
|
4701 |
entities play in system features, it is difficult to
|
|
4702 |
interpret the motivation behind changes and
|
|
4703 |
extensions in the code. To tackle this problem, we
|
|
4704 |
propose an approach to software evolution analysis
|
|
4705 |
that exploits the relationships between features and
|
|
4706 |
software entities. Our definition of a feature is a
|
|
4707 |
unit of observable behavior of a software system. We
|
|
4708 |
define history measurements that summarize the
|
|
4709 |
evolution of software entities from a feature
|
|
4710 |
perspective. We show how we use our feature
|
|
4711 |
perspective of software evolution to interpret
|
|
4712 |
modifications and extensions to the code. We apply
|
|
4713 |
our approach on two case studies and discuss our
|
|
4714 |
findings.},
|
|
4715 |
address = {Los Alamitos},
|
|
4716 |
aeres = {ACT},
|
|
4717 |
aeresstatus = {aeres08},
|
|
4718 |
annote = {internationalconference},
|
|
4719 |
author = {Orla Greevy and St\'ephane Ducasse and Tudor G\^irba},
|
|
4720 |
booktitle = {Proceedings of 21st IEEE International Conference on Software Maintenance (ICSM'05)},
|
|
4721 |
cvs = {TraceScraperICSM2005Evolution},
|
|
4722 |
doi = {10.1109/ICSM.2005.22},
|
|
4723 |
inria = {hors},
|
|
4724 |
keywords = {scg-pub girba greevy jb06 stefPub Features
|
|
4725 |
Feature-Traces Dynamic-Analysis Evolution history
|
|
4726 |
moose-pub recast06 listic},
|
|
4727 |
misc = {acceptance rate: 55/180 = 31\%},
|
|
4728 |
accepttotal = {180},
|
|
4729 |
acceptnum = {55},
|
|
4730 |
month = sep,
|
|
4731 |
pages = {347--356},
|
|
4732 |
publisher = {IEEE Computer Society},
|
|
4733 |
rate = {31%},
|
|
4734 |
selectif = {oui},
|
|
4735 |
title = {Analyzing Feature Traces to Incorporate the Semantics of Change in Software Evolution Analysis},
|
|
4736 |
url = {http://scg.unibe.ch/archive/papers/Gree05cTraceScraperICSM2005.pdf},
|
|
4737 |
year = {2005}
|
|
4738 |
}
|
|
4739 |
|
|
4740 |
@article{Gree06b,
|
|
4741 |
abstract = {Features encapsulate the domain knowledge of a
|
|
4742 |
software system and thus are valuable sources of
|
|
4743 |
information for a reverse engineer. When analyzing
|
|
4744 |
the evolution of a system, we need to know how and
|
|
4745 |
which features were modified to recover both the
|
|
4746 |
change intention and its extent, namely which source
|
|
4747 |
artifacts are affected. Typically, the
|
|
4748 |
implementation of a feature crosscuts a number of
|
|
4749 |
source artifacts. To obtain a mapping between
|
|
4750 |
features to the source artifacts, we exercise the
|
|
4751 |
features and capture their execution traces. However
|
|
4752 |
this results in large traces that are difficult to
|
|
4753 |
interpret. To tackle this issue we compact the
|
|
4754 |
traces into simple sets of source artifacts that
|
|
4755 |
participate in a feature's runtime behavior. We
|
|
4756 |
refer to these compacted traces as feature views.
|
|
4757 |
Within a feature view, we partition the source
|
|
4758 |
artifacts into disjoint sets of characterized
|
|
4759 |
software entities. The characterization defines the
|
|
4760 |
level of participation of a source entity in the
|
|
4761 |
features. We then analyze the features over several
|
|
4762 |
versions of a system and we plot their evolution to
|
|
4763 |
reveal how and hich features were affected by
|
|
4764 |
changes in the code. We show the usefulness of our
|
|
4765 |
approach by applying it to a case study where we
|
|
4766 |
address the problem of merging parallel development
|
|
4767 |
tracks of the same system.},
|
|
4768 |
aeres = {ACL},
|
|
4769 |
aeresstatus = {aeres08},
|
|
4770 |
annote = {internationaljournal},
|
|
4771 |
author = {Orla Greevy and St\'ephane Ducasse and Tudor G\^irba},
|
|
4772 |
doi = {10.1002/smr.340},
|
|
4773 |
misc = {5 Year ISI impact factor 1.523 (2010)},
|
|
4774 |
inria = {hors},
|
|
4775 |
journal = {Journal of Software Maintenance and Evolution: Research and Practice (JSME)},
|
|
4776 |
keywords = {scg-pub recast07 snf07 jb07 fb06 stefPub girba
|
|
4777 |
mooseCincom dynamic-analysis feature evolution
|
|
4778 |
moose-pub},
|
|
4779 |
impactfactor = {5 Year ISI impact factor 1.523 (2010)},
|
|
4780 |
number = {6},
|
|
4781 |
pages = {425--456},
|
|
4782 |
peerreview = {yes},
|
|
4783 |
selectif = {non},
|
|
4784 |
title = {Analyzing Software Evolution through Feature Views},
|
|
4785 |
url = {http://scg.unibe.ch/archive/papers/Gree06bTraceScraperJSME-SCG.pdf},
|
|
4786 |
volume = {18},
|
|
4787 |
year = {2006}
|
|
4788 |
}
|
|
4789 |
|
|
4790 |
@inproceedings{Gree07a,
|
|
4791 |
abstract = {Software systems are typically developed by teams of
|
|
4792 |
developers, with responsibilities for different
|
|
4793 |
parts of the code. Knowledge of how the developers
|
|
4794 |
collaborate, and how their responsibilities are
|
|
4795 |
distributed over the software artifacts is a
|
|
4796 |
valuable source of information when reverse
|
|
4797 |
engineering a system. Determining which developers
|
|
4798 |
are responsible for which software artifacts (\eg
|
|
4799 |
packages or classes) is just one perspective. In
|
|
4800 |
this paper we complement the static perspective with
|
|
4801 |
the dynamic perspective of a system in terms of its
|
|
4802 |
features. We want to extract information about which
|
|
4803 |
developers are responsible for which features. To
|
|
4804 |
achieve these two perspectives, we correlate
|
|
4805 |
developer responsibilities both with a structural
|
|
4806 |
view of the system and with a feature view. We
|
|
4807 |
identify which developers are responsible for which
|
|
4808 |
features, and whether the responsibilities
|
|
4809 |
correspond with structural source code artifacts or
|
|
4810 |
with features. We apply our technique to two
|
|
4811 |
software projects developed by two teams of students
|
|
4812 |
as part of their course work, and to one large open
|
|
4813 |
source project.},
|
|
4814 |
address = {Los Alamitos CA},
|
|
4815 |
aeres = {ACT},
|
|
4816 |
aeresstatus = {aeres08},
|
|
4817 |
annote = {internationalconference},
|
|
4818 |
author = {Orla Greevy and Tudor G\^irba and St\'ephane
|
|
4819 |
Ducasse},
|
|
4820 |
booktitle = {Proceedings of 11th European Conference on Software
|
|
4821 |
Maintenance and Reengineering (CSMR 2007)},
|
|
4822 |
cvs = {TraceScraperCSMR2007},
|
|
4823 |
doi = {10.1109/CSMR.2007.27},
|
|
4824 |
inria = {hors},
|
|
4825 |
isbn = {0-7695-2802-3},
|
|
4826 |
issn = {1534-5351},
|
|
4827 |
keywords = {scg07 scg-pub greevy jb07 stefPub snf07 moose-pub
|
|
4828 |
authors features evolution dynamic-analysis girba},
|
|
4829 |
medium = {2},
|
|
4830 |
misc = {Acceptance rate: 38/132=29\%},
|
|
4831 |
accepttotal = {132},
|
|
4832 |
acceptnum = {38},
|
|
4833 |
pages = {256--274},
|
|
4834 |
peerreview = {yes},
|
|
4835 |
publisher = {IEEE Computer Society},
|
|
4836 |
rate = {29%},
|
|
4837 |
selectif = {oui},
|
|
4838 |
title = {How Developers Develop Features},
|
|
4839 |
url = {http://scg.unibe.ch/archive/papers/Gree07aDevelopersDevelopFeatures.pdf},
|
|
4840 |
year = {2007},
|
|
4841 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Gree07aDevelopersDevelopFeatures.pdf},
|
|
4842 |
bdsk-url-2 = {http://dx.doi.org/10.1109/CSMR.2007.27}
|
|
4843 |
}
|
|
4844 |
|
|
4845 |
@article{Gybe06a,
|
|
4846 |
abstract = {Meta programming is the act of reasoning about a
|
|
4847 |
computational system. For example, a program in
|
|
4848 |
Prolog can reason about a program written in
|
|
4849 |
Smalltalk. Reflection is a more powerful form of
|
|
4850 |
meta programming where the same language is used to
|
|
4851 |
reason about, and act upon, itself in a causally
|
|
4852 |
connected way. Thus on the one hand we have meta
|
|
4853 |
programming that allows different languages or
|
|
4854 |
paradigms to be used, but without causal connection,
|
|
4855 |
while on the other hand we have reflection that
|
|
4856 |
offers causal connection but only for a single
|
|
4857 |
language. This paper combines both and presents
|
|
4858 |
inter-language reflection that allows one language
|
|
4859 |
to reason about and change in a causally connected
|
|
4860 |
way another language and vice versa. The fundamental
|
|
4861 |
aspects of inter-language reflection and the
|
|
4862 |
language symbiosis used therein, are discussed.
|
|
4863 |
Moreover the implementation of two symbiotic
|
|
4864 |
reflective languages is discussed: Agora/Java and
|
|
4865 |
SOUL/Smalltalk.},
|
|
4866 |
aeres = {ACL},
|
|
4867 |
aeresstatus = {aeres08},
|
|
4868 |
annote = {internationaljournal},
|
|
4869 |
author = {Kris Gybels and Roel Wuyts and St\'{e}phane Ducasse and Maja D'Hondt},
|
|
4870 |
doi = {10.1016/j.cl.2005.10.003},
|
|
4871 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
4872 |
inria = {hors},
|
|
4873 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
4874 |
keywords = {stefPub decomp-pub},
|
|
4875 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
4876 |
month = jul,
|
|
4877 |
number = {2-3},
|
|
4878 |
pages = {109--124},
|
|
4879 |
publisher = {Elsevier},
|
|
4880 |
selectif = {non},
|
|
4881 |
title = {Inter-Language Reflection --- A Conceptual Model and Its Implementation},
|
|
4882 |
url = {http://scg.unibe.ch/archive/papers/Gybe06aSymbioticReflectionESUGJournal.pdf},
|
|
4883 |
volume = {32},
|
|
4884 |
year = {2006}
|
|
4885 |
}
|
|
4886 |
|
|
4887 |
|
|
4888 |
@inproceedings{Hald07b,
|
|
4889 |
abstract = {Most languages fall into one of two camps: either
|
|
4890 |
they adopt a unique, static type system, or they
|
|
4891 |
abandon static type-checks for run-time checks.
|
|
4892 |
Pluggable types blur this division by (i) making
|
|
4893 |
static type systems optional, and (ii) supporting a
|
|
4894 |
choice of type systems for reasoning about different
|
|
4895 |
kinds of static properties. Dynamic languages can
|
|
4896 |
then benefit from static-checking without
|
|
4897 |
sacrificing dynamic features or committing to a
|
|
4898 |
unique, static type system. But the overhead of
|
|
4899 |
adopting pluggable types can be very high,
|
|
4900 |
especially if all existing code must be decorated
|
|
4901 |
with type annotations before any type-checking can
|
|
4902 |
be performed. We propose a practical and pragmatic
|
|
4903 |
approach to introduce pluggable type systems to
|
|
4904 |
dynamic languages. First of all, only annotated code
|
|
4905 |
is type-checked. Second, limited type inference is
|
|
4906 |
performed on unannotated code to reduce the number
|
|
4907 |
of reported errors. Finally, external annotations
|
|
4908 |
can be used to type third-party code. We present
|
|
4909 |
Typeplug, a Smalltalk implementation of our
|
|
4910 |
framework, and report on experience applying the
|
|
4911 |
framework to three different pluggable type
|
|
4912 |
systems.},
|
|
4913 |
annote = {internationalconference},
|
|
4914 |
author = {Niklaus Haldimann and Marcus Denker and Oscar
|
|
4915 |
Nierstrasz},
|
|
4916 |
booktitle = {Proceedings of the 2007 International Conference on
|
|
4917 |
Dynamic Languages (ICDL 2007)},
|
|
4918 |
doi = {10.1145/1352678.1352690},
|
|
4919 |
isbn = {978-1-60558-084-5},
|
|
4920 |
keywords = {scg07 scg-pub jb08 snf07 reflectivity marcusdenker fromscgbib},
|
|
4921 |
medium = {2},
|
|
4922 |
pages = {183--204},
|
|
4923 |
peerreview = {yes},
|
|
4924 |
publisher = {ACM Digital Library},
|
|
4925 |
title = {Practical, Pluggable Types},
|
|
4926 |
url = {http://rmod.lille.inria.fr/archives/papers/Hald07b-ICDL07-Typeplug.pdf},
|
|
4927 |
year = {2007}
|
|
4928 |
}
|
|
4929 |
|
|
4930 |
@article{Hald09a,
|
|
4931 |
abstract = {Most languages fall into one of two camps: either
|
|
4932 |
they adopt a unique, static type system, or they
|
|
4933 |
abandon static type-checks for run-time checks.
|
|
4934 |
Pluggable types blur this division by (i) making
|
|
4935 |
static type systems optional, and (ii) supporting a
|
|
4936 |
choice of type systems for reasoning about different
|
|
4937 |
kinds of static properties. Dynamic languages can
|
|
4938 |
then benefit from static-checking without
|
|
4939 |
sacrificing dynamic features or committing to a
|
|
4940 |
unique, static type system. But the overhead of
|
|
4941 |
adopting pluggable types can be very high,
|
|
4942 |
especially if all existing code must be decorated
|
|
4943 |
with type annotations before any type-checking can
|
|
4944 |
be performed. We propose a practical and pragmatic
|
|
4945 |
approach to introduce pluggable type systems to
|
|
4946 |
dynamic languages. First of all, only annotated code
|
|
4947 |
is type-checked. Second, limited type inference is
|
|
4948 |
performed on unannotated code to reduce the number
|
|
4949 |
of reported errors. Finally, external annotations
|
|
4950 |
can be used to type third-party code. We present
|
|
4951 |
Typeplug, a Smalltalk implementation of our
|
|
4952 |
framework, and report on experience applying the
|
|
4953 |
framework to three different pluggable type
|
|
4954 |
systems.},
|
|
4955 |
annote = {internationaljournal},
|
|
4956 |
author = {Niklaus Haldimann and Marcus Denker and Oscar
|
|
4957 |
Nierstrasz},
|
|
4958 |
doi = {10.1016/j.cl.2008.06.003},
|
|
4959 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
4960 |
keywords = {scg09 scg-pub jb08 snf08 reflectivity marcusdenker fromscgbib},
|
|
4961 |
medium = {2},
|
|
4962 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
4963 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
4964 |
miscmisc = {was: Hald08a},
|
|
4965 |
month = apr,
|
|
4966 |
number = {1},
|
|
4967 |
pages = {48--64},
|
|
4968 |
peerreview = {yes},
|
|
4969 |
publisher = {Elsevier},
|
|
4970 |
title = {Practical, Pluggable Types for a Dynamic Language},
|
|
4971 |
url = {http://rmod.lille.inria.fr/archives/papers/Hald08a-COMLAN-Typeplug.pdf},
|
|
4972 |
volume = {35},
|
|
4973 |
year = {2009}
|
|
4974 |
}
|
|
4975 |
|
|
4976 |
@inproceedings{Haup07a,
|
|
4977 |
abstract = {This position paper proposes the exploitation of
|
|
4978 |
type feedback mechanisms, or more precisely,
|
|
4979 |
polymorphic inline caches, for purely interpreting
|
|
4980 |
implementations of object-oriented programming
|
|
4981 |
languages. Using Squeak's virtual machine as an
|
|
4982 |
example, polymorphic inline caches are discussed as
|
|
4983 |
an alternative to global caching. An implementation
|
|
4984 |
proposal for polymorphic inline caches in the Squeak
|
|
4985 |
virtual machine is presented, and possible future
|
|
4986 |
applications for online optimization are outlined.},
|
|
4987 |
annote = {internationalworkshop},
|
|
4988 |
author = {Michael Haupt and Robert Hirschfeld and Marcus Denker},
|
|
4989 |
booktitle = {Proceedings of the Second Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS'2007), ECOOP Workshop},
|
|
4990 |
issn = {1436-9915},
|
|
4991 |
keywords = {scg07 scg-pub skip-doi jb08 snf07 fromscgbib marcusdenker},
|
|
4992 |
medium = {2},
|
|
4993 |
month = jul,
|
|
4994 |
pages = {17--22},
|
|
4995 |
peerreview = {yes},
|
|
4996 |
publisher = {TU Berlin},
|
|
4997 |
title = {Type feedback for bytecode interpreters},
|
|
4998 |
url = {http://rmod.lille.inria.fr/archives/workshops/Haup07a-ICOOLPS07-PIC.pdf},
|
|
4999 |
year = {2007}
|
|
5000 |
}
|
|
5001 |
|
|
5002 |
@inproceedings{Hofe06a,
|
|
5003 |
abstract = {Traditional debugging and stepping execution trace
|
|
5004 |
are well-accepted techniques to understand deep
|
|
5005 |
internals about a program. However in many cases
|
|
5006 |
navigating the stack trace is not enough to find
|
|
5007 |
bugs, since the cause of a bug is often not in the
|
|
5008 |
stack trace anymore and old state is lost, so out of
|
|
5009 |
reach from the debugger. In this paper, we present
|
|
5010 |
the design and implementation of a backward-in-time
|
|
5011 |
debugger for a dynamic language, i.e, a debugger
|
|
5012 |
that allows one to navigate back the history of the
|
|
5013 |
application. We present the design and
|
|
5014 |
implementation of a backward-in-time debugger called
|
|
5015 |
Unstuck and show our solution to key implementation
|
|
5016 |
challenges.},
|
|
5017 |
aeres = {ACT},
|
|
5018 |
aeresstatus = {aeres08},
|
|
5019 |
annote = {internationalconference},
|
|
5020 |
author = {Christoph Hofer and Marcus Denker and St\'ephane
|
|
5021 |
Ducasse},
|
|
5022 |
booktitle = {Proceedings of NODE'06},
|
|
5023 |
inria = {hors},
|
|
5024 |
keywords = {skip-doi scg-pub stefPub jb07 fb06 snf06 fromscgbib marcusdenker},
|
|
5025 |
medium = {2},
|
|
5026 |
month = sep,
|
|
5027 |
organization = {Gesellschaft f{\"u}r Informatik (GI)},
|
|
5028 |
pages = {17--32},
|
|
5029 |
peerreview = {yes},
|
|
5030 |
selectif = {non},
|
|
5031 |
series = {Lecture Notes in Informatics},
|
|
5032 |
title = {Design and Implementation of a Backward-In-Time
|
|
5033 |
Debugger},
|
|
5034 |
url = {http://rmod.lille.inria.fr/archives/papers/Hofe06a-NODE06-Unstuck.pdf},
|
|
5035 |
volume = {P-88},
|
|
5036 |
year = {2006}
|
|
5037 |
}
|
|
5038 |
|
|
5039 |
@inproceedings{Kuhn05a,
|
|
5040 |
abstract = {Understanding a software system by just analyzing
|
|
5041 |
the structure of the system reveals only half of the
|
|
5042 |
picture, since the structure tells us only how the
|
|
5043 |
code is working but not what the code is about. What
|
|
5044 |
the code is about can be found in the semantics of
|
|
5045 |
the source code: names of identifiers, comments etc.
|
|
5046 |
In this paper, we analyze how these terms are spread
|
|
5047 |
over the source artifacts using Latent Semantic
|
|
5048 |
Indexing, an information retrieval technique. We use
|
|
5049 |
the assumption that parts of the system that use
|
|
5050 |
similar terms are related. We cluster artifacts that
|
|
5051 |
use similar terms, and we reveal the most relevant
|
|
5052 |
terms for the computed clusters. Our approach works
|
|
5053 |
at the level of the source code which makes it
|
|
5054 |
language independent. Nevertheless, we correlated
|
|
5055 |
the semantics with structural information and we
|
|
5056 |
applied it at different levels of abstraction (e.g.
|
|
5057 |
classes, methods). We applied our approach on three
|
|
5058 |
large case studies and we report the results we
|
|
5059 |
obtained.},
|
|
5060 |
address = {Los Alamitos CA},
|
|
5061 |
aeres = {ACT},
|
|
5062 |
aeresstatus = {aeres08},
|
|
5063 |
annote = {internationalconference},
|
|
5064 |
author = {Adrian Kuhn and St\'ephane Ducasse and Tudor
|
|
5065 |
G\^irba},
|
|
5066 |
booktitle = {Proceedings of 12th Working Conference on Reverse
|
|
5067 |
Engineering (WCRE'05)},
|
|
5068 |
doi = {10.1109/WCRE.2005.16},
|
|
5069 |
inria = {hors},
|
|
5070 |
keywords = {scg-pub semantic clustering lsi stefPub girba jb06
|
|
5071 |
recast06 hapax moose-pub listic akuhn},
|
|
5072 |
location = {Pittsburgh, PA},
|
|
5073 |
misc = {acceptance rate: 21/58 = 36 \%},
|
|
5074 |
accepttotal = {58},
|
|
5075 |
acceptnum = {21},
|
|
5076 |
month = nov,
|
|
5077 |
pages = {113--122},
|
|
5078 |
publisher = {IEEE Computer Society Press},
|
|
5079 |
rate = {36%},
|
|
5080 |
selectif = {non},
|
|
5081 |
title = {Enriching Reverse Engineering with Semantic
|
|
5082 |
Clustering},
|
|
5083 |
url = {http://scg.unibe.ch/archive/papers/Kuhn05aSemanticClustering.pdf},
|
|
5084 |
year = {2005},
|
|
5085 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Kuhn05aSemanticClustering.pdf},
|
|
5086 |
bdsk-url-2 = {http://dx.doi.org/10.1109/WCRE.2005.16}
|
|
5087 |
}
|
|
5088 |
|
|
5089 |
@article{Kuhn07a,
|
|
5090 |
abstract = {Many of the existing approaches in Software
|
|
5091 |
Comprehension focus on program program structure or
|
|
5092 |
external documentation. However, by analyzing formal
|
|
5093 |
information the informal semantics contained in the
|
|
5094 |
vocabulary of source code are overlooked. To
|
|
5095 |
understand software as a whole, we need to enrich
|
|
5096 |
software analysis with the developer knowledge
|
|
5097 |
hidden in the code naming. This paper proposes the
|
|
5098 |
use of information retrieval to exploit linguistic
|
|
5099 |
information found in source code, such as identifier
|
|
5100 |
names and comments. We introduce Semantic
|
|
5101 |
Clustering, a technique based on Latent Semantic
|
|
5102 |
Indexing and clustering to group source artifacts
|
|
5103 |
that use similar vocabulary. We call these groups
|
|
5104 |
semantic clusters and we interpret them as
|
|
5105 |
linguistic topics that reveal the intention of the
|
|
5106 |
code. We compare the topics to each other, identify
|
|
5107 |
links between them, provide automatically retrieved
|
|
5108 |
labels, and use a visualization to illustrate how
|
|
5109 |
they are distributed over the system. Our approach
|
|
5110 |
is language independent as it works at the level of
|
|
5111 |
identifier names. To validate our approach we
|
|
5112 |
applied it on several case studies, two of which we
|
|
5113 |
present in this paper.},
|
|
5114 |
address = {Newton, MA, USA},
|
|
5115 |
aeres = {ACL},
|
|
5116 |
aereststatus = {2008},
|
|
5117 |
annote = {internationaljournal},
|
|
5118 |
author = {Adrian Kuhn and St\'ephane Ducasse and Tudor G\^irba},
|
|
5119 |
doi = {10.1016/j.infsof.2006.10.017},
|
|
5120 |
impactfactor = {0.435, SCI 2005},
|
|
5121 |
inria = {hors},
|
|
5122 |
issn = {0950-5849},
|
|
5123 |
journal = {Information and Software Technology},
|
|
5124 |
keywords = {scg07 moose-pub scg-pub snf07 jb07 recast07 girba stefPub akuhn},
|
|
5125 |
impactfactor = {ISI impact factor 1.821 (2010)},
|
|
5126 |
misc = {ISI impact factor 1.821 (2010)},
|
|
5127 |
month = mar,
|
|
5128 |
number = {3},
|
|
5129 |
pages = {230--243},
|
|
5130 |
peerreview = {yes},
|
|
5131 |
publisher = {Butterworth-Heinemann},
|
|
5132 |
title = {Semantic Clustering: Identifying Topics in Source Code},
|
|
5133 |
url = {http://scg.unibe.ch/archive/drafts/Kuhn06bSemanticClustering.pdf},
|
|
5134 |
volume = {49},
|
|
5135 |
year = {2007},
|
|
5136 |
bdsk-url-1 = {http://scg.unibe.ch/archive/drafts/Kuhn06bSemanticClustering.pdf}
|
|
5137 |
}
|
|
5138 |
|
|
5139 |
@techreport{Kuhn10m,
|
|
5140 |
author = {Adrian Kuhn and David Erni and Marcus Denker},
|
|
5141 |
title = {Empowering Collections with Swarm Behavior},
|
|
5142 |
institution = {Arxiv},
|
|
5143 |
number = {arXiv:1007.0159},
|
|
5144 |
keywords = {lse-pub marcusdenker},
|
|
5145 |
month = jul,
|
|
5146 |
url = {http://rmod.lille.inria.fr/archives/reports/Kuhn10a-ArXiv-SwarmBehavior.pdf},
|
|
5147 |
year = {2010},
|
|
5148 |
inria = {RMOD},
|
|
5149 |
aeresstatus = {aeres12},
|
|
5150 |
annote = {technicalReport notrefereed},
|
|
5151 |
aeres = {AP},
|
|
5152 |
x-editorial-board = {no},
|
|
5153 |
x-proceedings = {no},
|
|
5154 |
x-international-audience = {yes},
|
|
5155 |
x-country = {CH},
|
|
5156 |
x-language = {EN},
|
|
5157 |
abstract = {Often, when modelling a system there are properties and operations that
|
|
5158 |
are related to a group of objects rather than to a single object. In this paper we extend
|
|
5159 |
Java with Swarm Behavior, a new composition operator that associates behavior with
|
|
5160 |
a collection of instances. The lookup resolution of swarm behavior is based on the element
|
|
5161 |
type of a collection and is thus orthogonal to the collection hierarchy.}
|
|
5162 |
}
|
|
5163 |
|
|
5164 |
@inproceedings{Lanz01a,
|
|
5165 |
abstract = {One of the main problems which arises in the field
|
|
5166 |
of software evolution is the sheer amount of
|
|
5167 |
information to be dealt with. Compared to reverse
|
|
5168 |
engineering where the main goal is the main
|
|
5169 |
understanding of one single system. In the field of
|
|
5170 |
software evolution this information is multiplied by
|
|
5171 |
the number of versions of the system one wants to
|
|
5172 |
understand. To counter this problem we have come up
|
|
5173 |
with a flexible query engine which can perform
|
|
5174 |
queries on the different versions of a system. In
|
|
5175 |
this paper we give an outlook on our current work in
|
|
5176 |
the field of software evolution and focus
|
|
5177 |
particularly on the concepts behind the query engine
|
|
5178 |
we have built.},
|
|
5179 |
annote = {internationalworkshop},
|
|
5180 |
author = {Michele Lanza and St\'ephane Ducasse and Lukas Steiger},
|
|
5181 |
booktitle = {Proceedings of the Workshop on Formal Foundations of
|
|
5182 |
Software Evolution},
|
|
5183 |
keywords = {scg-pub skip-doi snf01 jb01 stefPub moose-pub},
|
|
5184 |
title = {Understanding Software Evolution using a Flexible
|
|
5185 |
Query Engine},
|
|
5186 |
url = {http://scg.unibe.ch/archive/papers/Lanz01aQueryEngine.pdf},
|
|
5187 |
year = {2001},
|
|
5188 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lanz01aQueryEngine.pdf}
|
|
5189 |
}
|
|
5190 |
|
|
5191 |
|
|
5192 |
@inproceedings{Lanz01b,
|
|
5193 |
abstract = {The reengineering and reverse engineering of
|
|
5194 |
software systems is gaining importance in software
|
|
5195 |
industry, because the accelerated turnover in
|
|
5196 |
software companies creates legacy systems in a
|
|
5197 |
shorter period of time. Especially understanding
|
|
5198 |
classes is a key activity in object-oriented
|
|
5199 |
programming, since classes represent the primary
|
|
5200 |
abstractions from which applications are built. The
|
|
5201 |
main problem of this task is to quickly grasp the
|
|
5202 |
purpose of a class and its inner structure. To help
|
|
5203 |
the reverse engineers in their first contact with a
|
|
5204 |
foreign system, we propose a categorization of
|
|
5205 |
classes based on the visualization of their internal
|
|
5206 |
structure. The contributions of this paper are a
|
|
5207 |
novel categorization of classes and a visualization
|
|
5208 |
of the classes which we call the class blueprint. We
|
|
5209 |
have validated the categorization on several case
|
|
5210 |
studies, two of which we present here.},
|
|
5211 |
annote = {internationalconference topconference},
|
|
5212 |
author = {Michele Lanza and St\'ephane Ducasse},
|
|
5213 |
booktitle = {Proceedings of 16th International Conference on
|
|
5214 |
Object-Oriented Programming Systems, Languages and
|
|
5215 |
Applications (OOPSLA '01)},
|
|
5216 |
doi = {10.1145/504282.504304},
|
|
5217 |
keywords = {scg-pub snf01 jb01 stefPub moose-pub},
|
|
5218 |
misc = {acceptance rate: 27/145 = 18\%},
|
|
5219 |
accepttotal = {145},
|
|
5220 |
acceptnum = {27},
|
|
5221 |
pages = {300--311},
|
|
5222 |
publisher = {ACM Press},
|
|
5223 |
title = {A {Categorization} of {Classes} based on the
|
|
5224 |
{Visualization} of their {Internal} {Structure}: the
|
|
5225 |
{Class} {Blueprint}},
|
|
5226 |
url = {http://scg.unibe.ch/archive/papers/Lanz01bClassBlueprint.pdf},
|
|
5227 |
year = {2001},
|
|
5228 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lanz01bClassBlueprint.pdf},
|
|
5229 |
bdsk-url-2 = {http://dx.doi.org/10.1145/504282.504304}
|
|
5230 |
}
|
|
5231 |
|
|
5232 |
@inproceedings{Lanz01d,
|
|
5233 |
abstract = {Understanding classes is a key activity in
|
|
5234 |
object-oriented programming, since classes represent
|
|
5235 |
the primary abstractions from which applications are
|
|
5236 |
built. The main problem of this task is to quickly
|
|
5237 |
grasp the purpose and inner structure of a class. In
|
|
5238 |
this paper we discuss the class blueprint, a
|
|
5239 |
visualization of the inner structure of classes.},
|
|
5240 |
annote = {internationalworkshop},
|
|
5241 |
author = {Michele Lanza and St\'ephane Ducasse},
|
|
5242 |
booktitle = {Workshop Proceedings of OOPSLA 2001},
|
|
5243 |
keywords = {scg-pub skip-doi snf01 jb01 stefPub moose-pub},
|
|
5244 |
title = {The Class Blueprint: A Visualization of the Internal
|
|
5245 |
Structure of Classes},
|
|
5246 |
url = {http://scg.unibe.ch/archive/papers/Lanz01dClassBlueprint.pdf},
|
|
5247 |
year = {2001},
|
|
5248 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lanz01dClassBlueprint.pdf}
|
|
5249 |
}
|
|
5250 |
|
|
5251 |
@inproceedings{Lanz02a,
|
|
5252 |
abstract = {Coping with huge amounts of data is one of the major
|
|
5253 |
problems in the context of software evolution.
|
|
5254 |
Current approaches reduce this complexity by
|
|
5255 |
filtering out irrelevant information. In this paper
|
|
5256 |
we propose an approach based on a combination of
|
|
5257 |
software visualization and software metrics, as
|
|
5258 |
software visualization is apt for complexity
|
|
5259 |
reduction and metrics introduce the possibility to
|
|
5260 |
qualify evolution. We discuss a simple and effective
|
|
5261 |
way to visualize the evolution of software systems
|
|
5262 |
which helps to recover the evolution of object
|
|
5263 |
oriented software systems. In addition we define a
|
|
5264 |
vocabulary that qualifies some specific situations
|
|
5265 |
that occurs when considering system evolution.},
|
|
5266 |
address = {Paris},
|
|
5267 |
annote = {nationalconference},
|
|
5268 |
author = {Michele Lanza and St\'ephane Ducasse},
|
|
5269 |
booktitle = {Proceedings of Langages et Mod\`eles \`a Objets
|
|
5270 |
(LMO'02)},
|
|
5271 |
keywords = {scg-pub skip-doi jb02 snf02 stefPub moose-pub},
|
|
5272 |
pages = {135--149},
|
|
5273 |
publisher = {Lavoisier},
|
|
5274 |
title = {Understanding Software Evolution Using a Combination
|
|
5275 |
of Software Visualization and Software Metrics},
|
|
5276 |
url = {http://scg.unibe.ch/archive/papers/Lanz02aEvolutionMatrix.pdf},
|
|
5277 |
year = {2002},
|
|
5278 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lanz02aEvolutionMatrix.pdf}
|
|
5279 |
}
|
|
5280 |
|
|
5281 |
@inproceedings{Lanz02b,
|
|
5282 |
abstract = {Software Metrics have become essential in software
|
|
5283 |
engineering for several reasons, among which quality
|
|
5284 |
assessment and reengineering. In the context of the
|
|
5285 |
European Esprit Pro ject FAMOOS, whose main goal was
|
|
5286 |
to provide methodologies for the reengineering of
|
|
5287 |
large industrial software systems, we have developed
|
|
5288 |
the Moose Reengineering Environment, based on the
|
|
5289 |
language independent FAMIX metamodel. Moose includes
|
|
5290 |
a metrics engine which supports language independent
|
|
5291 |
metrics, since coping with software written in
|
|
5292 |
different implementation languages was one of the
|
|
5293 |
project's main constraints. Our current research is
|
|
5294 |
pushing us towards the development and
|
|
5295 |
implementation of a metametamodel, which would
|
|
5296 |
include our metamodel and allow for several
|
|
5297 |
extension in different research directions, among
|
|
5298 |
which concept analysis, knowledge management and
|
|
5299 |
software evolution. In this article we want to
|
|
5300 |
present our current and future work for the
|
|
5301 |
transition from language independent to domain
|
|
5302 |
independent metrics.},
|
|
5303 |
annote = {internationalworkshop},
|
|
5304 |
author = {Michele Lanza and St\'ephane Ducasse},
|
|
5305 |
booktitle = {Proceedings of the 6th International Workshop on
|
|
5306 |
Quantitative Approaches in Object-Oriented Software
|
|
5307 |
Engineering},
|
|
5308 |
editor = {Fernando Brito e Abreu and Mario Piattini and Geert
|
|
5309 |
Poels and Houari A. Sahraoui},
|
|
5310 |
isbn = {84-699-8696-1},
|
|
5311 |
keywords = {scg-pub skip-doi jb02 snf02 stefPub moose-pub},
|
|
5312 |
pages = {77--84},
|
|
5313 |
title = {Beyond Language Independent Object-Oriented Metrics:
|
|
5314 |
Model Independent Metrics},
|
|
5315 |
url = {http://scg.unibe.ch/archive/papers/Lanz02bModelIndependentMetrics.pdf},
|
|
5316 |
year = {2002},
|
|
5317 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lanz02bModelIndependentMetrics.pdf}
|
|
5318 |
}
|
|
5319 |
|
|
5320 |
@article{Lanz03d,
|
|
5321 |
abstract = {Reverse engineering software systems has become a
|
|
5322 |
major concern in software industry because of their
|
|
5323 |
sheer size and complexity. This problem needs to be
|
|
5324 |
tackled, since the systems in question are of
|
|
5325 |
considerable worth to their owners an d maintainers.
|
|
5326 |
In this article we present the concept of a
|
|
5327 |
polymetric view, a lightweight software
|
|
5328 |
visualization technique enriched with software
|
|
5329 |
metrics information. Polymetric views help to
|
|
5330 |
understand the structure and detect problems of a
|
|
5331 |
software system in the initial phases of a reverse
|
|
5332 |
engineering process. We discuss the benefits and
|
|
5333 |
limits of several predefined polymetric views we
|
|
5334 |
have implemented in our tool CodeCrawler. Moreover,
|
|
5335 |
based on clusters of different polymetric views we
|
|
5336 |
have developed a methodology which supports and
|
|
5337 |
guides a software engineer in the first phases of a
|
|
5338 |
reverse engineering of a large software system. We
|
|
5339 |
have refined this methodology by repeatedly applying
|
|
5340 |
it on industrial systems, and illustrate it by
|
|
5341 |
applying a selection of polymetric views to a case
|
|
5342 |
study.},
|
|
5343 |
annote = {internationaljournal},
|
|
5344 |
author = {Michele Lanza and St\'ephane Ducasse},
|
|
5345 |
doi = {10.1109/TSE.2003.1232284},
|
|
5346 |
journal = {Transactions on Software Engineering (TSE)},
|
|
5347 |
keywords = {scg-pub jb04 recast04 stefPub moose-pub},
|
|
5348 |
misc = {5-Year ISI impact factor 4.865 (2010)},
|
|
5349 |
impactfactor = {5-Year ISI impact factor 4.865 (2010)},
|
|
5350 |
mismisc = {SCI impact factor 1.73},
|
|
5351 |
month = sep,
|
|
5352 |
number = {9},
|
|
5353 |
pages = {782--795},
|
|
5354 |
publisher = {IEEE Computer Society},
|
|
5355 |
title = {Polymetric Views---A Lightweight Visual Approach to Reverse Engineering},
|
|
5356 |
url = {http://scg.unibe.ch/archive/papers/Lanz03dTSEPolymetric.pdf},
|
|
5357 |
volume = {29},
|
|
5358 |
year = {2003},
|
|
5359 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lanz03dTSEPolymetric.pdf},
|
|
5360 |
bdsk-url-2 = {http://dx.doi.org/10.1109/TSE.2003.1232284}
|
|
5361 |
}
|
|
5362 |
|
|
5363 |
@inproceedings{Lanz05a,
|
|
5364 |
annote = {tooldemo},
|
|
5365 |
author = {Michele Lanza and St\'ephane Ducasse and Harald Gall and Martin Pinzger},
|
|
5366 |
booktitle = {Proceedings of ICSE 2005 (27th IEEE International Conference on Software Engineering)},
|
|
5367 |
keywords = {mlanza moose-pub},
|
|
5368 |
pages = {672--673},
|
|
5369 |
publisher = {ACM Press},
|
|
5370 |
title = {{CodeCrawler} --- An Information Visualization Tool for Program Comprehension},
|
|
5371 |
year = {2005}
|
|
5372 |
}
|
|
5373 |
|
|
5374 |
@incollection{Lanz05b,
|
|
5375 |
abstract = {CodeCrawler is an extensible and language
|
|
5376 |
independent software visualization tool. It has been
|
|
5377 |
validated in several industrial case studies over
|
|
5378 |
the past years. CodeCrawler enables the fast
|
|
5379 |
exploration of new visualization ideas. It
|
|
5380 |
implements and visualizes polymetric views,
|
|
5381 |
visualizations of software enriched with information
|
|
5382 |
such as software metrics and other source code
|
|
5383 |
semantics. It provides a rich set of views that can
|
|
5384 |
be customized using a large set of metrics. While
|
|
5385 |
CodeCrawler is mainly targeted at visualizing
|
|
5386 |
object-oriented software, in its latest
|
|
5387 |
implementation it has become a general information
|
|
5388 |
visualization tool.},
|
|
5389 |
address = {Milano},
|
|
5390 |
aeres = {OS},
|
|
5391 |
aeresstatus = {aeres08},
|
|
5392 |
annote = {articlebook},
|
|
5393 |
author = {Michele Lanza and St\'ephane Ducasse},
|
|
5394 |
booktitle = {Tools for Software Maintenance and Reengineering},
|
|
5395 |
inria = {hors},
|
|
5396 |
isbn = {88-464-6396-X},
|
|
5397 |
keywords = {scg-pub skip-doi stefPub recast05 jb05 moose-pub},
|
|
5398 |
pages = {74--94},
|
|
5399 |
publisher = {Franco Angeli},
|
|
5400 |
selectif = {non},
|
|
5401 |
series = {RCOST / Software Technology Series},
|
|
5402 |
title = {{CodeCrawler} --- An Extensible and Language
|
|
5403 |
Independent 2D and 3D Software Visualization Tool},
|
|
5404 |
url = {http://scg.unibe.ch/archive/papers/Lanz05bCCBookChapter.pdf},
|
|
5405 |
year = {2005},
|
|
5406 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lanz05bCCBookChapter.pdf}
|
|
5407 |
}
|
|
5408 |
|
|
5409 |
@inproceedings{Laut09a,
|
|
5410 |
title = {Meteoroid Towards a real MVC for the Web},
|
|
5411 |
abstract = {Web development has moved from simple static pages to complex web applications, some of them
|
|
5412 |
resembling desktop ones. In most of these applications the web browser acts as thin-client (or a view) of the
|
|
5413 |
model that sits on the server. Despite the technological evolution of the web, there is still no standard
|
|
5414 |
mechanism to send data or events from the server to the client without an explicit request from the later,
|
|
5415 |
thus forcing the web browser to constantly poll the server for updates. To solve this problem a set of
|
|
5416 |
techniques under the name of Comet were proposed, allowing to send information from the server to the web
|
|
5417 |
browser without an explicit client request. In this paper we introduce Meteoroid, a Comet approach to make
|
|
5418 |
live Seaside applications. Our framework exploits the Model-View-Controller (MVC) paradigm for building
|
|
5419 |
simple yet scalable web applications, requiring very little programming effort.},
|
|
5420 |
annote = {internationalworkshop},
|
|
5421 |
author = {Juan Lautaro Fern\'andez and Santiago Robles and Andr\'es Fortier and St\'ephane Ducasse
|
|
5422 |
and Gustavo Rossi and Silvia Gordillo},
|
|
5423 |
booktitle = {Proceedings of International Workshop on Smalltalk Technologies (IWST 2009)},
|
|
5424 |
peer = {yes},
|
|
5425 |
keywords = {stefPub},
|
|
5426 |
location = {Brest, France},
|
|
5427 |
publisher = {ACM Digital Library},
|
|
5428 |
year = {2009},
|
|
5429 |
inriareport = {2009},
|
|
5430 |
aeres = {ACT},
|
|
5431 |
aeresstatus = {aeres12},
|
|
5432 |
selectif = {non},
|
|
5433 |
inria = {RMOD},
|
|
5434 |
x-pays = {AR},
|
|
5435 |
x-editorial-board = {yes},
|
|
5436 |
x-proceedings = {yes},
|
|
5437 |
x-international-audience = {yes},
|
|
5438 |
url = {http://rmod.lille.inria.fr/archives/workshops/Laut09a-IWST09-Meteroid.pdf}
|
|
5439 |
}
|
|
5440 |
|
|
5441 |
@inproceedings{Lava08a,
|
|
5442 |
author = {Jannik Laval and Alexandre Bergel and St\'ephane Ducasse},
|
|
5443 |
title = {Assessing the Quality of your Software with MoQam},
|
|
5444 |
annote = {internationalworkshop},
|
|
5445 |
keywords = {moose-pub lse-pub stefPub},
|
|
5446 |
booktitle = {FAMOOSr, 2nd Workshop on FAMIX and Moose in Reengineering},
|
|
5447 |
url = {http://rmod.lille.inria.fr/archives/workshops/Lava08a-Famoosr2008-MoQam.pdf},
|
|
5448 |
year = {2008},
|
|
5449 |
x-editorial-board = {yes},
|
|
5450 |
x-proceedings = {no},
|
|
5451 |
x-international-audience = {yes},
|
|
5452 |
hal-id = {inria-00498482}
|
|
5453 |
}
|
|
5454 |
|
|
5455 |
@inproceedings{Lava09a,
|
|
5456 |
title = {Matrice de d\'ependances enrichie},
|
|
5457 |
author = {Jannik Laval and Alexandre Bergel and St\'ephane Ducasse},
|
|
5458 |
booktitle = {Proceedings of Languages et Mod\`eles \`a Objets (LMO 2009)},
|
|
5459 |
annote = {nationalconference},
|
|
5460 |
keywords = {moose-pub lse-pub},
|
|
5461 |
year = {2009},
|
|
5462 |
inria = {RMOD},
|
|
5463 |
inriareport = {2009},
|
|
5464 |
x-editorial-board = {yes},
|
|
5465 |
x-proceedings = {yes},
|
|
5466 |
x-international-audience = {no},
|
|
5467 |
x-country = {FR},
|
|
5468 |
x-language = {FR},
|
|
5469 |
address = {Nancy, France},
|
|
5470 |
url = {http://rmod.lille.inria.fr/archives/papers/Lava09a-LMO2009-DSM.pdf},
|
|
5471 |
abstract = {Les matrices de d\'ependance (DSM - Dependency Structure Matrix), d\'evelopp\'ees dans le cadre de l'optimisation de processus, ont fait leurs preuves pour identifier les d\'ependances logicielles entre des packages ou des sous-syst\`e\-mes. Il existe plusieurs algorithmes pour structurer une matrice de fa\c con \`a ce qu'elle refl\`ete l'architecture des \'el\'ements analys\'es et mette en \'evidence des cycles entre les sous-sys\-t\`e\-mes. Cependant, les impl\'ementations de matrices de d\'ependance existantes manquent d'informations importantes pour apporter une r\'eelle aide au travail de r\'eing\'enierie. Par exemple, le poids des relations qui posent probl\`eme ainsi que leur type ne sont pas clairement pr\'esent\'es. Ou encore, des cycles ind\'ependants sont fusionn\'es. Il est \'egalement difficile d'obtenir une visualisation centr\'ee sur un package. Dans ce papier, nous am\'eliorons les matrices de d\'ependance en ajoutant des informations sur (i) le type de r\'ef\'erences, (ii) le nombre d'entit\'es r\'ef\'eren\c cantes, (iii) le nombre d'entit\'es r\'ef\'erenc\'ees. Nous distinguons \'egalement les cycles ind\'ependants. Ce travail a \'et\'e impl\'ement\'e dans l'environnement de r\'eing\'enierie open-source \emph{Moose}. Il a \'et\'e appliqu\'e \`a des \'etudes de cas complexes comme le framework \emph{Morphic UI} contenu dans les environnements Smalltalk open-source \emph{Squeak} et \emph{Pharo}. Les r\'esultats obtenus ont \'et\'e appliqu\'es dans l'environnement de programmation \emph{Pharo} et ont men\'e \`a des am\'eliorations.},
|
|
5472 |
hal-id = {inria-00498463 /}
|
|
5473 |
}
|
|
5474 |
|
|
5475 |
@inproceedings{Lava09b,
|
|
5476 |
title = {Supporting Incremental Changes in Large Models},
|
|
5477 |
author = {Jannik Laval and Simon Denier and St\'ephane Ducasse and Andy Kellens},
|
|
5478 |
booktitle = {Proceedings of ESUG International Workshop on Smalltalk Technologies (IWST 2009)},
|
|
5479 |
year = {2009},
|
|
5480 |
keywords = {moose-pub lse-pub},
|
|
5481 |
annote = {internationalworkshop},
|
|
5482 |
aeres = {ACT},
|
|
5483 |
aeresstatus = {aeres12},
|
|
5484 |
selectif = {oui},
|
|
5485 |
inria = {RMOD},
|
|
5486 |
inriareport = {2009},
|
|
5487 |
labo = {dans},
|
|
5488 |
x-pays = {BE},
|
|
5489 |
x-editorial-board = {yes},
|
|
5490 |
x-proceedings = {yes},
|
|
5491 |
x-international-audience = {yes},
|
|
5492 |
x-country = {FR},
|
|
5493 |
x-language = {EN},
|
|
5494 |
address = {Brest, France},
|
|
5495 |
url = {http://rmod.lille.inria.fr/archives/workshops/Lava09b-IWST09-incrementalChange.pdf},
|
|
5496 |
abstract = {When 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.},
|
|
5497 |
hal-id = {inria-00498492 /}
|
|
5498 |
}
|
|
5499 |
|
|
5500 |
@inproceedings{Lava09c,
|
|
5501 |
title = {Identifying cycle causes with Enriched Dependency Structural Matrix},
|
|
5502 |
author = {Jannik Laval and Simon Denier and St\'ephane Ducasse and Alexandre Bergel},
|
|
5503 |
booktitle = {WCRE '09: Proceedings of the 2009 16th Working Conference on Reverse Engineering},
|
|
5504 |
year = {2009},
|
|
5505 |
keywords = {moose-pub lse-pub},
|
|
5506 |
aeres = {ACT},
|
|
5507 |
misc = {Acceptance rate: 20/79 = 25\%},
|
|
5508 |
rate = {25\%},
|
|
5509 |
annote = {internationalconference},
|
|
5510 |
aeresstatus = {aeres12},
|
|
5511 |
labo = {dans},
|
|
5512 |
inria = {RMOD},
|
|
5513 |
inriareport = {2009},
|
|
5514 |
selectif = {oui},
|
|
5515 |
x-editorial-board = {yes},
|
|
5516 |
x-proceedings = {yes},
|
|
5517 |
x-international-audience = {yes},
|
|
5518 |
x-language = {EN},
|
|
5519 |
x-country = {FR},
|
|
5520 |
address = {Lille, France},
|
|
5521 |
url = {http://rmod.lille.inria.fr/archives/papers/Lava09c-WCRE2009-eDSM.pdf},
|
|
5522 |
abstract = {Dependency Structure Matrix (DSM) has been successfully applied to identify software
|
|
5523 |
dependencies among packages and subsystems. A number of algorithms were proposed to compute the
|
|
5524 |
matrix so that it highlights patterns and problematic dependencies between subsystems. However,
|
|
5525 |
existing DSM implementations often miss important information to fully support reengineering
|
|
5526 |
effort. For example, they do not clearly qualify and quantify problematic relationships,
|
|
5527 |
information which is crucial to support remediation tasks.
|
|
5528 |
In this paper we present enriched DSM (eDSM) where cells are enriched with contextual information
|
|
5529 |
about (i) the type of dependencies (inheritance, class reference . . . ), (ii) the proportion of
|
|
5530 |
referencing entities, (iii) the proportion of referenced entities. We distinguish independent
|
|
5531 |
cycles and stress potentially simple fixes for cycles using coloring information. This work is
|
|
5532 |
language independent and has been implemented on top of the Moose reengineering environment. It has
|
|
5533 |
been applied to non-trivial case studies among which ArgoUML, and Morphic the UI framework
|
|
5534 |
available in two open-source Smalltalks, Squeak and Pharo. Solution to problems identified by eDSM
|
|
5535 |
have been performed and retrofitted in Pharo main distribution.},
|
|
5536 |
hal-id = {inria-00498446 /}
|
|
5537 |
}
|
|
5538 |
|
|
5539 |
@inproceedings{Lava09d,
|
|
5540 |
title = {Identifying cycle causes with CycleTable},
|
|
5541 |
author = {Jannik Laval and Simon Denier and St\'ephane Ducasse},
|
|
5542 |
booktitle = {FAMOOSr 2009: 3rd Workshop on FAMIX and MOOSE in Software Reengineering},
|
|
5543 |
year = {2009},
|
|
5544 |
keywords = {moose-pub lse-pub},
|
|
5545 |
aeres = {ACT},
|
|
5546 |
annote = {internationalworkshop},
|
|
5547 |
aeresstatus = {aeres12},
|
|
5548 |
labo = {dans},
|
|
5549 |
inria = {RMOD},
|
|
5550 |
inriareport = {2009},
|
|
5551 |
selectif = {non},
|
|
5552 |
x-editorial-board = {yes},
|
|
5553 |
x-proceedings = {yes},
|
|
5554 |
x-international-audience = {yes},
|
|
5555 |
x-language = {EN},
|
|
5556 |
x-country = {FR},
|
|
5557 |
address = {Brest, France},
|
|
5558 |
url = {http://rmod.lille.inria.fr/archives/workshops/Lava09d-Famoosr2009-CycleTable.pdf},
|
|
5559 |
abstract = {No abstract},
|
|
5560 |
hal-id = {inria-00498495}
|
|
5561 |
}
|
|
5562 |
|
|
5563 |
@misc{Lava10a,
|
|
5564 |
annote = {vulgarisation},
|
|
5565 |
author = {Jannik Laval and St\'ephane Ducasse},
|
|
5566 |
journal = {Linux Magazine},
|
|
5567 |
annote = {vulgarisation},
|
|
5568 |
keywords = {pharo-pub lse-pub},
|
|
5569 |
month = jan,
|
|
5570 |
number = 123,
|
|
5571 |
aeres = {OV},
|
|
5572 |
aeresstatus = {aeres12},
|
|
5573 |
selectif = {non},
|
|
5574 |
inria = {RMOD},
|
|
5575 |
inriareport = {2010},
|
|
5576 |
title = {Optimisation d'applications en Pharo},
|
|
5577 |
x-scientific-popularization = {yes},
|
|
5578 |
volume = 1,
|
|
5579 |
year = {2010}
|
|
5580 |
}
|
|
5581 |
|
|
5582 |
@article{Lava10b,
|
|
5583 |
title = {Supporting Simultaneous Versions for Software Evolution Assessment},
|
|
5584 |
author = {Jannik Laval and Simon Denier and St\'ephane Ducasse and Jean-R\'emy Falleri},
|
|
5585 |
journal = {Journal of Science of Computer Programming (SCP)},
|
|
5586 |
annote = {internationaljournal},
|
|
5587 |
keywords = {sub lse-pub moose-pub},
|
|
5588 |
year = {2010},
|
|
5589 |
month = may,
|
|
5590 |
inriareport = {2010},
|
|
5591 |
aeres = {ACL},
|
|
5592 |
aeresstatus = {aeres12},
|
|
5593 |
labo = {dans},
|
|
5594 |
inria = {RMOD},
|
|
5595 |
misc = {Core A},
|
|
5596 |
impactfactor = {Core A},
|
|
5597 |
selectif = {oui},
|
|
5598 |
abstract = {When reengineering software systems, maintainers should be able to assess and compare multiple change scenarios for a given goal, so as to choose the most pertinent one. Because they implicitly consider one single working copy, revision control systems do not scale up well to perform simultaneous analyses of multiple versions of systems. We designed Orion, an interactive prototyping tool for reengineering, to simulate changes and compare their impact on multiple versions of software source code models. Our approach offers an interactive simulation of changes, reuses existing assessment tools, and has the ability to hold multiple and branching versions simultaneously in memory. Specifically, we devise an infrastructure which optimizes memory usage of multiple versions for large models. This infrastructure uses an extension of the FAMIX source code meta-model but it is not limited to source code analysis tools since it can be applied to models in general. In this paper, we validate our approach by running benchmarks on memory usage and computation time of model queries on large models. Our benchmarks show that the Orion approach scales up well in terms of memory usage, while the current implementation could be optimized to lower its computation time. We also report on two large case studies on which we applied Orion.},
|
|
5599 |
x-editorial-board = {yes},
|
|
5600 |
x-proceedings = {yes},
|
|
5601 |
x-international-audience = {yes},
|
|
5602 |
x-language = {EN},
|
|
5603 |
hal-id = {inria-00531500},
|
|
5604 |
x-scientific-popularization = {yes},
|
|
5605 |
url = {http://dx.doi.org/10.1016/j.scico.2010.11.014}
|
|
5606 |
}
|
|
5607 |
|
|
5608 |
@misc{Lava10c,
|
|
5609 |
annote = {vulgarisation},
|
|
5610 |
author = {Jannik Laval and St\'ephane Ducasse},
|
|
5611 |
journal = {Linux Magazine},
|
|
5612 |
annote = {vulgarisation},
|
|
5613 |
keywords = {pharo-pub lse-pub},
|
|
5614 |
month = sep,
|
|
5615 |
number = 130,
|
|
5616 |
aeres = {OV},
|
|
5617 |
aeresstatus = {aeres12},
|
|
5618 |
selectif = {non},
|
|
5619 |
inria = {RMOD},
|
|
5620 |
inriareport = {2010},
|
|
5621 |
title = {Pharo: un nouveau Smalltalk open source},
|
|
5622 |
x-scientific-popularization = {yes},
|
|
5623 |
volume = 1,
|
|
5624 |
year = {2010}
|
|
5625 |
}
|
|
5626 |
|
|
5627 |
@misc{Lava10d,
|
|
5628 |
annote = {vulgarisation},
|
|
5629 |
author = {Jannik Laval and St\'ephane Ducasse},
|
|
5630 |
journal = {Linux Magazine},
|
|
5631 |
annote = {vulgarisation},
|
|
5632 |
keywords = {pharo-pub lse-pub},
|
|
5633 |
month = nov,
|
|
5634 |
number = 132,
|
|
5635 |
aeres = {OV},
|
|
5636 |
aeresstatus = {aeres12},
|
|
5637 |
selectif = {non},
|
|
5638 |
inria = {RMOD},
|
|
5639 |
title = {Package et gestion de versions en Pharo},
|
|
5640 |
x-scientific-popularization = {yes},
|
|
5641 |
volume = 1,
|
|
5642 |
Year = {2010}
|
|
5643 |
}
|
|
5644 |
|
|
5645 |
@inproceedings{Lava10e,
|
|
5646 |
title = {OZONE: Package Layered Structure Identification in presence of Cycles},
|
|
5647 |
author = {Jannik Laval and Nicolas Anquetil and St\'ephane Ducasse},
|
|
5648 |
booktitle = {Proceedings of the 9th edition of the Workshop BElgian-NEtherlands software eVOLution seminar, BENEVOL 2010},
|
|
5649 |
year = {2010},
|
|
5650 |
keywords = {moose-pub lse-pub},
|
|
5651 |
aeres = {ACT},
|
|
5652 |
annote = {internationalworkshop},
|
|
5653 |
aeresstatus = {aeres12},
|
|
5654 |
labo = {dans},
|
|
5655 |
inria = {RMOD},
|
|
5656 |
inriareport = {2010},
|
|
5657 |
selectif = {non},
|
|
5658 |
x-editorial-board = {yes},
|
|
5659 |
x-proceedings = {yes},
|
|
5660 |
x-international-audience = {yes},
|
|
5661 |
x-language = {EN},
|
|
5662 |
x-country = {FR},
|
|
5663 |
address = {Lille, France},
|
|
5664 |
url = {http://rmod.lille.inria.fr/archives/workshops/Lava10e-Benevol2010-Layers.pdf},
|
|
5665 |
abstract = {Packages are complex entities and it can be difficult to understand them as they play different roles (e.g., core package, UI class container, tests package . . . ). In particular, package interdependencies make difficult their management (substitution, evolutions, deprecation). Understanding whether a package has high or low impact on the system is another valuable piece of information. In addition, package organization represents the backbone of large software system. It is is usually agreed that packages should form layered structures. However, identifying such layered structure is difficult since packages are often in cycles. Several approaches propose to recover software structure or to visualize classes or files organization. Only few approaches provide layered organization and in particular take cycle into account. In this paper, we propose an approach which provides (i) a strategy to highlight dependencies which break Acyclic Dependency Principle and (ii) an organization of package (even in presence of cycles) in multiple layers. While our approach can be run automatically, it also supports human inputs and constraints. We validate our approach with a preliminary study on the structure of the Moose software analysis platform: it shows promising results.}
|
|
5666 |
}
|
|
5667 |
|
|
5668 |
@techreport{Leth97a,
|
|
5669 |
author = {Timothy C. Lethbridge and Nicolas Anquetil},
|
|
5670 |
institution = {University of Ottawa},
|
|
5671 |
month = jul,
|
|
5672 |
note = {Computer Science Technical Report of University of Ottawa},
|
|
5673 |
title = {Architecture of a Source Code Exploration Tool: A Software Engineering Case Study},
|
|
5674 |
year = {1997}
|
|
5675 |
}
|
|
5676 |
|
|
5677 |
@inproceedings{Lian02a,
|
|
5678 |
abstract = {PECOS is a collaborative project between industrial
|
|
5679 |
and research partners that seeks to enable
|
|
5680 |
component-based technology for a class of embedded
|
|
5681 |
systems known as "field devices". Results so far
|
|
5682 |
include a component model for field devices and a
|
|
5683 |
composition language for specifying connections
|
|
5684 |
between software components. Here we investigate the
|
|
5685 |
application of Rate Monotonic Analysis (RMA) to the
|
|
5686 |
problem of generating real-time schedules for
|
|
5687 |
compositions of field device components.},
|
|
5688 |
annote = {internationalworkshop},
|
|
5689 |
author = {Peng Liang and Gabriela Ar{\'e}valo and St\'ephane
|
|
5690 |
Ducasse and Michele Lanza and Nathanael Sch{\"a}rli
|
|
5691 |
and Roel Wuyts and Oscar Nierstrasz},
|
|
5692 |
booktitle = {ECOOP 2002 Workshop Reader},
|
|
5693 |
keywords = {scg-pub skip-doi jb02 pecos stefPub arevalo
|
|
5694 |
schaerli},
|
|
5695 |
title = {Applying RMA for Scheduling Field Device Components},
|
|
5696 |
url = {http://scg.unibe.ch/archive/papers/Lian02aPecosRMA.pdf},
|
|
5697 |
year = {2002},
|
|
5698 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lian02aPecosRMA.pdf}
|
|
5699 |
}
|
|
5700 |
|
|
5701 |
@inproceedings{Lien05a,
|
|
5702 |
abstract = {Traits are basically mixins or interfaces but with
|
|
5703 |
method bodies. In languages that support traits,
|
|
5704 |
classes are composed out of traits. There are two
|
|
5705 |
main advantages with traits. Firstly, decomposing
|
|
5706 |
existing classes into traits from which they can be
|
|
5707 |
recomposed improves the factoring of hierarchies.
|
|
5708 |
Secondly it increases the library reuse potential by
|
|
5709 |
providing more reusable traits. Identifying traits
|
|
5710 |
and decomposing class hierarchies into traits is
|
|
5711 |
therefore an important and challenging task to
|
|
5712 |
facilitate maintainability and evolution. In this
|
|
5713 |
paper we present how we use Formal Concept Analysis
|
|
5714 |
to identify traits in inheritance hierarchies. Our
|
|
5715 |
approach is two-staged: first we identify within a
|
|
5716 |
hierarchy maximal groups of methods that have a set
|
|
5717 |
of classes in common, second we cluster cohesive
|
|
5718 |
groups of methods based on method invocations as
|
|
5719 |
potential traits. We applied our approach on two
|
|
5720 |
significant hierarchies and compare our results with
|
|
5721 |
the manual refactorization of the same code which
|
|
5722 |
was done by the authors of traits.},
|
|
5723 |
aeres = {ACT},
|
|
5724 |
aeresstatus = {aeres08},
|
|
5725 |
annote = {internationalconference topconference},
|
|
5726 |
author = {Adrian Lienhard and St\'ephane Ducasse and Gabriela
|
|
5727 |
Ar{\'e}valo},
|
|
5728 |
booktitle = {Proceedings of 20th Conference on Automated Software
|
|
5729 |
Engineering (ASE'05)},
|
|
5730 |
cvs = {ConAnASE05Traits},
|
|
5731 |
doi = {10.1145/1101908.1101921},
|
|
5732 |
inria = {hors},
|
|
5733 |
keywords = {scg-pub snf05 recast06 stefPub moose-pub arevalo
|
|
5734 |
jb06 listic},
|
|
5735 |
medium = {2},
|
|
5736 |
misc = {acceptance rate: 28/291 = 9\%},
|
|
5737 |
accepttotal = {291},
|
|
5738 |
acceptnum = {28},
|
|
5739 |
month = nov,
|
|
5740 |
pages = {66--75},
|
|
5741 |
peerreview = {yes},
|
|
5742 |
publisher = {IEEE Computer Society},
|
|
5743 |
rate = {9%},
|
|
5744 |
selectif = {oui},
|
|
5745 |
title = {Identifying Traits with Formal Concept Analysis},
|
|
5746 |
url = {http://scg.unibe.ch/archive/papers/Lien05aIdentifyingTraits.pdf},
|
|
5747 |
year = {2005},
|
|
5748 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lien05aIdentifyingTraits.pdf},
|
|
5749 |
bdsk-url-2 = {http://dx.doi.org/10.1145/1101908.1101921}
|
|
5750 |
}
|
|
5751 |
|
|
5752 |
@inproceedings{Lien06a,
|
|
5753 |
abstract = {Most of today's dynamic analysis approaches are
|
|
5754 |
based on method traces. However, in the case of
|
|
5755 |
object-orientation understanding program execution
|
|
5756 |
by analyzing method traces is complicated because
|
|
5757 |
the behavior of a program depends on the sharing and
|
|
5758 |
the transfer of object references (aliasing). We
|
|
5759 |
argue that trace-based dynamic analysis is at a too
|
|
5760 |
low level of abstraction for object-oriented
|
|
5761 |
systems. We propose a new approach that captures the
|
|
5762 |
life cycle of objects by explicitly taking into
|
|
5763 |
account object aliasing and how aliases propagate
|
|
5764 |
during the execution of the program. In this paper,
|
|
5765 |
we present in detail our new meta-model and discuss
|
|
5766 |
future tracks opened by it.},
|
|
5767 |
annote = {internationalworkshop},
|
|
5768 |
author = {Adrian Lienhard and St\'ephane Ducasse and Tudor
|
|
5769 |
G\^irba and Oscar Nierstrasz},
|
|
5770 |
booktitle = {Proceedings International Workshop on Program
|
|
5771 |
Comprehension through Dynamic Analysis (PCODA'06)},
|
|
5772 |
keywords = {scg-pub skip-doi stefPub girba jb07 fb06 snf07
|
|
5773 |
object-flow dynamic-analysis},
|
|
5774 |
medium = {2},
|
|
5775 |
pages = {39--43},
|
|
5776 |
peerreview = {yes},
|
|
5777 |
title = {Capturing How Objects Flow At Runtime},
|
|
5778 |
url = {http://scg.unibe.ch/archive/papers/Lien06aCapturingHowObjectsFlowPCODA06.pdf
|
|
5779 |
http://www.lore.ua.ac.be/Events/PCODA2006/pcoda2006proceedings.pdf},
|
|
5780 |
year = {2006}
|
|
5781 |
}
|
|
5782 |
|
|
5783 |
@inproceedings{Lien07c,
|
|
5784 |
abstract = {To extract abstract views of the behavior of an
|
|
5785 |
object-oriented system for reverse engineering, a
|
|
5786 |
body of research exists that analyzes a system's
|
|
5787 |
runtime execution. Those approaches primarily
|
|
5788 |
analyze the control flow by tracing method execution
|
|
5789 |
events. However, they do not capture information
|
|
5790 |
flows. We address this problem by proposing a novel
|
|
5791 |
dynamic analysis technique named Object Flow
|
|
5792 |
Analysis, which complements method execution tracing
|
|
5793 |
with an accurate analysis of the runtime flow of
|
|
5794 |
objects. To exemplify the usefulness of our analysis
|
|
5795 |
we present a visual approach that allows a system
|
|
5796 |
engineer to study classes and components in terms of
|
|
5797 |
how they exchange objects at runtime. We illustrate
|
|
5798 |
and validate our approach on two case studies.},
|
|
5799 |
address = {New York, NY, USA},
|
|
5800 |
aeres = {ACT},
|
|
5801 |
aeresstatus = {aeres08},
|
|
5802 |
annote = {internationalconference},
|
|
5803 |
author = {Adrian Lienhard and St\'ephane Ducasse and Tudor
|
|
5804 |
G\^irba},
|
|
5805 |
booktitle = {Proceedings of the 2007 International Conference on
|
|
5806 |
Dynamic Languages (ICDL'07)},
|
|
5807 |
doi = {10.1145/1352678.1352686},
|
|
5808 |
inria = {hors},
|
|
5809 |
isbn = {978-1-60558-084-5},
|
|
5810 |
keywords = {scg07 scg-pub jb08 snf08 girba moose-pub object-flow
|
|
5811 |
dynamic-analysis},
|
|
5812 |
location = {Lugano, Switzerland},
|
|
5813 |
medium = {2},
|
|
5814 |
pages = {121--140},
|
|
5815 |
peerreview = {yes},
|
|
5816 |
publisher = {ACM Digital Library},
|
|
5817 |
selectif = {non},
|
|
5818 |
title = {Object Flow Analysis --- Taking an Object-Centric
|
|
5819 |
View on Dynamic Analysis},
|
|
5820 |
url = {http://scg.unibe.ch/archive/papers/Lien07c-ObjectFlowAnalysis.pdf},
|
|
5821 |
year = {2007},
|
|
5822 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lien07c-ObjectFlowAnalysis.pdf},
|
|
5823 |
bdsk-url-2 = {http://dx.doi.org/10.1145/1352678.1352686}
|
|
5824 |
}
|
|
5825 |
|
|
5826 |
@article{Lien08c,
|
|
5827 |
abstract = {A large body of research analyzes the runtime
|
|
5828 |
execution of a system to extract abstract behavioral
|
|
5829 |
views. Those approaches primarily analyze control
|
|
5830 |
flow by tracing method execution events or they
|
|
5831 |
analyze object graphs of heap snapshots. However,
|
|
5832 |
they do not capture how objects are passed through
|
|
5833 |
the system at runtime. We refer to the exchange of
|
|
5834 |
objects as the object flow, and we claim that object
|
|
5835 |
flow is necessary to analyze if we are to understand
|
|
5836 |
the runtime of an object-oriented application. We
|
|
5837 |
propose and detail Object Flow Analysis, a novel
|
|
5838 |
dynamic analysis technique that takes this new
|
|
5839 |
information into account. To evaluate its
|
|
5840 |
usefulness, we present a visual approach that allows
|
|
5841 |
a developer to study classes and components in terms
|
|
5842 |
of how they exchange objects at runtime. We
|
|
5843 |
illustrate our approach on three case studies.},
|
|
5844 |
aeres = {ACL},
|
|
5845 |
aeresstatus = {aeres10},
|
|
5846 |
annote = {internationaljournal},
|
|
5847 |
author = {Adrian Lienhard and St\'ephane Ducasse and Tudor G\^irba},
|
|
5848 |
doi = {10.1016/j.cl.2008.05.006},
|
|
5849 |
inria = {hors},
|
|
5850 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
5851 |
keywords = {scg09 scg-pub girba moose-pub object-flow dynamic-analysis remoose jb09 snf09},
|
|
5852 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
5853 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
5854 |
number = {1},
|
|
5855 |
pages = {63--79},
|
|
5856 |
peerreview = {yes},
|
|
5857 |
publisher = {Elsevier},
|
|
5858 |
selectif = {non},
|
|
5859 |
title = {Taking an Object-Centric View on Dynamic Information with Object Flow Analysis},
|
|
5860 |
url = {http://scg.unibe.ch/archive/papers/Lien08cObjectFlowAnalysis.pdf},
|
|
5861 |
volume = {35},
|
|
5862 |
year = {2009},
|
|
5863 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Lien08cObjectFlowAnalysis.pdf}
|
|
5864 |
}
|
|
5865 |
|
|
5866 |
@inproceedings{Loew07a,
|
|
5867 |
abstract = {While many software systems today have to be aware
|
|
5868 |
of the context in which they are executing, there is
|
|
5869 |
still little support for structuring a program with
|
|
5870 |
respect to context. A first step towards better
|
|
5871 |
context-orientation was the introduction of method
|
|
5872 |
layers. This paper proposes two additional language
|
|
5873 |
concepts, namely the implicit activation of method
|
|
5874 |
layers, and the introduction of dynamic variables},
|
|
5875 |
annote = {internationalconference},
|
|
5876 |
author = {Martin von L\"owis and Marcus Denker and Oscar Nierstrasz},
|
|
5877 |
booktitle = {Proceedings of the 2007 International Conference on
|
|
5878 |
Dynamic Languages (ICDL 2007)},
|
|
5879 |
doi = {10.1145/1352678.1352688},
|
|
5880 |
isbn = {978-1-60558-084-5},
|
|
5881 |
keywords = {scg07 scg-pub jb08 snf08 fromscgbib marcusdenker},
|
|
5882 |
medium = {2},
|
|
5883 |
pages = {143--156},
|
|
5884 |
peerreview = {yes},
|
|
5885 |
publisher = {ACM Digital Library},
|
|
5886 |
title = {Context-Oriented Programming: Beyond Layers},
|
|
5887 |
url = {http://rmod.lille.inria.fr/archives/papers/Loew07a-ICDL07-PyContext.pdf},
|
|
5888 |
year = {2007}
|
|
5889 |
}
|
|
5890 |
|
|
5891 |
@inproceedings{Manj02a,
|
|
5892 |
annote = {internationalconference},
|
|
5893 |
author = {Manjarr\'es, Angeles and Suny\'e, Gerson and Pollet, Damien and Pickin, Simon and J\'ez\'equel, Jean-Marc},
|
|
5894 |
booktitle = {International Conference on Software Engineering and Knowledge Engineering (SEKE)},
|
|
5895 |
editor = {ACM},
|
|
5896 |
month = {jul},
|
|
5897 |
pages = {237--238},
|
|
5898 |
title = {AI Analysis Patterns as UML Meta-model Constructs},
|
|
5899 |
url = {http://www.irisa.fr/triskell/publis/2002/Manjarres02a.pdf},
|
|
5900 |
year = {2002},
|
|
5901 |
bdsk-url-1 = {http://www.irisa.fr/triskell/publis/2002/Manjarres02a.pdf}
|
|
5902 |
}
|
|
5903 |
|
|
5904 |
@inproceedings{Manj02b,
|
|
5905 |
annote = {internationalconference},
|
|
5906 |
author = {Manjarr\'es, Angeles and Pickin, Simon and Suny\'e,
|
|
5907 |
Gerson and Pollet, Damien and J\'ez\'equel,
|
|
5908 |
Jean-Marc},
|
|
5909 |
booktitle = {SGAI International Conference on Knowledge Based
|
|
5910 |
Systems and Applied Artificial Intelligence:
|
|
5911 |
Research and Development in Intelligent Systems XIX
|
|
5912 |
(ES2002)},
|
|
5913 |
month = {dec},
|
|
5914 |
publisher = {Springer Verlag},
|
|
5915 |
series = {BCS Conference Series},
|
|
5916 |
title = {OO Analysis Patterns as UML Metalevel
|
|
5917 |
Collaborations},
|
|
5918 |
year = {2002}
|
|
5919 |
}
|
|
5920 |
|
|
5921 |
@inproceedings{Mens05a,
|
|
5922 |
aeres = {ACT},
|
|
5923 |
aeresstatus = {aeres08},
|
|
5924 |
annote = {internationalworkshop},
|
|
5925 |
author = {Tom Mens and Michel Wermelinger and St\'ephane Ducasse and Serge Demeyer and Robert Hirschfeld and Mehdi Jazayeri},
|
|
5926 |
booktitle = {Proceedings of the International Workshop on Principles of Software Evolution (IWPSE 2005)},
|
|
5927 |
inria = {hors},
|
|
5928 |
keywords = {stefPub scgPub},
|
|
5929 |
misc = {acceptance rate: 13/54 = 24\%},
|
|
5930 |
accepttotal = {54},
|
|
5931 |
acceptnum = {13},
|
|
5932 |
pages = {123--131},
|
|
5933 |
publisher = {IEEE Computer Society},
|
|
5934 |
rate = {24%},
|
|
5935 |
selectif = {oui},
|
|
5936 |
title = {Challenges in Software Evolution},
|
|
5937 |
year = {2005}
|
|
5938 |
}
|
|
5939 |
|
|
5940 |
@inproceedings{Minj05a,
|
|
5941 |
abstract = {The trait model is complementary to class
|
|
5942 |
inheritance and allows collections of methods to be
|
|
5943 |
reused by several classes. The classbox model allows
|
|
5944 |
a collection of classes to be locally extended with
|
|
5945 |
variables and/or methods addition. This paper
|
|
5946 |
describes a symbiosis of these two models: classes
|
|
5947 |
can be locally extended by using a trait. It is
|
|
5948 |
illustrated by an efficient implementation of the
|
|
5949 |
collaboration model where a collaboration is
|
|
5950 |
represented by a classbox and a role by a trait.},
|
|
5951 |
address = {Bern, Switzerland},
|
|
5952 |
aeres = {ACL},
|
|
5953 |
annote = {nationalconference},
|
|
5954 |
author = {Florian Minjat and Alexandre Bergel and Pierre Cointe and St\'ephane Ducasse},
|
|
5955 |
booktitle = {Actes de Langages et Mod\`eles \`a Objets (LMO'05)},
|
|
5956 |
inria = {hors},
|
|
5957 |
keywords = {traits classbox scg-pub skip-doi scg stefPub jb05
|
|
5958 |
alexPub alexandrePub noWorkshop snf05},
|
|
5959 |
pages = {33--46},
|
|
5960 |
selectif = {non},
|
|
5961 |
title = {Mise en symbiose des traits et des classboxes : Application \`a l'expression des collaborations},
|
|
5962 |
url = {http://scg.unibe.ch/archive/papers/Minj05a-TraitClassbox.pdf},
|
|
5963 |
volume = {11},
|
|
5964 |
year = {2005},
|
|
5965 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Minj05a-TraitClassbox.pdf}
|
|
5966 |
}
|
|
5967 |
|
|
5968 |
@inproceedings{Mord09a,
|
|
5969 |
author = {Karine Mordal-Manet and Fran{\c c}oise Balmas and Simon Denier and St\'ephane Ducasse and Harald Wertz and Jannik Laval and Fabrice Bellingard and Philippe Vaillergues},
|
|
5970 |
title = {The Squale Model -- A Practice-based Industrial Quality Model},
|
|
5971 |
annote = {internationalconference},
|
|
5972 |
booktitle = {ICSM '09: Proceedings of the IEEE International Conference on Software Maintenance},
|
|
5973 |
abstract = {No abstract},
|
|
5974 |
misc = {acceptance rate: 35(+29)/162: 21(40)\% for short papers},
|
|
5975 |
rate = {40\%},
|
|
5976 |
keywords = {squale-pub lse-pub},
|
|
5977 |
aeres = {ACT},
|
|
5978 |
aeresstatus = {aeres12},
|
|
5979 |
selectif = {oui},
|
|
5980 |
labo = {dans},
|
|
5981 |
inria = {RMOD},
|
|
5982 |
inriareport = {2009},
|
|
5983 |
pages = {94--103},
|
|
5984 |
keywords = {moose-pub},
|
|
5985 |
year = {2009},
|
|
5986 |
x-editorial-board = {yes},
|
|
5987 |
x-proceedings = {yes},
|
|
5988 |
x-international-audience = {yes},
|
|
5989 |
x-language = {EN},
|
|
5990 |
x-country = {FR},
|
|
5991 |
address = {Edmonton, Canada},
|
|
5992 |
url = {http://rmod.lille.inria.fr/archives/papers/Mord09a-ICSM2009-SqualeModel.pdf}
|
|
5993 |
}
|
|
5994 |
|
|
5995 |
@techreport{Mord09b,
|
|
5996 |
author = {Karine Mordal-Manet and Fran{\c c}oise Balmas and Simon Denier and St\'ephane Ducasse and Harald Wertz and Jannik Laval and Fabrice Bellingard and Philippe Vaillergues},
|
|
5997 |
title = {The Squale Model -- A \emph{Practice-}based Industrial Quality Model},
|
|
5998 |
keywords = {squale-pub lse-pub},
|
|
5999 |
annote = {technicalReport stefPub},
|
|
6000 |
institution = {INRIA Lille Nord Europe},
|
|
6001 |
type_rapport = {Rapport technique},
|
|
6002 |
year = {2009},
|
|
6003 |
inria = {RMOD},
|
|
6004 |
inriareport = {2009},
|
|
6005 |
x-language = {EN},
|
|
6006 |
abstract = {No abstract}
|
|
6007 |
}
|
|
6008 |
|
|
6009 |
@inproceedings{Mord11a,
|
|
6010 |
title = {An empirical model for continuous and weighted metric aggregation},
|
|
6011 |
author = {Karine Mordal-Manet and Jannik Laval and St\'ephane Ducasse and Nicolas Anquetil and Fran\c oise Balmas and Fabrice Bellingard and Laurent bouhier and Philippe Vaillergues and Thomas McCabe},
|
|
6012 |
booktitle = {CSMR 2011: Proceedings of the 15th European Conference on Software Maintenance and Reengineering},
|
|
6013 |
year = {2011},
|
|
6014 |
misc = {acceptance rate: 29/82 = 35\%},
|
|
6015 |
keywords = {moose-pub lse-pub},
|
|
6016 |
aeres = {ACT},
|
|
6017 |
annote = {internationalconference},
|
|
6018 |
aeresstatus = {aeres12},
|
|
6019 |
labo = {dans},
|
|
6020 |
inria = {RMOD},
|
|
6021 |
inriareport = {2009},
|
|
6022 |
selectif = {oui},
|
|
6023 |
x-editorial-board = {yes},
|
|
6024 |
x-proceedings = {yes},
|
|
6025 |
x-international-audience = {yes},
|
|
6026 |
x-language = {EN},
|
|
6027 |
x-country = {GE},
|
|
6028 |
address = {Oldenburg, Germany},
|
|
6029 |
url = {http://rmod.lille.inria.fr/archives/phd/Mord11a-CSMR2011-Squale.pdf}
|
|
6030 |
}
|
|
6031 |
|
|
6032 |
@inproceedings{Moug03a,
|
|
6033 |
abstract = {Array programming shines in its ability to express
|
|
6034 |
computations at a high-level of abstraction,
|
|
6035 |
allowing one to manipulate and query whole sets of
|
|
6036 |
data at once. This paper presents the OPA model that
|
|
6037 |
enhances object-oriented programming with array
|
|
6038 |
programming features. The goal of OPA is to
|
|
6039 |
determine a minimum set of modifications that must
|
|
6040 |
be made to the traditional object model in order to
|
|
6041 |
take advantage of the possibilities of array
|
|
6042 |
programming. It is based on a minimal extension of
|
|
6043 |
method invocation and the definition of a kernel of
|
|
6044 |
methods implementing fundamental array programming
|
|
6045 |
operations. The OPA model presents a generalization
|
|
6046 |
of traditional message passing in the sense that a
|
|
6047 |
message can be send to an entire set of objects. The
|
|
6048 |
model is validated in FS, a new scripting language.},
|
|
6049 |
annote = {internationalconference topconference},
|
|
6050 |
author = {Philippe Mougin and St\'ephane Ducasse},
|
|
6051 |
booktitle = {Proceedings of 17th International Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA'03)},
|
|
6052 |
doi = {10.1145/949305.949312},
|
|
6053 |
keywords = {snf04 scg-pub jb04 stefPub},
|
|
6054 |
misc = {acceptance rate: 26/142 = 18\%},
|
|
6055 |
accepttotal = {142},
|
|
6056 |
acceptnum = {26},
|
|
6057 |
month = oct,
|
|
6058 |
pages = {65--77},
|
|
6059 |
title = {{OOPAL}: Integrating Array Programming in Object-Oriented Programming},
|
|
6060 |
url = {http://scg.unibe.ch/archive/papers/Moug03aOOPALOOPSLA.pdf},
|
|
6061 |
year = {2003},
|
|
6062 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Moug03aOOPALOOPSLA.pdf},
|
|
6063 |
bdsk-url-2 = {http://dx.doi.org/10.1145/949305.949312}
|
|
6064 |
}
|
|
6065 |
|
|
6066 |
@misc{Mull05c,
|
|
6067 |
address = {Montego Bay, Jamaica},
|
|
6068 |
annote = {internationalworkshop},
|
|
6069 |
author = {Muller, Pierre-Alain and Fleurey, Franck and Vojtisek, Didier and Drey, Zo\'e and Pollet, Damien and Fondement, Fr\'ed\'eric and Studer, Philippe and J\'ez\'equel, Jean-Marc},
|
|
6070 |
howpublished = {Model Transformations In Practice Workshop},
|
|
6071 |
month = {oct},
|
|
6072 |
title = {On Executable Meta-Languages applied to Model Transformations},
|
|
6073 |
year = {2005}
|
|
6074 |
}
|
|
6075 |
|
|
6076 |
@unpublished{Nebb97a,
|
|
6077 |
author = {R. Nebbe and T.D. Meijler and S. Demeyer and S. Ducasse and T. Richner},
|
|
6078 |
month = feb,
|
|
6079 |
note = {Esprit IV \#21975 FAMOOS Achievement A2.2.1},
|
|
6080 |
publisher = {University of Bern},
|
|
6081 |
title = {Formal Model for Basic Object-Oriented Software
|
|
6082 |
Structures},
|
|
6083 |
year = {1997}
|
|
6084 |
}
|
|
6085 |
|
|
6086 |
@inproceedings{Nier02a,
|
|
6087 |
abstract = {Component-based software development is becoming
|
|
6088 |
mainstream for conventional applications. However,
|
|
6089 |
components can be difficult to deploy in embedded
|
|
6090 |
systems because of non-functional requirements.
|
|
6091 |
Pecos is a collaborative project between industrial
|
|
6092 |
and research partners that seeks to enable
|
|
6093 |
component-based technology for a class of embedded
|
|
6094 |
systems known as field devices. In this paper we
|
|
6095 |
introduce a component model for field devices that
|
|
6096 |
captures a range of non-functional properties and
|
|
6097 |
constraints. We report on the current status of
|
|
6098 |
Pecos, including the Pecos composition language,
|
|
6099 |
language mappings to {Java} and C++, and industrial
|
|
6100 |
case studies.},
|
|
6101 |
address = {Berlin, Germany},
|
|
6102 |
annote = {internationalconference},
|
|
6103 |
author = {Oscar Nierstrasz and Gabriela Ar{\'e}valo and St{\'e}phane Ducasse and Roel Wuyts and Andrew Black and Peter M{\"u}ller and Christian Zeidler and Thomas Genssler and Reinier van den Born},
|
|
6104 |
booktitle = {Proceedings First International IFIP/ACM Working Conference on Component Deployment},
|
|
6105 |
keywords = {scg-pub skip-doi jb02 pecos stefPub arevalo},
|
|
6106 |
month = jun,
|
|
6107 |
pages = {200--209},
|
|
6108 |
publisher = {ACM},
|
|
6109 |
title = {A Component Model for Field Devices},
|
|
6110 |
url = {http://scg.unibe.ch/archive/papers/Nier02aPecosModel.pdf},
|
|
6111 |
year = {2002},
|
|
6112 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Nier02aPecosModel.pdf}
|
|
6113 |
}
|
|
6114 |
|
|
6115 |
@article{Nier04c,
|
|
6116 |
abstract = {Aging software systems are difficult and expensive
|
|
6117 |
to maintain. Moose is a language-independent
|
|
6118 |
environment that supports a wide range of tools to
|
|
6119 |
visualise, analyse and manipulate complex software
|
|
6120 |
systems.},
|
|
6121 |
annote = {notrefereed},
|
|
6122 |
author = {Oscar Nierstrasz and St\'ephane Ducasse},
|
|
6123 |
cvs = {ERCIM_ASE},
|
|
6124 |
journal = {European Research Consortium for Informatics and Mathematics (ERCIM) News},
|
|
6125 |
keywords = {scg-pub skip-doi jb04 stefPub recast04 moose-pub},
|
|
6126 |
month = jul,
|
|
6127 |
pages = {24--25},
|
|
6128 |
title = {Moose--a Language-Independent Reengineering Environment},
|
|
6129 |
url = {http://www.ercim.org/publication/Ercim_News/enw58/nierstrasz.html},
|
|
6130 |
volume = {58},
|
|
6131 |
year = {2004},
|
|
6132 |
bdsk-url-1 = {http://www.ercim.org/publication/Ercim_News/enw58/nierstrasz.html}
|
|
6133 |
}
|
|
6134 |
|
|
6135 |
@inproceedings{Nier04d,
|
|
6136 |
abstract = {In this paper we briefly review various kinds of
|
|
6137 |
software changes and the issues that arise from
|
|
6138 |
them. As a consequence, we propose research into
|
|
6139 |
programming languages with explicit support for
|
|
6140 |
representing first-class changes, and for
|
|
6141 |
manipulating and merging multiple viewpoints of
|
|
6142 |
evolving software systems.},
|
|
6143 |
annote = {internationalworkshop},
|
|
6144 |
author = {Oscar Nierstrasz and Marcus Denker},
|
|
6145 |
booktitle = {OOPSLA Workshop on Revival of Dynamic Languages},
|
|
6146 |
cvs = {RDLchange},
|
|
6147 |
keywords = {snf05 scg-pub skip-doi jb05 fromscgbib marcusdenker},
|
|
6148 |
month = oct,
|
|
6149 |
title = {Supporting Software Change in the Programming Language},
|
|
6150 |
url = {http://rmod.lille.inria.fr/archives/workshops/Nier04d-RDL04-Change.pdf},
|
|
6151 |
year = {2004}
|
|
6152 |
}
|
|
6153 |
|
|
6154 |
@inproceedings{Nier05b,
|
|
6155 |
abstract = {The programming languages of today are stuck in a
|
|
6156 |
deep rut that has developed over the past 50 years.
|
|
6157 |
Although we are faced with new challenges posed by
|
|
6158 |
enormous advances in hardware and internet
|
|
6159 |
technology, we continue to struggle with
|
|
6160 |
old-fashioned languages based on rigid, static,
|
|
6161 |
closed-world file-based views of programming. We
|
|
6162 |
argue the need for a new class of dynamic languages
|
|
6163 |
that support a view of programming as constant
|
|
6164 |
evolution of living and open software models. Such
|
|
6165 |
languages would require features such as dynamic
|
|
6166 |
first-class namespaces, explicit meta-models,
|
|
6167 |
optional, pluggable type systems, and incremental
|
|
6168 |
compilation of running software systems.},
|
|
6169 |
aeres = {INV},
|
|
6170 |
annote = {invited},
|
|
6171 |
author = {Oscar Nierstrasz and Alexandre Bergel and Marcus
|
|
6172 |
Denker and St\'ephane Ducasse and Markus Gaelli and
|
|
6173 |
Roel Wuyts},
|
|
6174 |
booktitle = {Proceedings of Software Composition 2005},
|
|
6175 |
cvs = {SC05Revival},
|
|
6176 |
doi = {10.1007/11550679_1},
|
|
6177 |
editor = {Thomas Gschwind and Uwe A{\ss}mann},
|
|
6178 |
inria = {hors},
|
|
6179 |
isbn = {3-540-28748-5},
|
|
6180 |
keywords = {snf05 snf-actsc scg-pub jb06 gaelli fromscgbib},
|
|
6181 |
misc = {gaelli},
|
|
6182 |
note = {Invited paper},
|
|
6183 |
pages = {1--13},
|
|
6184 |
publisher = {LNCS 3628},
|
|
6185 |
title = {On the Revival of Dynamic Languages},
|
|
6186 |
url = {http://rmod.lille.inria.fr/archives/papers/Nier05b-SC05-Revival.pdf},
|
|
6187 |
volume = {3628},
|
|
6188 |
year = {2005}
|
|
6189 |
}
|
|
6190 |
|
|
6191 |
@inproceedings{Nier05c,
|
|
6192 |
abstract = {Moose is a language-independent environment for
|
|
6193 |
reverse- and re-engineering complex software
|
|
6194 |
systems. Moose provides a set of services including
|
|
6195 |
a common meta-model, metrics evaluation and
|
|
6196 |
visualization, a model repository, and generic GUI
|
|
6197 |
support for querying, browsing and grouping. The
|
|
6198 |
development effort invested in Moose has paid off in
|
|
6199 |
precisely those research activities that benefit
|
|
6200 |
from applying a combination of complementary
|
|
6201 |
techniques. We describe how Moose has evolved over
|
|
6202 |
the years, we draw a number of lessons learned from
|
|
6203 |
our experience, and we outline the present and
|
|
6204 |
future of Moose.},
|
|
6205 |
address = {New York NY},
|
|
6206 |
aeres = {INV},
|
|
6207 |
aeresstatus = {aeres08},
|
|
6208 |
annote = {invited},
|
|
6209 |
author = {Oscar Nierstrasz and St\'ephane Ducasse and Tudor
|
|
6210 |
G\^irba},
|
|
6211 |
booktitle = {Proceedings of the European Software Engineering
|
|
6212 |
Conference (ESEC/FSE'05)},
|
|
6213 |
cvs = {MOOSE-ESEC05},
|
|
6214 |
doi = {10.1145/1095430.1081707},
|
|
6215 |
inria = {hors},
|
|
6216 |
isbn = {1-59593-014-0},
|
|
6217 |
keywords = {hasler07 girba stefPub recast06 scg-pub jb06
|
|
6218 |
mooseCincom moose-pub snf-actsc snf-bmcc norex06},
|
|
6219 |
note = {Invited paper},
|
|
6220 |
pages = {1--10},
|
|
6221 |
publisher = {ACM Press},
|
|
6222 |
title = {The Story of {Moose}: an Agile Reengineering
|
|
6223 |
Environment},
|
|
6224 |
url = {http://scg.unibe.ch/archive/papers/Nier05cStoryOfMoose.pdf},
|
|
6225 |
year = {2005},
|
|
6226 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Nier05cStoryOfMoose.pdf},
|
|
6227 |
bdsk-url-2 = {http://dx.doi.org/10.1145/1095430.1081707}
|
|
6228 |
}
|
|
6229 |
|
|
6230 |
@inproceedings{Nier05d,
|
|
6231 |
abstract = {Successful software systems must be prepared to
|
|
6232 |
evolve or they will die. Although object-oriented
|
|
6233 |
software systems are built to last, over time they
|
|
6234 |
degrade as much as any legacy software system. As a
|
|
6235 |
consequence, one must invest in reengineering
|
|
6236 |
efforts to keep further development costs down. Even
|
|
6237 |
though software systems and their business contexts
|
|
6238 |
may differ in countless ways, the techniques one
|
|
6239 |
uses to understand, analyze and transform these
|
|
6240 |
systems tend to be very similar. As a consequence,
|
|
6241 |
one may identify various reengineering patterns that
|
|
6242 |
capture best practice in reverse- and re-engineering
|
|
6243 |
object-oriented legacy systems. We present a brief
|
|
6244 |
outline of a large collection of these patterns that
|
|
6245 |
have been mined over several years of experience
|
|
6246 |
with object-oriented legacy systems, and we indicate
|
|
6247 |
how some of these patterns can be supported by
|
|
6248 |
appropriate tools.},
|
|
6249 |
aeres = {INV},
|
|
6250 |
aeresstatus = {aeres08},
|
|
6251 |
annote = {invited},
|
|
6252 |
author = {Oscar Nierstrasz and St\'ephane Ducasse and Serge
|
|
6253 |
Demeyer},
|
|
6254 |
booktitle = {Proceedings of Generative Programming and Component
|
|
6255 |
Engineering (GPCE 2005)},
|
|
6256 |
cvs = {GPCE05ReengPatterns},
|
|
6257 |
doi = {10.1007/11561347_1},
|
|
6258 |
editor = {Robert Gl\"uck, Michael Lowry},
|
|
6259 |
inria = {hors},
|
|
6260 |
isbn = {3-540-29138-5},
|
|
6261 |
keywords = {stefPub recast06 scg-pub jb06},
|
|
6262 |
note = {Invited paper},
|
|
6263 |
pages = {1--9},
|
|
6264 |
publisher = {LNCS 3676},
|
|
6265 |
title = {Object-oriented Reengineering Patterns --- an
|
|
6266 |
Overview},
|
|
6267 |
url = {http://scg.unibe.ch/archive/papers/Nier05dReengineeringPatterns.pdf},
|
|
6268 |
year = {2005},
|
|
6269 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Nier05dReengineeringPatterns.pdf},
|
|
6270 |
bdsk-url-2 = {http://dx.doi.org/10.1007/11561347_1}
|
|
6271 |
}
|
|
6272 |
|
|
6273 |
@techreport{Nier05e,
|
|
6274 |
abstract = {Traits are fine-grained components that can be used
|
|
6275 |
to compose classes, while avoiding many of the
|
|
6276 |
problems of multiple inheritance and mixin-based
|
|
6277 |
approaches. Since most implementations of traits
|
|
6278 |
have focused on dynamically-typed languages, the
|
|
6279 |
question naturally arises, how can one best
|
|
6280 |
introduce traits to statically-typed languages, like
|
|
6281 |
{Java} and C#? In this paper we argue that the
|
|
6282 |
flattening property of traits should be used as a
|
|
6283 |
guiding principle for any attempt to add traits to
|
|
6284 |
statically-typed languages. This property
|
|
6285 |
essentially states that, semantically, traits can be
|
|
6286 |
compiled away. We demonstrate how this principle
|
|
6287 |
applies to FTJ, a conservative extension to
|
|
6288 |
Featherweight {Java}.},
|
|
6289 |
address = {Universit\"at Bern, Switzerland},
|
|
6290 |
author = {Oscar Nierstrasz and St\'ephane Ducasse and
|
|
6291 |
Nathanael Sch\"arli},
|
|
6292 |
cvs = {TraitFlatteningTR},
|
|
6293 |
institution = {Institut f\"ur Informatik},
|
|
6294 |
keywords = {scg-pub skip-doi scg-rotor traits jb06 snf05 jot
|
|
6295 |
stefPub},
|
|
6296 |
month = apr,
|
|
6297 |
number = {IAM-05-005},
|
|
6298 |
title = {Flattening {Traits}},
|
|
6299 |
type = {Technical Report},
|
|
6300 |
url = {http://scg.unibe.ch/archive/papers/Nier05eFlatteningTraitsTR.pdf},
|
|
6301 |
year = {2005},
|
|
6302 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Nier05eFlatteningTraitsTR.pdf}
|
|
6303 |
}
|
|
6304 |
|
|
6305 |
@article{Nier05f,
|
|
6306 |
abstract = {Erfolgreiche Softwaresysteme m\"ussen so konzipiert
|
|
6307 |
sein, dass sie sich weiterentwickeln k\"onnen ---
|
|
6308 |
ansonsten gehen sie ein. Obwohl objektorientierte
|
|
6309 |
Softwaresysteme auf eine lange Lebensda\"ur
|
|
6310 |
ausgerichtet sind, veralten sie \"uber die Jahre
|
|
6311 |
genauso wie jedes andere Legacy-Softwaresystem. Um
|
|
6312 |
die weiteren Entwicklungskosten niedrig zu halten,
|
|
6313 |
m\"ussen daher Investitionen im Bereich \
|
|
6314 |
Re-Engineering get\"atigt werden. Softwaresysteme
|
|
6315 |
und der Gesch\"aftskontext, in dem sie eingesetzt
|
|
6316 |
werden, unterscheiden sich in vielen Punkten ---
|
|
6317 |
dennoch \"ahneln sich Techniken, sie zu verstehen,
|
|
6318 |
zu analysieren und zu transformieren. Folglich
|
|
6319 |
lassen sich verschiedene Re-Engineering-Muster
|
|
6320 |
identifizieren, die bew\"ahrte Vorgehensweisen beim
|
|
6321 |
Reverse- und Re-Engineering objektorientierter
|
|
6322 |
Legacy-Systeme beinhalten. Dieser Artikel stellt
|
|
6323 |
einen kleinen Ausschnitt aus einer gr\"on Sammlung
|
|
6324 |
dieser Muster vor, die auf der mehrj\"ahrigen
|
|
6325 |
Erfahrung mit objektorientierten Legacy-Systemen
|
|
6326 |
basieren. Dar\"uber hinaus werden Hinweise gegeben,
|
|
6327 |
wie einige dieser Muster durch geeignete Werkzeuge
|
|
6328 |
unterst\"utzt werden k\"onnen.},
|
|
6329 |
aeres = {INV},
|
|
6330 |
aeresstatus = {aeres08},
|
|
6331 |
annote = {invited},
|
|
6332 |
author = {Oscar Nierstrasz and St\'ephane Ducasse and Serge
|
|
6333 |
Demeyer},
|
|
6334 |
inria = {hors},
|
|
6335 |
journal = {ObjektSpektrum},
|
|
6336 |
keywords = {stefPub recast06 scg-pub skip-doi jb06},
|
|
6337 |
note = {German translation of ``Object-oriented
|
|
6338 |
Reengineering Patterns --- an Overview'' (GPCE 05)},
|
|
6339 |
number = {6},
|
|
6340 |
pages = {46--51},
|
|
6341 |
title = {Objektorientierte Re-Engineering-Muster: ein
|
|
6342 |
\"{U}berblick},
|
|
6343 |
url = {http://www.sigs-datacom.de/sd/publications/pub_article_show.htm?&AID=1713&TABLE=sd_article
|
|
6344 |
http://www.sigs.de/publications/os/2005/06/demeyer_nierstrasz_OS_06_05.pdf
|
|
6345 |
http://scg.unibe.ch/archive/papers/Nier05fOORM.pdf},
|
|
6346 |
volume = {2005},
|
|
6347 |
year = {2005},
|
|
6348 |
bdsk-url-1 = {http://www.sigs-datacom.de/sd/publications/pub_article_show.htm?&AID=1713&TABLE=sd_article%20http://www.sigs.de/publications/os/2005/06/demeyer_nierstrasz_OS_06_05.pdf%20http://scg.unibe.ch/archive/papers/Nier05fOORM.pdf}
|
|
6349 |
}
|
|
6350 |
|
|
6351 |
@techreport{Nier05g,
|
|
6352 |
abstract = {Traits offer a fine-grained mechanism for composing
|
|
6353 |
classes in object-oriented languages from reusable
|
|
6354 |
components, while avoiding the fragility problems
|
|
6355 |
introduced by multiple inheritance and mixins.
|
|
6356 |
Although traits were developed in the context of
|
|
6357 |
dynamically typed languages, they would also offer
|
|
6358 |
clear benefits for statically typed languages like
|
|
6359 |
Java and C\#. This report summarizes the issues
|
|
6360 |
raised when integrating traits into such languages.
|
|
6361 |
We examine traits in the context of the statically
|
|
6362 |
typed languages FeatherweightJava, C\# and C++.},
|
|
6363 |
address = {Universit\"at Bern, Switzerland},
|
|
6364 |
author = {Oscar Nierstrasz and St\'ephane Ducasse and Stefan
|
|
6365 |
Reichhart and Nathanael Sch\"arli},
|
|
6366 |
cvs = {TraitsCSharp},
|
|
6367 |
institution = {Institut f\"ur Informatik},
|
|
6368 |
keywords = {scg-pub skip-doi scg-rotor traits jb06 snf05
|
|
6369 |
stefPub},
|
|
6370 |
month = dec,
|
|
6371 |
number = {IAM-05-006},
|
|
6372 |
title = {Adding {Traits} to (Statically Typed) Languages},
|
|
6373 |
type = {Technical Report},
|
|
6374 |
url = {http://scg.unibe.ch/archive/papers/Nier05gTraitsCSharp.pdf},
|
|
6375 |
year = {2005},
|
|
6376 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Nier05gTraitsCSharp.pdf}
|
|
6377 |
}
|
|
6378 |
|
|
6379 |
@article{Nier06a,
|
|
6380 |
abstract = {Traits are fine-grained components that can be used
|
|
6381 |
to compose classes, while avoiding many of the
|
|
6382 |
problems of multiple inheritance and mixin-based
|
|
6383 |
approaches. Since most implementations of traits
|
|
6384 |
have focused on dynamically-typed languages, the
|
|
6385 |
question naturally arises, how can one best
|
|
6386 |
introduce traits to statically-typed languages, like
|
|
6387 |
{Java} and C#? In this paper we argue that the
|
|
6388 |
flattening property of traits should be used as a
|
|
6389 |
guiding principle for any attempt to add traits to
|
|
6390 |
statically-typed languages. This property
|
|
6391 |
essentially states that, semantically, traits can be
|
|
6392 |
compiled away. We demonstrate how this principle
|
|
6393 |
applies to FTJ, a conservative extension to
|
|
6394 |
Featherweight {Java}.},
|
|
6395 |
aeres = {ACL},
|
|
6396 |
aeresstatus = {aeres08},
|
|
6397 |
annote = {internationaljournal},
|
|
6398 |
author = {Oscar Nierstrasz and St\'ephane Ducasse and
|
|
6399 |
Nathanael Sch\"arli},
|
|
6400 |
cached = {http://scg.unibe.ch/archive/papers/Nier06aFlatteningTraits.pdf},
|
|
6401 |
cvs = {TraitFlatteningJOT},
|
|
6402 |
inria = {hors},
|
|
6403 |
journal = {Journal of Object Technology},
|
|
6404 |
keywords = {scg-pub skip-doi scg-rotor traits jb06 fb06 snf05
|
|
6405 |
snf06 jot stefPub},
|
|
6406 |
medium = {2},
|
|
6407 |
misc = {May-June},
|
|
6408 |
month = may,
|
|
6409 |
number = {4},
|
|
6410 |
pages = {129--148},
|
|
6411 |
peerreview = {yes},
|
|
6412 |
selectif = {non},
|
|
6413 |
title = {Flattening {Traits}},
|
|
6414 |
url = {http://www.jot.fm/issues/issue_2006_05/article4.pdf},
|
|
6415 |
volume = {5},
|
|
6416 |
year = {2006},
|
|
6417 |
bdsk-url-1 = {http://www.jot.fm/issues/issue_2006_05/article4.pdf}
|
|
6418 |
}
|
|
6419 |
|
|
6420 |
|
|
6421 |
@inproceedings{Nier06b,
|
|
6422 |
abstract = {Software systems need to continuously change to
|
|
6423 |
remain useful. Change appears in several forms and
|
|
6424 |
needs to be accommodated at different levels. We
|
|
6425 |
propose ChangeBoxes as a mechanism to encapsulate,
|
|
6426 |
manage, analyze and exploit changes to software
|
|
6427 |
systems. Our thesis is that only by making change
|
|
6428 |
explicit and manipulable can we enable the software
|
|
6429 |
developer to manage software change more effectively
|
|
6430 |
than is currently possible. Furthermore we argue
|
|
6431 |
that we need new insights into assessing the impact
|
|
6432 |
of changes and we need to provide new tools and
|
|
6433 |
techniques to manage them. We report on the results
|
|
6434 |
of some initial prototyping efforts, and we outline
|
|
6435 |
a series of research activities that we have started
|
|
6436 |
to explore the potential of ChangeBoxes.},
|
|
6437 |
annote = {internationalworkshop},
|
|
6438 |
author = {Oscar Nierstrasz and Marcus Denker and Tudor G{\^\i}rba and Adrian Lienhard},
|
|
6439 |
booktitle = {Proceedings of the Workshop on Revival of Dynamic Languages (co-located with ECOOP'06)},
|
|
6440 |
cvs = {RDL06ACTSC},
|
|
6441 |
keywords = {girba snf06 scg-pub skip-doi jb06 fb06 fromscgbib marcusdenker},
|
|
6442 |
medium = {2},
|
|
6443 |
month = jul,
|
|
6444 |
peerreview = {yes},
|
|
6445 |
title = {Analyzing, Capturing and Taming Software Change},
|
|
6446 |
url = {http://rmod.lille.inria.fr/archives//workshops/Nier06b-RDL06-ACTSC.pdf},
|
|
6447 |
year = {2006}
|
|
6448 |
}
|
|
6449 |
|
|
6450 |
@techreport{Nier08a,
|
|
6451 |
abstract = {Few real software systems are built completely from
|
|
6452 |
scratch nowadays. Instead, systems are built
|
|
6453 |
iteratively and incrementally, while integrating and
|
|
6454 |
interacting with components from many other systems.
|
|
6455 |
These systems also last longer than their developers
|
|
6456 |
might imagine --- they are, in effect, eternal.
|
|
6457 |
Nevertheless the platforms, tools and environments
|
|
6458 |
we use to develop software are still largely based
|
|
6459 |
on an outmoded model that presupposes that software
|
|
6460 |
systems are closed and will not significantly evolve
|
|
6461 |
after deployment. We claim that in order to enable
|
|
6462 |
effective and graceful evolution of eternal systems,
|
|
6463 |
we must make them self-aware. A self-aware eternal
|
|
6464 |
system supports evolution by: (i) providing
|
|
6465 |
explicit, first-class models of software artifacts,
|
|
6466 |
change and history at the level of the platform,
|
|
6467 |
(ii) continuously analysing static and dynamic
|
|
6468 |
evolution to track emergent properties, and (iii)
|
|
6469 |
closing the gap between the domain model and the
|
|
6470 |
developers' view of the evolving system. We outline
|
|
6471 |
our vision of self-aware eternal systems and
|
|
6472 |
identify the research challenges to realizing this
|
|
6473 |
vision.},
|
|
6474 |
annote = {report notrefereed},
|
|
6475 |
author = {Oscar Nierstrasz and Marcus Denker and Tudor G\^irba
|
|
6476 |
and Adrian Kuhn and Adrian Lienhard and David
|
|
6477 |
R{\"o}thlisberger},
|
|
6478 |
institution = {University of Bern, Institute of Applied Mathematics
|
|
6479 |
and Computer Sciences},
|
|
6480 |
keywords = {scg-pub jb08 snf08 skip-doi girba roethlisberger
|
|
6481 |
akuhn fromscgbib marcusdenker},
|
|
6482 |
number = {IAM-08-001},
|
|
6483 |
title = {Self-aware, Evolving Eternal Systems},
|
|
6484 |
type = {Technical Report},
|
|
6485 |
url = {http://rmod.lille.inria.fr/archives/reports/Nier08a-TechReport-SelfAwareEternal.pdf},
|
|
6486 |
year = {2008}
|
|
6487 |
}
|
|
6488 |
|
|
6489 |
@incollection{Nier08b,
|
|
6490 |
abstract = {Few real software systems are built completely from
|
|
6491 |
scratch nowadays. Instead, systems are built
|
|
6492 |
iteratively and incrementally, while integrating and
|
|
6493 |
interacting with components from many other systems.
|
|
6494 |
Adaptation, reconfiguration and evolution are
|
|
6495 |
normal, ongoing processes throughout the lifecycle
|
|
6496 |
of a software system. Nevertheless the platforms,
|
|
6497 |
tools and environments we use to develop software
|
|
6498 |
are still largely based on an outmoded model that
|
|
6499 |
presupposes that software systems are closed and
|
|
6500 |
will not significantly evolve after deployment. We
|
|
6501 |
claim that in order to enable effective and graceful
|
|
6502 |
evolution of modern software systems, we must make
|
|
6503 |
these systems more amenable to change by (i)
|
|
6504 |
providing explicit, first-class models of software
|
|
6505 |
artifacts, change, and history at the level of the
|
|
6506 |
platform, (ii) continuously analysing static and
|
|
6507 |
dynamic evolution to track emergent properties, and
|
|
6508 |
(iii) closing the gap between the domain model and
|
|
6509 |
the developers' view of the evolving system. We
|
|
6510 |
outline our vision of dynamic, evolving software
|
|
6511 |
systems and identify the research challenges to
|
|
6512 |
realizing this vision.},
|
|
6513 |
author = {Oscar Nierstrasz and Marcus Denker and Tudor G\^irba and Adrian Lienhard and David R\"othlisberger},
|
|
6514 |
booktitle = {Challenges for Software-Intensive Systems and New
|
|
6515 |
Computing Paradigms},
|
|
6516 |
doi = {10.1007/978-3-540-89437-7_3},
|
|
6517 |
editor = {Martin Wirsing and Jean-Pierre Ban\^atre and
|
|
6518 |
Matthias H\"olzl},
|
|
6519 |
isbn = {978-3-540-89436-0},
|
|
6520 |
keywords = {scg08 scg-pub snf09 jb09 hasler09 girba cop-lit roethlisberger marcusdenker fromscgbib},
|
|
6521 |
medium = {2},
|
|
6522 |
pages = {64-79},
|
|
6523 |
peerreview = {yes},
|
|
6524 |
publisher = {Springer-Verlag},
|
|
6525 |
series = {LNCS},
|
|
6526 |
title = {Change-Enabled Software Systems},
|
|
6527 |
url = {http://rmod.lille.inria.fr/archives/papers/Nier08b-bookchapter-ChangeEnabledSoftware.pdf},
|
|
6528 |
volume = {5380},
|
|
6529 |
year = {2008}
|
|
6530 |
}
|
|
6531 |
|
|
6532 |
@incollection{Nier09a,
|
|
6533 |
abstract = {Software must be constantly adapted to changing
|
|
6534 |
requirements. The time scale, abstraction level and
|
|
6535 |
granularity of adaptations may vary from short-term,
|
|
6536 |
fine-grained adaptation to long-term, coarse-grained
|
|
6537 |
evolution. Fine-grained, dynamic and
|
|
6538 |
context-dependent adaptations can be particularly
|
|
6539 |
difficult to realize in long-lived, large-scale
|
|
6540 |
software systems. We argue that, in order to
|
|
6541 |
effectively and efficiently deploy such changes,
|
|
6542 |
adaptive applications must be built on an
|
|
6543 |
infrastructure that is not just model-driven, but is
|
|
6544 |
both model-centric and context-aware. Specifically,
|
|
6545 |
this means that high-level, causally-connected
|
|
6546 |
models of the application and the software
|
|
6547 |
infrastructure itself should be available at
|
|
6548 |
run-time, and that changes may need to be scoped to
|
|
6549 |
the run-time execution context. We first review the
|
|
6550 |
dimensions of software adaptation and evolution, and
|
|
6551 |
then we show how model-centric design can address
|
|
6552 |
the adaptation needs of a variety of applications
|
|
6553 |
that span these dimensions. We demonstrate through
|
|
6554 |
concrete examples how model-centric and
|
|
6555 |
context-aware designs work at the level of
|
|
6556 |
application interface, programming language and
|
|
6557 |
runtime. We then propose a research agenda for a
|
|
6558 |
model-centric development environment that supports
|
|
6559 |
dynamic software adaptation and evolution.},
|
|
6560 |
author = {Oscar Nierstrasz and Marcus Denker and Lukas
|
|
6561 |
Renggli},
|
|
6562 |
booktitle = {Software Engineering for Self-Adaptive Systems},
|
|
6563 |
doi = {10.1007/978-3-642-02161-9_7},
|
|
6564 |
editor = {Betty H.C. Cheng and Rogerio de Lemos and Holger
|
|
6565 |
Giese and Paola Inverardi and Jeff Magee},
|
|
6566 |
keywords = {scg09 scg-pub diesel helvetia reflectivity snf09
|
|
6567 |
jb09 fromscgbib marcusdenker},
|
|
6568 |
medium = {2},
|
|
6569 |
pages = {128-145},
|
|
6570 |
peerreview = {yes},
|
|
6571 |
publisher = {Springer-Verlag},
|
|
6572 |
series = {LNCS},
|
|
6573 |
title = {Model-Centric, Context-Aware Software Adaptation},
|
|
6574 |
url = {http://rmod.lille.inria.fr/archives/papers/Nier09a-bookchapter-ModelCentric.pdf},
|
|
6575 |
volume = {5525},
|
|
6576 |
year = {2009}
|
|
6577 |
}
|
|
6578 |
|
|
6579 |
@mastersthesis{Peirs08a,
|
|
6580 |
author = {Romain Peirs},
|
|
6581 |
title = {Enhanced Dependency Structure Matrix},
|
|
6582 |
year = {2008},
|
|
6583 |
abstract = {Dependency Structure Matrix (DSM) is an approach taken from
|
|
6584 |
process optimization and it exists a variety of algorithms
|
|
6585 |
to help organizing the matrix in a form that reflects the
|
|
6586 |
architecture and highlights patterns and problematic
|
|
6587 |
dependencies. However, the existing DSM implementations have
|
|
6588 |
a lack of information in their visualization. That is why, we
|
|
6589 |
enhanced DSM by adding written and colored information in the
|
|
6590 |
visualization to improve the architecture understanding of a
|
|
6591 |
software system and the support of its remodularization. This
|
|
6592 |
visualization has been implemented on top of Moose which is a
|
|
6593 |
collaborative research platform for Software Analysis and
|
|
6594 |
Information Visualization. This report presents my
|
|
6595 |
internship done at the research centre INRIA Lille - Nord
|
|
6596 |
Europe with the RMoD Team led by S. Ducasse.},
|
|
6597 |
annote = {master cook},
|
|
6598 |
school = {Enseita}
|
|
6599 |
}
|
|
6600 |
|
|
6601 |
@misc{Poll02a,
|
|
6602 |
address = {Malaga},
|
|
6603 |
annote = {internationalworkshop},
|
|
6604 |
author = {Pollet, Damien and Vojtisek, Didier and
|
|
6605 |
J\'ez\'equel, Jean-Marc},
|
|
6606 |
howpublished = {Workshop on Integration and Transformation of UML
|
|
6607 |
models (WITUML~2002)},
|
|
6608 |
month = jun,
|
|
6609 |
title = {OCL as a Core UML Transformation Language},
|
|
6610 |
url = {http://ctp.di.fct.unl.pt/~ja/wituml02.htm},
|
|
6611 |
year = {2002},
|
|
6612 |
bdsk-url-1 = {http://ctp.di.fct.unl.pt/~ja/wituml02.htm}
|
|
6613 |
}
|
|
6614 |
|
|
6615 |
@phdthesis{Poll05a,
|
|
6616 |
annote = {phdthesis},
|
|
6617 |
author = {Pollet, Damien},
|
|
6618 |
month = jun,
|
|
6619 |
school = {Universit\'e de Rennes 1},
|
|
6620 |
title = {Une architecture pour les transformations de
|
|
6621 |
mod\`eles et la restructuration de mod\`eles UML},
|
|
6622 |
url = {http://www.irisa.fr/bibli/publi/theses/2005/pollet/pollet.html},
|
|
6623 |
year = {2005},
|
|
6624 |
bdsk-url-1 = {http://www.irisa.fr/bibli/publi/theses/2005/pollet/pollet.html}
|
|
6625 |
}
|
|
6626 |
|
|
6627 |
|
|
6628 |
|
|
6629 |
@inproceedings{Poll07a,
|
|
6630 |
abstract = {To maintain and understand large applications, it is
|
|
6631 |
crucial to know their architecture. The first
|
|
6632 |
problem is that unlike classes and packages,
|
|
6633 |
architecture is not explicitly represented in the
|
|
6634 |
code. The second problem is that successful
|
|
6635 |
applications evolve over time, so their architecture
|
|
6636 |
inevitably drifts. Reconstructing the architecture
|
|
6637 |
and checking whether it is still valid is therefore
|
|
6638 |
an important aid. While there is a plethora of
|
|
6639 |
approaches and techniques supporting architecture
|
|
6640 |
reconstruction, there is no comprehensive state of
|
|
6641 |
the art and it is often difficult to compare the
|
|
6642 |
approaches. This article presents a state of the art
|
|
6643 |
on software architecture reconstruction approaches.},
|
|
6644 |
aeres = {ACT},
|
|
6645 |
aeresstatus = {aeres08},
|
|
6646 |
annote = {internationalconference},
|
|
6647 |
author = {Pollet, Damien and Ducasse, St\'ephane and Poyet,
|
|
6648 |
Lo\"{\i}c and Alloui, Ilham and C\^impan, Sorana and
|
|
6649 |
Verjus, Herv\'e},
|
|
6650 |
booktitle = {Proceedings of 11th European Conference on Software
|
|
6651 |
Maintenance and Reengineering (CSMR'07)},
|
|
6652 |
editor = {Krikhaar, Ren\'e and Verhoef, Chris and Di Lucca,
|
|
6653 |
Giuseppe},
|
|
6654 |
inria = {hors},
|
|
6655 |
keywords = {recast},
|
|
6656 |
location = {Amsterdam, the Netherlands},
|
|
6657 |
misc = {Acceptance rate: 38/132=29\%},
|
|
6658 |
accepttotal = {132},
|
|
6659 |
acceptnum = {38},
|
|
6660 |
month = mar,
|
|
6661 |
note = {Best Paper Award},
|
|
6662 |
publisher = {IEEE Computer Society},
|
|
6663 |
rate = {29%},
|
|
6664 |
selectif = {oui},
|
|
6665 |
title = {Towards A Process-Oriented Software Architecture Reconstruction Taxonomy},
|
|
6666 |
url = {http://scg.unibe.ch/archive/papers/Poll07a-CSMRSARTaxonomy.pdf},
|
|
6667 |
year = {2007},
|
|
6668 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Poll07a-CSMRSARTaxonomy.pdf}
|
|
6669 |
}
|
|
6670 |
|
|
6671 |
|
|
6672 |
@misc{PowerfullIdeas,
|
|
6673 |
aeres = {OV},
|
|
6674 |
annote = {notrefereed},
|
|
6675 |
author = {St\'ephane Ducasse and Alexandre Bergel and
|
|
6676 |
Fran\c{c}ois Schnell and Noury Bouraqadi and Serge
|
|
6677 |
Stinckwich},
|
|
6678 |
inria = {hors},
|
|
6679 |
keywords = {squeak etoy book powerfull ideas stefPub jb-none},
|
|
6680 |
note = {French translation of Powerful Ideas in the
|
|
6681 |
Classroom by B.J. Allen-Conn and Kim Rose},
|
|
6682 |
selectif = {non},
|
|
6683 |
title = {Des idees puissantes dans la classe --- Utilisation
|
|
6684 |
de Squeak pour l'amelioration de l'apprentissage des
|
|
6685 |
mathematiques et des sciences (traduction de
|
|
6686 |
Powerful Ideas in the Classroom)}
|
|
6687 |
}
|
|
6688 |
|
|
6689 |
@inproceedings{Rama02a,
|
|
6690 |
author = {M. Fenoll Ramal and Ricardo de Moura Meneses and Nicolas Anquetil},
|
|
6691 |
title = {A Disturbing Result on the Knowledge Used during Software Maintenance},
|
|
6692 |
abstract = {As part of a long term project aiming at empowering software maintainers with knowledge based tools, we conducted an empirical study on the knowledge they use when doing maintenance. The study was intended as a preliminary work to get initial data on the type on knowledge used and the importance of each type of knowledge. For example, it is commonly assumed that application domain knowledge is important when doing maintenance. However nobody can tell exactly how much more important it is than Computer Science knowledge. We monitored six software engineers in two different organizations and analyzed the knowledge they used in their maintenance activity. In this paper we present and discuss some results and propose research directions from these. Our results include: the fact that software engineers rarely "search for" some new knowledge and rather work from what they already know; or the acknowledgment of a variation of the knowledge used depending on the organization one is working in. The most disturbing result is that, contrary to what is commonly assumed, the software engineers we studied seemed to make little use of application domain knowledge.},
|
|
6693 |
booktitle = {9th Working Conference on Reverse Engineering (WCRE 2002)},
|
|
6694 |
year = {2002},
|
|
6695 |
pages = {277-},
|
|
6696 |
publisher = {IEEE Computer Society},
|
|
6697 |
isbn = {0-7695-1799-4},
|
|
6698 |
doi = {10.1109/WCRE.2002.1173085},
|
|
6699 |
annote = {internationalconference},
|
|
6700 |
aeres = {ACT},
|
|
6701 |
selectif = {oui},
|
|
6702 |
labo = {non},
|
|
6703 |
x-editorial-board = {yes},
|
|
6704 |
x-international-audience = {yes},
|
|
6705 |
x-pays = {BR}
|
|
6706 |
}
|
|
6707 |
|
|
6708 |
@inproceedings{Ramo04a,
|
|
6709 |
author = {Cristiane S. Ramos and
|
|
6710 |
K{\'a}thia Mar\c{c}al de Oliveira and
|
|
6711 |
Nicolas Anquetil},
|
|
6712 |
title = {Legacy Software Evaluation Model for Outsourced Maintainer},
|
|
6713 |
abstract = {Outsourcing has become common practice in the software industry. Organizations routinely subcontract the maintenance of their software assets to specialized companies. A great challenge for these companies, is to rapidly evaluate the quality of the systems they will have to maintain so as to accurately estimate the amount of work they will require. To answer these concerns, we developed a framework of metrics to evaluate the complexity of a legacy software system and help an outsourcing maintainer define its contracts. This framework was defined using a well known approach in software quality, called "goal-question-metric". We present the goal-question-metric approach, its results, and the initial experimentation of the metrics on five real life systems in Cobol.},
|
|
6714 |
booktitle = {8th European Conference on Software Maintenance and Reengineering
|
|
6715 |
(CSMR 2004)},
|
|
6716 |
publisher = {IEEE Computer Society},
|
|
6717 |
year = {2004},
|
|
6718 |
isbn = {0-7695-2107-X},
|
|
6719 |
doi = {10.1109/CSMR.2004.1281405},
|
|
6720 |
pages = {48-57},
|
|
6721 |
annote = {internationalconference},
|
|
6722 |
aeres = {ACT},
|
|
6723 |
selectif = {oui},
|
|
6724 |
labo = {non},
|
|
6725 |
x-editorial-board = {yes},
|
|
6726 |
x-international-audience = {yes},
|
|
6727 |
x-pays = {BR}
|
|
6728 |
}
|
|
6729 |
|
|
6730 |
@misc{Rapi98a,
|
|
6731 |
abstract = {Type information is a crucial information to support
|
|
6732 |
object-oriented reengineering. In a dynamically
|
|
6733 |
typed language like Smalltalk standard static type
|
|
6734 |
inference is a complex and heavily computational
|
|
6735 |
task. In this paper, we report how we use message
|
|
6736 |
passing control and compiler extension to support
|
|
6737 |
dynamic inference type in Smalltalk.},
|
|
6738 |
annote = {internationalworkshop},
|
|
6739 |
author = {Pascal Rapicault and Mireille Blay-Fornarino and
|
|
6740 |
St\'ephane Ducasse and Anne-Marie Dery},
|
|
6741 |
keywords = {scg-pub skip-doi olit famoos-papunr oobib snf98 jb98
|
|
6742 |
stefPub},
|
|
6743 |
note = {Proceedings of the ECOOP '98 International Workshop
|
|
6744 |
Experiences in Object-Oriented Reengineering,
|
|
6745 |
abstract in Object-Oriented Technology (ECOOP '98
|
|
6746 |
Workshop Reader forthcoming LNCS)},
|
|
6747 |
pages = {76--77},
|
|
6748 |
title = {Dynamic Type Inference to Support Object-Oriented
|
|
6749 |
Reengineering in Smalltalk},
|
|
6750 |
url = {http://scg.unibe.ch/archive/famoos/Rapi98a/type.pdf},
|
|
6751 |
year = {1998},
|
|
6752 |
bdsk-url-1 = {http://scg.unibe.ch/archive/famoos/Rapi98a/type.pdf}
|
|
6753 |
}
|
|
6754 |
|
|
6755 |
@inproceedings{Rati04a,
|
|
6756 |
abstract = {As systems evolve and their structure decays,
|
|
6757 |
maintainers need accurate and automatic
|
|
6758 |
identification of the design problems. Current
|
|
6759 |
approaches for automatic detection of design
|
|
6760 |
problems are not accurate enough because they
|
|
6761 |
analyze only a single version of a system and
|
|
6762 |
consequently they miss essential information as
|
|
6763 |
design problems appear and evolve over time. Our
|
|
6764 |
approach is to use the historical information of the
|
|
6765 |
suspected flawed structure to increase the accuracy
|
|
6766 |
of the automatic problem detection. Our means is to
|
|
6767 |
define measurements which summarize how persistent
|
|
6768 |
the problem was and how much maintenance effort was
|
|
6769 |
spent on the suspected structure. We apply our
|
|
6770 |
approach on a large scale case study and show how it
|
|
6771 |
improves the accuracy of the detection of God
|
|
6772 |
Classes and Data Classes, and additionally how it
|
|
6773 |
adds valuable semantical information about the
|
|
6774 |
evolution of flawed design structures.},
|
|
6775 |
address = {Los Alamitos CA},
|
|
6776 |
annote = {internationalconference},
|
|
6777 |
author = {Daniel Ra{\c t}iu and St\'ephane Ducasse and Tudor
|
|
6778 |
G{\^\i}rba and Radu Marinescu},
|
|
6779 |
booktitle = {Proceedings of 8th European Conference on Software
|
|
6780 |
Maintenance and Reengineering (CSMR'04)},
|
|
6781 |
keywords = {recast04 scg-pub skip-doi stefPub jb04 moose-pub
|
|
6782 |
girba ratiu evolution},
|
|
6783 |
misc = {acceptance rate: 33/62 = 52\%},
|
|
6784 |
accepttotal = {62},
|
|
6785 |
acceptnum = {33},
|
|
6786 |
pages = {223--232},
|
|
6787 |
publisher = {IEEE Computer Society},
|
|
6788 |
title = {Using History Information to Improve Design Flaws
|
|
6789 |
Detection},
|
|
6790 |
url = {http://scg.unibe.ch/archive/papers/Rati04aHistoryImproveFlawsDetection.pdf},
|
|
6791 |
year = {2004},
|
|
6792 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Rati04aHistoryImproveFlawsDetection.pdf}
|
|
6793 |
}
|
|
6794 |
|
|
6795 |
@inproceedings{Raza09a,
|
|
6796 |
title = {Multiple Viewpoints Architecture Extraction},
|
|
6797 |
year = {2009},
|
|
6798 |
author = {Azadeh Razavizadeh and Sorana C\^impan and Herv\'e Verjus and St\'ephane Ducasse},
|
|
6799 |
booktitle = {Proceedings of the 2009 Joint Working IEEE/IFIP Conference on Software Architecture \& European Conference on Software Architectures},
|
|
6800 |
annote = {internationalconference},
|
|
6801 |
pages = {329--332},
|
|
6802 |
aeres = {ACT},
|
|
6803 |
aeresstatus = {aeres12},
|
|
6804 |
labo = {dans},
|
|
6805 |
keywords = {moose-pub lse-pub},
|
|
6806 |
inria = {RMOD},
|
|
6807 |
inriareport = {2009},
|
|
6808 |
x-editorial-board = {yes},
|
|
6809 |
x-proceedings = {yes},
|
|
6810 |
x-international-audience = {yes},
|
|
6811 |
url = {http://rmod.lille.inria.fr/archives/papers/Raza09a-WASECSA-MultipleViewPoints.pdf}
|
|
6812 |
}
|
|
6813 |
|
|
6814 |
@inproceedings{Raza09b,
|
|
6815 |
title = {Software System Understanding via Architectural Views Extraction According to Multiple Viewpoints},
|
|
6816 |
year = {2009},
|
|
6817 |
author = {Azadeh Razavizadeh and Sorana C\^impan and Herv\'e Verjus and St\'ephane Ducasse},
|
|
6818 |
booktitle = {8th International Workshop on System/Software Architectures},
|
|
6819 |
annote = {internationalworkshop},
|
|
6820 |
aeres = {ACT},
|
|
6821 |
aeresstatus = {aeres12},
|
|
6822 |
keywords = {moose-pub lse-pub},
|
|
6823 |
inria = {RMOD},
|
|
6824 |
inriareport = {2009},
|
|
6825 |
labo = {hors},
|
|
6826 |
x-editorial-board = {yes},
|
|
6827 |
x-proceedings = {yes},
|
|
6828 |
x-international-audience = {yes},
|
|
6829 |
url = {http://rmod.lille.inria.fr/archives/workshops/Raza09b-iwssa-.pdf}
|
|
6830 |
}
|
|
6831 |
|
|
6832 |
@inproceedings{Reic07a,
|
|
6833 |
abstract = {With the success of agile methodologies more and
|
|
6834 |
more projects develop large test suites to ensure
|
|
6835 |
that the system is behaving as expected. Not only do
|
|
6836 |
tests ensure correctness, but they also offer a live
|
|
6837 |
documentation for the code. However, as the system
|
|
6838 |
evolves, the tests need to evolve as well to keep up
|
|
6839 |
with the system, and as the test suite grows larger,
|
|
6840 |
the effort invested into maintaining tests is a
|
|
6841 |
significant activity. In this context, the quality
|
|
6842 |
of tests becomes an important issue, as developers
|
|
6843 |
need to assess and understand the tests they have to
|
|
6844 |
maintain. In this paper we present TestLint, an
|
|
6845 |
approach together with an experimental tool for
|
|
6846 |
qualifying tests. We define a set of criteria to
|
|
6847 |
determine test quality, and we evaluate our approach
|
|
6848 |
on a large sample of unit tests found in open-source
|
|
6849 |
projects.},
|
|
6850 |
aeres = {ACT},
|
|
6851 |
aeresstatus = {aeres08},
|
|
6852 |
annote = {internationalconference},
|
|
6853 |
author = {Stefan Reichhart and Tudor G\^irba and St\'ephane
|
|
6854 |
Ducasse},
|
|
6855 |
booktitle = {Journal of Object Technology, Special Issue.
|
|
6856 |
Proceedings of TOOLS Europe 2007},
|
|
6857 |
cached = {http://scg.unibe.ch/archive/papers/Reic07aTestQualityAssessment.pdf},
|
|
6858 |
inria = {hors},
|
|
6859 |
issn = {1660-1769},
|
|
6860 |
keywords = {scg07 scg-pub jb08 snf07 skip-doi testlint test
|
|
6861 |
smell refactoring girba},
|
|
6862 |
medium = {2},
|
|
6863 |
month = oct,
|
|
6864 |
note = {Special Issue. Proceedings of TOOLS Europe 2007},
|
|
6865 |
pages = {231--251},
|
|
6866 |
peerreview = {yes},
|
|
6867 |
selectif = {non},
|
|
6868 |
title = {Rule-based Assessment of Test Quality},
|
|
6869 |
url = {http://www.jot.fm/issues/issue_2007_10/paper12/
|
|
6870 |
http://www.jot.fm/issues/issue_2007_10/paper12.pdf},
|
|
6871 |
volume = {6/9},
|
|
6872 |
year = {2007},
|
|
6873 |
bdsk-url-1 = {http://www.jot.fm/issues/issue_2007_10/paper12/%20http://www.jot.fm/issues/issue_2007_10/paper12.pdf}
|
|
6874 |
}
|
|
6875 |
|
|
6876 |
@inproceedings{Reng07a,
|
|
6877 |
abstract = {Model-driven engineering is a powerful approach to
|
|
6878 |
build large-scale applications. However, an
|
|
6879 |
application's metamodel often remains static after
|
|
6880 |
the development phase and cannot be changed unless a
|
|
6881 |
new development effort occurs. Yet, end users often
|
|
6882 |
need to rapidly adapt their applications to new
|
|
6883 |
business needs. In many cases, the end users would
|
|
6884 |
know how to make the required adaptations, if only,
|
|
6885 |
the application would let them do so. In this paper
|
|
6886 |
we present how we built a runtime-dynamic
|
|
6887 |
meta-environment by integrating Magritte, a
|
|
6888 |
self-described metamodel, into Smalltalk's
|
|
6889 |
reflective language model. Our solution offers the
|
|
6890 |
best of both worlds: developers can develop their
|
|
6891 |
applications using the same tools they were used to,
|
|
6892 |
but at the same time they gain the power of
|
|
6893 |
meta-programming. We show in particular that our
|
|
6894 |
approach is adapted to support end user
|
|
6895 |
customization of applications: the adaptive model of
|
|
6896 |
Magritte enables to not only describe existing
|
|
6897 |
classes, but also lets end users build their own
|
|
6898 |
metamodels on the fly.},
|
|
6899 |
aeres = {ACT},
|
|
6900 |
aeresstatus = {aeres08},
|
|
6901 |
annote = {internationalconference},
|
|
6902 |
author = {Lukas Renggli and St\'ephane Ducasse and Adrian
|
|
6903 |
Kuhn},
|
|
6904 |
booktitle = {Model Driven Engineering Languages and Systems},
|
|
6905 |
doi = {10.1007/978-3-540-75209-7_8},
|
|
6906 |
editor = {Gregor Engels and Bill Opdyke and Douglas C. Schmidt
|
|
6907 |
and Frank Weil},
|
|
6908 |
inria = {hors},
|
|
6909 |
isbn = {978-3-540-75208-0},
|
|
6910 |
keywords = {scg07 scg-pub jb07 snf07 snf-bmcc akuhn fame},
|
|
6911 |
medium = {2},
|
|
6912 |
month = sep,
|
|
6913 |
pages = {106--120},
|
|
6914 |
peerreview = {yes},
|
|
6915 |
publisher = {Springer},
|
|
6916 |
ratex = {32%},
|
|
6917 |
series = {LNCS},
|
|
6918 |
title = {Magritte --- A Meta-Driven Approach to Empower
|
|
6919 |
Developers and End Users},
|
|
6920 |
url = {http://scg.unibe.ch/archive/papers/Reng07aMagritte.pdf},
|
|
6921 |
volume = {4735},
|
|
6922 |
year = {2007},
|
|
6923 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Reng07aMagritte.pdf},
|
|
6924 |
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-540-75209-7_8}
|
|
6925 |
}
|
|
6926 |
|
|
6927 |
@inproceedings{Reng09c,
|
|
6928 |
abstract = {As domain-specific modeling begins to attract
|
|
6929 |
widespread acceptance, pressure is increasing for
|
|
6930 |
the development of new domain-specific languages.
|
|
6931 |
Unfortunately these DSLs typically conflict with the
|
|
6932 |
grammar of the host language, making it difficult to
|
|
6933 |
compose hybrid code except at the level of strings;
|
|
6934 |
few mechanisms (if any) exist to control the scope
|
|
6935 |
of usage of multiple DSLs; and, most seriously,
|
|
6936 |
existing host language tools are typically unaware
|
|
6937 |
of the DSL extensions, thus hampering the
|
|
6938 |
development process. Language boxes address these
|
|
6939 |
issues by offering a simple, modular mechanism to
|
|
6940 |
encapsulate (i) compositional changes to the host
|
|
6941 |
language, (ii) transformations to address various
|
|
6942 |
concerns such as compilation and highlighting, and
|
|
6943 |
(iii) scoping rules to control visibility of
|
|
6944 |
language extensions. We describe the design and
|
|
6945 |
implementation of language boxes, and show with the
|
|
6946 |
help of several examples how modular extensions can
|
|
6947 |
be introduced to a host language and environment.},
|
|
6948 |
annote = {internationalconference},
|
|
6949 |
author = {Lukas Renggli and Marcus Denker and Oscar Nierstrasz},
|
|
6950 |
booktitle = {Software Language Engineering: Second International Conference (SLE 2009)},
|
|
6951 |
doi = {10.1007/978-3-642-12107-4_20},
|
|
6952 |
isbn = {978-3-642-12106-7},
|
|
6953 |
keywords = {scg09 scg-pub snf10 jb10 helvetia fromscgbib marcusdenker remoose lse-pub},
|
|
6954 |
medium = {2},
|
|
6955 |
pages = {274--293},
|
|
6956 |
peerreview = {yes},
|
|
6957 |
inria = {RMOD},
|
|
6958 |
inriareport = {2010},
|
|
6959 |
publisher = {Springer},
|
|
6960 |
ratex = {29%},
|
|
6961 |
series = {LNCS},
|
|
6962 |
title = {Language Boxes: Bending the Host Language with Modular Language Changes},
|
|
6963 |
url = {http://rmod.lille.inria.fr/archives/papers/Reng09c-SLE09-LanguageBoxes.pdf},
|
|
6964 |
volume = {5969},
|
|
6965 |
year = {2009}
|
|
6966 |
}
|
|
6967 |
|
|
6968 |
@inproceedings{Reng10b,
|
|
6969 |
abstract = {Lint-like program checkers are popular tools that
|
|
6970 |
ensure code quality by verifying compliance with
|
|
6971 |
best practices for a particular programming
|
|
6972 |
language. The proliferation of internal
|
|
6973 |
domain-specific languages and models, however, poses
|
|
6974 |
new challenges for such tools. Traditional program
|
|
6975 |
checkers produce many false positives and fail to
|
|
6976 |
accurately check constraints, best practices, common
|
|
6977 |
errors, possible optimizations and portability
|
|
6978 |
issues particular to domain-specific languages. We
|
|
6979 |
advocate the use of dedicated rules to check
|
|
6980 |
domain-specific practices. We demonstrate the
|
|
6981 |
implementation of domain-specific rules, the
|
|
6982 |
automatic fixing of violations, and their
|
|
6983 |
application to two case-studies: (1) Seaside defines
|
|
6984 |
several internal DSLs through a creative use of the
|
|
6985 |
syntax of the host language; and (2) Magritte adds
|
|
6986 |
meta-descriptions to existing code by means of
|
|
6987 |
special methods. Our empirical validation
|
|
6988 |
demonstrates that domain-specific program checking
|
|
6989 |
significantly improves code quality when compared
|
|
6990 |
with general purpose program checking.},
|
|
6991 |
annote = {internationalconference},
|
|
6992 |
author = {Lukas Renggli and St\'ephane Ducasse and Tudor G\^irba and Oscar Nierstrasz},
|
|
6993 |
booktitle = {Proceedings of the 48th International Conference on Objects, Models, Components and Patterns (TOOLS'10)},
|
|
6994 |
keywords = {scg-pub helvetia girba snf10 jb10 remoose lse-pub},
|
|
6995 |
inria = {RMOD},
|
|
6996 |
inriareport = {2010},
|
|
6997 |
series = {LNCS},
|
|
6998 |
pages = {213--232},
|
|
6999 |
isnb = {978-3-642-13952-9},
|
|
7000 |
doi = {10.1007/978-3-642-13953-6\_12},
|
|
7001 |
publisher = {Springer-Verlag},
|
|
7002 |
volume = {6141},
|
|
7003 |
editor = {Jan Vitek},
|
|
7004 |
peerreview = {yes},
|
|
7005 |
ratex = {29%},
|
|
7006 |
title = {Domain-Specific Program Checking},
|
|
7007 |
url = {http://rmod.lille.inria.fr/archives/papers/Reng10b-DomainSpecificProgramChecking.pdf},
|
|
7008 |
hal-id = {inria-00531509},
|
|
7009 |
year = {2010},
|
|
7010 |
x-proceedings = {yes},
|
|
7011 |
x-international-audience = {yes}
|
|
7012 |
}
|
|
7013 |
|
|
7014 |
@inproceedings{Reng10c,
|
|
7015 |
abstract = {Grammars for programming languages are traditionally
|
|
7016 |
specified statically. They are hard to compose and
|
|
7017 |
reuse due to ambiguities that inevitably arise.
|
|
7018 |
PetitParser combines ideas from scannerless parsing,
|
|
7019 |
parser combinators, parsing expression grammars and
|
|
7020 |
packrat parsers to model grammars and parsers as
|
|
7021 |
objects that can be reconfigured dynamically.
|
|
7022 |
Through examples and benchmarks we demonstrate that
|
|
7023 |
dynamic grammars are not only flexible but highly
|
|
7024 |
practical.},
|
|
7025 |
author = {Lukas Renggli and St\'ephane Ducasse and Tudor
|
|
7026 |
G\^irba and Oscar Nierstrasz},
|
|
7027 |
booktitle = {4th Workshop on Dynamic Languages and Applications (DYLA 2010)},
|
|
7028 |
title = {Practical Dynamic Grammars for Dynamic Languages},
|
|
7029 |
keywords = {scg-pub helvetia girba missing-doi moose-pub snf10 jb10 lse-pub},
|
|
7030 |
annote = {internationalworkshop},
|
|
7031 |
url = {http://scg.unibe.ch/archive/papers/Reng10cDynamicGrammars.pdf},
|
|
7032 |
month = jun,
|
|
7033 |
inria = {RMOD},
|
|
7034 |
inriareport = {2010},
|
|
7035 |
address = {Malaga, Spain},
|
|
7036 |
peerreview = {yes},
|
|
7037 |
year = {2010},
|
|
7038 |
x-proceedings = {no},
|
|
7039 |
x-international-audience = {yes}
|
|
7040 |
}
|
|
7041 |
|
|
7042 |
@inproceedings{Rich02a,
|
|
7043 |
abstract = {Modeling object-oriented applications using
|
|
7044 |
collaborations and roles is now well accepted.
|
|
7045 |
Collaboration-based or role-based designs decompose
|
|
7046 |
an application into tasks performed by a subset of
|
|
7047 |
the applications' classes. Collaborations prov ide a
|
|
7048 |
larger unit of understanding and reuse than classes,
|
|
7049 |
and are an important aid in the maintenance and
|
|
7050 |
evolution of the software. This kind of design
|
|
7051 |
information is lost, however, at the implementation
|
|
7052 |
level, making it hard to maintain and evolve an e
|
|
7053 |
xisting software application. The extraction of
|
|
7054 |
collaborations from code is therefore an important
|
|
7055 |
issue in design recovery. In this paper we propose
|
|
7056 |
an iterative approach which uses dynamic information
|
|
7057 |
to support the recovery and understanding of collabo
|
|
7058 |
rations. We describe a tool we have developed to
|
|
7059 |
support our approach and demonstrate its use on a
|
|
7060 |
case study.},
|
|
7061 |
address = {Los Alamitos CA},
|
|
7062 |
annote = {internationalconference},
|
|
7063 |
author = {Tamar Richner and St\'ephane Ducasse},
|
|
7064 |
booktitle = {Proceedings of 18th IEEE International Conference on
|
|
7065 |
Software Maintenance (ICSM'02)},
|
|
7066 |
doi = {10.1109/ICSM.2002.1167745},
|
|
7067 |
keywords = {scg-pub snf02 jb02 stefPub},
|
|
7068 |
misc = {acceptance rate: 61/127 = 48\%},
|
|
7069 |
accepttotal = {127},
|
|
7070 |
acceptnum = {61},
|
|
7071 |
month = oct,
|
|
7072 |
pages = {34},
|
|
7073 |
publisher = {IEEE Computer Society},
|
|
7074 |
title = {Using Dynamic Information for the Iterative Recovery
|
|
7075 |
of Collaborations and Roles},
|
|
7076 |
url = {http://scg.unibe.ch/archive/papers/Rich02aRolesExtractionICSM2002.pdf},
|
|
7077 |
year = {2002},
|
|
7078 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Rich02aRolesExtractionICSM2002.pdf},
|
|
7079 |
bdsk-url-2 = {http://dx.doi.org/10.1109/ICSM.2002.1167745}
|
|
7080 |
}
|
|
7081 |
|
|
7082 |
@inproceedings{Rich98b,
|
|
7083 |
abstract = {Understanding how components in an application
|
|
7084 |
interact to ensure a certain functionality is an
|
|
7085 |
essential aspect of understanding a software
|
|
7086 |
application. To obtain this kind of information an
|
|
7087 |
analysis of the dynamic behavior of an application
|
|
7088 |
is more appropriate than a static analysis of the
|
|
7089 |
code. Understanding dynamic behavior through event
|
|
7090 |
analysis is a challenge because of the large amount
|
|
7091 |
of data gathered through program executions. In this
|
|
7092 |
paper, we show how we define declarative queries
|
|
7093 |
that allow us to filter the event data collected and
|
|
7094 |
to define new abstractions which aid in program
|
|
7095 |
understanding.},
|
|
7096 |
annote = {internationalworkshop},
|
|
7097 |
author = {Tamar Richner and St\'ephane Ducasse and Roel Wuyts},
|
|
7098 |
booktitle = {Object-Oriented Technology (ECOOP '98 Workshop
|
|
7099 |
Reader)},
|
|
7100 |
editor = {Serge Demeyer and Jan Bosch},
|
|
7101 |
keywords = {olit famoos-papunr scglit oobib scg-pub skip-doi
|
|
7102 |
toBeChecked snf98 jb98 stefPub},
|
|
7103 |
month = jul,
|
|
7104 |
publisher = {Springer-Verlag},
|
|
7105 |
series = {LNCS},
|
|
7106 |
title = {Understanding Object-Oriented Programs with
|
|
7107 |
Declarative Event Analysis},
|
|
7108 |
url = {http://scg.unibe.ch/archive/papers/Rich98bEvents.pdf},
|
|
7109 |
volume = {1543},
|
|
7110 |
year = {1998},
|
|
7111 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Rich98bEvents.pdf}
|
|
7112 |
}
|
|
7113 |
|
|
7114 |
|
|
7115 |
@inproceedings{Rich99a,
|
|
7116 |
abstract = {Recovering architectural documentation from code is
|
|
7117 |
crucial to maintaining and reengineering software
|
|
7118 |
systems. Reverse engineering and program
|
|
7119 |
understanding approaches are often limited by the
|
|
7120 |
fact that (1) they propose a fixed set of predefined
|
|
7121 |
views and (2) they consider either purely static or
|
|
7122 |
purely dynamic views of the application. In this
|
|
7123 |
paper we present an environment supporting the
|
|
7124 |
generation of tailorable views of object-oriented
|
|
7125 |
systems from both static and dynamic information.
|
|
7126 |
Our approach is based on the combination of
|
|
7127 |
user-defined queries which allow an engineer to
|
|
7128 |
create high-level abstractions and to produce views
|
|
7129 |
using these abstractions.},
|
|
7130 |
address = {Los Alamitos CA},
|
|
7131 |
annote = {internationalconference},
|
|
7132 |
author = {Tamar Richner and St\'ephane Ducasse},
|
|
7133 |
booktitle = {Proceedings of 15th IEEE International Conference on
|
|
7134 |
Software Maintenance (ICSM'99)},
|
|
7135 |
doi = {10.1109/ICSM.1999.792487},
|
|
7136 |
editor = {Hongji Yang and Lee White},
|
|
7137 |
keywords = {olit famoos-papref scg-pub toBeChecked snf99 jb99
|
|
7138 |
oorp stefPub},
|
|
7139 |
misc = {acceptance rate: 49/100 = 49\%},
|
|
7140 |
accepttotal = {100},
|
|
7141 |
acceptnum = {49},
|
|
7142 |
month = sep,
|
|
7143 |
pages = {13--22},
|
|
7144 |
publisher = {IEEE Computer Society Press},
|
|
7145 |
title = {Recovering High-Level Views of Object-Oriented
|
|
7146 |
Applications from Static and Dynamic Information},
|
|
7147 |
url = {http://scg.unibe.ch/archive/papers/Rich99aRecoveringViews.pdf},
|
|
7148 |
year = {1999},
|
|
7149 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Rich99aRecoveringViews.pdf},
|
|
7150 |
bdsk-url-2 = {http://dx.doi.org/10.1109/ICSM.1999.792487}
|
|
7151 |
}
|
|
7152 |
|
|
7153 |
@inproceedings{Rieg04b,
|
|
7154 |
abstract = {Duplication of code is a common phenomenon in the
|
|
7155 |
development and maintenance of large software
|
|
7156 |
systems. The detection and removal of duplicated
|
|
7157 |
code has become a standard activity during the
|
|
7158 |
refactoring phases of a software life-cycle.
|
|
7159 |
However, code duplication identification ends to
|
|
7160 |
produce large amounts of data making the
|
|
7161 |
understanding of the duplication situation as a
|
|
7162 |
whole difficult. Reengineers can easily lose sight
|
|
7163 |
of the forest for the trees. There is a need to
|
|
7164 |
support a qualitative analysis of the duplicated
|
|
7165 |
code. In this paper we propose a number of
|
|
7166 |
visualzations of duplicated source elements that
|
|
7167 |
support reengineers in answering questions, e.g.,
|
|
7168 |
which parts of the sysem are connected by copied
|
|
7169 |
code or which parts of the sysem are copied the
|
|
7170 |
most.},
|
|
7171 |
annote = {internationalconference},
|
|
7172 |
author = {Matthias Rieger and St\'ephane Ducasse and Michele
|
|
7173 |
Lanza},
|
|
7174 |
booktitle = {Proceedings of 11th Working Conference on Reverse
|
|
7175 |
Engineering (WCRE'04)},
|
|
7176 |
cvs = {DuplocVizPaper},
|
|
7177 |
doi = {10.1109/WCRE.2004.25},
|
|
7178 |
keywords = {olit scg-pub jb05 recast05 stefPub clones},
|
|
7179 |
location = {Delft, The Netherlands},
|
|
7180 |
misc = {acceptance rate: 28/78 = 36\%},
|
|
7181 |
accepttotal = {78},
|
|
7182 |
acceptnum = {28},
|
|
7183 |
month = nov,
|
|
7184 |
pages = {100--109},
|
|
7185 |
publisher = {IEEE Computer Society Press},
|
|
7186 |
title = {Insights into System-Wide Code Duplication},
|
|
7187 |
url = {http://scg.unibe.ch/archive/papers/Rieg04bWCRE2004ClonesVisualization.pdf},
|
|
7188 |
year = {2004},
|
|
7189 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Rieg04bWCRE2004ClonesVisualization.pdf},
|
|
7190 |
bdsk-url-2 = {http://dx.doi.org/10.1109/WCRE.2004.25}
|
|
7191 |
}
|
|
7192 |
|
|
7193 |
@inproceedings{Rieg98a,
|
|
7194 |
abstract = {Code duplication is considered as bad practice that
|
|
7195 |
complicates the maintenance and evolution of
|
|
7196 |
software. Detecting duplicated code is a difficult
|
|
7197 |
task because of the large amount of data to be
|
|
7198 |
checked and the fact that a priori it is unknown
|
|
7199 |
which code part has been duplicated. In this paper,
|
|
7200 |
we present a tool called DUPLOC that supports code
|
|
7201 |
duplication detection in a visual and exploratory or
|
|
7202 |
an automatic way.},
|
|
7203 |
annote = {internationalworkshop},
|
|
7204 |
author = {Matthias Rieger and St\'ephane Ducasse},
|
|
7205 |
booktitle = {Proceedings ECOOP Workshop on Experiences in Object-Oriented Re-Engineering},
|
|
7206 |
editor = {St\'ephane Ducasse and Joachim Weisbrod},
|
|
7207 |
keywords = {jb98 famoos-papunr snf98 scg-pub skip-doi},
|
|
7208 |
number = {6/7/98},
|
|
7209 |
publisher = {Forschungszentrum Informatik Karlsruhe},
|
|
7210 |
series = {FZI Report},
|
|
7211 |
title = {Visual Detection of Duplicated Code},
|
|
7212 |
url = {http://scg.unibe.ch/archive/papers/Rieg98aEcoopWorkshop.pdf},
|
|
7213 |
year = {1998}
|
|
7214 |
}
|
|
7215 |
|
|
7216 |
@inproceedings{Rieg98b,
|
|
7217 |
abstract = {Code duplication is considered as bad practice that
|
|
7218 |
complicates the maintenance and evolution of
|
|
7219 |
software. Detecting duplicated code is a difficult
|
|
7220 |
task because of the large amount of data to be
|
|
7221 |
checked and the fact that a priori it is unknown
|
|
7222 |
which code part has been duplicated. In this paper,
|
|
7223 |
we present a tool called DUPLOC that supports code
|
|
7224 |
duplication detection in a visual and exploratory or
|
|
7225 |
an automatic way.},
|
|
7226 |
annote = {internationalworkshop},
|
|
7227 |
author = {Matthias Rieger and St\'ephane Ducasse},
|
|
7228 |
booktitle = {Object-Oriented Technology (ECOOP '98 Workshop Reader)},
|
|
7229 |
editor = {Serge Demeyer and Jan Bosch},
|
|
7230 |
keywords = {olit famoos-papunr reveng scg-pub skip-doi jb-none stefPub},
|
|
7231 |
month = jul,
|
|
7232 |
pages = {75--76},
|
|
7233 |
publisher = {Springer-Verlag},
|
|
7234 |
series = {LNCS},
|
|
7235 |
title = {Visual Detection of Duplicated Code},
|
|
7236 |
url = {http://scg.unibe.ch/archive/papers/Rieg98aEcoopWorkshop.pdf},
|
|
7237 |
volume = {1543},
|
|
7238 |
year = {1998}
|
|
7239 |
}
|
|
7240 |
|
|
7241 |
@inproceedings{Rieg99a,
|
|
7242 |
abstract = {Code duplication is an important problem in
|
|
7243 |
application maintenance. Tools exist that support
|
|
7244 |
code duplication detection. However, few of them
|
|
7245 |
propose a solution for the problem, i.e.
|
|
7246 |
refactorings. We propose an approach that uses the
|
|
7247 |
information given by code duplication detection to
|
|
7248 |
guide the refactorings of OO applications.},
|
|
7249 |
annote = {internationalworkshop},
|
|
7250 |
author = {Matthias Rieger and St\'ephane Ducasse and Georges Golomingi},
|
|
7251 |
booktitle = {Object-Oriented Technology (ECOOP '99 Workshop Reader)},
|
|
7252 |
keywords = {olit scg-pub skip-doi jb-none},
|
|
7253 |
number = {1743},
|
|
7254 |
publisher = {Springer-Verlag},
|
|
7255 |
series = {LNCS},
|
|
7256 |
title = {Tool Support for Refactoring Duplicated OO Code},
|
|
7257 |
url = {http://scg.unibe.ch/archive/papers/Rieg99aToolSuppRefacOOCode.pdf},
|
|
7258 |
year = {1999}
|
|
7259 |
}
|
|
7260 |
|
|
7261 |
@inproceedings{Robb05b,
|
|
7262 |
abstract = {Understanding classes and methods is a key activity
|
|
7263 |
in object-oriented programming, since classes
|
|
7264 |
represent the primary abstractions from which
|
|
7265 |
applications are built, while methods contain the
|
|
7266 |
actual program logic. The main problem of this task
|
|
7267 |
is to quickly grasp the purpose and inner structure
|
|
7268 |
of a class. To achieve this goal, one must be able
|
|
7269 |
to overview multiple methods at once. In this paper,
|
|
7270 |
we present microprints, pixel-based representations
|
|
7271 |
of methods enriched with semantical information. We
|
|
7272 |
present three specialized microprints each dealing
|
|
7273 |
with a specific aspect we want to understand of
|
|
7274 |
methods: (1) state access, (2) control flow, and (3)
|
|
7275 |
invocation relationship. We present the microprints
|
|
7276 |
in conjunction with the class blueprints of the CODE
|
|
7277 |
CRAWLER visualization tool [12] and also integrated
|
|
7278 |
into the default code browser of the Smalltalk
|
|
7279 |
VisualWorks development environment.},
|
|
7280 |
aeres = {ACT},
|
|
7281 |
aeresstatus = {aeres08},
|
|
7282 |
annote = {internationalconference},
|
|
7283 |
author = {Romain Robbes and St\'ephane Ducasse and Michele Lanza},
|
|
7284 |
booktitle = {Proceedings of 13th International Smalltalk Conference (ISC'05)},
|
|
7285 |
inria = {hors},
|
|
7286 |
keywords = {scg-pub skip-doi stefPub snf05 jb06 listic},
|
|
7287 |
pages = {131--157},
|
|
7288 |
selectif = {non},
|
|
7289 |
title = {Microprints: A Pixel-based Semantically Rich Visualization of Methods},
|
|
7290 |
url = {http://scg.unibe.ch/archive/papers/Robb05b-microprintsESUG.pdf},
|
|
7291 |
year = {2005}
|
|
7292 |
}
|
|
7293 |
|
|
7294 |
@inproceedings{Robb10a,
|
|
7295 |
author = {Robbes, Romain and Pollet, Damien and Lanza, Michele},
|
|
7296 |
title = {Replaying IDE Interactions to Evaluate and Improve Change Prediction Approaches},
|
|
7297 |
editor = {Whitehead, Jim and Zimmermann, Thomas},
|
|
7298 |
booktitle = {7th IEEE Working Conference on Mining Software Repositories (MSR)},
|
|
7299 |
pages = {161--170},
|
|
7300 |
publisher = {IEEE Computer Society},
|
|
7301 |
month = may,
|
|
7302 |
year = {2010},
|
|
7303 |
misc = {Acceptance rate: 16/51 = 31.4\%},
|
|
7304 |
isbn = {978-1-4244-6803-4},
|
|
7305 |
url = {http://rmod.lille.inria.fr/archives/papers/Robb10a-MSR10-ChangePrediction.pdf},
|
|
7306 |
doi = {10.1109/MSR.2010.5463278},
|
|
7307 |
abstract = {
|
|
7308 |
Change prediction helps developers by recommending program entities that will have to be changed alongside the entities currently
|
|
7309 |
being changed. To evaluate their accuracy, current change prediction approaches use data from versioning systems such as CVS or SVN.
|
|
7310 |
These data sources provide a coarse-grained view of the development history that flattens the sequence of changes in a single commit.
|
|
7311 |
They are thus not a valid basis for evaluation in the case of developmentstyle prediction, where the order of the predictions has to
|
|
7312 |
match the order of the changes a developer makes.
|
|
7313 |
We propose a benchmark for the evaluation of change prediction approaches based on fine-grained change data recorded from IDE usage.
|
|
7314 |
Moreover, the change prediction approaches themselves can use the more accurate data to fine-tune their prediction. We present an
|
|
7315 |
evaluation procedure and use it on several change prediction approaches, both novel and from the literature, and report on the
|
|
7316 |
results.},
|
|
7317 |
keywords = {lse-pub},
|
|
7318 |
annote = {internationalconference},
|
|
7319 |
hal = {inria-00531788},
|
|
7320 |
inria = {RMOD},
|
|
7321 |
inriareport = {2010},
|
|
7322 |
selectif = {non},
|
|
7323 |
labo = {hors},
|
|
7324 |
TODO-impactfactor = {},
|
|
7325 |
rate = {31.4\%},
|
|
7326 |
x-editorial-board = {yes},
|
|
7327 |
x-proceedings = {yes},
|
|
7328 |
x-international-audience = {yes},
|
|
7329 |
x-pays = {CL,CH},
|
|
7330 |
aeres = {aeres12},
|
|
7331 |
aeresstatus = {ACT}
|
|
7332 |
}
|
|
7333 |
|
|
7334 |
@inproceedings{Roet07b,
|
|
7335 |
abstract = {Dynamic, unanticipated adaptation of running systems
|
|
7336 |
is of interest in a variety of situations, ranging
|
|
7337 |
from functional upgrades to on-the-fly debugging or
|
|
7338 |
monitoring of critical applications. In this paper
|
|
7339 |
we study a particular form of computational
|
|
7340 |
reflection, called unanticipated partial behavioral
|
|
7341 |
reflection, which is particularly well-suited for
|
|
7342 |
unanticipated adaptation of real-world systems. Our
|
|
7343 |
proposal combines the dynamicity of unanticipated
|
|
7344 |
reflection, i.e., reflection that does not require
|
|
7345 |
preparation of the code of any sort, and the
|
|
7346 |
selectivity and efficiency of partial behavioral
|
|
7347 |
reflection. First, we propose unanticipated partial
|
|
7348 |
behavioral reflection which enables the developer to
|
|
7349 |
precisely select the required reifications, to
|
|
7350 |
flexibly engineer the metalevel and to introduce the
|
|
7351 |
meta behavior dynamically. Second, we present a
|
|
7352 |
system supporting unanticipated partial behavioral
|
|
7353 |
reflection in Squeak Smalltalk, called Geppetto, and
|
|
7354 |
illustrate its use with a concrete example of a
|
|
7355 |
Seaside web application. Benchmarks validate the
|
|
7356 |
applicability of our proposal as an extension to the
|
|
7357 |
standard reflective abilities of Smalltalk.},
|
|
7358 |
annote = {internationalconference},
|
|
7359 |
author = {David R{\"o}thlisberger and Marcus Denker and
|
|
7360 |
{\'E}ric Tanter},
|
|
7361 |
booktitle = {Advances in Smalltalk --- Proceedings of 14th
|
|
7362 |
International Smalltalk Conference (ISC 2006)},
|
|
7363 |
doi = {10.1007/978-3-540-71836-9\_3},
|
|
7364 |
isbn = {978-3-540-71835-2},
|
|
7365 |
issn = {0302-9743},
|
|
7366 |
keywords = {scg07 scg-pub jb07 snf06 roethlisberger
|
|
7367 |
reflectivity marcusdenker fromscgbib},
|
|
7368 |
medium = {2},
|
|
7369 |
pages = {47--65},
|
|
7370 |
peerreview = {yes},
|
|
7371 |
publisher = {Springer},
|
|
7372 |
series = {LNCS},
|
|
7373 |
title = {Unanticipated Partial Behavioral Reflection},
|
|
7374 |
url = {http://rmod.lille.inria.fr/archives/papers/Roet07b-ISC06-UPBReflection.pdf},
|
|
7375 |
volume = {4406},
|
|
7376 |
year = {2007}
|
|
7377 |
}
|
|
7378 |
|
|
7379 |
@article{Roet08a,
|
|
7380 |
abstract = {Dynamic, unanticipated adaptation of running systems
|
|
7381 |
is of interest in a variety of situations, ranging
|
|
7382 |
from functional upgrades to on-the-fly debugging or
|
|
7383 |
monitoring of critical applications. In this paper
|
|
7384 |
we study a particular form of computational
|
|
7385 |
reflection, called unanticipated partial behavioral
|
|
7386 |
reflection, which is particularly well-suited for
|
|
7387 |
unanticipated adaptation of real-world systems. Our
|
|
7388 |
proposal combines the dynamicity of unanticipated
|
|
7389 |
reflection, i.e. reflection that does not require
|
|
7390 |
preparation of the code of any sort, and the
|
|
7391 |
selectivity and efficiency of partial behavioral
|
|
7392 |
reflection. First, we propose unanticipated partial
|
|
7393 |
behavioral reflection which enables the developer to
|
|
7394 |
precisely select the required reifications, to
|
|
7395 |
flexibly engineer the metalevel and to introduce the
|
|
7396 |
meta behavior dynamically. Second, we present a
|
|
7397 |
system supporting unanticipated partial behavioral
|
|
7398 |
reflection in Squeak Smalltalk, called Geppetto, and
|
|
7399 |
illustrate its use with a concrete example of a web
|
|
7400 |
application. Benchmarks validate the applicability
|
|
7401 |
of our proposal as an extension to the standard
|
|
7402 |
reflective abilities of Smalltalk.},
|
|
7403 |
annote = {internationaljournal},
|
|
7404 |
author = {David R{\"o}thlisberger and Marcus Denker and
|
|
7405 |
{\'E}ric Tanter},
|
|
7406 |
doi = {10.1016/j.cl.2007.05.001},
|
|
7407 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
7408 |
keywords = {scg08 scg08 scg-pub jb08 snf08 roethlisberger reflectivity marcusdenker fromscgbib},
|
|
7409 |
medium = {2},
|
|
7410 |
month = jul,
|
|
7411 |
number = {2-3},
|
|
7412 |
pages = {46--65},
|
|
7413 |
peerreview = {yes},
|
|
7414 |
publisher = {Elsevier},
|
|
7415 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
7416 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
7417 |
title = {Unanticipated Partial Behavioral Reflection:
|
|
7418 |
Adapting Applications at Runtime},
|
|
7419 |
url = {http://rmod.lille.inria.fr/archives/papers/Roet08a-COMLAN-UPBReflectionJournal.pdf},
|
|
7420 |
volume = {34},
|
|
7421 |
year = {2008}
|
|
7422 |
}
|
|
7423 |
|
|
7424 |
@inproceedings{Roet09a,
|
|
7425 |
author = {David R\"{o}thlisberger and Oscar Nierstrasz and St\'ephane Ducasse and Damien Pollet and Romain Robbes},
|
|
7426 |
keywords = {scg-pub snf09 jb09 roethlisberger},
|
|
7427 |
annote = {internationalconference},
|
|
7428 |
title = {Supporting Task-oriented Navigation in {IDEs} with Configurable HeatMaps},
|
|
7429 |
abstract = {Mainstream IDEs generally rely on the static structure of a
|
|
7430 |
software project to support browsing and navigation.
|
|
7431 |
We propose HeatMaps, a simple but highly configurable technique
|
|
7432 |
to enrich the way an IDE displays the static structure of a software
|
|
7433 |
system with additional kinds of information.
|
|
7434 |
A heatmap highlights software artifacts according to various metric values,
|
|
7435 |
such as bright red or pale blue, to indicate their potential degree of interest.
|
|
7436 |
We present a prototype system that implements heatmaps, and we describe
|
|
7437 |
an initial study that assesses the degree to which different heatmaps effectively
|
|
7438 |
guide developers in navigating software.},
|
|
7439 |
peer = {yes},
|
|
7440 |
booktitle = {Proceedings of the 17th International Conference on Program Comprehension (ICPC 2009)},
|
|
7441 |
publisher = {IEEE Computer Society},
|
|
7442 |
address = {Los Alamitos, CA, USA},
|
|
7443 |
pages = {253--257},
|
|
7444 |
isbn = {978-0-7695-3176-2},
|
|
7445 |
doi = {10.1109/ICPC.2008.32},
|
|
7446 |
url = {http://rmod.lille.inria.fr/archives/papers/Roet09a-ICPC2009-HeatMaps.pdf},
|
|
7447 |
year = {2009},
|
|
7448 |
inria = {RMOD},
|
|
7449 |
inriareport = {2009},
|
|
7450 |
labo = {dans},
|
|
7451 |
x-pays = {CH},
|
|
7452 |
x-editorial-board = {yes},
|
|
7453 |
x-proceedings = {yes},
|
|
7454 |
x-international-audience = {yes},
|
|
7455 |
hal-id = {inria-00498454 /}
|
|
7456 |
}
|
|
7457 |
|
|
7458 |
@techreport{Roet09d,
|
|
7459 |
abstract = {Mainstream IDEs generally rely on the static structure of a
|
|
7460 |
software project to support browsing and navigation.
|
|
7461 |
We propose HeatMaps, a simple but highly configurable technique
|
|
7462 |
to enrich the way an IDE displays the static structure of a software
|
|
7463 |
system with additional kinds of information.
|
|
7464 |
A heatmap highlights software artifacts according to various metric values,
|
|
7465 |
such as bright red or pale blue, to indicate their potential degree of interest.
|
|
7466 |
We present a prototype system that implements heatmaps, and we describe
|
|
7467 |
an initial study that assesses the degree to which different heatmaps effectively
|
|
7468 |
guide developers in navigating software.},
|
|
7469 |
address = {Universit\"at Bern, Switzerland},
|
|
7470 |
author = {David R\"{o}thlisberger and Oscar Nierstrasz and St\'ephane Ducasse and Damien Pollet and Romain Robbes},
|
|
7471 |
classification = {D.2.2 Tools and Techniques; D.2.3 Coding; D.2.6 Programming Environments; D.2.9 Management},
|
|
7472 |
general_terms = {Coding, Programming Environments, Program Editors, Integrated Environments},
|
|
7473 |
institution = {Institut f\"ur Informatik},
|
|
7474 |
keywords = {scg-pub snf09 jb09 roethlisberger},
|
|
7475 |
month = jul,
|
|
7476 |
number = {IAM-09-005},
|
|
7477 |
annote = {technicalreport},
|
|
7478 |
title = {Supporting Task-oriented Navigation in {IDEs} with Configurable HeatMaps},
|
|
7479 |
type = {Technical Report},
|
|
7480 |
url = {http://rmod.lille.inria.fr/archives/reports/Roet09d-TechReport-HeatMaps.pdf},
|
|
7481 |
year = {2009},
|
|
7482 |
x-pays = {CH},
|
|
7483 |
x-editorial-board = {no},
|
|
7484 |
x-proceedings = {no},
|
|
7485 |
x-international-audience = {yes}
|
|
7486 |
}
|
|
7487 |
|
|
7488 |
@inproceedings{Roet09e,
|
|
7489 |
title = {Tackling Software Navigation Issues of the Smalltalk IDE},
|
|
7490 |
abstract = {The IDE used in most Smalltalk dialects such as Pharo, Squeak or Cincom Smalltalk did not evolve
|
|
7491 |
significantly over the last years, if not to say decades. For other languages, for instance Java, the
|
|
7492 |
available IDEs made tremendous progress as Eclipse or NetBeans illustrate. While the Smalltalk
|
|
7493 |
IDE served as an exemplar for many years, other IDEs caught up or even overtook the erstwhile
|
|
7494 |
leader in terms of feature-richness, usability, or code navigation facilities.
|
|
7495 |
In this paper we first analyze the difficulty of software navigation in the Smalltalk IDE and second
|
|
7496 |
illustrate with concrete examples the features we added to the Smalltalk IDE to fill the gap to
|
|
7497 |
modern IDEs and to provide novel, improved means to navigate source space. We show that
|
|
7498 |
thanks to the agility and dynamics of Smalltalk, we are able to extend and enhance with reasonable
|
|
7499 |
effort the Smalltalk IDE to better support software navigation, program comprehension, and software
|
|
7500 |
maintenance in general. One such support is the integration of dynamic information into the static
|
|
7501 |
source views we are familiar with. Other means include easing the access to static information
|
|
7502 |
(for instance by better arranging important packages) or helping developers re-locating artifacts
|
|
7503 |
of interest (for example with a categorization system such as smart groups).},
|
|
7504 |
annote = {internationalworkshop},
|
|
7505 |
author = {David R\"{o}thlisberger and Oscar Nierstrasz and St\'ephane Ducasse and Alexandre Bergel},
|
|
7506 |
booktitle = {Proceedings of International Workshop on Smalltalk Technologies (IWST 2009)},
|
|
7507 |
peer = {yes},
|
|
7508 |
keywords = {scg-sub jb10 roethlisberger remoose2-pub},
|
|
7509 |
location = {Brest, France},
|
|
7510 |
publisher = {ACM Digital Library},
|
|
7511 |
year = {2009},
|
|
7512 |
aeres = {ACT},
|
|
7513 |
aeresstatus = {aeres12},
|
|
7514 |
selectif = {non},
|
|
7515 |
labo = {dans},
|
|
7516 |
inria = {RMOD},
|
|
7517 |
inriareport = {2009},
|
|
7518 |
x-editorial-board = {yes},
|
|
7519 |
x-proceedings = {yes},
|
|
7520 |
x-international-audience = {yes},
|
|
7521 |
x-pays = {CH},
|
|
7522 |
url = {http://rmod.lille.inria.fr/archives/workshops/Roet09e-IWST2009-obEnhancements.pdf}
|
|
7523 |
}
|
|
7524 |
|
|
7525 |
@inproceedings{Roet09f,
|
|
7526 |
author = {David R\"{o}thlisberger and Oscar Nierstrasz and St\'ephane Ducasse},
|
|
7527 |
keywords = {snf09 jb10 roethlisberger remoose2-pub},
|
|
7528 |
annote = {internationalconference},
|
|
7529 |
title = {Autumn Leaves: Curing the Window Plague in IDEs},
|
|
7530 |
abstract = {Navigating large software systems is difficult as the various artifacts are distributed in a huge space, while the relationships between different artifacts often remain hidden and obscure. As a consequence, developers using a modern interactive development environment (IDE) are forced to open views on numerous source artifacts to reveal these hidden relationships, leading to a crowded workspace with many opened windows or tabs. Developers often lose the overview in such a cluttered workspace as IDEs provide little support to get rid of unused windows. AutumnLeaves automatically selects windows unlikely for future use to be closed or grayed out while important ones are displayed more prominently. This reduces the number of windows opened at a time and adds structure to the developer's workspace. We validate AutumnLeaves with a benchmark evaluation using recorded navigation data of various developers to determine the prediction quality of the employed algorithms.},
|
|
7531 |
peer = {yes},
|
|
7532 |
booktitle = {Proceedings of the 16th Working Conference on Reverse Engineering (WCRE 2009)},
|
|
7533 |
publisher = {IEEE Computer Society},
|
|
7534 |
address = {Los Alamitos, CA, USA},
|
|
7535 |
aeres = {ACT},
|
|
7536 |
misc = {Acceptance rate: 20/79 = 25\%},
|
|
7537 |
rate = {25\%},
|
|
7538 |
aeresstatus = {aeres12},
|
|
7539 |
selectif = {non},
|
|
7540 |
inria = {RMOD},
|
|
7541 |
labo = {dans},
|
|
7542 |
location = {Lille, France},
|
|
7543 |
year = {2009},
|
|
7544 |
inriareport = {2009},
|
|
7545 |
x-editorial-board = {yes},
|
|
7546 |
x-proceedings = {yes},
|
|
7547 |
x-international-audience = {yes},
|
|
7548 |
x-pays = {CH},
|
|
7549 |
url = {http://rmod.lille.inria.fr/archives/papers/Roet09f-WCRE2009-AutumnLeaves-ieee.pdf}
|
|
7550 |
}
|
|
7551 |
|
|
7552 |
@article{Sade02a,
|
|
7553 |
abstract = {The concept of interfaces is central to
|
|
7554 |
object-oriented methodologies and is one of the most
|
|
7555 |
attractive features of {Java} and COM. Although
|
|
7556 |
Smalltalk always had interfaces implicitly, in
|
|
7557 |
Smalltalk interfaces are not first-class objects: t
|
|
7558 |
hey cannot be conversed with, referred to, or
|
|
7559 |
reflected upon. Consequently, Smalltalkers have been
|
|
7560 |
deprived of such an important and useful tool. Since
|
|
7561 |
a fundamental feature of Smalltalk is that just
|
|
7562 |
about everything in the language is an
|
|
7563 |
implementation feature, explicit, static interfaces
|
|
7564 |
can be added to Smalltalk using Smalltalk itself
|
|
7565 |
with ease. However, such an addition would
|
|
7566 |
short-change the powerful dynamic aspects of
|
|
7567 |
Smalltalk. In this article we present
|
|
7568 |
SmallInterfaces; a new ontology of dynamic i
|
|
7569 |
nterfaces which makes a powerful use of the dynamic
|
|
7570 |
nature of Smalltalk. SmallInterfaces adds interfaces
|
|
7571 |
as honorary members to Smalltalk's extensive
|
|
7572 |
reflection mechanism, in a manner portable across
|
|
7573 |
the many Smalltalk variants},
|
|
7574 |
annote = {internationaljournal},
|
|
7575 |
author = {Benny Sadeh and St\'ephane Ducasse},
|
|
7576 |
journal = {Journal of Object Technology},
|
|
7577 |
keywords = {scg-pub skip-doi jb02 snf02 stefPub},
|
|
7578 |
number = {1},
|
|
7579 |
title = {Adding Dynamic Interfaces to {Smalltalk}},
|
|
7580 |
url = {http://scg.unibe.ch/archive/papers/Sade02aDynamicInterfaces.pdf},
|
|
7581 |
volume = {1},
|
|
7582 |
year = {2002},
|
|
7583 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Sade02aDynamicInterfaces.pdf}
|
|
7584 |
}
|
|
7585 |
|
|
7586 |
@inproceedings{Scha02a,
|
|
7587 |
abstract = {We present a simple, component-based model of
|
|
7588 |
mixins, called traits, and argue that this simple
|
|
7589 |
model sidesteps many of the practical problems with
|
|
7590 |
other approaches to mixins and multiple inheritance.
|
|
7591 |
With our model, classes are built from a set of
|
|
7592 |
traits by specifying glue code that connects them
|
|
7593 |
together and accesses the necessary state. We
|
|
7594 |
briefly discuss practical experience with an
|
|
7595 |
implementation of traits for Squeak, and we list a
|
|
7596 |
number of open questions for discussion.},
|
|
7597 |
annote = {internationalworkshop},
|
|
7598 |
author = {Nathanael Sch{\"a}rli and St\'ephane Ducasse and
|
|
7599 |
Oscar Nierstrasz},
|
|
7600 |
booktitle = {Proceedings of the International Workshop on
|
|
7601 |
Inheritance},
|
|
7602 |
keywords = {scg-pub skip-doi scg-traits jb02 snf02 stefPub
|
|
7603 |
schaerli},
|
|
7604 |
title = {Classes = Traits + States + Glue (Beyond mixins and
|
|
7605 |
multiple inheritance)},
|
|
7606 |
url = {http://scg.unibe.ch/archive/papers/Scha02aTraitsPlusGlue2002.pdf},
|
|
7607 |
year = {2002},
|
|
7608 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Scha02aTraitsPlusGlue2002.pdf}
|
|
7609 |
}
|
|
7610 |
|
|
7611 |
|
|
7612 |
|
|
7613 |
@techreport{Scha02b,
|
|
7614 |
abstract = {Inheritance is the fundamental reuse mechanism in
|
|
7615 |
object-oriented programming languages; its most
|
|
7616 |
prominent variants are single inheritance, multiple
|
|
7617 |
inheritance, and mixin inheritance. In the first
|
|
7618 |
part of this paper, we identify and illustrate the
|
|
7619 |
conceptual and practical reusability problems that
|
|
7620 |
arise with these forms of inheritance. We then
|
|
7621 |
present a simple compositional model for structuring
|
|
7622 |
object-oriented programs, which we call traits.
|
|
7623 |
Traits are essentially groups of methods that serve
|
|
7624 |
as building blocks for classes and are primitive
|
|
7625 |
units of code reuse. In this model, classes are
|
|
7626 |
composed from a set of traits by specifying glue
|
|
7627 |
code that connects the traits together and accesses
|
|
7628 |
the necessary state. We demonstrate how traits
|
|
7629 |
overcome the problems arising with the different
|
|
7630 |
variants of inheritance, we discuss how traits can
|
|
7631 |
be implemented effectively, and we summarize our
|
|
7632 |
experience applying traits to refactor an existing
|
|
7633 |
class hierarchy.},
|
|
7634 |
address = {Universit\"at Bern, Switzerland},
|
|
7635 |
annote = {report notrefereed},
|
|
7636 |
author = {Nathanael Sch\"arli and St\'ephane Ducasse and Oscar
|
|
7637 |
Nierstrasz and Andrew P. Black},
|
|
7638 |
classification = {D.1.5 Object-oriented Programming; D.3.3 Language
|
|
7639 |
Constructs and Features},
|
|
7640 |
cvs = {TraitsECOOP},
|
|
7641 |
general_terms = {Inheritance, Mixins, Multiple Inheritance, Traits,
|
|
7642 |
Reuse, Smalltalk},
|
|
7643 |
institution = {Institut f\"ur Informatik},
|
|
7644 |
keywords = {snf-redundant scg-pub skip-doi jb02 scg-traits
|
|
7645 |
stefPub schaerli},
|
|
7646 |
month = nov,
|
|
7647 |
note = {Also available as Technical Report CSE-02-014, OGI
|
|
7648 |
School of Science \& Engineering, Beaverton, Oregon,
|
|
7649 |
USA},
|
|
7650 |
number = {IAM-02-005},
|
|
7651 |
title = {Traits: Composable Units of Behavior},
|
|
7652 |
type = {Technical Report},
|
|
7653 |
url = {http://scg.unibe.ch/archive/papers/Scha02bTraits.pdf},
|
|
7654 |
year = {2002},
|
|
7655 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Scha02bTraits.pdf}
|
|
7656 |
}
|
|
7657 |
|
|
7658 |
|
|
7659 |
@techreport{Scha02c,
|
|
7660 |
abstract = {Single-inheritance in object-oriented languages can
|
|
7661 |
lead to duplicated code in rich class libraries
|
|
7662 |
where feature-sharing cannot be linearized.
|
|
7663 |
Multiple-inheritance and mixins alleviate this
|
|
7664 |
problem, but lead to other difficulties in the face
|
|
7665 |
of evolution. Changes to classes or mixins can break
|
|
7666 |
code lower in the hierarchy in unexpected ways.
|
|
7667 |
Traits solve both problems by factoring out shared
|
|
7668 |
behaviour as sets of methods that do not depend on
|
|
7669 |
state. Traits have the important property that
|
|
7670 |
composition is symmetric, so changes do not lead to
|
|
7671 |
unexpected side effects. We present a formal model
|
|
7672 |
of traits, and define some basic properties of
|
|
7673 |
traits and classes.},
|
|
7674 |
address = {Universit\"at Bern, Switzerland},
|
|
7675 |
annote = {notrefereed},
|
|
7676 |
author = {Nathanael Sch\"arli and Oscar Nierstrasz and
|
|
7677 |
St\'ephane Ducasse and Roel Wuyts and Andrew Black},
|
|
7678 |
classification = {D.3.1 Formal Definitions and Theory; D.1.5
|
|
7679 |
Object-oriented Programming; D.3.3 Language
|
|
7680 |
Constructs and Features},
|
|
7681 |
cvs = {TraitsECOOP},
|
|
7682 |
general_terms = {Inheritance, Mixins, Multiple Inheritance, Traits,
|
|
7683 |
Reuse, Smalltalk},
|
|
7684 |
institution = {Institut f\"ur Informatik},
|
|
7685 |
keywords = {snf03 scg-pub skip-doi jb02 scg-traits schaerli},
|
|
7686 |
month = nov,
|
|
7687 |
note = {Also available as Technical Report CSE-02-013, OGI
|
|
7688 |
School of Science \& Engineering, Beaverton, Oregon,
|
|
7689 |
USA},
|
|
7690 |
number = {IAM-02-006},
|
|
7691 |
title = {Traits: The Formal Model},
|
|
7692 |
type = {Technical Report},
|
|
7693 |
url = {http://scg.unibe.ch/archive/papers/Scha02cTraitsModel.pdf},
|
|
7694 |
year = {2002},
|
|
7695 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Scha02cTraitsModel.pdf}
|
|
7696 |
}
|
|
7697 |
|
|
7698 |
@inproceedings{Scha03a,
|
|
7699 |
abstract = {Despite the undisputed prominence of inheritance as
|
|
7700 |
the fundamental reuse mechanism in object-oriented
|
|
7701 |
programming languages, the main variants --- single
|
|
7702 |
inheritance, multiple inheritance, and mixin
|
|
7703 |
inheritance --- all suffer from conceptual and
|
|
7704 |
practical problems. In the first part of this paper,
|
|
7705 |
we identify and illustrate these problems. We then
|
|
7706 |
present traits, a simple compositional model for
|
|
7707 |
structuring object-oriented programs. A trait is
|
|
7708 |
essentially a group of pure methods that serves as a
|
|
7709 |
building block for classes and is a primitive unit
|
|
7710 |
of code reuse. In this model, classes are composed
|
|
7711 |
from a set of traits by specifying glue code that
|
|
7712 |
connects the traits together and accesses the
|
|
7713 |
necessary state. We demonstrate how traits overcome
|
|
7714 |
the problems arising from the different variants of
|
|
7715 |
inheritance, we discuss how traits can be
|
|
7716 |
implemented effectively, and we summarize our
|
|
7717 |
experience applying traits to refactor an existing
|
|
7718 |
class hierarchy.},
|
|
7719 |
annote = {internationalconference topconference},
|
|
7720 |
author = {Nathanael Sch\"arli and St\'ephane Ducasse and Oscar
|
|
7721 |
Nierstrasz and Andrew P. Black},
|
|
7722 |
booktitle = {Proceedings of European Conference on
|
|
7723 |
Object-Oriented Programming (ECOOP'03)},
|
|
7724 |
cvs = {TraitsECOOP2003},
|
|
7725 |
doi = {10.1007/b11832},
|
|
7726 |
isbn = {978-3-540-40531-3},
|
|
7727 |
keywords = {snf03 scg-pub jb03 scg-traits stefPub schaerli},
|
|
7728 |
misc = {acceptance rate: 18/88 = 20\%},
|
|
7729 |
accepttotal = {88},
|
|
7730 |
acceptnum = {18},
|
|
7731 |
month = jul,
|
|
7732 |
pages = {248--274},
|
|
7733 |
publisher = {Springer Verlag},
|
|
7734 |
series = {LNCS},
|
|
7735 |
title = {Traits: Composable Units of Behavior},
|
|
7736 |
url = {http://scg.unibe.ch/archive/papers/Scha03aTraits.pdf},
|
|
7737 |
volume = {2743},
|
|
7738 |
year = {2003},
|
|
7739 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Scha03aTraits.pdf},
|
|
7740 |
bdsk-url-2 = {http://dx.doi.org/10.1007/b11832}
|
|
7741 |
}
|
|
7742 |
|
|
7743 |
@inproceedings{Scha04a,
|
|
7744 |
abstract = {Given the importance of encapsulation to
|
|
7745 |
object-oriented programming, it is surprising to
|
|
7746 |
note that mainstream object-oriented languages offer
|
|
7747 |
only limited and fixed ways of encapsulating
|
|
7748 |
methods. Typically one may only address two
|
|
7749 |
categories of clients, users and heirs, and one must
|
|
7750 |
bind visibility and access rights at an early stage.
|
|
7751 |
This can lead to inflexible and fragile code as well
|
|
7752 |
as clumsy workarounds. We propose a simple and
|
|
7753 |
general solution to this problem in which
|
|
7754 |
encapsulation policies can be specified separately
|
|
7755 |
from implementations. As such they become
|
|
7756 |
first-class composable entities that can be reused
|
|
7757 |
by different classes. We present a detailed analysis
|
|
7758 |
of the problem with encapsulation and visibility
|
|
7759 |
mechanisms in mainstream OO languages, we introduce
|
|
7760 |
our approach in terms of a simple model, and we
|
|
7761 |
evaluate how our approach compares with existing
|
|
7762 |
approaches. We also assess the impact of
|
|
7763 |
incorporating encapsulation policies into Smalltalk
|
|
7764 |
and discuss some implementation issues.},
|
|
7765 |
annote = {internationalconference topconference},
|
|
7766 |
author = {Nathanael Sch\"arli and St\'ephane Ducasse and Oscar
|
|
7767 |
Nierstrasz and Roel Wuyts},
|
|
7768 |
booktitle = {Proceedings of European Conference on
|
|
7769 |
Object-Oriented Programming (ECOOP'04)},
|
|
7770 |
cvs = {EncapsulationPoliciesECOOP2004},
|
|
7771 |
doi = {10.1007/b98195},
|
|
7772 |
isbn = {978-3-540-22159-3},
|
|
7773 |
keywords = {snf04 scg-pub jb04 scg-traits stefPub schaerli},
|
|
7774 |
misc = {acceptance rate: 25/132 = 19\%},
|
|
7775 |
accepttotal = {132},
|
|
7776 |
acceptnum = {25},
|
|
7777 |
month = jun,
|
|
7778 |
pages = {26--50},
|
|
7779 |
publisher = {Springer Verlag},
|
|
7780 |
series = {LNCS},
|
|
7781 |
title = {Composable Encapsulation Policies},
|
|
7782 |
url = {http://scg.unibe.ch/archive/papers/Scha04aEncapsulationPolicies.pdf},
|
|
7783 |
volume = {3086},
|
|
7784 |
year = {2004},
|
|
7785 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Scha04aEncapsulationPolicies.pdf},
|
|
7786 |
bdsk-url-2 = {http://dx.doi.org/10.1007/b98195}
|
|
7787 |
}
|
|
7788 |
|
|
7789 |
@inproceedings{Scha04b,
|
|
7790 |
abstract = {Encapsulation in object-oriented languages has
|
|
7791 |
traditionally been based on static type systems. As
|
|
7792 |
a consequence, dynamically-typed languages have only
|
|
7793 |
limited support for encapsulation. This is
|
|
7794 |
surprising, considering that encapsulation is one of
|
|
7795 |
the most fundamental and important concepts behind
|
|
7796 |
object-oriented programming and that it is essential
|
|
7797 |
for writing programs that are maintainable and
|
|
7798 |
reliable, and that remain robust as they evolve. In
|
|
7799 |
this paper we describe the problems that are caused
|
|
7800 |
by insufficient encapsulation mechanisms and then
|
|
7801 |
present object-oriented encapsulation, a simple and
|
|
7802 |
uniform approach that solves these problems by
|
|
7803 |
bringing state of the art encapsulation features to
|
|
7804 |
dynamically typed languages. We provide a detailed
|
|
7805 |
discussion of our design rationales and compare them
|
|
7806 |
and their consequences to the encapsulation
|
|
7807 |
approaches used for statically typed languages. We
|
|
7808 |
also describe an implementation of object-oriented
|
|
7809 |
encapsulation in Smalltalk. Benchmarks show that
|
|
7810 |
extensive use of objectoriented encapsulation
|
|
7811 |
results in a slowdown of less than 15 per cent.},
|
|
7812 |
annote = {internationalconference topconference},
|
|
7813 |
author = {Nathanael Sch\"arli and Andrew P. Black and
|
|
7814 |
St\'ephane Ducasse},
|
|
7815 |
booktitle = {Proceedings of 18th International Conference on
|
|
7816 |
Object-Oriented Programming Systems, Languages and
|
|
7817 |
Applications (OOPSLA'04)},
|
|
7818 |
cvs = {OOEncapsulationOOPSLA2004},
|
|
7819 |
doi = {10.1145/1028976.1028988},
|
|
7820 |
keywords = {snf05 scg-pub jb03 scg-traits stefPub schaerli},
|
|
7821 |
misc = {acceptance rate: 27/174 = 16\%},
|
|
7822 |
accepttotal = {174},
|
|
7823 |
acceptnum = {27},
|
|
7824 |
month = oct,
|
|
7825 |
pages = {130--149},
|
|
7826 |
title = {Object-oriented Encapsulation for Dynamically Typed
|
|
7827 |
Languages},
|
|
7828 |
url = {http://scg.unibe.ch/archive/papers/Scha04bOOEncapsulation.pdf},
|
|
7829 |
year = {2004},
|
|
7830 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Scha04bOOEncapsulation.pdf},
|
|
7831 |
bdsk-url-2 = {http://dx.doi.org/10.1145/1028976.1028988}
|
|
7832 |
}
|
|
7833 |
|
|
7834 |
@inproceedings{Seeb06b,
|
|
7835 |
abstract = {To understand a certain issue of the system we want
|
|
7836 |
to ask the knowledgeable developers. Yet, in large
|
|
7837 |
systems, not every developer is knowledgeable in all
|
|
7838 |
the details of the system. Thus, we would want to
|
|
7839 |
know which developer is knowledgeable in the issue
|
|
7840 |
at hand. In this paper we present the Chronia tool
|
|
7841 |
that implements the Ownership Map visu- alization to
|
|
7842 |
understand when and how different developers
|
|
7843 |
interacted in which way and in which part of the
|
|
7844 |
system. circle reflects the size of the change, and
|
|
7845 |
the color of the line denotes the author who owns
|
|
7846 |
most of the lines of code of the file in that
|
|
7847 |
period. File A commit by the green author followed
|
|
7848 |
by the ownership file removed by the blue author
|
|
7849 |
file present from the first import},
|
|
7850 |
annote = {tooldemo},
|
|
7851 |
author = {Mauricio Seeberger and Adrian Kuhn and Tudor G\^irba
|
|
7852 |
and St\'ephane Ducasse},
|
|
7853 |
booktitle = {Proceedings of 10th European Conference on Software
|
|
7854 |
Maintenance and Reengineering (CSMR'06)},
|
|
7855 |
cvs = {ChroniaDemoCSMR2006},
|
|
7856 |
keywords = {scg-misc moose-pub stefPub recast06 jb06 fb06 girba
|
|
7857 |
chronia},
|
|
7858 |
month = mar,
|
|
7859 |
note = {Tool demo},
|
|
7860 |
pages = {345--346},
|
|
7861 |
title = {{Chronia}: Visualizing How Developers Change
|
|
7862 |
Software Systems},
|
|
7863 |
url = {http://scg.unibe.ch/archive/papers/Seeb06bChronia.pdf},
|
|
7864 |
year = {2006},
|
|
7865 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Seeb06bChronia.pdf}
|
|
7866 |
}
|
|
7867 |
|
|
7868 |
@inproceedings{Sing97a,
|
|
7869 |
author = {Singer, Janice and Lethbridge, Timothy and Vinson, Norman and Anquetil, Nicolas},
|
|
7870 |
title = {An examination of software engineering work practices},
|
|
7871 |
abstract = {This paper presents work practice data of the daily activities of software engineers. Four separate studies are presented; one looking longitudinally at an individual SE; two looking at a software engineering group; and one looking at company-wide tool usage statistics. We also discuss the advantages in considering work practices in designing tools for software engineers, and include some requirements for a tool we have developed as a result of our studies.},
|
|
7872 |
booktitle = {Proceedings of the 1997 conference of the Centre for Advanced Studies on Collaborative research},
|
|
7873 |
series = {CASCON '97},
|
|
7874 |
year = {1997},
|
|
7875 |
location = {Toronto, Ontario, Canada},
|
|
7876 |
pages = {21--},
|
|
7877 |
url = {http://nparc.cisti-icist.nrc-cnrc.gc.ca/npsi/ctrl?action=rtdoc&an=5209032},
|
|
7878 |
publisher = {IBM Press},
|
|
7879 |
aeres = {ACT},
|
|
7880 |
selectif = {oui},
|
|
7881 |
labo = {non},
|
|
7882 |
x-editorial-board = {yes},
|
|
7883 |
x-international-audience = {yes},
|
|
7884 |
x-pays = {CA}
|
|
7885 |
}
|
|
7886 |
|
|
7887 |
@inproceedings{Sous04a,
|
|
7888 |
author = {Kleiber D. de Sousa and
|
|
7889 |
Nicolas Anquetil and
|
|
7890 |
K{\'a}thia Mar\c{c}al de Oliveira},
|
|
7891 |
title = {Learning Software Maintenance Organizations},
|
|
7892 |
abstract = {Developing and maintaining software systems is a knowledge intensive task. One needs knowledge of the application domain of the software, the problem the system solves, the requirements for this problem, the architecture of the system and how the different parts fit together, how the system interacts with its environment, etc. More often than not, this knowledge is not documented and lives only in the head of the software engineers. It is, therefore, volatile and an organization may repeatedly pay professionals to rediscover a knowledge it previously acquired and lost. In recognition of this fact, knowledge management techniques such as Postmortem Analysis are being used to help salvage this knowledge. Traditionally, Postmortem Analysis has been applied at the end of software development projects with a focus on organizational aspects such as how to improve the execution of a process. In this paper, we present the application of Postmortem Analysis in a new context: for software maintenance projects. We also apply it, not only for process improvement, but to discover knowledge on the software maintained itself.},
|
|
7893 |
booktitle = {Advances in Learning Software Organizations, 6th International
|
|
7894 |
Workshop, LSO 2004},
|
|
7895 |
year = {2004},
|
|
7896 |
pages = {67-77},
|
|
7897 |
publisher = {Springer},
|
|
7898 |
series = {Lecture Notes in Computer Science},
|
|
7899 |
volume = {3096},
|
|
7900 |
isbn = {3-540-22192-1},
|
|
7901 |
annote = {internationalworkshop},
|
|
7902 |
aeres = {ACT},
|
|
7903 |
selectif = {oui},
|
|
7904 |
labo = {hors},
|
|
7905 |
x-editorial-board = {yes},
|
|
7906 |
x-international-audience = {yes},
|
|
7907 |
x-pays = {BR}
|
|
7908 |
}
|
|
7909 |
|
|
7910 |
@inproceedings{Souz05a,
|
|
7911 |
author = {de Souza, Sergio Cozzetti B. and Anquetil, Nicolas and de Oliveira, K\'{a}thia M.},
|
|
7912 |
title = {A study of the documentation essential to software maintenance},
|
|
7913 |
abstract = {Software engineering has been striving for years to improve the practice of software development and maintenance. Documentation has long been prominent on the list of recommended practices to improve development and help maintenance. Recently however, agile methods started to shake this view, arguing that the goal of the game is to produce software and that documentation is only useful as long as it helps to reach this goal.On the other hand, in the re-engineering field, people wish they could re-document useful legacy software so that they may continue maintain them or migrate them to new platform.In these two case, a crucial question arises: "How much documentation is enough?" In this article, we present the results of a survey of software maintainers to try to establish what documentation artifacts are the most useful to them.},
|
|
7914 |
booktitle = {Proceedings of the 23rd annual international conference on Design of communication: documenting \& designing for pervasive information},
|
|
7915 |
series = {SIGDOC '05},
|
|
7916 |
year = {2005},
|
|
7917 |
isbn = {1-59593-175-9},
|
|
7918 |
location = {Coventry, United Kingdom},
|
|
7919 |
pages = {68--75},
|
|
7920 |
doi = {10.1145/1085313.1085331},
|
|
7921 |
publisher = {ACM},
|
|
7922 |
address = {New York, NY, USA},
|
|
7923 |
keywords = {empirical study, program understanding, software maintenance, software system documentation},
|
|
7924 |
annote = {internationalconference},
|
|
7925 |
aeres = {ACT},
|
|
7926 |
selectif = {oui},
|
|
7927 |
labo = {non},
|
|
7928 |
x-editorial-board = {yes},
|
|
7929 |
x-international-audience = {yes},
|
|
7930 |
x-pays = {BR}
|
|
7931 |
}
|
|
7932 |
|
|
7933 |
@article{Souz06a,
|
|
7934 |
author = {Souza, Sergio Cozzetti B. de and Anquetil, Nicolas and Oliveira, K\'{a}thia M. de},
|
|
7935 |
title = {Which documentation for software maintenance?},
|
|
7936 |
abstract = {Software engineering has been striving for years to improve the practice of software development and maintenance. Documentation has long been prominent on the list of recommended practices to improve development and help maintenance. Recently however, agile methods started to shake this view, arguing that the goal of the game is to produce software and that documentation is only useful as long as it helps to reach this goal. On the other hand, in the re-engineering field, people wish they could re-document useful legacy software so that they may continue maintain them or migrate them to new platform. In these two case, a crucial question arises: "How much documentation is enough?" In this article, we present the results of a survey of software maintainers to try to establish what documentation artifacts are the most useful to
|
|
7937 |
them.},
|
|
7938 |
journal = {Journal of the Brazilian Computer Society},
|
|
7939 |
issn = {0104-6500},
|
|
7940 |
year = {2006},
|
|
7941 |
pages = {31--44},
|
|
7942 |
url = {http://www.scielo.br/pdf/jbcos/v12n3/04.pdf},
|
|
7943 |
annote = {nationaljournal},
|
|
7944 |
aeres = {ACLN},
|
|
7945 |
impactfactor = {},
|
|
7946 |
labo = {hors},
|
|
7947 |
inria = {hors},
|
|
7948 |
selectif = {oui},
|
|
7949 |
x-editorial-board = {yes},
|
|
7950 |
x-proceedings = {no},
|
|
7951 |
x-international-audience = {yes},
|
|
7952 |
x-language = {EN}
|
|
7953 |
}
|
|
7954 |
|
|
7955 |
@misc{Stin05a,
|
|
7956 |
aeres = {OV},
|
|
7957 |
annote = {vulgarisation},
|
|
7958 |
author = {Serge Stinckwich and St\'ephane Ducasse},
|
|
7959 |
inria = {hors},
|
|
7960 |
journal = {Linux Pratique},
|
|
7961 |
keywords = {stefPub jb05},
|
|
7962 |
month = nov,
|
|
7963 |
number = 32,
|
|
7964 |
pages = {18--23},
|
|
7965 |
selectif = {non},
|
|
7966 |
title = {La syntaxe Smalltalk},
|
|
7967 |
volume = 1,
|
|
7968 |
year = {2005}
|
|
7969 |
}
|
|
7970 |
|
|
7971 |
@misc{Stin06a,
|
|
7972 |
aeres = {OV},
|
|
7973 |
annote = {vulgarisation},
|
|
7974 |
author = {Serge Stinckwich and St\'ephane Ducasse},
|
|
7975 |
inria = {hors},
|
|
7976 |
journal = {Linux Pratique},
|
|
7977 |
keywords = {stefPub jb05},
|
|
7978 |
month = jan,
|
|
7979 |
number = 33,
|
|
7980 |
pages = {18--23},
|
|
7981 |
selectif = {non},
|
|
7982 |
title = {Les structures de contr\^ole en Smalltalk},
|
|
7983 |
volume = 1,
|
|
7984 |
year = {2006}
|
|
7985 |
}
|
|
7986 |
|
|
7987 |
@misc{Stin06b,
|
|
7988 |
aeres = {OV},
|
|
7989 |
annote = {vulgarisation},
|
|
7990 |
author = {Serge Stinckwich and Hilaire Fernandes},
|
|
7991 |
inria = {hors},
|
|
7992 |
journal = {Linux Magazine},
|
|
7993 |
month = jun,
|
|
7994 |
number = 84,
|
|
7995 |
pages = {18--23},
|
|
7996 |
selectif = {non},
|
|
7997 |
title = {Nos premi\`eres classes en Smalltalk},
|
|
7998 |
volume = 1,
|
|
7999 |
year = {2006}
|
|
8000 |
}
|
|
8001 |
|
|
8002 |
@inproceedings{Suen07a,
|
|
8003 |
annote = {internationalworkshop stefPub},
|
|
8004 |
author = {Mathieu Suen and St\'ephane Ducasse and Damien
|
|
8005 |
Pollet and Hani Abdeen and Ilham Alloui},
|
|
8006 |
booktitle = {FAMOOSr, 1st Workshop on FAMIX and Moose in
|
|
8007 |
Reengineering},
|
|
8008 |
keywords = {moose-pub},
|
|
8009 |
title = {Package Surface Blueprint: A Software Map},
|
|
8010 |
year = {2007}
|
|
8011 |
}
|
|
8012 |
|
|
8013 |
@inproceedings{Suny01a,
|
|
8014 |
address = {Toronto, Canada},
|
|
8015 |
annote = {internationalconference},
|
|
8016 |
author = {Suny\'e, Gerson and Pollet, Damien and Le~Traon, Yves and J\'ez\'equel, Jean-Marc},
|
|
8017 |
booktitle = {UML~2001 --- The Unified Modeling Language --- Modeling Languages, Concepts, and Tools},
|
|
8018 |
editor = {Gogolla, Martin and Kobryn, Cris},
|
|
8019 |
isbn = {3-540-42667-1},
|
|
8020 |
month = oct,
|
|
8021 |
pages = {134--148},
|
|
8022 |
publisher = {Springer Verlag},
|
|
8023 |
series = {LNCS},
|
|
8024 |
title = {Refactoring UML Models},
|
|
8025 |
url = {http://www.irisa.fr/triskell/publis/2001/Sunye01b.pdf},
|
|
8026 |
volume = {2185},
|
|
8027 |
year = {2001},
|
|
8028 |
bdsk-url-1 = {http://www.irisa.fr/triskell/publis/2001/Sunye01b.pdf}
|
|
8029 |
}
|
|
8030 |
|
|
8031 |
@techreport{Tant05a,
|
|
8032 |
aeres = {ACT},
|
|
8033 |
author = {{\'E}ric Tanter and Kris Gybels and Marcus Denker and Alexandre Bergel},
|
|
8034 |
inria = {hors},
|
|
8035 |
keywords = {fromscgbib marcusdenker},
|
|
8036 |
institution = {University of Chile},
|
|
8037 |
note = {published to Software Composition (SC'06)},
|
|
8038 |
number = {TR/DCC-2005-12},
|
|
8039 |
selectif = {non},
|
|
8040 |
title = {Context-aware aspects},
|
|
8041 |
year = {2005}
|
|
8042 |
}
|
|
8043 |
|
|
8044 |
@inproceedings{Tant06a,
|
|
8045 |
abstract = {Context-aware applications behave differently
|
|
8046 |
depending on the context in which they are running.
|
|
8047 |
Since context-specific behavior tends to crosscut
|
|
8048 |
base programs, it can advantageously be implemented
|
|
8049 |
as aspects. This leads to the notion of
|
|
8050 |
context-aware aspects, e.g., aspects whose behavior
|
|
8051 |
depends on context. This paper analyzes the issue of
|
|
8052 |
appropriate support from the aspect language to both
|
|
8053 |
restrict the scope of aspects according to the
|
|
8054 |
context and allow aspect definitions to access
|
|
8055 |
information associated to the context. We propose an
|
|
8056 |
open framework for context-aware aspects that allows
|
|
8057 |
for the definition of first-class contexts and
|
|
8058 |
supports the definition of context awareness
|
|
8059 |
constructs for aspects, including the ability to
|
|
8060 |
refer to past contexts, and to provide domain- and
|
|
8061 |
application-specific constructs.},
|
|
8062 |
address = {Vienna, Austria},
|
|
8063 |
aeres = {ACT},
|
|
8064 |
annote = {internationalconference},
|
|
8065 |
author = {{\'E}ric Tanter and Kris Gybels and Marcus Denker and Alexandre Bergel},
|
|
8066 |
booktitle = {Proceedings of the 5th International Symposium on Software Composition (SC 2006)},
|
|
8067 |
doi = {10.1007/11821946_15},
|
|
8068 |
inria = {hors},
|
|
8069 |
isbn = {978-3-540-37657-6},
|
|
8070 |
keywords = {scg-pub jb06 fb06 snf06 fromscgbib marcusdenker},
|
|
8071 |
medium = {2},
|
|
8072 |
month = mar,
|
|
8073 |
pages = {227--242},
|
|
8074 |
peerreview = {yes},
|
|
8075 |
selectif = {non},
|
|
8076 |
series = {LNCS},
|
|
8077 |
title = {Context-Aware Aspects},
|
|
8078 |
url = {http://rmod.lille.inria.fr/archives/papers/Tant06a-SC06-ContextAspects.pdf},
|
|
8079 |
volume = {4089},
|
|
8080 |
year = {2006}
|
|
8081 |
}
|
|
8082 |
|
|
8083 |
|
|
8084 |
|
|
8085 |
@inproceedings{Tich00b,
|
|
8086 |
abstract = {Refactoring --- transforming code while preserving
|
|
8087 |
behaviour --- is currently considered a key approach
|
|
8088 |
for improving object-oriented software systems.
|
|
8089 |
Unfortunately, all of the current refactoring tools
|
|
8090 |
depend on language-dependent refactoring engines,
|
|
8091 |
which prevents a smooth integration with mainstream
|
|
8092 |
development environments. In this paper we
|
|
8093 |
investigate the similarities between refactorings
|
|
8094 |
for Smalltalk and {Java}, derive a
|
|
8095 |
language-independent meta-model and show that it is
|
|
8096 |
feasible to build a language-independent refactoring
|
|
8097 |
engine on top of this meta-model. Our feasibility
|
|
8098 |
study is validated by means of a tool prototype
|
|
8099 |
which uses the same engine to refactor both
|
|
8100 |
Smalltalk and {Java} code. Using our approach we
|
|
8101 |
minimize the language-dependent part of refactoring
|
|
8102 |
tools, providing a standard way for programmers and
|
|
8103 |
tools to perform refactorings no matter what
|
|
8104 |
language they work in.},
|
|
8105 |
annote = {internationalconference},
|
|
8106 |
author = {Sander Tichelaar and St\'ephane Ducasse and Serge Demeyer and Oscar Nierstrasz},
|
|
8107 |
booktitle = {Proceedings of International Symposium on Principles of Software Evolution (ISPSE '00)},
|
|
8108 |
doi = {10.1109/ISPSE.2000.913233},
|
|
8109 |
keywords = {reengineering refactoring FAMIX repositories
|
|
8110 |
mooseCincom tich-papref scg-pub jb00 snf01 stePub
|
|
8111 |
moose-pub},
|
|
8112 |
misc = {acceptance rate: 22/51 = 43\%},
|
|
8113 |
accepttotal = {51},
|
|
8114 |
acceptnum = {22},
|
|
8115 |
pages = {157--167},
|
|
8116 |
publisher = {IEEE Computer Society Press},
|
|
8117 |
title = {A Meta-model for Language-Independent Refactoring},
|
|
8118 |
url = {http://scg.unibe.ch/archive/papers/Tich00bRefactoringMetamodel.pdf},
|
|
8119 |
year = {2000},
|
|
8120 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Tich00bRefactoringMetamodel.pdf},
|
|
8121 |
bdsk-url-2 = {http://dx.doi.org/10.1109/ISPSE.2000.913233}
|
|
8122 |
}
|
|
8123 |
|
|
8124 |
@inproceedings{Tich00m,
|
|
8125 |
abstract = {In the FAMOOS project we have developed a set of
|
|
8126 |
tools for reengineering object-oriented legacy
|
|
8127 |
systems. These tools are based on the FAMIX meta
|
|
8128 |
model and exchange information using CDIF, an
|
|
8129 |
industry standard exchange format. For several
|
|
8130 |
reasons XMI, an emerging standard for information
|
|
8131 |
exchange, has appealed to us to be used as our
|
|
8132 |
interchange format. In this paper we discuss why XMI
|
|
8133 |
is interesting for us and what, to our current
|
|
8134 |
experience, are the advantages and disadvantages of
|
|
8135 |
XMI over CDIF.},
|
|
8136 |
annote = {internationalworkshop},
|
|
8137 |
author = {Sander Tichelaar and St\'ephane Ducasse and Serge Demeyer},
|
|
8138 |
booktitle = {Proceedings of the ICSE 2000 Workshop on Standard Exchange Format (WoSEF 2000)},
|
|
8139 |
keywords = {components scg-pub skip-doi snf00 jb00 stefPub moose-pub},
|
|
8140 |
month = jun,
|
|
8141 |
title = {{FAMIX}: Exchange Experiences with {CDIF} and {XMI}},
|
|
8142 |
url = {http://scg.unibe.ch/archive/papers/Tich00mFamixCdifXmi.pdf},
|
|
8143 |
year = {2000},
|
|
8144 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Tich00mFamixCdifXmi.pdf}
|
|
8145 |
}
|
|
8146 |
|
|
8147 |
@inproceedings{Tich00n,
|
|
8148 |
abstract = {Recently exchange formats have gained lots of
|
|
8149 |
attention. Multiple tools need to interact and/or
|
|
8150 |
work on the same software system. Especially there
|
|
8151 |
is a need to reuse parser technology. Within the
|
|
8152 |
FAMOOS project we have developed a model for
|
|
8153 |
representing object-oriented software systems at the
|
|
8154 |
program entity level. The model has been designed
|
|
8155 |
for language independence, extensibility and
|
|
8156 |
information exchange. For the actual exchange of
|
|
8157 |
data we are currently moving to use XMI, a standard
|
|
8158 |
for model-based information exchange.},
|
|
8159 |
address = {Los Alamitos CA},
|
|
8160 |
annote = {internationalworkshop},
|
|
8161 |
author = {Sander Tichelaar and St\'ephane Ducasse and Serge
|
|
8162 |
Demeyer},
|
|
8163 |
booktitle = {Proceedings WCRE 2000 Workshop on Exchange Formats},
|
|
8164 |
doi = {10.1109/WCRE.2000.891485},
|
|
8165 |
keywords = {components scg-pub tich-papunr sergedem-papunr snf00
|
|
8166 |
jb00 stefPub moose-pub},
|
|
8167 |
month = nov,
|
|
8168 |
pages = {296--296},
|
|
8169 |
publisher = {IEEE Computer Society Press},
|
|
8170 |
title = {{FAMIX} and {XMI}},
|
|
8171 |
url = {http://scg.unibe.ch/archive/papers/Tich00nFamixWCRE2000.pdf},
|
|
8172 |
year = {2000},
|
|
8173 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Tich00nFamixWCRE2000.pdf},
|
|
8174 |
bdsk-url-2 = {http://dx.doi.org/10.1109/WCRE.2000.891485}
|
|
8175 |
}
|
|
8176 |
|
|
8177 |
@techreport{Tich01y,
|
|
8178 |
annote = {report notrefereed},
|
|
8179 |
author = {Sander Tichelaar and St\'ephane Ducasse},
|
|
8180 |
institution = {Institute of Computer Science and Applied Mathematics},
|
|
8181 |
note = {University of Bern, IAM-TR-09-01},
|
|
8182 |
title = {Pull Up/Push Down Method: an Analysis},
|
|
8183 |
year = {2001}
|
|
8184 |
}
|
|
8185 |
|
|
8186 |
@inproceedings{Tich97b,
|
|
8187 |
abstract = {In this workshop proposal we present a prototype
|
|
8188 |
approach to help the extraction of architectural
|
|
8189 |
information in the re-engineering process. Commonly,
|
|
8190 |
the re-engineering life-cycle has been defined as a
|
|
8191 |
succession of the following tasks: analysis of
|
|
8192 |
requirements, model capture (understanding the
|
|
8193 |
system), problem detection, problem analysis,
|
|
8194 |
reorganization and change propagation. We have
|
|
8195 |
evaluated the benefit of a prototyping approach with
|
|
8196 |
a focus on model capture. Although prototyping is a
|
|
8197 |
known approach to evaluate the application
|
|
8198 |
feasibility, costs, comparison and validation of
|
|
8199 |
choices, we focus in this paper on the aspects of
|
|
8200 |
prototyping that are helpful for re-engineering.},
|
|
8201 |
annote = {internationalworkshop},
|
|
8202 |
author = {Sander Tichelaar and St\'ephane Ducasse and Theo-Dirk Meijler},
|
|
8203 |
booktitle = {Proceedings of the ESEC/FSE Workshop on Object-Oriented Re-engineering},
|
|
8204 |
editor = {Serge Demeyer and Harald Gall},
|
|
8205 |
keywords = {olit famoos-papunr tich-papunr scglit oobib scg-pub
|
|
8206 |
skip-doi snf97 jb97 stePub},
|
|
8207 |
month = sep,
|
|
8208 |
note = {Technical Report TUV-1841-97-10},
|
|
8209 |
publisher = {Technical University of Vienna, Information Systems
|
|
8210 |
Institute, Distributed Systems Group},
|
|
8211 |
title = {Architectural Extraction In Reverse Engineering by
|
|
8212 |
Prototyping: An experiment},
|
|
8213 |
url = {http://scg.unibe.ch/archive/papers/Tich97bArchExtraction.pdf},
|
|
8214 |
year = {1997},
|
|
8215 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Tich97bArchExtraction.pdf}
|
|
8216 |
}
|
|
8217 |
|
|
8218 |
@inproceedings{Uqui09b,
|
|
8219 |
address = {New York, NY, USA},
|
|
8220 |
author = {Uquillas G\'{o}mez, Ver\'{o}nica and Kellens, Andy and Brichau, Johan and D'Hondt, Theo},
|
|
8221 |
booktitle = {IWPSE-Evol '09: Proceedings of the joint international and annual ERCIM workshops on Principles of software evolution (IWPSE) and software evolution (Evol) workshops},
|
|
8222 |
doi = {10.1145/1595808.1595825},
|
|
8223 |
isbn = {978-1-60558-678-6},
|
|
8224 |
location = {Amsterdam, The Netherlands},
|
|
8225 |
pages = {79--88},
|
|
8226 |
publisher = {ACM},
|
|
8227 |
title = {Time warp, an approach for reasoning over system histories},
|
|
8228 |
year = {2009}
|
|
8229 |
}
|
|
8230 |
|
|
8231 |
@inproceedings{Uqui10a,
|
|
8232 |
title = {Visually Supporting Source Code Changes Integration: the Torch Dashboard},
|
|
8233 |
author = {Uquillas G\'omez, Ver\'onica and St\'ephane Ducasse and Theo D'Hondt},
|
|
8234 |
booktitle = {Working Conference on Reverse Engineering (WCRE 2010)},
|
|
8235 |
year = {2010},
|
|
8236 |
annote = {internationalconference},
|
|
8237 |
keywords = {lse-pub},
|
|
8238 |
month = oct,
|
|
8239 |
inria = {RMOD},
|
|
8240 |
labo = {dans},
|
|
8241 |
inriareport = {2010},
|
|
8242 |
x-editorial-board = {yes},
|
|
8243 |
x-proceedings = {yes},
|
|
8244 |
x-international-audience = {yes},
|
|
8245 |
x-country = {BE},
|
|
8246 |
x-language = {EN},
|
|
8247 |
url = {http://rmod.lille.inria.fr/archives/papers/Uqui10a-Torch-WCRE10.pdf},
|
|
8248 |
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.},
|
|
8249 |
hal-id = {inria-00531508}
|
|
8250 |
}
|
|
8251 |
|
|
8252 |
@inproceedings{Webs05a,
|
|
8253 |
author = {Webster, Kenia P. Batista and de Oliveira, Kathia M. and Anquetil, Nicolas},
|
|
8254 |
title = {A Risk Taxonomy Proposal for Software Maintenance},
|
|
8255 |
abstract = {There can be no doubt that risk management is an important activity in the software engineering area. One proof of this is the large body of work existing in this area. However, when one takes a closer look at it, one perceives that almost all this work is concerned with risk management for software development projects. The literature on risk management for software maintenance is much scarcer. On the other hand, software maintenance projects do present specificities that imply they offer different risks than development. This suggests that maintenance projects could greatly benefit from better risk management tools. One step in this direction would be to help identifying potential risk factors at the beginning of a maintenance project. For this, we propose a taxonomy of possible risks for software management projects. The ontology was created from: i) an extensive survey of risk management literature, to list known risk factors for software development; and, ii) an extensive survey of maintenance literature, to list known problems that may occur during maintenance.},
|
|
8256 |
booktitle = {Proceedings of the 21st IEEE International Conference on Software Maintenance},
|
|
8257 |
year = {2005},
|
|
8258 |
isbn = {0-7695-2368-4},
|
|
8259 |
pages = {453--461},
|
|
8260 |
doi = {10.1109/ICSM.2005.14},
|
|
8261 |
publisher = {IEEE Computer Society},
|
|
8262 |
address = {Washington, DC, USA},
|
|
8263 |
annote = {internationalconference},
|
|
8264 |
aeres = {ACT},
|
|
8265 |
selectif = {oui},
|
|
8266 |
labo = {non},
|
|
8267 |
x-editorial-board = {yes},
|
|
8268 |
x-international-audience = {yes},
|
|
8269 |
x-pays = {BR}
|
|
8270 |
}
|
|
8271 |
|
|
8272 |
@inproceedings{Weih05a,
|
|
8273 |
abstract = {We introduce Higher Order Messaging, a higher order
|
|
8274 |
programming mechanism for dynamic object-oriented
|
|
8275 |
languages. Higher Order Messages allow user-defined
|
|
8276 |
message dispatch mechanism to be expressed using an
|
|
8277 |
optimally compact syntax that is a natural extension
|
|
8278 |
of plain messaging and also have a simple conceptual
|
|
8279 |
model. They can be implemented without extending the
|
|
8280 |
base language and operate through language bridges.},
|
|
8281 |
aeres = {ACT},
|
|
8282 |
aeresstatus = {aeres08},
|
|
8283 |
annote = {internationalconference},
|
|
8284 |
author = {Marcel Weiher and St\'ephane Ducasse},
|
|
8285 |
booktitle = {Proceedings of International Symposium on Dynamic Languages (SDL'05)},
|
|
8286 |
inria = {hors},
|
|
8287 |
keywords = {stefPub jb06 listic},
|
|
8288 |
pages = {23--34},
|
|
8289 |
publisher = {ACM Press},
|
|
8290 |
selectif = {non},
|
|
8291 |
title = {High-Order Messaging},
|
|
8292 |
url = {http://scg.unibe.ch/archive/papers/Weih05aHigherOrderMessagingOOPSLA2005.pdf},
|
|
8293 |
year = {2005},
|
|
8294 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Weih05aHigherOrderMessagingOOPSLA2005.pdf}
|
|
8295 |
}
|
|
8296 |
|
|
8297 |
@inproceedings{Wint02a,
|
|
8298 |
abstract = {This paper presents a domain specific composition
|
|
8299 |
language called CoCo. The CoCo language has been
|
|
8300 |
developed in the context of the PECOS project which
|
|
8301 |
aims at enabling component-based technology for a
|
|
8302 |
certain class of embedded systems called "field
|
|
8303 |
devices".},
|
|
8304 |
annote = {internationalworkshop},
|
|
8305 |
author = {Michael Winter and Thomas Gen{\ss}ler and Alexander
|
|
8306 |
Christoph and Oscar Nierstrasz and St\'ephane
|
|
8307 |
Ducasse and Roel Wuyts and Gabriela Ar{\'e}valo and
|
|
8308 |
Peter M\"uller and Christian Stich and Bastiaan
|
|
8309 |
Sch\"onhage},
|
|
8310 |
booktitle = {Proc. Second International Workshop on Composition
|
|
8311 |
Languages},
|
|
8312 |
keywords = {olit skip-doi scg-pub jb-skip pecos stefPub arevalo},
|
|
8313 |
note = {In conjunction with 16th European Conference on
|
|
8314 |
Object-Oriented Programming (ECOOP) Malaga, Spain,
|
|
8315 |
June 11, 2002},
|
|
8316 |
title = {Components for Embedded Software --- The PECOS
|
|
8317 |
Approach},
|
|
8318 |
url = {http://scg.unibe.ch/archive/pecos/public_documents/Wint02a.pdf},
|
|
8319 |
year = {2002},
|
|
8320 |
bdsk-url-1 = {http://scg.unibe.ch/archive/pecos/public_documents/Wint02a.pdf}
|
|
8321 |
}
|
|
8322 |
|
|
8323 |
@inproceedings{Wuyt01a,
|
|
8324 |
abstract = {Meta-programming is the act of using one system or
|
|
8325 |
language to reason about another one. Reflection
|
|
8326 |
describes systems that have access to and change a
|
|
8327 |
causally connected representation of themselves,
|
|
8328 |
hence leading to self-extensible systems . Up to
|
|
8329 |
now, most of the reflective languages have been
|
|
8330 |
implemented in the same paradigm. In this paper, we
|
|
8331 |
propose \emph{symbiotic reflection} as a way to
|
|
8332 |
integrate a meta programming language with the
|
|
8333 |
object-oriented language it reasons about and is
|
|
8334 |
implemented in. New to this approach is that any
|
|
8335 |
element of the implementation language can be
|
|
8336 |
reasoned about and acted upon (not only the self
|
|
8337 |
representation), and that both languages are of
|
|
8338 |
different paradigms. Moreover, every language
|
|
8339 |
implementer that is faced with the problem of
|
|
8340 |
allowing the base language to access the underlying
|
|
8341 |
meta-language has to solve the problem of enabling
|
|
8342 |
entity transfer between both worlds. We propose a
|
|
8343 |
uniform schema, called upping/downing, to this
|
|
8344 |
problem that avoid explicit wrapping or
|
|
8345 |
typechecking. We illustrate this with SOUL (the
|
|
8346 |
Smalltalk Open Unification Language), a logic
|
|
8347 |
programming language in symbiotic reflection with
|
|
8348 |
the object-oriented language Smalltalk. We show how
|
|
8349 |
SOUL does logic reasoning directly on Smalltalk
|
|
8350 |
objects, and how to use this to implement type
|
|
8351 |
snooping},
|
|
8352 |
annote = {internationalworkshop},
|
|
8353 |
author = {Roel Wuyts and St\'ephane Ducasse},
|
|
8354 |
booktitle = {ECOOP 2001 International Workshop on MultiParadigm
|
|
8355 |
Programming with Object-Oriented Languages},
|
|
8356 |
keywords = {scg-pub skip-doi snf01 snf02 jb01 component Pecos
|
|
8357 |
stefPub},
|
|
8358 |
title = {Symbiotic Reflection between an Object-Oriented and
|
|
8359 |
a Logic Programming Language},
|
|
8360 |
url = {http://scg.unibe.ch/archive/papers/Wuyt01a.pdf},
|
|
8361 |
year = {2001},
|
|
8362 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Wuyt01a.pdf}
|
|
8363 |
}
|
|
8364 |
|
|
8365 |
@inproceedings{Wuyt01c,
|
|
8366 |
abstract = {Supporting reuse of existing pieces of code is one
|
|
8367 |
of the main goals of software engineering. In the
|
|
8368 |
name of reuse, module-based programming languages
|
|
8369 |
came to be, only to be surpassed by object-oriented
|
|
8370 |
technology. With the same motivation component-based
|
|
8371 |
solutions are overtaking object-oriented solutions.
|
|
8372 |
However, the delegation-only focus of
|
|
8373 |
component-based programming risks of resulting in
|
|
8374 |
the same problems that modular-based approaches ran
|
|
8375 |
into. To counter this, we claim that one of th e
|
|
8376 |
important problems that should be addressed by
|
|
8377 |
component languages is the composition of
|
|
8378 |
components. More specifically, we see component
|
|
8379 |
languages where components are black-box
|
|
8380 |
abstractions, and with (one or more) composition
|
|
8381 |
languages to glue them tog ether. As an example we
|
|
8382 |
show a functional (Piccola) and a logic (QSoul)
|
|
8383 |
composition approach.},
|
|
8384 |
annote = {internationalworkshop},
|
|
8385 |
author = {Roel Wuyts and St\'ephane Ducasse},
|
|
8386 |
booktitle = {First OOPSLA Workshop on Language Mechanisms for
|
|
8387 |
Programming Software Components},
|
|
8388 |
keywords = {scg-pub skip-doi snf01 jb01 component piccola Pecos
|
|
8389 |
stefPub},
|
|
8390 |
title = {Composition Languages for Black-Box Components},
|
|
8391 |
url = {http://scg.unibe.ch/archive/papers/Wuyt01c.pdf},
|
|
8392 |
year = {2001},
|
|
8393 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Wuyt01c.pdf}
|
|
8394 |
}
|
|
8395 |
|
|
8396 |
@inproceedings{Wuyt01d,
|
|
8397 |
abstract = {This position paper presents some preliminary work
|
|
8398 |
we made for applying declaractive component oriented
|
|
8399 |
design in the context of embedded devices. We
|
|
8400 |
quickly describes COMES the model we develop and
|
|
8401 |
present how logic rules can be used to describe
|
|
8402 |
architectures.},
|
|
8403 |
annote = {internationalworkshop},
|
|
8404 |
author = {Roel Wuyts and St\'ephane Ducasse and Gabriela
|
|
8405 |
Ar{\'e}valo},
|
|
8406 |
booktitle = {Ecoop 6th International Workshop on
|
|
8407 |
Component-Oriented Programming},
|
|
8408 |
keywords = {scg-pub skip-doi snf01 jb01 component Pecos stefPub
|
|
8409 |
arevalo},
|
|
8410 |
title = {Applying Experiences with Declarative Codifications
|
|
8411 |
of Software Architectures on COD},
|
|
8412 |
url = {http://scg.unibe.ch/archive/papers/Wuyt01d.pdf},
|
|
8413 |
year = {2001},
|
|
8414 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Wuyt01d.pdf}
|
|
8415 |
}
|
|
8416 |
|
|
8417 |
@inproceedings{Wuyt01e,
|
|
8418 |
abstract = {In this paper we describe an interesting context to
|
|
8419 |
study formal methods for component systems: embedded
|
|
8420 |
devices. The context of embedded devices is highly
|
|
8421 |
constrained by the physical requirements the devices
|
|
8422 |
have to adhere to. As a result, component models for
|
|
8423 |
embedded devices are not general purpose but geared
|
|
8424 |
towards these constrained contexts. In this paper we
|
|
8425 |
give the concrete setting of the Pecos project (a
|
|
8426 |
project with as goal component engineering for
|
|
8427 |
embedded devices). We describe the Pecos component
|
|
8428 |
model, and show possibilities where we think formal
|
|
8429 |
verification could be useful. We would like to use
|
|
8430 |
this as a very concrete example to discuss formal
|
|
8431 |
verification techniques.},
|
|
8432 |
annote = {internationalworkshop},
|
|
8433 |
author = {Roel Wuyts and St\'ephane Ducasse},
|
|
8434 |
booktitle = {International Workshop on Specification and
|
|
8435 |
Verification of Component-Based Systems},
|
|
8436 |
keywords = {scg-pub skip-doi snf01 jb01 component Pecos stefPub},
|
|
8437 |
title = {Non-Functional Requirements in a Component Model for
|
|
8438 |
Embedded Systems},
|
|
8439 |
url = {http://scg.unibe.ch/archive/papers/Wuyt01e.pdf},
|
|
8440 |
year = {2001},
|
|
8441 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Wuyt01e.pdf}
|
|
8442 |
}
|
|
8443 |
|
|
8444 |
@article{Wuyt04a,
|
|
8445 |
abstract = {The increasing complexity of software development
|
|
8446 |
spawns lots of specialised tools to edit code,
|
|
8447 |
employ UML schemes, integrate documentation, and so
|
|
8448 |
on. The problem is that the tool builders themselves
|
|
8449 |
are responsible for making their tools interoperable
|
|
8450 |
with other tools or development environments.
|
|
8451 |
Because they cannot anticipate all other tools they
|
|
8452 |
can integrate with, a lot of tools cannot
|
|
8453 |
co-operate. This paper introduces the classication
|
|
8454 |
model, a lightweight integration medium that enables
|
|
8455 |
unrelated tools that were not meant to be integrated
|
|
8456 |
to cooperate easily. Moreover, the tool integration
|
|
8457 |
is done by a tool integrator, and not by the tool
|
|
8458 |
builder. To validate this claim, we show how to
|
|
8459 |
integrate several third-party tools using the
|
|
8460 |
classication model, and how it forms the foundation
|
|
8461 |
for the StarBrowser, a Smalltalk browser integrating
|
|
8462 |
different tools.},
|
|
8463 |
annote = {internationaljournal},
|
|
8464 |
author = {Roel Wuyts and St\'ephane Ducasse},
|
|
8465 |
doi = {10.1016/j.cl.2003.08.003},
|
|
8466 |
journal = {Journal of Computer Languages, Systems and Structures},
|
|
8467 |
keywords = {recast04 scg-pub jb04 decomp-pub},
|
|
8468 |
impactfactor = {5 Year ISI impact factor 0.698 (2010)},
|
|
8469 |
misc = {5 Year ISI impact factor 0.698 (2010)},
|
|
8470 |
number = {1-2},
|
|
8471 |
pages = {63--77},
|
|
8472 |
publisher = {Elsevier},
|
|
8473 |
title = {Unanticipated Integration of Development Tools using the Classification Model},
|
|
8474 |
url = {http://scg.unibe.ch/archive/papers/Wuyt04aClassifications.pdf},
|
|
8475 |
volume = {30},
|
|
8476 |
year = {2004},
|
|
8477 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Wuyt04aClassifications.pdf},
|
|
8478 |
bdsk-url-2 = {http://dx.doi.org/10.1016/j.cl.2003.08.003}
|
|
8479 |
}
|
|
8480 |
|
|
8481 |
@inproceedings{Wuyt04x,
|
|
8482 |
abstract = {This paper reports on the results of the Fifth
|
|
8483 |
International Workshop on Object-Oriented
|
|
8484 |
Reengineering in Oslo on June 15, 2004. It
|
|
8485 |
enumerates the presentations made, classifies the
|
|
8486 |
contributions and lists the main results of the
|
|
8487 |
discussions held at the workshop. As such it
|
|
8488 |
provides the context for future workshops around
|
|
8489 |
this topic.},
|
|
8490 |
annote = {workshopproceedings},
|
|
8491 |
author = {Roel Wuyts and Serge Demeyer and St\'ephane Ducasse
|
|
8492 |
and Kim Mens},
|
|
8493 |
booktitle = {Object-Oriented Technology. ECOOP'04 Workshop
|
|
8494 |
Reader},
|
|
8495 |
doi = {10.1007/b104146},
|
|
8496 |
isbn = {978-3-540-23988-8},
|
|
8497 |
keywords = {scg-pub jb04 stefPub recast04},
|
|
8498 |
pages = {177--186},
|
|
8499 |
publisher = {Springer-Verlag},
|
|
8500 |
series = {LNCS},
|
|
8501 |
title = {Report of the {ECOOP}'04 Workshop on Object-Oriented
|
|
8502 |
Reengineering},
|
|
8503 |
url = {http://scg.unibe.ch/archive/papers/Wuyt04x-OOR04Report.pdf},
|
|
8504 |
volume = {3344},
|
|
8505 |
year = {2004},
|
|
8506 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Wuyt04x-OOR04Report.pdf},
|
|
8507 |
bdsk-url-2 = {http://dx.doi.org/10.1007/b104146}
|
|
8508 |
}
|
|
8509 |
|
|
8510 |
@article{Wuyt05a,
|
|
8511 |
abstract = {Software for embedded systems must cope with a
|
|
8512 |
variety of stringent constraints, such as real-time
|
|
8513 |
requirements, small memory footprints, and low power
|
|
8514 |
consumption. It is usually implemented using
|
|
8515 |
low-level programming languages, and as a result has
|
|
8516 |
not benefitted from component-based software
|
|
8517 |
development techniques. This paper describes a
|
|
8518 |
\emph{data-centric component model} for embedded
|
|
8519 |
devices that (i) minimizes the number of concurrent
|
|
8520 |
tasks needed to implement the system, (ii) allows
|
|
8521 |
one to verify whether components meet their
|
|
8522 |
deadlines by applying Rate Monotonic Analysis (RMA),
|
|
8523 |
and (iii) can generate and verify schedules using
|
|
8524 |
Constraint Logic Programming (CLP). This model forms
|
|
8525 |
the foundation for a suite of tools for specifying,
|
|
8526 |
composing, verifying and deploying embedded software
|
|
8527 |
components developed in the context of the \pecos
|
|
8528 |
project.},
|
|
8529 |
aeres = {ACL},
|
|
8530 |
aeresstatus = {aeres08},
|
|
8531 |
annote = {internationaljournal},
|
|
8532 |
author = {Roel Wuyts and St\'ephane Ducasse and Oscar
|
|
8533 |
Nierstrasz},
|
|
8534 |
cvs = {PecosJournalPaper},
|
|
8535 |
doi = {10.1016/j.jss.2003.05.004},
|
|
8536 |
inria = {hors},
|
|
8537 |
journal = {Journal of Systems and Software --- Special Issue on
|
|
8538 |
Automated Component-Based Software Engineering},
|
|
8539 |
keywords = {scg-pub jb03 pecos stefPub},
|
|
8540 |
misc = {SCI impact factor 0.744},
|
|
8541 |
number = {1},
|
|
8542 |
pages = {25--34},
|
|
8543 |
publisher = {Elsevier},
|
|
8544 |
title = {A Data-centric Approach to Composing Embedded,
|
|
8545 |
Real-time Software Components},
|
|
8546 |
url = {http://scg.unibe.ch/archive/papers/Wuyt05aPecosElsevier.pdf},
|
|
8547 |
volume = {74},
|
|
8548 |
year = {2005},
|
|
8549 |
bdsk-url-1 = {http://scg.unibe.ch/archive/papers/Wuyt05aPecosElsevier.pdf},
|
|
8550 |
bdsk-url-2 = {http://dx.doi.org/10.1016/j.jss.2003.05.004}
|
|
8551 |
}
|
|
8552 |
|
|
8553 |
@inproceedings{Wuyt07a,
|
|
8554 |
aeres = {OV},
|
|
8555 |
aeresstatus = {aeres08},
|
|
8556 |
annote = {workshopproceedings},
|
|
8557 |
author = {Roel Wuyts and Serge Demeyer and Yann-Ga\"el Gu\'e{e}h\'{e}neuc and Kim Mens and St\'ephane Ducasse},
|
|
8558 |
booktitle = {Object-Oriented Technology. ECOOP'06 Workshop Reader},
|
|
8559 |
inria = {hors},
|
|
8560 |
keywords = {stefPub},
|
|
8561 |
pages = {69--71},
|
|
8562 |
publisher = {Springer-Verlag},
|
|
8563 |
series = {LNCS},
|
|
8564 |
title = {Report of the 7th ECOOP'06 Workshop on
|
|
8565 |
Object-Oriented Reengineering},
|
|
8566 |
url = {http://www.info.ucl.ac.be/~km/MyResearchPages/publications/workshop_report/WR_2007_ECOOP2006_WOOR.pdf},
|
|
8567 |
year = {2007}
|
|
8568 |
}
|
|
8569 |
|
|
8570 |
|
|
8571 |
@inproceedings{Mart10a,
|
|
8572 |
annote = {internationalworkshop},
|
|
8573 |
author = {Martinez Peck, Mariano and Noury Bouraqadi and Marcus Denker and St\'ephane Ducasse and Luc Fabresse},
|
|
8574 |
booktitle = {Smalltalks 2010},
|
|
8575 |
keywords = {moose-pub stefPub lse-pub marcusdenker},
|
|
8576 |
title = {Visualizing Objects and Memory Usage},
|
|
8577 |
year = {2010},
|
|
8578 |
abstract = {Most of the current garbage collector implementations work by reachability. This means they only take care of the objects that nobody else points to. As a consequence, there are objects which are not really used but are not garbage collected because they are still referenced. Such unused but reachable objects create memory leaks. This is a problem because applications use much more memory than what is actually needed. In addition, they may get slower and crash. It is important to understand which parts of the system are instantiated but also which are used or unused. There is a plethora of work on runtime information or class instantiation visualizations but none of them show whether instances are actually used. Such information is important to identify memory leaks.
|
|
8579 |
In this paper, we present some visualizations that show used/unused objects in object-oriented applications. For this, we use Distribution Map which is a visualization showing spread and focus of properties across systems. We extend Distribution Maps to represent the way classes are used or not, since we distinguish between a class that just has instances from one that has used instances. To identify unused objects, we modified the Pharo Virtual Machine.},
|
|
8580 |
aeresstatus = {aeres12},
|
|
8581 |
aeres = {ACT},
|
|
8582 |
inria = {RMOD},
|
|
8583 |
x-editorial-board = {yes},
|
|
8584 |
x-proceedings = {yes},
|
|
8585 |
inriareport = {2010},
|
|
8586 |
x-international-audience = {yes},
|
|
8587 |
url = {http://rmod.lille.inria.fr/archives/workshops/Mart10a-Smalltalks2010-VisualizingUnusedObjects.pdf},
|
|
8588 |
hal-id = {inria-00531510}
|
|
8589 |
}
|
|
8590 |
|
|
8591 |
@inproceedings{Mart10b,
|
|
8592 |
annote = {internationalworkshop},
|
|
8593 |
author = {Martinez Peck, Mariano and Noury Bouraqadi and Marcus Denker and St\'ephane Ducasse and Luc Fabresse},
|
|
8594 |
booktitle = {Smalltalks 2010},
|
|
8595 |
keywords = {moose-pub stefPub lse-pub marcusdenker},
|
|
8596 |
title = {Experiments with a Fast Object Swapper},
|
|
8597 |
year = {2010},
|
|
8598 |
abstract = {In object-oriented systems, runtime memory is composed of an object graph in which objects refer to other objects. This graph of objects evolves while the system is running. Graph exporting and swapping are two important object graph operations. Exporting refers to copying the graph to some other memory so that it can be loaded by another system. Swapping refers to moving the graph to a secondary memory (e.g., a hard disk) to temporary release part of the primary memory.
|
|
8599 |
While exporting and swapping are achieved in different ways, each of them faces a common and central problem which is the speed of the approach in presence of large object graphs. Nevertheless, most of the existing solutions do not address well this issue. Another challenge is to deal with extremely common situations where objects outside the exported/swapped graph point to objects inside the graph. To correctly load back an exported subgraph, it is necessary to compute and export extra information that is not explicit in the object subgraph. This extra information is needed because certain objects may require to be reinitialized or recreated, to run specific code before or after the loading, to be updated to a new class definition, etc.
|
|
8600 |
In this paper, we present most of the general problems of object exporting and swapping. As a case of study, we present an analysis of ImageSegment, a fast solution to export and swap object graphs, developed by Dan Ingalls. ImageSegment addresses the speed problems in an efficient way, as shown by the results of several benchmarks we have conducted using Pharo Smalltalk. However, ImageSegment is not a panacea since it still has other problems that hampers its general use.},
|
|
8601 |
aeresstatus = {aeres12},
|
|
8602 |
aeres = {ACT},
|
|
8603 |
inria = {RMOD},
|
|
8604 |
x-editorial-board = {yes},
|
|
8605 |
x-proceedings = {yes},
|
|
8606 |
inriareport = {2010},
|
|
8607 |
x-international-audience = {yes},
|
|
8608 |
url = {http://rmod.lille.inria.fr/archives/workshops/Mart10b-Smalltalks2010-Swapper-ImageSegments.pdf},
|
|
8609 |
hal-id = {inria-00531565}
|
|
8610 |
}
|
|
8611 |
|
|
8612 |
|
|
8613 |
@inproceedings{Uqui10b,
|
|
8614 |
annote = {internationalworkshop},
|
|
8615 |
author = {Uquillas G\'omez, Ver\'onica and St\'ephane Ducasse and Theo D'Hondt},
|
|
8616 |
booktitle = {Smalltalks'2010},
|
|
8617 |
keywords = {moose-pub stefPub lse-pub},
|
|
8618 |
title = {Meta-models and Infrastructure for Smalltalk Omnipresent History},
|
|
8619 |
year = {2010},
|
|
8620 |
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.},
|
|
8621 |
aeresstatus = {aeres12},
|
|
8622 |
aeres = {ACT},
|
|
8623 |
inria = {RMOD},
|
|
8624 |
x-editorial-board = {yes},
|
|
8625 |
x-proceedings = {yes},
|
|
8626 |
inriareport = {2010},
|
|
8627 |
x-international-audience = {yes},
|
|
8628 |
url = {http://rmod.lille.inria.fr/archives/workshops/Uqui10b-Smalltalk2010-Metamodels.pdf},
|
|
8629 |
hal-id = {inria-00531613}
|
|
8630 |
}
|
|
8631 |
|
|
8632 |
@inproceedings{Mart11a,
|
|
8633 |
title = {Efficient Proxies in Smalltalk},
|
|
8634 |
author = {Mariano Martinez Peck and Noury Bouraqadi and Marcus Denker and St\'ephane Ducasse and Luc Fabresse},
|
|
8635 |
booktitle = {Proceedings of ESUG International Workshop on Smalltalk Technologies (IWST 2011)},
|
|
8636 |
year = {2011},
|
|
8637 |
keywords = {pharo-pub lse-pub},
|
|
8638 |
annote = {internationalworkshop},
|
|
8639 |
aeres = {ACT},
|
|
8640 |
aeresstatus = {aeres12},
|
|
8641 |
inria = {RMOD},
|
|
8642 |
labo = {dans},
|
|
8643 |
x-pays = {FR},
|
|
8644 |
selectif = {non},
|
|
8645 |
x-editorial-board = {yes},
|
|
8646 |
x-proceedings = {yes},
|
|
8647 |
x-international-audience = {yes},
|
|
8648 |
x-country = {FR},
|
|
8649 |
x-language = {EN},
|
|
8650 |
address = {Edinburgh, Scotland},
|
|
8651 |
url = {http://rmod.lille.inria.fr/archives/workshops/Mart11a-IWST11-Ghost.pdf},
|
|
8652 |
abstract = {A proxy object is a surrogate or placeholder that controls access to another target object. Proxy objects are a widely used solution for different scenarios such as remote method invocation, future objects, behavioral reflection, object databases, inter-languages communications and bindings, access control, lazy or parallel evaluation, security, among others. Most proxy implementations support proxies for regular objects but they are unable to create proxies for classes or methods. Proxies can be complex to install, have a significant overhead, be limited to certain type of classes, etc. Moreover, most proxy implementations are not stratified at all and there is no separation between proxies and handlers. In this paper, we present Ghost, a uniform, light-weight and stratified general purpose proxy model and its Smalltalk implementation.Ghost supports proxies for classes or methods. When a proxy takes the place of a class it intercepts both, messages received by the class and lookup of methods for messages received by instances. Similarly, if a proxy takes the place of a method, then the method execution is intercepted too.},
|
|
8653 |
hal-id = {inria-00614720}
|
|
8654 |
}
|
|
8655 |
|
|
8656 |
@inproceedings{Dia11a,
|
|
8657 |
title = {Clustered Serialization with Fuel},
|
|
8658 |
author = {Martin Dias and Mariano Martinez Peck and St\'ephane Ducasse and Gabriela Ar\'evalo},
|
|
8659 |
booktitle = {Proceedings of ESUG International Workshop on Smalltalk Technologies (IWST 2011)},
|
|
8660 |
year = {2011},
|
|
8661 |
keywords = {pharo-pub lse-pub},
|
|
8662 |
annote = {internationalworkshop},
|
|
8663 |
aeres = {ACT},
|
|
8664 |
aeresstatus = {aeres12},
|
|
8665 |
inria = {RMOD},
|
|
8666 |
labo = {dans},
|
|
8667 |
x-pays = {FR},
|
|
8668 |
selectif = {non},
|
|
8669 |
x-editorial-board = {yes},
|
|
8670 |
x-proceedings = {yes},
|
|
8671 |
x-international-audience = {yes},
|
|
8672 |
x-country = {FR},
|
|
8673 |
x-language = {EN},
|
|
8674 |
address = {Edinburgh, Scotland},
|
|
8675 |
abstract = {Serializing object graphs is an important activity since objects should be stored and reloaded on different environments. There is a plethora of frameworks to serialize objects based on recursive parsing of the object graphs. However such approaches are often too slow. Most approaches are limited in their provided features. For example, several serializers do not support class shape changes, global references, transient references or hooks to execute something before or after being stored or loaded. Moreover, to be faster, some serializers are not written taking into account the object-oriented paradigm and they are sometimes even implemented in the Virtual Machine hampering code portability. VM-based serializers such as ImageSegment are difficult to understand, maintain, and fix. For the final user, it means a serializer which is difficult to customize, adapt or extend to his own needs. In this paper we present a general purpose object graph serializer based on a pickling format and algorithm. We implement and validate this approach in the Pharo Smalltalk environment. We demonstrate that we can build a really fast serializer without specific VM support, with a clean object-oriented design, and providing most possible required features for a serializer. We show that our approach is faster that traditional serializers and compare favorably with ImageSegment as soon as serialized objects are not in isolation.}
|
|
8676 |
}
|
|
8677 |
|
|
8678 |
@inproceedings{Duca11a,
|
|
8679 |
title = {Challenges to support automated random testing for dynamically typed languages},
|
|
8680 |
author = {St\'ephane Ducasse and Manuel Oriol and Alexandre Bergel},
|
|
8681 |
booktitle = {Proceedings of ESUG International Workshop on Smalltalk Technologies (IWST 2011)},
|
|
8682 |
year = {2011},
|
|
8683 |
keywords = {pharo-pub lse-pub},
|
|
8684 |
annote = {internationalworkshop},
|
|
8685 |
aeres = {ACT},
|
|
8686 |
aeresstatus = {aeres12},
|
|
8687 |
inria = {RMOD},
|
|
8688 |
labo = {dans},
|
|
8689 |
x-pays = {FR},
|
|
8690 |
selectif = {non},
|
|
8691 |
x-editorial-board = {yes},
|
|
8692 |
x-proceedings = {yes},
|
|
8693 |
x-international-audience = {yes},
|
|
8694 |
x-country = {FR},
|
|
8695 |
x-language = {EN},
|
|
8696 |
hal-id = {inria-00614769},
|
|
8697 |
address = {Edinburgh, Scotland},
|
|
8698 |
url = {http://rmod.lille.inria.fr/archives/workshops/Duca11a-IWST11-RandomTesting},
|
|
8699 |
abstract = {Automated random testing is a proven way to identify bugs and precondition violations, and this even in well tested libraries.
|
|
8700 |
In the context of statically typed languages, current automated random testing tools heavily take advantage of static method declaration (argument types, thrown exceptions) to constrain input domains while testing and to identify errors. For such reason, automated random testing has not been investigated in the context of dynamically typed languages. In this paper we present the key challenges that have to be addressed to support automated testing in dynamic languages.}
|
|
8701 |
}
|
|
8702 |
|
|
8703 |
@techreport{Abde11i,
|
|
8704 |
hal_id = {inria-00614583},
|
|
8705 |
url = {http://hal.inria.fr/inria-00614583/en/},
|
|
8706 |
title = {{Modularization Metrics: Assessing Package Organization in Legacy Large Object-Oriented Software}},
|
|
8707 |
author = {Abdeen, Hani and Ducasse, St{\'e}phane and Sahraoui, Houari},
|
|
8708 |
year = {2011},
|
|
8709 |
keywords = {Software Metrics; Software Modularization; Coupling; Cohesion; Packages; Modularity},
|
|
8710 |
pdf = {http://hal.inria.fr/inria-00614583/PDF/ModularizationMetrics-INRIA.pdf},
|
|
8711 |
url = {http://rmod.lille.inria.fr/archives/reports/Abde11a-TechReport-ModularizationMetrics-INRIA.pdf},
|
|
8712 |
Institution = {RMod -- INRIA Lille-Nord Europe},
|
|
8713 |
abstract = {There exist many large object-oriented software systems consisting of several thousands of classes that are organized into several hundreds of packages. In such software systems, classes cannot be considered as units for software modularization. In such context, packages are not simply classes containers, but they also play the role of modules: a package should focus to provide well identified services to the rest of the software system. Therefore, understanding and assessing package organization is primordial for software maintenance tasks. Although there exist a lot of works proposing metrics for the quality of a single class and/or the quality of inter-class relationships, there exist few works dealing with some aspects for the quality of package organization and relationship. We believe that additional investigations are required for assessing package modularity aspects. The goal of this paper is to provide a complementary set of metrics that assess some modularity principles for packages in large legacy object-oriented software: Information-Hiding, Changeability and Reusability principles. Our metrics are defined with respect to object-oriented inter-package and intra-package dependencies. The dependencies that are caused by different types of inter-class dependencies, such as inheritance and method call. We validate our metrics theoretically through a careful study of the mathematical properties of each metric.},
|
|
8714 |
annote = {technicalreport},
|
|
8715 |
aeres = {COM},
|
|
8716 |
aeresstatus = {aeres12},
|
|
8717 |
inria = {RMOD},
|
|
8718 |
labo = {dans},
|
|
8719 |
x-pays = {FR},
|
|
8720 |
selectif = {non},
|
|
8721 |
x-editorial-board = {yes},
|
|
8722 |
x-proceedings = {yes},
|
|
8723 |
x-international-audience = {yes},
|
|
8724 |
x-country = {FR},
|
|
8725 |
x-language = {EN}
|
|
8726 |
}
|
|
8727 |
|
|
8728 |
@inproceedings{Abde11a,
|
|
8729 |
author = {Hani Abdeen and St\'ephane Ducasse and Houari A. Sahraoui},
|
|
8730 |
title = {Modularization Metrics: Assessing Package Organization in Legacy Large Object-Oriented Software},
|
|
8731 |
booktitle = {International Working Conference on Reverse Engineering (WCRE)},
|
|
8732 |
publisher = {IEEE Computer Society Press},
|
|
8733 |
address = {Washington, DC, USA},
|
|
8734 |
misc = {acceptance rate (Full and Short papers): 50/104 = 48\%},
|
|
8735 |
pages = {?--?},
|
|
8736 |
aeres = {ACT},
|
|
8737 |
aeresstatus = {aeres12},
|
|
8738 |
inria = {RMOD},
|
|
8739 |
labo = {dans},
|
|
8740 |
x-pays = {FR},
|
|
8741 |
selectif = {non},
|
|
8742 |
x-editorial-board = {yes},
|
|
8743 |
x-proceedings = {yes},
|
|
8744 |
x-international-audience = {yes},
|
|
8745 |
x-country = {FR},
|
|
8746 |
x-language = {EN},
|
|
8747 |
annote = {internationalconference},
|
|
8748 |
x-proceedings = {yes},
|
|
8749 |
x-international-audience = {yes},
|
|
8750 |
rate = {48\%},
|
|
8751 |
inria = {RMOD},
|
|
8752 |
year = {2011},
|
|
8753 |
hal = {http://hal.inria.fr/inria-00614583/en/},
|
|
8754 |
hal-id = {inria-00614583},
|
|
8755 |
url = {http://hal.inria.fr/docs/00/61/45/83/PDF/ModularizationMetrics-INRIA.pdf},
|
|
8756 |
abstract = {There exist many large object-oriented software systems consisting of several thousands of classes that are organized into several hundreds of packages. In such software systems, classes cannot be considered as units for software modularization. In such context, packages are not simply classes containers, but they also play the role of modules: a package should focus to provide well identified services to the rest of the software system. Therefore, understanding and assessing package organization is primordial for software maintenance tasks. Although there exist a lot of works proposing metrics for the quality of a single class and/or the quality of inter-class relationships, there exist few works dealing with some aspects for the quality of package organization and relationship. We believe that additional investigations are required for assessing package modularity aspects. The goal of this paper is to provide a complementary set of metrics that assess some modularity principles for packages in large legacy object-oriented software: Information-Hiding, Changeability and Reusability principles. Our metrics are defined with respect to object-oriented inter-package and intra-package dependencies. The dependencies that are caused by different types of inter-class dependencies, such as inheritance and method call. We validate our metrics theoretically through a careful study of the mathematical properties of each metric.},
|
|
8757 |
} |