Content uploaded by Yann-Gaël Guéhéneuc
Author content
All content in this area was uploaded by Yann-Gaël Guéhéneuc on Feb 05, 2015
Content may be subject to copyright.
A preview of the PDF is not available
Discussion on the Results of the Detection of Design Defects
Abstract and Figures
Software engineers often need to identify in their systems "poor" design choices—design defects—that hinder the development and maintenance, as op-portunities of improvements and as a measure of the quality of their systems. However, the detection of design defects is difficult because of the lack of specifications and tools. We propose DECOR, a method to specify design defects systematically and to generate automatically detection algorithms. With this method, software engineers analyse and specify design defects at a high-level of abstraction using a unified vocabulary and a dedicated language for generating detection algorithms. To illustrate our method, in this paper, we specify 4 well-known design defects, the antipatterns Blob, Functional Decomposition, Spaghetti Code, and Swiss Army Knife and their 15 underlying code smells and we generate automatically their detection algorithms. We apply and validate the detection algorithms in terms of precision and recall and discuss the precision of these algorithms on 11 open-source object-oriented systems.
Figures - uploaded by Yann-Gaël Guéhéneuc
Author content
All figure content in this area was uploaded by Yann-Gaël Guéhéneuc
Content may be subject to copyright.
... Naouel Moha et al. have explained different types of design defects. Design patterns defects contain problems at different levels of granularity starting from architectural problems i.e anti-patterns to low level problems i.e. code smells [11] [12]. An anti-pattern suggests that solution to design problem generate negative or incorrect results. ...
Design patterns are problem-solution pairs that provide proven solutions for commonly occurring design problems. They are used to increase maintainability, reusability, comprehensibility and code quality. However, some studies have indicated relationship between design patterns and defects that doubts the claimed benefits of design patterns. In this paper we present an empirical study to evaluate the error proneness of design patterns. We extract the design patterns from open source software and map these patterns to post-release defects. Information on defects is extracted from version control repositories and bug databases. We have applied Mann-Whitney test to find the design patterns that are more error-prone than others.
... another researcher in the field has understood from the submission and thinks about the approach. As in previous years, this format resulted in vivid discussions during the presentations, which formed a good foundation for the afternoon discussions. We now give a short summary of each of the five position papers that were presented at the workshop. [16]. In this paper, the authors present validation results of their design defect detection method (DECOR), which allows the systematic specification of design defects and subsequently the automatic generation of design defect detection algorithms from these specifications. The specification language is based on high-level key concepts iden ...
The ability to reengineer object-oriented legacy systems has become a vital matter in today’s software industry. Early adopters of the object-oriented programming paradigm are now facing the problem of transforming their object-oriented “legacy” systems into full-fledged frameworks. To address this problem, a series of workshops has been organised to set up a forum for exchanging experiences, discussing solutions, and exploring new ideas. Typically, these workshops were organised as satellite events of major software engineering conferences, such as ECOOP [1,2,3,4,5,6,7,8,9,10,11] and ESEC/FSE [12,13,14] . During the past 10 years, participants of this workshop series have been actively contributing to the state-of-the-art on reengineering of object-oriented systems. This special 10th
anniversary edition was no exception and this report summarises the key discussions and outcome of that workshop.
The ability to reengineer object-oriented legacy systems has become a vital matter in today's software industry. Early adopters of the object-oriented programming paradigm are now facing the problem of transforming their object-oriented "legacy" systems into full-fledged frameworks. To address this problem, a series of workshops has been organised to set up a forum for exchanging experiences, discussing solutions, and exploring new ideas. Typically, these workshops were organised as satellite events of major software engineering conferences, such as ECOOP [1,2,3,4,5,6,7,8,9,10,11] and ESEC/FSE [12,13,14]. During the past 10 years, participants of this workshop series have been actively contributing to the state-of-the-art on reengineering of object-oriented systems. This special 10th anniversary edition was no exception and this report summarises the key discussions and outcome of that workshop.
Les défauts de code et de conception sont des problèmes d'implémentation et de conception qui proviennent de ``mauvais'' choix conceptuels récurrents. Ces défauts ont pour conséquence de freiner le développement et la maintenance des systèmes en les rendant plus difficiles à maintenir et évoluer. Une détection et une correction semi-automatiques sont donc des facteurs clefs pour faciliter les phases de maintenance et d'évolution.
Des techniques et outils ont été proposés dans la littérature à la fois pour la détection et la correction des défauts. Les techniques de détection proposées consistent principalement à définir des règles pour détecter les défauts et à les appliquer sur le code source d'un système. Quant aux techniques de correction, elles consistent à appliquer de façon automatique des refactorisations dans le code source du système analysé afin de le restructurer de manière à corriger les défauts. Cependant, la phase qui consiste à identifier les restructurations est réalisée manuellement par les
ingénieurs logiciels. Ainsi, il n'est pas possible de corriger
directement et automatiquement les défauts détectés. Ce problème est dû au fait que la détection et la correction des défauts sont traitées de façon isolée.
Ainsi, nous proposons DECOR, une méthode qui englobe et définit toutes les étapes nécessaires pour la détection et la correction des défauts de code et de conception. Cette méthode permet de spécifier des règles de détection à un haut niveau d'abstraction et de suggérer des restructurations de code afin d'automatiser la correction des défauts.
Nous appliquons et validons notre méthode sur des systèmes libres orientés objet afin de montrer que notre méthode permet une détection précise et une correction adaptée des défauts.
Inspections can be used to identify defects in software artifacts. In this way, inspection methods help to improve software quality, especially when used early in software development. Inspections of software design may be especially crucial since design defects (problems of correctness and completeness with respect to the requirements, internal consistency, or other quality attributes) can directly affect the quality of, and effort required for, the implementation. We have created a set of "reading techniques" (so called because they help a reviewer to "read" a design artifact for the purpose of finding relevant information) that gives specific and practical guidance for identifying defects in Object-Oriented designs. Each reading technique in the family focuses the reviewer on some aspect of the design, with the goal that an inspection team applying the entire family should achieve a high degree of coverage of the design defects. In this paper, we present an overview of this new set of reading techniques. We discuss how some elements of these techniques are based on empirical results concerning an analogous set of reading techniques that supports defect detection in requirements documents. We present an initial empirical study that was run to assess the feasibility of these new techniques, and discuss the changes made to the latest version of the techniques based on the results of this study.
Maintenance is recognised as the most di-cult and expansive activity of the software development process. Numerous techniques and processes have been pro- posed to ease the maintenance of software. In par- ticular, several authors published design defects for- malising \bad" solutions to recurring design problems (e.g., anti-patterns, code smells). We propose a lan- guage and a framework to express design defects syn- thetically and to generate detection algorithms auto- matically. We show that this language is su-cient to describe some design defects and to generate detection algorithms, which have a good precision. We validate the generated algorithms on several programs.
A discontinuity exists between object-oriented modeling and programming languages. This discontinuity arises from ambiguous concepts in modeling languages and a lack of corresponding concepts in programming languages. It is particularly acute for binary class relationships---association, aggregation, and composition. It hinders the traceability between software implementation and design, thus hampering software analysis. We propose consensual definitions of the binary class relationships with four minimal properties---exclusivity, invocation site, lifetime, and multiplicity. We describe algorithms to detect automatically these properties in source code and apply these on several frameworks. Thus, we bridge the gap between implementation and design for the binary class relationships, easing software analysis.
A discontinuity exists between object-oriented modeling and programming languages. This discontinuity arises from ambiguous concepts in modeling languages and a lack of corresponding concepts in programming languages. It is particularly acute for binary class relationships---association, aggregation, and composition. It hinders the traceability between software implementation and design, thus hampering software analysis. We propose consensual definitions of the binary class relationships with four minimal properties---exclusivity, invocation site, lifetime, and multiplicity. We describe algorithms to detect automatically these properties in source code and apply these on several frameworks. Thus, we bridge the gap between implementation and design for the binary class relationships, easing software analysis.
Information retrieval is a sub-field of computer science that deals with the automated storage and retrieval of documents. Providing the latest information retrieval techniques, this guide discusses Information Retrieval data structures and algorithms, including implementations in C. Aimed at software engineers building systems with book processing components, it provides a descriptive and evaluative explanation of storage and retrieval systems, file structures, term and query operations, document operations and hardware. Contains techniques for handling inverted files, signature files, and file organizations for optical disks. Discusses such operations as lexical analysis and stoplists, stemming algorithms, thesaurus construction, and relevance feedback and other query modification techniques. Provides information on Boolean operations, hashing algorithms, ranking algorithms and clustering algorithms. In addition to being of interest to software engineering professionals, this book will be useful to information science and library science professionals who are interested in text retrieval technology.
Almost every expert in Object-Oriented Development stresses the importance of iterative development. As you proceed with the iterative development, you need to add function to the existing code base. If you are really lucky that code base is structured just right to support the new function while still preserving its design integrity. Of course most of the time we are not lucky, the code does not quite fit what we want to do. You could just add the function on top of the code base. But soon this leads to applying patch upon patch making your system more complex than it needs to be. This complexity leads to bugs, and cripples your productivity.