Discovery of design patterns variants for quality software development

Nowadays, an increase in the growth of software systems has risen the importance of the design phase. So far, developers have introduced numerous software design patterns. This study presents a new method to select the Gang of Four (GoF) design patterns. The proposed method is implemented based on the vector space model (VSM). In this method, the Term Frequency-Inverse Document Frequency (TF-IDF) weighting algorithm has been improved to determine the similarity between two texts, more accurately. Also, we used a set of hyponyms and synonyms of the words in weighting. We evaluated the proposed method with 23 design patterns, 29 object-oriented related design problems, and nine real-world problems. Finally, we observed promising results compared to other methods. We found 8.5%, 1.2%, and 5.2% improvement in terms of precision, recall, and accuracy of the proposed method as compared to other methods.

A declarative approach to detecting design patterns from Java execution traces and source code

In October 1994, Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides published a book they wrote on the topic of software engineering, identifying common problems in software design and classifying their solutions in groups of design patterns. After 500,000 copies sold in 13 different languages around the world, the original authors would come to be famously known as the Gang of Four (GoF), and their design patterns have since made it into countless articles, journals, books and software development kits (SDKs).KeywordsDesign PatternData LayerBusiness ObjectApplication CodeProvider TypeThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Design patterns in software development have shown great promise in improving software quality. Traditionally, software developers utilize a set of design patterns to foster reusability and better software design. Recently, mobile applications (apps) have become a mainstay of modern computing, as well as, a challenging domain for software engineers. This is because mobile apps now target more critical domains such as health, banking, m-payments, and even military to mention just a few. Android is a very popular mobile platform, and has managed to take over the majority of mobile market. It is true that there are comprehensive studies in the area of design patterns detection in several object-oriented languages such as Java, C# and C++. However, little studies target design patterns in Android apps. As a step toward helping to measure and explore the application of design patterns in Android apps, we introduce PatRoid, an automated framework for detecting design patterns. PatRoid is a model-based approach that is able to detect design patterns laying inside Android apps source code. The model is based on a graph isomorphism approach, where design patterns are divided into sub-patterns that can be aggregated to formulate design patterns. We have conducted a preliminary evaluation and the results show that PatRoid can detect all of the 23 GoF design patterns.

Periodic refactoring of a large source code often becomes a ne- cessity especially for long-lived projects. In order to increase maintainabil- ity and extensibility of such projects, design pattern based refactoring can be seen as an emerging alternative. Manual inspection of source code to find candidate spots where patterns can be introduced is time consuming. Therefore automated tools can help in identifying candidate spots where patterns can be introduced. The level of source code abstraction plays an important role for building such tools. We propose a new abstrac- tion for object oriented source code that is named as Refactoring Pattern (ReP) Graph to realize an eective design pattern based refactoring tool. The ReP graph abstracts the source code information thereby making the process of design pattern inference easier. The proposed tool identifies candidate spots in a given source code to introduce design patterns.

Design patterns are elegant and well-tested solutions to recurrent software development problems. They are the result of software developers dealing with problems that frequently occur, solving them in the same or a slightly adapted way. A pattern's semantics provide the intent, motivation, and applicability, describing what it does, why it is needed, and where it is useful. Consequently, design patterns encode a well of information. Developers weave this information into their systems whenever they use design patterns to solve problems. This work presents Feature Maps, a flexible human- and machine-comprehensible software representation based on micro-structures. Our algorithm, the Feature-Role Normalization, presses the high-dimensional, inhomogeneous vector space of micro-structures into a feature map. We apply these concepts to the problem of detecting instances of design patterns in source code. We evaluate our methodology on four design patterns, a wide range of balanced and imbalanced labeled training data, and compare classical machine learning (Random Forests) with modern deep learning approaches (Convolutional Neural Networks). Feature maps yield robust classifiers even under challenging settings of strongly imbalanced data distributions without sacrificing human comprehensibility. Results suggest that feature maps are an excellent addition in the software analysis toolbox that can reveal useful information hidden in the source code.

Design pattern detection is a popular re-engineering job in software development. It provides essential information to the developers to recognize, sustain, and recycle the software. This article proposes a graph matching algorithm using a correlation-based feature selection technique to discover the design pattern (DP) instances from the software or system design. Usually, the feature selection method is used to choose the best instances from the dataset, which mostly matches the target feature. However, this paper has applied a correlation feature selection method to match the system design to the design pattern. We have taken three DPs comparing examples for this intention:•the first example for an entire match•the second example for a partial match•the third example of a not matchIn this experiment, we took the Abstract factory DP as a model graph, and the remaining twenty-two DPs are system or DPs. Software instances groups lots of classes and objects we converted into a graph. We observed that three of the 22 DPs are completely matched to the model DP, one pattern is not matched, and the remaining 18 patterns are only partially matched.

Detection of design patterns is an important part of reverse engineering. Availability of patterns provides for a better understanding of code and also makes analysis more efficient in terms of time and cost. In recent years, we have observed a continual improvement in the field of automatic detection of design patterns in source code. Existing approaches can detect a fairly broad range of design patterns, targeting both structural and behavioral aspects of patterns. However, it is not straightforward to assess and compare these approaches. There is no common ground on which to evaluate the accuracy of the detection approaches, given the existence of variants and specific code constructs used to implement a design pattern. We propose a systematic approach to constructing a comprehensive test suite for detectors of design patterns. This approach is applied to construct a test suite covering the Singleton pattern. The test suite contains many implementation variants of these patterns, along with such code constructs as method forwarding, access modifiers, and long inheritance paths. Furthermore, we use this test suite to compare three detection tools and to identify their strengths and weaknesses.

Recovering design pattern usage in source code is a very difficult task. Several tools are described in the literature for this purpose, but there is little work invested in evaluating them. The main reason for this is the lack of an approved benchmark for these tools. In this paper we present work in progress towards creating a benchmark, called DEEBEE (design pattern evaluation benchmark environment), for evaluating and comparing design pattern miner tools. It is programming language, tool, pattern and software independent, and it is open to the community and freely available. Currently, the benchmark database contains the results of three tools: Columbus (C++), Maisa (C++), and design pattern detection tool (Java). The tools were evaluated on reference implementations of patterns and on open source software (Mozilla, NotePad++, JHotDraw, JRefactory and JUnit). Additionally, instances recovered by researchers are added from NotePad++ as well. Some recovered patterns are already verified by experienced developers. This work is the first step in building a large reference database of design pattern usage in open source software and we expect that researchers will join us in this effort.

Design pattern detection, or rather the detection of structures that match design patterns, is useful for reverse engineering, program comprehension and for design recovery as well as for re-documenting object-oriented systems. Finding design patterns inside the code gives hints to software engineers about the methodologies adopted and the problems found during its design phases, and helps the engineers to evolve and maintain the system. In this paper, we present the results provided by four dierent design pattern detection tools on the analysis of JHotDraw 6.0b1, a well-known Java GUI framework. We show that the tools generally provide dierent results, even while evaluating the same system. From this observation, we introduce an approach based on micro structures detection that aims to discard the false positives from the detected results, hence improving the precision of the analyzed tools results. For this purpose we exploit a set of micro structures called design pattern clues, which give useful hints for the detection of design patterns.

Design patterns support extraction of design information for better program understanding, reusability and reengineering. With the advent of contemporary applications, the extraction of design information has become quite complex and challenging. These applications are multilingual in nature i.e. their design information is spread across various language components that are interlinked with each other. At present, no approach is available that is capable to extract design information of multilingual applications by using design patterns. This paper lays foundation for the analysis of multilingual source code for the detection of J2EE Patterns. J2EE Patterns provide design solutions for effective enterprise applications. A novel approach is presented for the detection of J2EE Patterns from multilingual source code of J2EE applications. For this purpose, customizable and reusable feature types are presented as definitions of J2EE Patterns catalogue. A prototype implementation is evaluated on a corpus that contains the repository of multilingual source code of J2EE Patterns. Additionally, the tool is tested on open source applications. The accuracy of the tool is validated by successfully recognizing J2EE Patterns from the multilingual source code. The results demonstrate the significance of customizable definitions of J2EE Pattern’s catalogue and capability of prototype.

Software maintenance is an important issue during the software design life cycle, especially, in late stages. Frequent changes in the software system with lack of documentation lead to the increase in the cost of maintenance. For this reason an important step for software maintenance is detecting patterns from the source code to provide relevant information that can help in understanding the system design and improve its documentation. Design patterns help maintainers and developers to understand the implementation of any software system which make software maintenance process faster and well-informed. Also it decreases the time and efforts that are needed in learning the software. Detecting patterns is not an easy task because the nature of design patterns. This research introduces a detection process based on software domains. This work is done through collecting five different domains for Java open source code. The dynamic analysis approach is used in extracting patterns. The experimental results showed that there are existing some common patterns between source codes which have the same domain in some source codes.

Generative software product line development using variability-aware design patterns

Design patterns have been widely adopted by software industry to reuse the best practices and improve the quality of software systems. In order to enable software engineers to understand and re-engineer the software program, quite a few approaches have been developed to identify design patterns from source code. However, the existing approaches generally identify patterns sequentially. As a result, the computation time of these approaches is linearly dependent on the number of design patterns to be detected. In this paper, a new approach based on subgraph discovery is proposed to recoginze a set of design patterns at a time. The computational time of the novel algorithm is sublinearly dependent on the number of patterns. A state space graph is introduced to avoid the search space explosion and reduce the opportunity to detect subgraph isomorphism. We run detailed experiments on three open source systems to evaluate our approach. The results of our experiments confirm on the efficiency and effectiveness of the proposed approach.KeywordsDesign PatternInput GraphIntermediate RepresentationSubgraph IsomorphismOpen Source SystemThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Present day software engineering concept gives emphasis on the use of design patterns for developing software which are recurring in nature. Detection of design pattern is one of the emerging field of Software Reverse Engineering. In this work, an attempt has been made to present an approach for design pattern detection with the help of Graph Isomorphism and Normalized Cross Correlation techniques. In this study, system and design pattern are presented in the form of graphs. The Graph Isomorphism technique finds the pattern subgraph in the system graph and Normalized Cross Correlation provides a way to formulate the percentage existence of the design pattern in the system. An Eclipse Plug-in i.e., ObjectAid is used to extract Unified Modeling Language (UML) class diagrams as well as eXtensible Markup Language (XML) files from the software system and design patterns. An algorithm is proposed to identify relevant information from the XML files. Then Graph Isomorphism and Normalized Cross Correlation techniques are used to find the pattern subgraph and its percentage existence in the system. This approach has been applied on four open source software tools for the evaluation of five design patterns, such as Composite, Facade, Flyweight, State, and Template Method.