scholarly journals Co-Occurrence of Design Patterns and Bad Smells in Software Systems: An Exploratory Study

2015 ◽  
Author(s):  
Bruno Cardoso ◽  
Eduardo Figueiredo
Keyword(s):  
System Design ◽  
Software Design ◽  
Exploratory Study ◽  
Design Pattern ◽  
Design Patterns ◽  
Template Method ◽  
Software Systems ◽  
Good Design

A design pattern is a general reusable solution to a recurring problem in software design. Bad smells are symptoms that may indicate something wrong in the system design or code. Therefore, design patterns and bad smells represent antagonistic structures. They are subject of recurring research and typically appear in software systems. Although design patterns represent good design, their use is often inadequate because their implementation is not always trivial or they may be unnecessarily employed. The inadequate use of design patterns may lead to a bad smell. Therefore, this paper performs an exploratory study in order to identify instances of co-occurrences of design patterns and bad smells. This study is performed over five systems and discovers some co-occurrences between design patterns and bad smells. For instance, we observed the co-occurrences of Command with God Class and Template Method with Duplicated Code. The results of this study make it possible to understand in which situations design patterns are misused or overused and establish guidelines for their better use.

ANALYZING AND IMPROVING WEB APPLICATION QUALITY USING DESIGN PATTERNS

2012 ◽  
Vol 2 (2) ◽  
pp. 112-116
Author(s):  
Shikha Bhatia ◽  
Mr. Harshpreet Singh
Keyword(s):  
Web Application ◽  
Design Pattern ◽  
Design Patterns ◽  
Web Applications ◽  
Past Research ◽  
Software Systems ◽  
Interactive Software ◽  
Web Based ◽  
Software Application ◽  
Execution Speed

With the mounting demand of web applications, a number of issues allied to its quality have came in existence. In the meadow of web applications, it is very thorny to develop high quality web applications. A design pattern is a general repeatable solution to a generally stirring problem in software design. It should be noted that design pattern is not a finished product that can be directly transformed into source code. Rather design pattern is a depiction or template that describes how to find solution of a problem that can be used in many different situations. Past research has shown that design patterns greatly improved the execution speed of a software application. Design pattern are classified as creational design patterns, structural design pattern, behavioral design pattern, etc. MVC design pattern is very productive for architecting interactive software systems and web applications. This design pattern is partition-independent, because it is expressed in terms of an interactive application running in a single address space. We will design and analyze an algorithm by using MVC approach to improve the performance of web based application. The objective of our study will be to reduce one of the major object oriented features i.e. coupling between model and view segments of web based application. The implementation for the same will be done in by using .NET framework.

A Survey on Different Approaches to Automating the Design Phase in the Software Development Life Cycle

2020 ◽  
pp. 350-372
Author(s):  
Sahana Prabhu Shankar ◽  
Harshit Agrawal ◽  
Naresh E.
Keyword(s):  
Software Development ◽  
Software Design ◽  
Design Pattern ◽  
Design Patterns ◽  
Development Process ◽  
Design Phase ◽  
Implementation Phase ◽  
Technological Field ◽  
Development Life Cycle ◽  
Tools And Techniques

Software design is a basic plan of all elements in the software, how they relate to each other in such a way that they meet the user requirements. In software development process, software design phase is an important phase as it gives a plan of what to do and how to do it during the implementation phase. As the technology is evolving and people's needs in the technological field are increasing, the development of software is becoming more complex. To make the development process somewhat easy, it is always better to have a plan which is followed throughout the process. In this way, many problems can be solved in the design phase, for which a number of tools and techniques are present. One is known as Design Patterns. In software engineering, a design pattern is a general solution to commonly occurring problems in software design. A design pattern isn't a finished design that can be transformed directly into code.

Development of an Intelligent Information Systems for Object-Oriented Software Design

2011 ◽  
pp. 273-286
Author(s):  
Gary P. Moynihan ◽  
Bin Qiao ◽  
Matthew E. Elam ◽  
Joel Jones
Keyword(s):  
Software Development ◽  
Software Design ◽  
Design Problem ◽  
Design Pattern ◽  
Design Patterns ◽  
Object Oriented ◽  
Pattern Selection ◽  
Prototype System ◽  
Intelligent Information ◽  
The Individual

The purpose of this research was to apply an artificial intelligence approach to improve the efficiency of design pattern selection used in the development of object-oriented software. Design patterns provide a potential solution to the limitations occurring with traditional software design approaches. Current methods of design pattern selection tend to be intuitive, and based on the experience of the individual software engineer. This expertise is very specialized and frequently unavailable to many software development organizations. A prototype expert system was developed in order to automate this process of selecting suitable patterns to be applied to the design problem under consideration. It guides the designer through the pattern selection process through inquiry regarding the nature of the design problem. The prototype system also provides the capabilities to browse patterns, view the relationship between patterns, and generate code based on the pattern selected. The routine application of such a system is viewed as a means to improve the productivity of software development by increasing the use of accepted design patterns.

An Idea Towards Improving Design Pattern Detection

2015 ◽  
Vol 3 (2) ◽  
Author(s):  
Arti Chaturvedi ◽  
Manjari Gupta ◽  
Sanjay Kumar Gupta
Keyword(s):  
System Design ◽  
Design Pattern ◽  
Design Patterns ◽  
Graph Isomorphism ◽  
Pattern Detection ◽  
Engineering Process ◽  
Significant Information ◽  
Matching Algorithm ◽  
Mining Design ◽  
Reliable Design

Design Pattern Detection is a part of re-engineering process and thus gives significant information to the designer. Detection of design patterns is helpful for improving the software characteristics. Therefore, a reliable design pattern discovery is required. The problem of finding an isomorphic sub-graph is used to solve design pattern detection in past. It is noticed that ordering of vertices of the design pattern saves the time of process. In this paper we are doing ordering of vertices for few design patterns proposed by Gamma, Helm, Johnson, and Vlissides (1995) using an algorithm Greatest Constraint First proposed by Bonnici, Giugno, Pulvirenti, Shasha, and Ferro (2013). After getting this ordering, we use a matching algorithm that uses subgraph isomorphism conditions to check whether a particular design pattern exists in the system design or not (Bonnici et al., 2013). We redefine sub-graph isomorphism conditions in the context of the problem of mining design patterns from the system design.

Development of an Intelligent Information Systems for Object-Oriented Software Design

2011 ◽  
pp. 698-710
Author(s):  
Gary P. Moynihan ◽  
Bin Qiao ◽  
Matthew E. Elam ◽  
Joel Jones
Keyword(s):  
Software Development ◽  
Software Design ◽  
Design Problem ◽  
Design Pattern ◽  
Design Patterns ◽  
Object Oriented ◽  
Pattern Selection ◽  
Prototype System ◽  
Intelligent Information ◽  
The Individual

The purpose of this research was to apply an artificial intelligence approach to improve the efficiency of design pattern selection used in the development of object-oriented software. Design patterns provide a potential solution to the limitations occurring with traditional software design approaches. Current methods of design pattern selection tend to be intuitive, and based on the experience of the individual software engineer. This expertise is very specialized and frequently unavailable to many software development organizations. A prototype expert system was developed in order to automate this process of selecting suitable patterns to be applied to the design problem under consideration. It guides the designer through the pattern selection process through inquiry regarding the nature of the design problem. The prototype system also provides the capabilities to browse patterns, view the relationship between patterns, and generate code based on the pattern selected. The routine application of such a system is viewed as a means to improve the productivity of software development by increasing the use of accepted design patterns.

A General Framework to Detect Design Patterns by Combining Static and Dynamic Analysis Techniques

2021 ◽  
Vol 31 (01) ◽  
pp. 21-54
Author(s):  
Cong Liu
Keyword(s):  
Dynamic Analysis ◽  
Open Source ◽  
Design Pattern ◽  
Design Patterns ◽  
General Framework ◽  
Process Mining ◽  
Pattern Detection ◽  
Software Systems ◽  
Static And Dynamic Analysis ◽  
Analysis Techniques

Design pattern detection can provide useful insights to support software comprehension. Accurate and complete detection of pattern instances are extremely important to enable software usability improvements. However, existing design pattern detection approaches and tools suffer from the following problems: incomplete description of design pattern instances, inaccurate behavioral constraint checking, and inability to support novel design patterns. This paper presents a general framework to detect design patterns while solving these issues by combining static and dynamic analysis techniques. The framework has been instantiated for typical behavioral and creational patterns, such as the observer pattern, state pattern, strategy pattern, and singleton pattern to demonstrate the applicability. Based on the open-source process mining toolkit ProM, we have developed an integrated tool that supports the whole detection process for these patterns. We applied and evaluated the framework using software execution data containing around 1,000,000 method calls generated from eight synthetic software systems and three open-source software systems. The evaluation results show that our approach can guarantee a higher precision and recall than existing approaches and can distinguish state and strategy patterns that are indistinguishable by the state-of-the-art.

Modeling Design Patterns for Semi-Automatic Reuse in System Design

2012 ◽  
pp. 29-56
Author(s):  
Galia Shlezinger ◽  
Iris Reinhartz-Berger ◽  
Dov Dori
Keyword(s):  
System Design ◽  
Software Quality ◽  
Design Pattern ◽  
Design Patterns ◽  
Design Problems ◽  
Suggested Approach ◽  
Main Design ◽  
Analysis And Design ◽  
Correct Usage

Design patterns provide reusable solutions for recurring design problems. They constitute an important tool for improving software quality. However, correct usage of design patterns depends to a large extent on the designer. Design patterns often include models that describe the suggested solutions, while other aspects of the patterns are neglected or described informally only in text. Furthermore, design pattern solutions are usually described in an object-oriented fashion that is too close to the implementation, masking the essence of and motivation behind a particular design pattern. We suggest an approach to modeling the different aspects of design patterns and semi-automatically utilizing these models to improve software design. Evaluating our approach on commonly used design patterns and a case study of an automatic application for composing, taking, checking, and grading analysis and design exams, we found that the suggested approach successfully locates the main design problems modeled by the selected design patterns.

An Extensible Compiler for Implementing Software Design Patterns as Concise Language Constructs

2021 ◽  
Vol 31 (07) ◽  
pp. 1043-1067
Author(s):  
Taher Ahmed Ghaleb ◽  
Khalid Aljasser ◽  
Musab A. Alturki
Keyword(s):  
Software Design ◽  
Design Pattern ◽  
Design Patterns ◽  
Source Code ◽  
Design Reuse ◽  
Novel Approach ◽  
Software Design Patterns ◽  
Class Level ◽  
Language Constructs

Design patterns are generic solutions to common programming problems. Design patterns represent a typical example of design reuse. However, implementing design patterns can lead to several problems, such as programming overhead and traceability. Existing research introduced several approaches to alleviate the implementation issues of design patterns. Nevertheless, existing approaches pose different implementation restrictions and require programmers to be aware of how design patterns should be implemented. Such approaches make the source code more prone to faults and defects. In addition, existing design pattern implementation approaches limit programmers to apply specific scenarios of design patterns (e.g. class-level), while other approaches require scattering implementation code snippets throughout the program. Such restrictions negatively impact understanding, tracing, or reusing design patterns. In this paper, we propose a novel approach to support the implementation of software design patterns as an extensible Java compiler. Our approach allows developers to use concise, easy-to-use language constructs to apply design patterns in their code. In addition, our approach allows the application of design patterns in different scenarios. We illustrate our approach using three commonly used design patterns, namely Singleton, Observer and Decorator. We show, through illustrative examples, how our design pattern constructs can significantly simplify implementing design patterns in a flexible, reusable and traceable manner. Moreover, our design pattern constructs allow class-level and instance-level implementations of design patterns.

scholarly journals Searching Design Patterns Fast by Using Tree Traversals

2015 ◽  
Vol 61 (4) ◽  
pp. 321-326
Author(s):  
Stefano Cicciarella ◽  
Christian Napoli ◽  
Emiliano Tramontana
Keyword(s):  
Design Pattern ◽  
Design Patterns ◽  
Software Systems ◽  
Software System ◽  
Large Software ◽  
Tree Traversals

Abstract Large software systems need to be modified to remain useful. Changes can be more easily performed when their design has been carefully documented. This paper presents an approach to quickly find design patterns that have been implemented into a software system. The devised solution greatly reduces the performed checks by organising the search for a design pattern as tree traversals, where candidate classes are carefully positioned into trees. By automatically tagging classes with design pattern roles we make it easier for developers to reason with large software systems. Our approach can provide documentation that lets developers understand the role each class is playing, assess the quality of the code, have assistance for refactoring and enhancing the functionalities of the software system.

scholarly journals Utilizing Graph Matching for Mining Design Patterns

2020 ◽  
Vol 8 (10S2) ◽  
pp. 110-112
Keyword(s):  
System Design ◽  
Design Pattern ◽  
Design Patterns ◽  
Semantic Analysis ◽  
Graph Matching ◽  
Object Oriented ◽  
Pattern Identification ◽  
Mining Design ◽  
Object Oriented Approach ◽  
Oriented Approach

Design Patterns are one of the demonstrated reusable answers for the normally experienced design issues. The identification of design pattern is significant action that underpins re-building procedure and gives insights to the designer. The uncovering of these design patterns help understand the object oriented models clearly by analyzing the relations present in the model. Many design pattern identification approaches have been proposed in past years. These methodologies work upon the behavioral, structural and semantic analysis of the software. Many algorithms were used to recognize design patterns in software. In this paper, we will be extracting an attribute relational matrix from the graph using object oriented approach. The aim of the paper is to discover all the design patterns present in the system design.

Sign in / Sign up

Export Citation Format

Share Document