Feature Maps: A Comprehensible Software Representation for Design Pattern Detection

Software patterns are often considered as an important methodology in the process of analysis and design of a software, when the proposed architecture of the software is a complex one. During the process of reverse engineering, design patterns become helpful to analyze the source code. A pattern-based analysis often improves maintainability of the source code. The proposed reverse engineering approach considers software metrics for the development of the datasets. The study is comprises of two phases such as preparation of requisite dataset based on object-oriented software metrics and identification of design patterns. Preparation of dataset is carried out using pattern instances from source code, mapped with software metrics. Analysis of design patterns is accomplished by considering a learning-based method i.e., Artificial Neural Network. In this study, two open source software such as JRefactory and Quaqua have been considered to exploit the idea of reverse engineering.

Static analysis technology is used to find programming errors before run time. Unlike dynamic analysis technique which looks at the application state while it is being executed, static analysis technique does not require the application to be executed. In this paper, we classify security vulnerability patterns in source code and design a model to express various security vulnerability patterns by making use of pushdown automata. On the basis of the model, it is possible to find a security vulnerability by making use of Abstract Syntax Tree (AST) based pattern matching technique in parsing level.

Insecurity Refactoring is a change to the internal structure of software to inject a vulnerability without changing the observable behavior in a normal use case scenario. An implementation of Insecurity Refactoring is formally explained to inject vulnerabilities in source code projects by using static code analysis. It creates learning examples with source code patterns from known vulnerabilities.Insecurity Refactoring is achieved by creating an Adversary Controlled Input Dataflow tree based on a Code Property Graph. The tree is used to find possible injection paths. Transformation of the possible injection paths allows to inject vulnerabilities. Insertion of data flow patterns introduces different code patterns from related Common Vulnerabilities and Exposures (CVE) reports. The approach is evaluated on 307 open source projects. Additionally, insecurity-refactored projects are deployed in virtual machines to be used as learning examples. Different static code analysis tools, dynamic tools and manual inspections are used with modified projects to confirm the presence of vulnerabilities.The results show that in 8.1% of the open source projects it is possible to inject vulnerabilities. Different inspected code patterns from CVE reports can be inserted using corresponding data flow patterns. Furthermore the results reveal that the injected vulnerabilities are useful for a small sample size of attendees (n=16). Insecurity Refactoring is useful to automatically generate learning examples to improve software security training. It uses real projects as base whereas the injected vulnerabilities stem from real CVE reports. This makes the injected vulnerabilities unique and realistic.

Since Gamma et al. published their design patterns, patterns are very popular in the area of software engineering. They provide best practice to handle recurring problems during the software development phase. Three years later, security patterns appeared and provided solutions for security problems. Besides the name analogy, design and security patterns should be very similar except for the security factor. In research and industry software engineering with design patterns is widespread. However, some researchers suspect that security-pattern engineering is made difficult by some issues such as terminology or description form. Detecting adoption problems can help to improve security patterns in future. Thus, they can promote the awareness of security especially in the software maintenance phase where many programmers first give attention to security problems. Therefore, we will compare design and security patterns to find indicators for negative impact on security pattern engineering in software development. We address this issue on inspecting the aspects classification, description form, provided code examples, and usage in the software life-cycle. We determine the degree of maturity of software-security patterns by comparing them to the well-explored design patterns. To achieve the objective, we inspect the pattern terminology and conducted a study on the used description forms including provided UML diagrams and code examples. Moreover, a literature review is conducted to compare their state of research w.r.t. the software life-cycle. The maturity degree of security patterns compared to common design patterns differs and we depict further research opportunities on security patterns.

Software design patterns classification and selection using text categorization approach

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.

.Significance: Automatic and accurate classification of three-dimensional (3-D) retinal optical coherence tomography (OCT) images is essential for assisting ophthalmologist in the diagnosis and grading of macular diseases. Therefore, more effective OCT volume classification for automatic recognition of macular diseases is needed.Aim: For OCT volumes in which only OCT volume-level labels are known, OCT volume classifiers based on its global feature and deep learning are designed, validated, and compared with other methods.Approach: We present a general framework to classify OCT volume for automatic recognizing macular diseases. The architecture of the framework consists of three modules: B-scan feature extractor, two-dimensional (2-D) feature map generation, and volume-level classifier. Our architecture could address OCT volume classification using two 2-D image machine learning classification algorithms. Specifically, a convolutional neural network (CNN) model is trained and used as a B-scan feature extractor to construct a 2-D feature map of an OCT volume and volume-level classifiers such as support vector machine and CNN with/without attention mechanism for 2-D feature maps are described.Results: Our proposed methods are validated on the publicly available Duke dataset, which consists of 269 intermediate age-related macular degeneration (AMD) volumes and 115 normal volumes. Fivefold cross-validation was done, and average accuracy, sensitivity, and specificity of 98.17%, 99.26%, and 95.65%, respectively, are achieved. The experiments show that our methods outperform the state-of-the-art methods. Our methods are also validated on our private clinical OCT volume dataset, consisting of 448 AMD volumes and 462 diabetic macular edema volumes.Conclusions: We present a general framework of OCT volume classification based on its 2-D feature map and CNN with attention mechanism and describe its implementation schemes. Our proposed methods could classify OCT volumes automatically and effectively with high accuracy, and they are a potential practical tool for screening of ophthalmic diseases from OCT volume.

Generative software product line development using variability-aware design patterns

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

In this paper two new learning-based eXplainable AI (XAI) methods for deep convolutional neural network (DCNN) image classifiers, called L-CAM-Fm and L-CAM-Img, are proposed. Both methods use an attention mechanism that is inserted in the original (frozen) DCNN and is trained to derive class activation maps (CAMs) from the last convolutional layer’s feature maps. During training, CAMs are applied to the feature maps (L-CAM-Fm) or the input image (L-CAM-Img) forcing the attention mechanism to learn the image regions explaining the DCNN’s outcome. Experimental evaluation on ImageNet shows that the proposed methods achieve competitive results while requiring a single forward pass at the inference stage. Moreover, based on the derived explanations a comprehensive qualitative analysis is performed providing valuable insight for understanding the reasons behind classification errors, including possible dataset biases affecting the trained classifier (Source code is made publicly available at: https://github.com/bmezaris/L-CAM).KeywordsExplainable AIXAIImage classificationClass activation mapDeep convolutional neural networksAttentionBias

In recent electroencephalograph (EEG)-based emotion recognition, the differential entropy (DE) features extracted from multiple electrodes are organized as a 2D feature map for convolutional neural network (CNN) in order to utilize the information hidden in the electrodes. In this study, we attempt to investigate the influence of different feature maps on the recognition performance. Six different 2D feature maps (M1-M4: baseline feature maps without sparsity and location relationship, M5-M6: pre-defined feature maps with sparsity and location relationship) are used to organize the DE features for the traditional CNN model. Evaluation study on the DEAP dataset finds that the 2D feature map configuration exhibits statistically significant effect on the classification performance of the traditional CNN model in classifying the high/low arousal and high/low valence, respectively. However, the differences are rather limited, e.g., only 1% improvement can be resulted from selecting the optimal 2D feature map among 6 feature maps. This implies that the feature map may not be a critical issue when applying the DE features to classifying the emotion states in a CNN.

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 and their variants detection from source code using different techniques and tools are keys to understand complex architecture of different applications. Design patterns are key to develop quality applications and well know solutions to well know problems. The discussion is on accuracy of existing techniques and tools is debatable because of multiple advanced technologies and a lot of variations in Gang of Four (GOF) design patterns. In fact, during development developers modified standard patterns according to their needs and design, but intent remain same. In this research, we will find different variants of Gang of Four design patterns from source code of legacy applications through various techniques that developers are using to tackle commonly occurring problems. These discovered variants are detected and validated through different design patterns detection techniques and tools.

Convolutional neural network (CNN) has developed such a large network size in last few years, so reducing the storage requirement without hurting its accuracy becomes necessary. In this paper, in order to reduce the number of high dimensional feature maps in shallow layers, we propose a feature map selection method, which cuts the feature map number by correlation coefficient between kernels and finishes detection by HOG+SVM method. Firstly, we extract feature maps of shallow layers from trained CNN. Then, we merge strongly relevant feature maps and choose all maps among weakly relevant feature maps by analyzing correlation coefficient of kernels. Finally, we extract HOG features of the chosen feature maps and use SVM to complete the training and classification. The experimental results show that the proposed method can effectively prune high dimensional feature maps and stabilize or even advance the performance in pedestrian detection.