 Open Access
 Authors : Rajwant Singh Rao
 Paper ID : IJERTV8IS110353
 Volume & Issue : Volume 08, Issue 11 (November 2019)
 Published (First Online): 03122019
 ISSN (Online) : 22780181
 Publisher Name : IJERT
 License: This work is licensed under a Creative Commons Attribution 4.0 International License
A Review on Design Pattern Detection
Rajwant Singh Rao
Department of Computer Science & Information Technology Guru Ghasidas Vishwavidyalaya (A Central University), Bilaspur (C. G.)
Abstract In many object oriented software, there are recurring patterns of classes. With the help of these patterns specific design problem can be solved and object oriented design become more flexible and reusable. Design Pattern existence improve the program understanding and software maintenance. Hence a reliable design pattern mining is required. Graph Matching algorithms are useful and very general form of pattern matching to find the realistic use in several areas. In this paper we are reviewing the different graph matching algorithms to detect design patterns.
Keywords Design pattern, UML, matrix, subgraph isomorphism
I. INTRODUCTION
To reuse expert design experiences, the design patterns [1] have been extensively used by software industry. When patterns are implemented in a system, the patternrelated information is generally no longer available. To understand the systems and to modifications in them it is necessary to recover pattern instances. For graph matching there are many algorithms, we are reviewing some of the algorithms which can be applied for design pattern detection. The details of each of the algorithms are discussed in sections.

Exact graph matching algorithms
Exact graph matching algorithms [7], used to find a oneto one mapping (isomorphism) between the nodes of two graphs which have the same number of nodes so that there is also a oneto one mapping between the related edges. In the context of design pattern detection, the application of such an algorithm would require the Examination of all possible sub graphs of the system Graph that have the same number of vertices with the pattern. The most important drawback, is that a given design pattern may be implemented in various forms that differ from the basic structure found in the literature, and as a result exact matching is insufficient for design pattern detection.

Inexact Graph Matching Algorithm
The inexact graph matching procedure is used when an one to one correspondence is not found between two graphs and the purpose is to find the finest corresponding between both graphs. There are procedures which compute the edit distance between two graphs [1], defined as the number of alterations required to reach from one graph to the other graph. In the background of design pattern finding this gives incorrect results.
In inexact graph matching process which graph takings fewer number of alterations to reach to the goal graph is supposed to the nearer to the goal graph.

Kleinberg Approach for Vertices Scoring
Kleinberg [3] offered a link analysis system for identifying pages on the web (by computing hub and authority). That is authoritative sources on broad search queries.
The hubs can be defined as pages which points to several good authorities and authorities are the pages which are pointed to by several good hubs. The disadvantage of this process is that it only computes the similarity between two nodes rather than whole graph. To remove this drawback another approach is introduced, called sub graph isomorphism detection.

Exact and Approximate Matches
There is lack of research on the set of characteristics of each pattern. It needs to be checked, most of the researchers simplify the problem by making their own definitions. Most approaches give a piece of architectural design which structurally confirms to the structural characteristics of the pattern that they defined and behaviorally exhibits the expected actions that they defined. As the time over they find that all matching rules are conformed and they claim to find a match. If some of the rules are not conformed they claim a mismatch. Therefore there is a need to solve this problem. But different definition of the same pattern seems to make different search results. Some pattern candidates which are real instances are filtered out due to strict exact matches and some approaches perform approximate matches by computing the similarity degree.
V (a). Similarity Scoring
V (c) Comparative study between exact match and approximate matching
Exact matching is required when the system piece is exactly the same as the pattern, i. e., a range in [0, 1] can be used as the matching degree So the exact matching selects system pieces with a matching degree of 1, and eliminates those with a degree less than 1. Exact matching approaches usually omit the effort of calculating matching degrees. While approximate matching sets a number between 0 and 1 as the threshold. For example 0.8 can be a reasonable threshold. Thus, any system piece with a matching degree equal to or higher than 0.8 is retained and others are filtered out when matching a particular pattern.
Niere et al. [47] purposed fuzzybelief, a value between 0 and 1, for each structural rule which express its precision. To limit the rule applications to reasonable cases, they introduce thresholds to the rules. The match with a fuzzy value lower
than the threshold will be excluded. This helps to minimize computation load and improve the scalability. Tsantalis et al. [44] applied a similarity scoring algorithm, an inexact graph matching algorithm, to compute matching degree between system under study and the pattern, when an exact isomorphism between two graphs cannot be found. Dong et al. [6] applied a template matching algorithm to calculate the matching degree between a piece of system and a design pattern. GuÃ©hÃ©neuc et al. [42] propose a machine learning algorithm to compute software metrics and use the degree of confidence to infer the rules by a rule learner. Ferenc et al.
[43] introduce predictors for each pattern and use machine learning algorithm training the pattern recognizer to acquire the value of the predictors. These predictor values are then used as the standards to compare with the predictor values13 obtained for system under study. A preprocessing algorithm is also proposed by Dong et al. [48] for generating the training set of machine learning algorithms for pattern mining. Table 1 gives the categorization of different tools on exact or approximate matching.
Matching Technique
Authors
Tools
Exact Match
Kramer 1996 [12]
Pat
Seemann 1998[19]
Bansiya 1998[8]
DP++
Antoniol 1998 [14]
Tonella 1999 [20]
Keller 1999 [10]
SPOOL
Blewitt 2001 [21]
Hedgehog
Mei 2001 [22]
JBOORET
AlbinAmiot 2001 [23]
Ptidej
Asencio 2002 [24]
Wendehals 2003 [25]
Smith 2003 [26]
SPQR
Heuzeroth 2003 [27][28]
Beyer 2003 [29]
CroCoPat
Park 2004 [30]
Zhang 2004 [31]
Costagliola 2005 [32][33]
DPRE
Streitferdt 2005 [34]
Huang 2005 [35]
PRAssistor
Wang 2005 [36]
DPVK
Kaczor 2006 [37]
Ptidej
Shi 2006 [38]
PINOT
Dong 2007 [39][40]
DPMiner
Approximate Match
Niere 2002 [41]
FUJABA
GuÃ©hÃ©neuc 2004 [42]
Ferenc 2005 [43]
Columbus
Tsantalis 2006 [44]
Table 1 Categorization of Current Discovery Method Based on Matching Techniques [48]

Sub Graph Isomorphism Detection

Theoretical Approach
The subgraph isomorphism is a convenient generalization of graph isomorphism. The subgraph isomorphism problem [4] is define whether a graph is isomorphic to a subgraph of any other graph. Consider [5] G1 (V1, E1) and G2 (V2, E2) be two graphs, where V1, V2 are the set of nodes and E1, E2 are the set of edges. Let M1 and M2 be the adjacency matrices of dimensions m x m and n x n, where m < =n, corresponding to the graphs G1 and G2 respectively. A
permutation matrix is a square (0, 1)matrix that has exactly one entry 1 in each row and each column and 0's elsewhere. Two graphs G1 (M1, Lv, Le) and G2 (M2, Lv, Le) are said to be isomorphic [5] if there exist a permutation matrix P such that
M2 = P M1 PT (1)
A subgraph S of a graph G, G, is a graph S = (Mi, Lv, Le) where Mi = Sm,m(P M PT) is an m x m adjacency matrix for some permutation matrix P.
There is a subgraph isomorphism from G1 to G2 if there exists an n x n permutation matrix P such that
M1 = Sm,m(P M2 PT) (2)
We take M2 matrix as a system design matrix and we guess nondeterministically M1 as a design pattern matrix. And then try to find out whether M1 is subisomorphic to M2 or not or it can be easily said whether there exist design pattern in the system graph or not.
Hence the problem of finding a subgraph isomorphism from graph G1 to G2 is equivalent to finding a permutation matrix for which equation (2) holds. Thus, we generate permutation adjacency matrix of a model graph (system under study) one by one and check whether equation (2) holds or not, when it holds we stop and declare that that particular design pattern has been detected. It can be also possible that there is no design pattern exists in system graph. In this case we find no permutation matrix for which equation (2) holds.


Searching for minimal key structures
In this method a defined key structure is associated to each pattern. The key structure for pattern describes the number of minimum classes and objects that are present in that structure. By define the key structure of pattern the pattern can be securely identified. The properties of key structure are used as the search criteria. There are three software systems for automated searching is known which are based on this approach. These are DP++[8], for C++, KT [9] for Smalltalk and SPOOL [10] realized for C++, applicable for Java and Smalltalk.
The DP++[8] searches the following design patterns: COMPOSITE, DECORATOR, ADAPTER, FACADE, BRIDGE, FLYWEIGHT, TEMPLATE METHOD and
CHAIN OF RESPONSIBILITY. DP++ [8] is not applicable for other patterns. This tool has three parts: (i) C++ Code Translation Subsystem used for analyzing source code. (ii) Pattern Detection Subsystem used for the recognition of generation patterns and (iii) Display Subsystem used for the visualization of detected patterns. Information about the achieved values of recall and precision is not available.
KT [9] is able to search COMPOSITE, DECORATOR, STATE, STRATEGY, COMMAND, TEMPLATE METHOD and CHAIN OF RESPONSIBILITY patterns. It
is unable to recognize INTERPRETER pattern .The information about other patterns are not mentioned.
Information about the achieved values of recall and precision is not available.
SPOOL [10] is capable of searching BRIDGE, FACTORYMETHOD and TEMPLATEMETHOD patterns.

Searching for class structures

This approach uses the pattern class structures described by Gamma patterns [11].For example consider the following figure 18. This is the composite pattern. A composition pattern exit if a class has at least two subclasses and one of them has 1 to n aggregation to the super class. There are three software systems for automated search which are based on this approach. These are Pat [12] for C++, IDEA [13] for UML diagrams and the multistep search tool [14].
A
B 
C 
Fig.18. A Composite Pattern
patterns, such as Kramer [12] and Costagliola [32][33], usually discover structural patterns with few behavioral patterns. Approaches which takes both structural and behavioral patterns, such as Heuzeroth et al. [27][28], are able to discover more behavioral patterns.
XII. Experiments
To evaluate the different approaches experiment is the good way. Table 4 shows a list of software system used in the experiments by different studies. It is difficult to evaluate the precision value of different approaches since there is a lack
Pat [12] describes the pattern class structure by PROLOG rules. This tool is able to finds ADAPTER, PROXY, BRIDGE, DECORATOR and COMPOSITE patterns. This search tool has been been tested with software systems containing 9343 classes. The achieved recall value in each case is 100% and the average precision value is 36.75%. IDEA [13] based on UML search approach which uses class and collaboration diagrams. It also used PROLOG rules. This is able to find the following patterns: TEMPLATE METOD, PROXY, ADAPTER, BRIDGE, COMPOSITE, DECORATOR, FACTORY METHOD, ABSTRACT FACTORY, ITERATOR, OBSERVER and PROTOTYPE.
The multi step search tool [14] is able to find the following patterns ADAPTER, BRIDGE, PROXY, COMPOSITE and
DECORATOR. This is unable to recognize the other patterns.
The multi step search tool was tested with different C++ Libraries [14]. The achieved recall value is 100% and an average precision value is 35%..

Discovered Patterns
Since there are large numbers of available patterns, each approach often considers only a small number of patterns. The following table 3 shows the summarization of patterns discovered by different tools. This table show that the approaches that focus to the structural aspect of
of document of these systems, especially for open source system.

Analysis of Experiment Results
As shown in Table 2 and Table 4 most approaches given experiments on mining different patterns from some application systems. Based on study in the previous section we found that different approaches give different results when mining the same pattern in the same system. For instance, Table 5 shows the comparison of the mining results of the same design patterns from the same systems by two different approaches.
Authors 
Tools 
Languag e 
Structural (ST) Behavioral (BE) Semantic (SE) 
Exact (EX) Approximate (AP) match 
Autom atic(AT) Inter active(IT) 
Techniques 
System Representation 
Pattern Representatio n 
Kramer 1996 [12] 
Pat 
C++ 
ST 
EX 
AT 
Prolog 
Prolog 
Prolog 
Seemann 1998[19] 
Java 
ST 
EX 
AT 
first order logic, graph 
Graph 
Predicate 

Bansiya 1998[8] 
DP++ 
C++ 
ST 
EX 
AT 
class hierarchy 
text 

Antoniol 1998 [14] 
C++ 
ST & BE 
EX 
AT/p> 
metrics 
AST 
AOL 

Tonella 1999 [20] 
C++ 
ST & BE 
EX 
AT 
concept analysis 

Keller 1999 [10] 
SPOOL 
C++ 
EX 
IT 
UML/CDIF 

Blewitt 2001 [21] 
Hedgeh og 
Java 
ST & BE & SE 
EX 
AT 
Spine 

Mei 2001 [22] 
JBOOR ET 
C++ 
ST 
EX 

AlbinAmiot 2001 [23] 
Ptidej 
Java 
EX 
AT 
CSP 

Asencio 2002 [24] 
C++ 
ST 
EX 
IT 

Wendehals 2003 [25] 
Java 
ST & BE 
EX 
AT 
dynamic runtime data 
ASG & call graph 

Smith 2003 [26] 
SPQR 
C++ 
ST 
EX 
AT 
OTTER rho calculus 
OML & OTTER 
otter rules 
Heuzeroth 2003 [27][28] 
Java 
ST & BE 
EX 
AT 
SanD and SanD Prolog 
AST 
AST &TLA 
Beyer 2003 [29] 
CroCoP at 
Java 
ST 
EX 
AT 
predicate calculus 
BDDs 
predicates 
Park 2004 [30] 
BE 
EX 
AT 
Class Diagram 

Zhang 2004 [31] 
ST 
EX 
AT 
Graph (matrix) 
Graph (matrix) 

Costagliola 2005 [32][33] 
DPRE 
C++ Java 
ST 
EX 
AT 
XPG formalism & LRbased parsing 
SVG & AOL >AST 
Grammar based Pattern Specification 
Streitferdt 2005 [34] 
Java 
ST 
EX 
AT 

Huang 2005 35] 
PRAssi stor 
EX 
AT 

Wang 2005 [36] 
DPVK 
ST & BE 
EX 
AT 
REQL query 
REQL static & RSF dynamic 
REQL script 

Kaczor 2006 [37] 
Ptidej 
Java 
ST 
EX 
AT 
bit representation 
bit representation 

Shi 2006 [38] 
PINOT 
Java 
ST & BE 
EX 
AT 
Data/Control Flows 
AST 
DFG & CFG 
Dong 2007 [39][40] 
DP Miner 
Java 
ST & BE & SE 
EX 
AT 
Matrix and Weight 
XMI 
XMI 
Niere 2002 [41] 
FUJAB A 
Java 
AP 
IT 
bottomup & top down 
ASG 
ASG 

GuÃ©hÃ©neuc 2004 [42] 
Java 
ST 
AP 
AT 
XML tree & PADL 
PADL 

Ferenc 2005 [43] 
Columb us 
C++ 
ST 
AP 
AT 
ASG, XML DOM tree 
DPML 

Tsantalis 2006 [44] 
Java 
ST 
Ap 
AT 
Similarity Matrix 
matrix 
Table 2 Comparison of Pattern Recovery Approaches
Authors 
Abstract Factory 
Adapter/Command 
Builder 
Bridge 
Chain of Responsibilities 
Command 
Composite 
Decorator 
Facade 
Factory Method 
Flyweight 
Mediator 
Observer/MVC 
Prototype 
Proxy 
Singleton 
Strategy/State 
Template Method 
Visitor 
Kramer 1996 [12] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Seemann 1998[19] 
Ã— 
Ã— 
Ã— 

Antoniol 1998 [14] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Keller 1999 [10] 
Ã— 
Ã— 
Ã— 

Blewitt 2001 [21] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Asencio 2002 [24] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Heuzeroth 2003 [27][28] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Balanyi 2003 [45] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Hericko 2005 [46] 
Ã— 
Ã— 
Ã— 

Costagliola 2005 [32] [33] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Huang 2005 [35] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Kaczor 2006 [37] 
Ã— 
Ã— 

Shi 2006 [38] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Dong 2007 [39][40] 
Ã— 
Ã— 
Ã— 
Ã— 

Niere 2002 [41] 
Ã— 
Ã— 
Ã— 

GuÃ©hÃ©neuc 2004 [42] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Ferenc 2005 [43] 
Ã— 
Ã— 

Tsantalis 2006 [44] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Table 3 Design Patterns Discovered by Different Approaches
Authors 
Galib 
LEDA 
Libg++ 
Java AWT 
Java Swing 
JDK 
JEdit 
JHotDraw 
JRefactory 
JUnit 
Mec 
QuickUML 
Socket 
zApp class library 
Other 
Kramer 1996 [12] 
Ã— 
Ã— 

Seemann 1998[19] 
Ã— 

Antoniol 1998 [14] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Tonella 1999 [20] 
Ã— 

Keller 1999 [10] 
Ã— 

Blewitt 2001 [21] 
Ã— 

AlbinAmiot 2001 [23] 
Ã— 
Ã— 
Ã— 
Ã— 

Asencio 2002 [24] 
Ã— 

Beyer 2003 [29] 
Ã— 
Ã— 
Ã— 
Ã— 

Heuzeroth 2003 [27][28] 
Ã— 
Ã— 

Balanyi 2003 [45] 
Ã— 
Ã— 

Costagliola 2005 [32] [33] 
Ã— 
Ã— 
Ã— 
Ã— 

Streitferdt 2005 [34] 
Ã— 
Ã— 

Huang 2005 [35] 
Ã— 
Ã— 

Kaczor 2006 [37] 
Ã— 
Ã— 
Ã— 

Shi 2006 [38] 
Ã— 
Ã— 
Ã— 
Ã— 

Dong 2007 [39][40] 
Ã— 
Ã— 
Ã— 
Ã— 

Niere 2002 [41] 
Ã— 
Ã— 

GuÃ©hÃ©neuc 2004 [42] 
Ã— 
Ã— 
Ã— 
Ã— 
Ã— 

Ferenc 2005 [43] 
Ã— 

Wang 2005 [36] 
Ã— 

Tsantalis 2006 [44] 
Ã— 
Ã— 
Ã— 
Table 4 Experiments Done in Different Studies
Systems 
JHotDraw5.1 
JRefactory2.6.24 
JUnit3.7 

Authors 
Tsantalis et al. 2006 [44] 
GuÃ©hÃ©neuc et al. 2004 [42] 
Tsantalis et al. 2006 [44] 
GuÃ©hÃ©neuc et al. 2004 [42] 
Tsantalis et al. 2006 [44] 
GuÃ©hÃ©neuc et al. 2004 [42] 
Adapter 
18 
1 
7 
7 
1 
0 
Composite 
1 
1 
0 
0 
1 
1 
Decorator 
3 
1 
1 
0 
1 
1 
Factory Method 
3 
3 
4 
1 
0 
0 
Observer 
5 
2 
0 
0 
4 
3 
Prototype 
1 
2 
0 
0 
0 
0 
Singleton 
2 
2 
12 
2 
0 
2 
State 
23 
2 
12 
2 
3 
0 
Template Method 
5 
2 
17 
0 
1 
0 
Visitor 
1 
0 
2 
2 
0 
0 
Table 5 Different Results from the Same System of the Same Version
CONCLUSION:
The exact graph matching, inexact graph matching and Kleinberg Approach for vertices scoring shows the similarity between nodes not in the whole graph. This drawback, is reduced by sub graph isomorphism detection. The subgraph isomorphism shows whether a graph is isomorphic to a subgraph of any other graph or not .It uses
the concept of Overall matrix to reduce the number of manipulations, it combines different matrices (like generalization matrix, association matrix, dependency matrix, aggregation matrix etc) into a single matrix. So there will be only two overall matrices, one corresponding to system and one for design pattern. After it we try to find out
whether a particular design pattern exists on the given graph. This paper also shows different table on several studies.
REFERENCES:

D.J. Cook and L.B. Holder, Substructure Discovery Using Minimum Description Length and Background Knowledge,J.
Artificial Intelligence Research, vol. 1, pp. 231255, Feb. 1994

J.M. Smith, An Elemental Design Pattern Catalog, echnical Report TR02040, Dept. of Computer Science, Univ. of North Carolina, Oct. 2002.

J.M. Kleinberg, Authoritative Sources in a Hyperlinked Environment, J. ACM, vol. 46, no. 5, pp. 60432, Sept. 999.

Gabriel Valiente, Algorithms On Trees And Graphs, 2002, page 367

B.T. Messmer, H. Bunke, Subgraph isomorphism detection in polynomial time on preprocessed model graphs, Second Asian Conference on Computer Vision, 1995, pp. 151155.

Jing Dong, Yongtao Sun, Yajing Zhao, Design Pattern Detection By Template Matching, the Proceedings of the 23rd Annual ACM Symposium on Applied Computing (SAC), pages 765769,CearÃ¡,
Brazil, March 2008

Nikolaos Tsantalis, Alexander Chatzigeorgiou, George Stephanides, and Spyros T. Halkidis, Design Pattern Detection Using Similarity Scoring

Bansiya J (1998) Automatic DesignPattern Identification. Dr.
Dobbs Journal. Available online at: http://www.ddj.com

Brown K (1996) Design reverseengineering and automated design pattern detection in Smalltalk. Masters thesis. Department of Computer Engineering, North Carolina State University. Available online at: http://www.ncsu.edu/

Keller RK, Schauer R, Robitaille S, Page P (1999) Pattern based reverse engineering of design components. In: Proc. Of the 21st International Conference On Software Engineering. IEEE Computer Society Press, pp 226235

Gamma E, Helm R, Johnson R, Vlissides J (1995) Design Patterns
Elements of Reusable ObjectOriented Software, Addison Wesley

Kraemer C, Prechelt L (1996) Design recovery by automated search for structural design patterns in objectoriented software. In: Proc. of the Working Conference on Reverse Engineering, pp. 208215

Bergenti F, Poggi A (2000) Improving UML design using automatic design pattern detection. In: Proc. 12th. International Conference on Software Engineering and Knowledge Engineering (SEKE 2000), pp 336343

Antoniol G, Fiutem R, Cristoforetti L (1998) Design pattern recovery in objectoriented software. In: 6th International Workshop on Program Comprehension, June, pp 153160

Niere J, Wadsack JP, Wendehals L (2001) Design pattern recovery based on source code analysis with fuzzy logic. Technical eport trri01222, University of Paderborn. Available online

Kim H, Boldyreff C (2000) A method to recover design patterns using software product metrics. In: Proc. of the 6th International Conference on Software Reuse (ICSR6).Available online at: http://www.soi.city.ac.uk/hkim69/ publications/icsr6.pdf

V.D. Blondel, A. Gajardo, M. Heymans, P. Senellart, and P. Van Dooren, A Measure of Similarity between Graph Vertices: Applications to Synonym Extraction and Web Searching, SIAM Rev.,vol. 46, no. 4, pp. 647666, 2004.

D.H. Ballard and C.M. Brown, Computer Vision, Prentice Hall, 1982.

J. Seemann and J. Wolff. von Gudenberg, Patternbased design recovery of Java software. In Proceedings of 6th ACM SIGSOFT International Symposium on Foundations of Software Engineering, pp. 1016. ACM Press, 1998.

P. Tonella, G. Antoniol, Object oriented design pattern inference. In Proceedings of International Conference on Software Maintenance (ICSM99), 1999.

Blewitt and A. Bundy, Automatic verification of Java design patterns. Proceedings of International Conference on Automated Software Engineering, pp. 324327, 2001.

H. Mei, T. Xie, and F. Yang, JBOORET: an automated tool to recover OO design and source models. In Proceedings of the 25h Annual International Computer Software & Applications Conference (COMPSAC), 2001.

H. AlbinAmiot, P. Cointe, Y. GuÃ©hÃ©neuc, and N. Jussien, Instantiating and detecting design patterns: putting bits and pieces together. In Proceedings 16th Annual International Conference on Automated Software Engineering (ASE), 2001.

Asencio, S. Cardman, D. Harris, and E. Laderman, Relating expectations to automatically recovered design patterns. Proceedings of the 9th Working Conference on Reverse Engineering (WCRE), 2002.

L. Wendehals, Improving design pattern instance recognition by dynamic analysis. Proceedings of the ICSE workshop on Dynamic Analysis, pp. 2932, 2003.

J. M. Smith and D. Stotts, SPQR: Flexible automated design pattern extraction from source code. In Proceedings of the 18th IEEE International Conference on Automated Software Engineering (ASE), 2003.

D. Heuzeroth, T. Holl, G. Hogstrom, and W. Lowe, Automatic design pattern detection. In Proceedings of the 11th International Workshop on Program Comprehension (IWPC 2003), pp 94103, 2003.

D. Heuzeroth, S. Mandel, and W. Lowe, Generating design pattern detectors from pattern specifications. Proceedings of the 18th IEEE International Conference on Automated Software Engineering (ASE), 2003.

D. Beyer, A. Noack, and C. Lewerentz, Simple and efficient relational querying of software structures. In Proceedings of the 10th Working Conference on Reverse Engineering (WCRE03), 2003.

C. Park, Y. Kang, C. Wu, and K. Yi, A static reference analysis to understand design pattern behavior. In Proceedings of the 11th Working Conference on Reverse Engineering (WCRE04), 2004

Z. Zhang, Q. Li, and K. Ben, A new method for design pattern mining. In Proceedings of the 3rd International Conference on Machine Learning and Cybernetics, 2004.

G. Costagliola, A. De Lucia, V. Deufemia, C. Gravino, and M. Risi, Design Pattern Recovery by Visual Language Parsing, Proceeding of the Ninth European Conference on Software Maintenance and Reengineering. (CSMR05), pp. 102111, 2005.

G. Costagliola, A. Lucia, V. Deufemia, C. Gravino, and M. Risi, Case studies of visual language based design patterns recovery. In Proceedings of the Conference on Software Maintenance and Reengineering (CSMR), 2006.

D. Streitferdt, C. Heller, I. Philippow, Searching design patterns in source code. In Proceedings of the 29th Annual International Computer Software and Application Conference. (COMPSAC), 2005.

Heyuan Huang, Shensheng Zhang, Jian Cao, Yonghong Duan, A practical pattern recovery approach based on both structural and behavioral analysis, Journal of Systems and Software, 75(12), pp.6987, February 2005

W. Wang and V. Tzerpos, Design pattern detection in Eiffel systems. In Proceedings of 12th Working Conference on Reverse Engineering (WCRE05), 2005.

Kaczor, Y. GuÃ©hÃ©neuc, and S. Hamel, Efficient Identification of Design Patterns with Bitvector Algorithm, Proceedings of the Conference on Software Maintenance and Reengineering (CSMR), 2006.

N. Shi and R. A. Olsson, Reverse engineering of design patterns from java source code. 21st IEEE/ACM International Conference on Automated Software Engineering, 2006.

J. Dong, D. S. Lad and Y. Zhao, DPMiner: Design Pattern Discovery Using Matrix. The Proceedings of the Fourteenth Annual IEEE International Conference on Engineering of Computer Based Systems (ECBS), Arizona, USA, March 2007.

J. Dong and Y. Zhao, Experiments on Design Pattern Discovery, the Proceedings of the 3rd International. Workshop on Predictor Models in Software Engineering (PROMISE), in conjunction with ICSE, USA, May 2007.

J. Niere, W. Schafer, J. P. Wadsack, L. Wendehals, and J. Welsh, Towards patternbased design recovery. In Proceedings of the 24th International Conference on Software Engineering (ICSE), pp 338348, 2002.

Y. GuÃ©hÃ©neuc, H. Sahraoui, and F. Zaidi, Fingerprinting design patterns. Proceedings of the 11th Working Conference on Reverse Engineering (WCRE), 2004.

R. Ferenc, A. Beszedes, L. Fulop, and J. Lele, Design pattern mining enhanced by machine learning. In Proceedings of the 21st IEEE International Conference on Software Maintenance (ICSM05), 2005.

N. Tsantalis, A. Chatzigeorgiou, G. Stephanides, and S. Halkidis, Design Pattern Detection Using Similarity Soring. IEEE transaction on software engineering, Vol. 32,No. 11, November 2006.

Z. Balanyi and R. Ferenc, Mining design patterns from C++ source code. Proceedings of the 19th IEEE International Conference on Software Maintenance (ICSM), pp. 305314, September, 2003.

M. Hericko and S. Beloglavec, A composite designpattern identification technique. Informatica 29, pp 469476, 2005

J. Niere, J. P. Wadsack, L. Wendehals, Handling large search space in patternbased reverse engineering. Proceedings of the 11th IEEE International Workshop on Program Comprehension (IWPC), pp. 274279, 2003.

Jing Dong, Yongtao Sun, Yajing Zhao, Compound Record Clustering Algorithm for Design Pattern Detection by Decision Tree Learning, the Proceedings of the IEEE International Conference on Information Reuse and Integration (IRI), USA, July 2008.