Academia.eduAcademia.edu

Outline

Title
Abstract
FAQs
Figures
Introduction
Background and Related Work
DP-Core: A Design Pattern Detection Tool
Representing Design Patterns
Design Pattern Detection Algorithm
Grouping Design Pattern Instances
Example Design Patterns Project
Java Libraries with Design Patterns
Conclusion
References
All Topics
Computer Science

DP-CORE: A Design Pattern Detection Tool for Code Reuse

Profile image of Themistoklis DiamantopoulosThemistoklis Diamantopoulos

2016, Proceedings of the Sixth International Symposium on Business Modeling and Software Design

https://doi.org/10.5220/0006223301600167
visibility

…

description

10 pages

link

1 file

Abstract

In order to maintain, extend or reuse software projects one has to primarily understand what a system does and how well it does it. And, while in some cases information on system functionality exists, information covering the non-functional aspects is usually unavailable. Thus, one has to infer such knowledge by extracting design patterns directly from the source code. Several tools have been developed to identify design patterns, however most of them are limited to compilable and in most cases executable code, they rely on complex representations, and do not offer the developer any control over the detected patterns. In this paper we present DP-CORE, a design pattern detection tool that defines a highly descriptive representation to detect known and define custom patterns. DP-CORE is flexible, identifying exact and approximate pattern versions even in non-compilable code. Our analysis indicates that DP-CORE provides an efficient alternative to existing design pattern detection tools.

FAQs

sparkles

AI

What distinguishes DP-CORE from other design pattern detection tools?add

DP-CORE supports detection in non-executable source code and allows for custom pattern definitions. Unlike others, it uses UML-based representations and efficiently handles incomplete code, yielding results in under 5 seconds.

How does the pattern detection algorithm in DP-CORE operate?add

DP-CORE employs a recursive pruning algorithm that reduces permutations for candidate patterns based on object matching. This approach minimizes computational inefficiency, checking significantly fewer combinations than brute force methods.

What were the evaluation results comparing DP-CORE to PINOT?add

In tests across libraries like JHotDraw and Java AWT, both tools detected similar patterns but showed variation due to representation differences. DP-CORE proved efficient, with detection taking less than 5 seconds per project.

What types of design patterns does DP-CORE effectively identify?add

DP-CORE successfully identified 6 GoF design patterns, including Abstract Factory and Visitor, in a curated example project. The tool did report some false positives, highlighting the need for precise pattern definitions.

How does DP-CORE handle common code errors during pattern detection?add

DP-CORE effectively detects patterns even in non-compilable code, tolerating common syntax and semantic errors. It can ignore many issues, enabling detection of reusable code that may have minor inconsistencies.

Figures (8)
Table 1: DP-CORE Connections.
Table 1: DP-CORE Connections.
The connections cover all possible relations that can exist in a source code project. UML dependencies and associations are handled by connections calls/ uses and references respectively, while composi- tions and aggregations correspond to the creates and has connections. Inheritance and realization relations are handled by the inherits connection. Finally, we define a relates connection that covers all possible connection types, and thus is used as a wildcard.
The connections cover all possible relations that can exist in a source code project. UML dependencies and associations are handled by connections calls/ uses and references respectively, while composi- tions and aggregations correspond to the creates and has connections. Inheritance and realization relations are handled by the inherits connection. Finally, we define a relates connection that covers all possible connection types, and thus is used as a wildcard.
Figure 2: Abstract Factory Pattern File.
Figure 2: Abstract Factory Pattern File.
Figure 5: Combinations of objects and their relationships, where the object that matches the first pattern member is (a) Car, (b) Wheel, (c) Tires, and (d) Fuel.
Figure 5: Combinations of objects and their relationships, where the object that matches the first pattern member is (a) Car, (b) Wheel, (c) Tires, and (d) Fuel.
Table 4: Pattern Detection Results for Example Project. Por we second experiment we evaluated VUr-CUNRE against PINOT (Shi and Olsson, 2006) in a dataset of 3 libraries: JHotDraw 6.0b1, Java AWT 1.3, and Apache Ant 1.6.2. PINOT was selected as it resem- bles DP-CORE in the way that it extracts source code objects and detects patterns. Since, however, the rep- resentation used by PINOT differs from that of DP- CORE, the comparison is quantitative, thus the results can only provide a proof-of concept for our DPD. As already noted, the scope of DP-CORE lies in provid- ing an intuitive way of detecting custom patterns and software architectures, instead of strictly defining the known design patterns. For compatibility reasons, the comparison between the two tools includes the pat- terns Abstract Factory, Bridge, Visitor, and Observer.
Table 4: Pattern Detection Results for Example Project. Por we second experiment we evaluated VUr-CUNRE against PINOT (Shi and Olsson, 2006) in a dataset of 3 libraries: JHotDraw 6.0b1, Java AWT 1.3, and Apache Ant 1.6.2. PINOT was selected as it resem- bles DP-CORE in the way that it extracts source code objects and detects patterns. Since, however, the rep- resentation used by PINOT differs from that of DP- CORE, the comparison is quantitative, thus the results can only provide a proof-of concept for our DPD. As already noted, the scope of DP-CORE lies in provid- ing an intuitive way of detecting custom patterns and software architectures, instead of strictly defining the known design patterns. For compatibility reasons, the comparison between the two tools includes the pat- terns Abstract Factory, Bridge, Visitor, and Observer.

Related papers

Finding the design pattern from the source code for developing reusable object oriented software
K.M Azharul Hasan

2009 Second International Conference on the Applications of Digital Information and Web Technologies, 2009

One of the principal goals of object-oriented software is to improve the reusability of software components. In this paper the identification of design patterns from source code is described to improve the reusability of software. The methodology for parsing scheme to recover the design pattern from the source code is described by defining interactions between objects. Three industrial softwares are use in case study to verify the methodologies and sufficient experimental results are presented.

View PDFchevron_right
Automatic design pattern detection
Dirk Heuzeroth

MHS2003. Proceedings of 2003 International Symposium on Micromechatronics and Human Science (IEEE Cat. No.03TH8717), 2003

We detect design patterns in legacy code combining static and dynamic analyses. The analyses do not depend on coding or naming conventions. We classify potential pattern instances according to the evidence our analyses provide. We discuss our approach for the Observer, Composite, Mediator, Chain of Responsibility and Visitor Patterns. Our Java analysis tool analyzes Java programs. We evaluate our approach by applying the tool on itself and on the Java SwingSetExample using the Swing library.

View PDFchevron_right
DPDX - A Common Exchange Format for Design Pattern Detection Tools
Alexander Binun

Tools for design pattern detection (DPD) can sig- nificantly ease program comprehension, helping programmers understand the design and intention of certain parts of a system's implementation. Many tools have been proposed in the past. However, the many different output formats used by the tools make it difficult to compare their results and to improve their accuracy and performance through data fusion. In addition, all the output formats have been shown to have several limitations in both their forms and contents. Consequently, we develop DPDX, a rich common exchange format for DPD tools, to overcome previous limitations. DPDX provides the basis for an open federation of tools that perform comparison, fusion, visualisation, and-or validation of DPD results. In the process of building the format, we also clarify some central notions of design patterns that lacked a common, generally accepted definitions, and thus provide a sound common foundation and terminology for DPD.

View PDFchevron_right
Generating design pattern detectors from pattern specifications
Dirk Heuzeroth

18th IEEE International Conference on Automated Software Engineering, 2003. Proceedings., 2003

We present our approach to support program understanding by a tool that generates static and dynamic analysis algorithms from design pattern specifications to detect design patterns in legacy code. We therefore specify the static and dynamic aspects of patterns as predicates, and represent legacy code by predicates that encode its attributed abstract syntax trees. Given these representations, the static analysis is performed on the legacy code representation as a query derived from the specification of the static pattern aspects. It provides us with pattern candidates in the legacy code. The dynamic specification represents state sequences expected when using a pattern. We monitor the execution of the candidates and check their conformance to this expectation.

View PDFchevron_right
Relaxing Queries to Detect Variants of Design Patterns
Krzysztof Stencel

Design patterns codify general solutions to frequently encountered design problems. They also facilitate writing robust and readable code. Their usage happens to be particularly profitable if the documentation of the resulting system is lost, inaccurate or out of date. In reverse engineering, detection of instances of design patterns is extremely helpful as it aids grasping high level design ideas. However, the actual instances of design patterns can diverge from their canonical textbook templates. Useful pattern detection tools should thus be able to identify not only orthodox implementations but also their disparate variants. In this paper, we present a method to generate queries to detect canonical instances of design patters. We formulate these queries so that they are language-agnostic. They precisely reflect the intents of the canonical implementations of design patterns. However, they abstract from any peculiarities of programming languages. Next, we show a systematic technique to relax these queries so that they also cover variant implementations of patterns. We discuss our proof-of-concept implementation of this approach in our prototype tool D-CUBED. Finally, we report the results of an experimental comparison of D-CUBED and stateof-the-art detectors.

View PDFchevron_right
An Eclipse plug-in for the detection of design pattern instances through static and dynamic analysis
Vincenzo Deufemia

2010

The extraction of design pattern information from software systems can provide conspicuous insight to software engineers on the software structure and its internal characteristics. In this demonstration we present ePAD, an Eclipse plug-in for recovering design pattern instances from object-oriented source code. The tool is able to recover design pattern instances through a structural analysis performed on a data model extracted from source code, and a behavioral analysis performed through the instrumentation and the monitoring of the software system. ePAD is fully configurable since it allows software engineers to customize the design pattern recovery rules and the layout used for the visualization of the recovered instances.

View PDFchevron_right
Mining Design Patterns from C++ Source Code
Asma Labadi

Design patterns are micro architectures that have proved to be reliable, easy-to implement and robust. There is a need in science and industry for recognizing these patterns. We present a new method for discovering design patterns in the source code. This method provides a precise specification of how the patterns work by describing basic structural information like inheritance, composition, aggregation and association, and as an indispensable part, by defining call delegation, object creation and operation overriding. We introduce a new XML–based language, the Design Pattern Markup Language (DPML), which provides an easy way for the users to modify pattern descriptions to suit their needs, or even to define their own patterns or just classes in certain relations they wish to find. We tested our method on four open-source systems, and found it effective in discovering design pattern instances.

View PDFchevron_right
DPET – A Simple C++ Design Pattern Extraction Tool
Samuel A Ajila

2003

All in-text references underlined in blue are linked to publications on ResearchGate, letting you access and read them immediately.

View PDFchevron_right
Using metric-based filtering to improve design pattern detection approaches
nadia bouassida

Innovations in Systems and Software Engineering, 2014

Design patterns represent high-level recurring abstractions that reflect the know-how of experts. Their detection is a key task in the context of software engineering; it is very useful in program comprehension, design recovery and also for re-documenting object-oriented systems. Despite their usefulness, current design pattern detection approaches have a high time complexity that hinders their application. This complexity is further aggravated with the absence of guiding principles in determining which pattern to look for first among the various patterns. To overcome this practical limit, we propose to optimize any pattern detection approach by foregoing it by a filtering phase that detects possible existence of patterns and that orders the candidate patterns in terms of their degree of resemblance to the analyzed design fragments. The herein proposed filtering approach exploits semantic and structural design metrics to look for the semantic and structural symptoms of design pattern instances. Its performance is experimentally demonstrated through our design pattern detection method MAPeD (Multi-phase Approach for Pattern Discovery) applied on the open source system JUnit.

View PDFchevron_right
A Technique for Design Patterns Detection
Manjari Gupta

2017

Several recurring patterns of classes exist in many object oriented software as an experience of developers. Design Pattern Detection is an important part of many solutions to Software Reuse practices. Design pattern instances are highly important and useful for program understanding and software maintenance. Hence an automatic and reliable design pattern mining is required. In this paper inexact graph matching approach is applied for design pattern detection using genetic algorithm. Keywordsdesign pattern, UML, subgraph isomorphism, genetic algorithm

View PDFchevron_right

References (17)

  1. Arcelli, F. and Christina, L. (2007). Enhancing Software Evolution through Design Pattern Detection. In Pro- ceedings of the 2007 Third International IEEE Work- shop on Software Evolvability, pages 7-14, Paris, France.
  2. Arcelli, F. F., Perin, F., Raibulet, C., and Ravani, S. (2008). Behavioral Design Pattern Detection through Dynamic Analysis. In Proceedings of the 4th Interna- tional Workshop on Program Comprehension through Dynamic Analysis, pages 11-16, Antwerp, Belgium.
  3. Beck, K. and Cunningham, W. (1987). Using Pattern Lan- guages for Object-Oriented Programs. In Proceedings of the OOPSLA-87 Workshop on the Specification and Design for Object-Oriented Programming, Orlando, FL, USA.
  4. Birkner, M. (2007). Object-Oriented Design Pattern Detec- tion Using Static and Dynamic Analysis of Java Soft- ware. Master's thesis, University of Applied Sciences Bonn-Rhein-Sieg Sankt Augustin, Germany.
  5. Dong, J., Lad, D. S., and Zhao, Y. (2007a). DP-Miner: Design Pattern Discovery Using Matrix. In Proceed- ings of the 14th Annual IEEE International Confer- ence and Workshops on the Engineering of Computer- Based Systems, ECBS '07, pages 371-380, Tucson, AZ, USA.
  6. Dong, J., Zhao, Y., and Peng, T. (2007b). Architecture and Design Pattern Discovery Techniques -A Review. In Proceedings of the 2007 International Conference on Software Engineering Research & Practice, volume 2 of SERP 2007, pages 621-627, Las Vegas, NV, USA.
  7. Dong, J., Zhao, Y., and Peng, T. (2009). A Review of De- sign Pattern Mining Techniques. International Jour- nal of Software Engineering and Knowledge Engi- neering, 19(06):823-855.
  8. Gamma, E., Vlissides, J., Johnson, R., and Helm, R. (1998). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley Longman Publishing Co., Inc., Boston, MA, USA.
  9. Guéhéneuc, Y.-G. and Antoniol, G. (2008). DeMIMA: A Multilayered Approach for Design Pattern Identifica- tion. IEEE Trans. Softw. Eng., 34(5):667-684.
  10. Kaczor, O., Guéhéneuc, Y.-G., and Hamel, S. (2006). Effi- cient Identification of Design Patterns with Bit-vector Algorithm. In Proceedings of the 10th European Con- ference on Software Maintenance and Reengineering, CSMR 2006, pages 175-184, Bari, Italy.
  11. Lucia, A. D., Deufemia, V., Gravino, C., and Risi, M. (2009). Design Pattern Recovery Through Visual Lan- guage Parsing and Source Code Analysis. J. Syst. Softw., 82(7):1177-1193.
  12. Nickel, U., Niere, J., and Zündorf, A. (2000). The FU- JABA Environment. In Proceedings of the 22nd Inter- national Conference on Software Engineering, ICSE '00, pages 742-745, Limerick, Ireland.
  13. Oracle (2015). Compiler Tree API. Avail. online: http:// docs.oracle.com/javase/8/docs/jdk/api/ javac/tree/index.html, [retrieved March, 2015].
  14. Rasool, G. and Streitferdt, D. (2011). A Survey on Design Pattern Recovery Techniques. International Journal of Computer Science Issues, 8(6):251-260.
  15. Shi, N. and Olsson, R. A. (2006). Reverse Engineering of Design Patterns from Java Source Code. In Proceed- ings of the 21st IEEE/ACM International Conference on Automated Software Engineering, ASE '06, pages 123-134, Tokyo, Japan.
  16. Stencel, K. and Wegrzynowicz, P. (2008). Detection of Di- verse Design Pattern Variants. In Proceedings of the 2008 15th Asia-Pacific Software Engineering Confer- ence, APSEC '08, pages 25-32, Beijing, China.
  17. Tsantalis, N., Chatzigeorgiou, A., Stephanides, G., and Halkidis, S. (2006). Design Pattern Detection us- ing Similarity Scoring. IEEE Trans. Softw. Eng., 32(11):896-909.

Related papers

A Novel Approach to Automated Design Pattern Detection
Spyros Halkidis

2005

The importance of the use of Design Patterns in order to build reusable and wellstructured software has been eminent since these patterns have been formalized. Thus, it became desirable to be able to detect which design patterns are present in a software system. Knowing this information it is possible to make an evaluation on different aspects of the system. Though, it is a very difficult task for a software engineer to pinpoint all the Design Patterns present in a system, without any assistance. Addressing this need, techniques for automated design pattern detection have appeared in the literature. Some are based on reverseengineering of already existing code while others can work already at design level by analyzing UML diagrams. Though, complexity is one of the characteristics of all the methods proposed until now. Furthermore, all of these techniques work only for a limited number of the GoF patterns. Our aim in this paper is to elaborate on a simple approach for automatic detec...

View PDFchevron_right
Detection of diverse design pattern variants
Krzysztof Stencel

2008

We propose a method for automatic detection of occurrences of design patterns. We also describe its proof-ofconcept implementation and the results of comparative experiments with other tools. The method presented here is able to detect many nonstandard implementation variants of design patterns, while its efficiency is comparable to other state-of-the-art detection tools. Moreover, the method is highly customizable because an analyst can introduce a new pattern retrieval query or modify an existing one and then repeat the detection using the results of earlier source code analysis stored in a relational database.

View PDFchevron_right
A Customizable Approach to Design Patterns Recognition Based on Feature Types
Ghulam Rasool

Arabian Journal for Science and Engineering, 2014

Accurate recognition of design patterns from source code supports development-related tasks such as program comprehension, maintenance, reverse engineering, and re-engineering. Researchers focused on this problem for many years, and a variety of recognition approaches have been proposed. Though, much progress has been made, we still identify a lack of flexibility and accuracy in the pattern recognition process. This paper evaluates different design pattern recovery approaches and examines the detection accuracy of these approaches. We found that the major impedance in the accurate recovery of design patterns is the large number of variations for implementing the same pattern. Furthermore, we realized that the combination of multiple searching techniques is required to improve accuracy of pattern detection. Based on these observations, we propose variable pattern definitions, which can be customized and improved towards a pattern catalog that detects patterns in all their variations. The customizable pattern definitions are created from reusable feature types. Each feature type can use one or more searching techniques for efficient detection. The proposed approach supports detection of patterns from multiple programming languages. A prototype implementation of the approach was tested on seven different open-source software projects. For each software project, a baseline was determined and the trustworthiness of each pattern-project combination was rated. The extracted results have been compared

View PDFchevron_right
Flexible design pattern detection based on feature types
Ghulam Rasool

2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011), 2011

Accurately recovered design patterns support development related tasks like program comprehension and reengineering. Researchers proposed a variety of recognition approaches already. Though, much progress was made, there is still a lack of accuracy and flexibility in recognition. A major problem is the large variety of variants for implementing the same pattern. Furthermore, the integration of multiple search techniques is required to provide more accurate and effective pattern detection. In this paper, we propose variable pattern definitions composed of reusable feature types. Each feature type is assigned to one of multiple search techniques that is best fitting for its detection. A prototype implementation was applied to three open source applications. For each system a baseline was determined and used for comparison with the results of previous techniques. We reached very good results with an improved pattern catalog, but also demonstrated the necessity for customizations on new inspected systems. These results demonstrate the importance of customizable pattern definitions and multiple search techniques in order to overcome accuracy and flexibility issues of previous approaches.

View PDFchevron_right
Model-driven detection of Design Patterns
Giuseppe Di Lucca

2010 IEEE International Conference on Software Maintenance, 2010

Tracing source code elements of an existing Object Oriented software system to the components of a Design Pattern is a key step in program comprehension or re-engineering. It helps, mainly for legacy systems, to discover the main design decisions and trade-offs that are often not documented. In this paper an approach is presented to automatically detect Design Patterns in existing Object Oriented systems by tracing system's source code components to the roles they play in the Patterns. Design Patterns are modelled by high level structural Properties (e.g. inheritance, dependency, invocation, delegation, type nesting and membership relationships) that are checked, by source code parsing, against the system structure and components. The approach allows to detect also Pattern variants, defined by overriding the Pattern structural properties. The approach was applied to some open-source systems to validate it. Results on the detected patterns, discovered variants and on the overall quality of the approach are provided and discussed.

View PDFchevron_right

Related topics

  • Computer Science
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved