Detecting Meta-Patterns from Frameworks Using Hybrid Genetic Algorithm (original) (raw)
Related papers
A Technique for Design Patterns Detection
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
International Journal of Computer Applications, 2016
Design patterns have been proposed as a technique to introduce reuse in design phase. In industry, it is focused to reuse design patterns as a reusable part when designing a new application. Reusable Design Pattern, that are proven solutions to common design problems, to improves many qualities of applications like Reusability and its maintainability. If better reusability is required for an application where design patterns were used, then an automated tool that can detect the used design pattern in the application will be useful. Therefore, a reliable design pattern discovery is required to promote software reusability. The techniques of finding an isomorphic sub-graph were used to solve design pattern detection in past. Furthermore, we are applying a hybrid genetic algorithm for sub-graph isomorphism problem which uses an incremental approach to detect design patterns. Moreover, detection is done with increasing the size of sub-problem step by step. A hybrid GA is applied to each sub-problem, initialized with the evolved population of previous step. This proposed work of identifying and then later reusing of design pattern facilitate to bring software design in reduced time and consequently expedite software reusability.
Meta-modeling design patterns: Application to pattern detection and code synthesis
2001
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.
A Review on Design Pattern Detection
2019
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
Finding the design pattern from the source code for developing reusable object oriented software
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.
A Novel Approach to Automated Design Pattern Detection
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...
Model-driven detection of Design Patterns
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.
Language-Independent Detection of Object-Oriented Design Patterns
This paper shows that one can reason at a meta level about the structure of object-oriented source code in a language-independent way. To achieve this, we propose a language-independent meta-level interface to extract complex information about the structure of the source code. This approach is validated by defining a set of logic queries to detect object-oriented best practice patterns and design patterns in two different languages: Smalltalk and Java. The queries were applied to two similar medium-sized applications available for each language, and the results were confirmed by manually investigating the source code and available documentation.
Sub-graph Mining: Identifying Micro-architectures in Evolving Object-Oriented Software
2011
Abstract Developers introduce novel and undocumented micro-architectures when performing evolution tasks on object-oriented applications. We are interested in understanding whether those organizations of classes and relations can bear, much like cataloged design and anti-patterns, potential harm or benefit to an object-oriented application.
Detecting Patterns In Object-Oriented Source CodeA Case Study
do
Pattern detection methods discover recurring solutions in a system's implementation, for example design patterns in object-oriented source code. Usually this is done with a pattern library. This has the disadvantage that the precise implementation of the patterns must be known in advance. The method used in our case study does not have this disadvantage. It uses a mathematical technique called Formal Concept Analysis and is applied to find structural patterns in two subsystems of a printer controller. The case study shows that it is possible to detect frequently used structural design constructs without upfront knowledge. However, even the detection of relatively simple patterns in relatively small pieces of software takes a lot of computing time. Since this is due to the complexity of the applied algorithms, applying the method to large software systems like the complete controller is not practical. They can be applied to its subsystems though, which are about five to ten percent of its size.