1. Hervé Albin-Amiot, Pierre Cointe, Yann-Gaël Guéhéneuc, and Narendra Jussien. Instantiating and Detecting Design Patterns: Putting Bits and Pieces Together. In Debra Richardson, Martin Feather, and Michael Goedicke, editors, Proceedings of the 16^th Conference on Automated Software Engineering (ASE), pages 166--173, November 2001. IEEE Computer Society Press. Note: 8 pages. [Text ] [Slides ] Keyword(s): Design patterns, ASE. Abstract:

   Design patterns ease designing, understanding, and re-engineering software. Achieving a well-designed piece of software requires a deep understanding and a good practice of design patterns. Understanding existing software relies on the ability to identify architectural forms resulting of the implementation of design patterns. Maintaining software involves spotting places that can be improved by using better design decisions, like those advocated by design patterns. Nevertheless, there is a lack of tools automating the use of design patterns to achieve well-designed pieces of software, to identify recurrent architectural forms, and to maintain software. In this paper, we present a set of tools and techniques to help OO software practitioners design, understand, and re-engineer a piece of software, using design-patterns. A first prototype tool, PatternsBox, provides assistance in designing the architecture of a new piece of software, while a second prototype tool, Ptidej, identifies design patterns used in an existing one. These tools, in combination, support maintenance by highlighting defects in an existing design, and by suggesting and applying corrections based on widely-accepted design patterns solutions.

   
   

   @INPROCEEDINGS{AlbinAmiot01-ASE-BitsPieces,
   author = {Herv{\'e} Albin-Amiot and Pierre Cointe and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Narendra Jussien},
   editor = {Debra Richardson and Martin Feather and Michael Goedicke},
   month = {November},
   year = 2001,
   title = {Instantiating and Detecting Design Patterns: {P}utting Bits and Pieces Together},
   booktitle = {Proceedings of the 16{th} Conference on Automated Software Engineering ({ASE})},
   pages = {166--173},
   note = {8 pages.},
   publisher = {IEEE Computer Society Press},
   kind = {MISA},
   language = {english},
   abstract = {Design patterns ease designing, understanding, and re-engineering software. Achieving a well-designed piece of software requires a deep understanding and a good practice of design patterns. Understanding existing software relies on the ability to identify architectural forms resulting of the implementation of design patterns. Maintaining software involves spotting places that can be improved by using better design decisions, like those advocated by design patterns. Nevertheless, there is a lack of tools automating the use of design patterns to achieve well-designed pieces of software, to identify recurrent architectural forms, and to maintain software. In this paper, we present a set of tools and techniques to help OO software practitioners design, understand, and re-engineer a piece of software, using design-patterns. A first prototype tool, PatternsBox, provides assistance in designing the architecture of a new piece of software, while a second prototype tool, Ptidej, identifies design patterns used in an existing one. These tools, in combination, support maintenance by highlighting defects in an existing design, and by suggesting and applying corrections based on widely-accepted design patterns solutions.},
   keywords = {Design patterns ; ASE},
   url = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/ASE01.doc.pdf},
   pdf = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/ASE01.ppt.pdf},
   grant = {\ygg@company{Object Technology International, Inc.}} 
   }
   




2. Hervé Albin-Amiot and Yann-Gaël Guéhéneuc. Design Patterns Application: Pure-generative Approach vs. Conservative-generative Approach. In Krzysztof Czarnecki, editor, Proceedings of the 1^st OOPSLA workshop on Generative Programming, October 2001. ACM Press. Note: 3 pages. [Text ] Keyword(s): Design patterns, GP. Abstract:

   For our discussion we summarize software developments in two kinds: Development of large applications (such as accounting application or billing systems); and, development of large framework (such as window system [SunAWT] or networking system [Zweig90]). In one hand, when developing large applications, the developers need to abstract the functional and non-functional requirements of the application. They must be particularly careful with the specifications of the business rules and policies of the application, while the language and the code implementing the application are not really important. On the other hand, when developing large frameworks, the developers need to abstract the potential extension and implementations of the framework. They must be particularly careful with the architecture, the design, and the implementation of the framework, which is, at least, as important as the functionalities provided. In this position paper, we present two tools that help the developers in implementing large applications and large frameworks, using design patterns. Scriptor [Scriptor] (Section 2) is an industrial-strength application generator. Developers use it to generate large applications from scripts stating their functional and non-functional requirements. PatternsBox [PatternsBox] (Section 3) is an academic conservative application generator. Developers use it to implement design patterns in existing applications. PatternsBox modifies or creates only the required code artifacts (class, interface, fields, methods) to implement the design patterns, leaving the rest of the code untouched.

   
   

   @INPROCEEDINGS{AlbinAmiot01-WGP-Generative,
   author = {Herv{\'e} Albin-Amiot and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
   editor = {Krzysztof Czarnecki},
   month = {October},
   year = 2001,
   title = {Design Patterns Application: {P}ure-generative Approach {vs.} Conservative-generative Approach},
   booktitle = {Proceedings of the 1{st} {OOPSLA} workshop on Generative Programming},
   note = {3 pages.},
   publisher = {ACM Press},
   kind = {MIADR},
   language = {english},
   abstract = {For our discussion we summarize software developments in two kinds: Development of large applications (such as accounting application or billing systems); and, development of large framework (such as window system [SunAWT] or networking system [Zweig90]). In one hand, when developing large applications, the developers need to abstract the functional and non-functional requirements of the application. They must be particularly careful with the specifications of the business rules and policies of the application, while the language and the code implementing the application are not really important. On the other hand, when developing large frameworks, the developers need to abstract the potential extension and implementations of the framework. They must be particularly careful with the architecture, the design, and the implementation of the framework, which is, at least, as important as the functionalities provided. In this position paper, we present two tools that help the developers in implementing large applications and large frameworks, using design patterns. Scriptor [Scriptor] (Section 2) is an industrial-strength application generator. Developers use it to generate large applications from scripts stating their functional and non-functional requirements. PatternsBox [PatternsBox] (Section 3) is an academic conservative application generator. Developers use it to implement design patterns in existing applications. PatternsBox modifies or creates only the required code artifacts (class, interface, fields, methods) to implement the design patterns, leaving the rest of the code untouched.},
   keywords = {Design patterns ; GP},
   url = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/OOPSLA01GP.doc.pdf},
   grant = {\ygg@company{Object Technology International, Inc.}} 
   }
   




3. Hervé Albin-Amiot and Yann-Gaël Guéhéneuc. Design Patterns: A Round-Trip. In Gilles Ardourel, Michael Haupt, Jose Luis Herrero Agustin, Rainer Ruggaber, and Charles Suscheck, editors, Proceedings of the 11^th ECOOP workshop for Ph.D. Students in Object-Oriented Systems, June 2001. Note: 10 pages. [Text ] [Slides ] Keyword(s): Design patterns, PHDOOS. Abstract:

   Design patterns are of major interest to increase software quality and abstraction level. However, design patterns are difficult to choose, to apply, and to recover. We propose a set of tools to use design patterns in a round-trip fashion. We define a meta-model to describe design patterns. This meta-model is specifically oriented towards design patterns instantiation and detection. We develop a source-to-source transformation engine to modify the source code to comply with design patterns descriptions. Meanwhile, we use an explanation-based constraint solver to detect design patterns in source code from their descriptions. With these tools, we hope to offer a mean to apply and to recover design patterns without overhead for the developers.

   
   

   @INPROCEEDINGS{AlbinAmiot01-WPHDOOS-RoundTrip,
   author = {Herv{\'e} Albin-Amiot and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
   editor = {Gilles Ardourel and Michael Haupt and Jose Luis Herrero Agustin and Rainer Ruggaber and Charles Suscheck},
   month = {June},
   year = 2001,
   title = {Design Patterns: {A} Round-Trip},
   booktitle = {Proceedings of the 11{th} {ECOOP} workshop for {Ph.D.} Students in Object-Oriented Systems},
   note = {10 pages.},
   kind = {MIADR},
   language = {english},
   abstract = {Design patterns are of major interest to increase software quality and abstraction level. However, design patterns are difficult to choose, to apply, and to recover. We propose a set of tools to use design patterns in a round-trip fashion. We define a meta-model to describe design patterns. This meta-model is specifically oriented towards design patterns instantiation and detection. We develop a source-to-source transformation engine to modify the source code to comply with design patterns descriptions. Meanwhile, we use an explanation-based constraint solver to detect design patterns in source code from their descriptions. With these tools, we hope to offer a mean to apply and to recover design patterns without overhead for the developers.},
   keywords = {Design patterns ; PHDOOS},
   url = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/ECOOP01PHDOOS.doc.pdf},
   pdf = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/ECOOP01PHDOOS.ppt.pdf},
   grant = {\ygg@company{Object Technology International, Inc.}} 
   }
   




4. Hervé Albin-Amiot and Yann-Gaël Guéhéneuc. Meta-Modeling Design Patterns: Application to Pattern Detection and Code Synthesis. In Pim van den Broek, Pavel Hruby, Motoshi Saeki, Gerson Sunyé, and Bedir Tekinerdogan, editors, Proceedings of the 1^st ECOOP workshop on Automating Object-Oriented Software Development Methods, October 2001. Centre for Telematics and Information Technology, University of Twente. Note: TR-CTIT-01-35. 8 pages. [Text ] [Slides ] Keyword(s): Design patterns. Abstract:

   Design Patterns have been quickly adopted by the object-oriented community, in particular since the publication of ``Design Patterns: Elements of Reusable Object-Oriented Software". They offer elegant and reusable solutions to recurring problems of design. Their use increases productivity and development quality. However, these solutions, at the boundary of programming languages and design models, suffer from a lack of formalism. For this reason, their application remains empirical and manually performed. This position paper presents how a meta-model can be used to obtain a representation of design patterns and how this representation allows both automatic code generation and design patterns detection.

   
   

   @INPROCEEDINGS{AlbinAmiot01-WAOOSDM-MetaModel,
   author = {Herv{\'e} Albin-Amiot and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
   editor = {Pim van den Broek and Pavel Hruby and Motoshi Saeki and Gerson Suny{\'e} and Bedir Tekinerdogan},
   month = {October},
   year = 2001,
   title = {Meta-Modeling Design Patterns: {A}pplication to Pattern Detection and Code Synthesis},
   booktitle = {Proceedings of the 1{st} {ECOOP} workshop on Automating Object-Oriented Software Development Methods},
   note = {TR-CTIT-01-35. 8 pages.},
   publisher = {University of Twente},
   kind = {MIADR},
   language = {english},
   organization = {Centre for Telematics and Information Technology},
   abstract = {Design Patterns have been quickly adopted by the object-oriented community, in particular since the publication of ``Design Patterns: Elements of Reusable Object-Oriented Software". They offer elegant and reusable solutions to recurring problems of design. Their use increases productivity and development quality. However, these solutions, at the boundary of programming languages and design models, suffer from a lack of formalism. For this reason, their application remains empirical and manually performed. This position paper presents how a meta-model can be used to obtain a representation of design patterns and how this representation allows both automatic code generation and design patterns detection.}, keywords = {Design patterns}, url = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/ECOOP01AOOSDM.doc.pdf}, pdf = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/ECOOP01AOOSDM.ppt.pdf}, grant = {\ygg@company{Object Technology International, Inc.}} 
   }
   




5. Yann-Gaël Guéhéneuc and Hervé Albin-Amiot. Using Design Patterns and Constraints to Automate the Detection and Correction of Inter-Class Design Defects. In Quioyun Li, Richard Riehle, Gilda Pour, and Bertrand Meyer, editors, Proceedings of the 39^th Conference on the Technology of Object-Oriented Languages and Systems (TOOLS USA), pages 296--305, July 2001. IEEE Computer Society Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, TOOLS USA. Abstract:

   Developing code free of defects is a major concern for the object-oriented software community. In this paper, we classify design defects as those within classes ( extit{intra-class}), those among classes ( extit{inter-classes}), and those of semantic nature ( extit{behavioral}). Then, we introduce guidelines to automate the detection and correction of inter-class design defects: We assume that design patterns embody good architectural solutions and that a group of entities with organization similar, but not equal, to a design pattern represents an inter-class design defect. Thus, the transformation of such a group of entities, such that its organization complies exactly with a design pattern, corresponds to the correction of an inter-class design defect. We use a meta-model to describe design patterns and we exploit the descriptions to infer sets of detection and transformation rules. A constraints solver with explanations uses the descriptions and rules to recognize groups of entities with organizations similar to the described design patterns. A transformation engine modifies the source code to comply with the recognized distorted design patterns. We apply these guidelines on the \ygg@pattern{Composite} pattern using \ygg@product{Ptidej}, our prototype tool that integrates the complete guidelines.

   
   

   @INPROCEEDINGS{Gueheneuc01-TOOLSUSA-DesignDefects,
   author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Herv{\'e} Albin-Amiot},
   editor = {Quioyun Li and Richard Riehle and Gilda Pour and Bertrand Meyer},
   month = {July},
   year = 2001,
   title = {Using Design Patterns and Constraints to Automate the Detection and Correction of Inter-Class Design Defects},
   booktitle = {Proceedings of the 39{th} Conference on the Technology of Object-Oriented Languages and Systems ({TOOLS USA})},
   pages = {296--305},
   note = {10 pages.},
   publisher = {IEEE Computer Society Press},
   kind = {MISA},
   language = {english},
   abstract = {Developing code free of defects is a major concern for the object-oriented software community. In this paper, we classify design defects as those within classes (	extit{intra-class}), those among classes (	extit{inter-classes}), and those of semantic nature (	extit{behavioral}). Then, we introduce guidelines to automate the detection and correction of inter-class design defects: We assume that design patterns embody good architectural solutions and that a group of entities with organization similar, but not equal, to a design pattern represents an inter-class design defect. Thus, the transformation of such a group of entities, such that its organization complies exactly with a design pattern, corresponds to the correction of an inter-class design defect. We use a meta-model to describe design patterns and we exploit the descriptions to infer sets of detection and transformation rules. A constraints solver with explanations uses the descriptions and rules to recognize groups of entities with organizations similar to the described design patterns. A transformation engine modifies the source code to comply with the recognized distorted design patterns. We apply these guidelines on the \ygg@pattern{Composite} pattern using \ygg@product{Ptidej}, our prototype tool that integrates the complete guidelines.},
   keywords = {Code and design smells ; TOOLS USA},
   url = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/TOOLSUSA01.doc.pdf},
   pdf = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/TOOLSUSA01.ppt.pdf},
   grant = {\ygg@company{Object Technology International, Inc.}} 
   }
   




6. Yann-Gaël Guéhéneuc and Narendra Jussien. Quelques explications pour les patrons -- Une application de la PPC avec explications pour l'identification de patrons de conception. In Bertrand Neveu, editor, Actes des 7^e Journées Nationales sur la résolution de Problèmes NP-Complets (JNPC), pages 111--122, juin 2001. ONERA. Note: 12 pages. [Text ] [Slides ] Keyword(s): Design patterns, JNPC. Abstract:

   Les patrons de conception d\'ecrivent des micro-architectures qui r\'esolvent des probl\`emes architecturaux r\'ecurrents. Il est important d'identifier ces micro-archi\-tectures lors de la maintenance des programmes orient\'es objets. Mais ces micro-architectures apparaissent souvent sous des formes d\'egrad\'ees dans le code source. Nous pr\'esentons une application de la programmation par contraintes avec explications pour l'identification de ces micro-architectures d\'egrad\'ees.

   
   

   @INPROCEEDINGS{Gueheneuc01-JNPC-Explications,
   author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Narendra Jussien},
   editor = {Bertrand Neveu},
   month = {juin},
   year = 2001,
   title = {Quelques explications pour les patrons~-- {U}ne application de la {PPC} avec explications pour {l'}identification de patrons de conception},
   booktitle = {Actes des 7{e} Journ{\'e}es Nationales sur la r{\'e}solution de Probl{\`e}mes NP-Complets ({JNPC})},
   pages = {111--122},
   note = {12 pages.},
   publisher = {ONERA},
   kind = {MNSA},
   language = {francais},
   abstract = {Les patrons de conception d\'ecrivent des micro-architectures qui r\'esolvent des probl\`emes architecturaux r\'ecurrents. Il est important d'identifier ces micro-archi\-tectures lors de la maintenance des programmes orient\'es objets. Mais ces micro-architectures apparaissent souvent sous des formes d\'egrad\'ees dans le code source. Nous pr\'esentons une application de la programmation par contraintes avec explications pour l'identification de ces micro-architectures d\'egrad\'ees.},
   keywords = {Design patterns ; JNPC},
   url = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/JNPC01.doc.pdf},
   pdf = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/JNPC01.ppt.pdf},
   grant = {\ygg@company{Object Technology International, Inc.}} 
   }
   




7. Yann-Gaël Guéhéneuc and Narendra Jussien. Using Explanations for Design-Patterns Identification. In Christian Bessière, editor, Proceedings of the 1^st IJCAI Workshop on Modeling and Solving Problems with Constraints, pages 57--64, August 2001. AAAI Press. Note: 8 pages. [Text ] [Slides ] Keyword(s): Design patterns, WMSPC. Abstract:

   Design-patterns describe micro-architectures that solve recurrent architectural problems in objec-oriented programming languages. It is important to identify these micro-architectures during the maintenant of objec-oriented programs. But, these micro-architectures often appear distorted in the source code. We present an application of explanation-based constraint programming for identifying these distorted micro-architectures.

   
   

   @INPROCEEDINGS{Gueheneuc01-WMSPC-Explanations,
   author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Narendra Jussien},
   editor = {Christian Bessi{\`e}re},
   month = {August},
   year = 2001,
   title = {Using Explanations for Design-Patterns Identification},
   booktitle = {Proceedings of the 1{st} {IJCAI} Workshop on Modeling and Solving Problems with Constraints},
   pages = {57--64},
   note = {8 pages.},
   publisher = {AAAI Press},
   kind = {MIADR},
   language = {english},
   abstract = {Design-patterns describe micro-architectures that solve recurrent architectural problems in objec-oriented programming languages. It is important to identify these micro-architectures during the maintenant of objec-oriented programs. But, these micro-architectures often appear distorted in the source code. We present an application of explanation-based constraint programming for identifying these distorted micro-architectures.},
   keywords = {Design patterns ; WMSPC},
   url = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/IJCAI01MSPC.doc.pdf},
   pdf = { http://www-etud.iro.umontreal.ca/~ptidej/yann-gael/Work/Publications/Documents/IJCAI01MSPC.ppt.pdf},
   grant = {\ygg@company{Object Technology International, Inc.}} 
   }
   

1. Yann-Gaël Guéhéneuc. Ptidej, since July 2001. Note: A tool suite to evaluate and to enhance the quality of object-oriented programs. [Text ]
   

   @MISC{Ptidej,
   author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
   month = {since July},
   year = 2001,
   title = {{Ptidej}},
   note = {A tool suite to evaluate and to enhance the quality of object-oriented programs.},
   kind = {OUTIL},
   language = {english},
   url = {http://www.ptidej.net} 
   }
   

This document was translated from BibT_EX by bibtex2html