A Method for Testing Software Systems Based on State Design Pattern Using Symbolic Execution

2010 ◽  
Author(s):  
Cristina Tudose ◽  
Radu Opria
Keyword(s):  
Design Pattern ◽  
Symbolic Execution ◽  
Software Systems

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 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.

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.

Design Patterns from Theory to Practice

2011 ◽  
pp. 1047-1052
Author(s):  
Jing Dong ◽  
Tu Peng ◽  
Yongtao Sun ◽  
Longji Tang ◽  
Yajing Zhao
Keyword(s):  
Design Pattern ◽  
Design Patterns ◽  
Research Work ◽  
Software Systems ◽  
Original Design ◽  
Design Problems ◽  
Design Decisions ◽  
Related Information ◽  
Theory To Practice

Design patterns (Gamma, Helm, Johnson, & Vlissides, 1995) extract good solutions to standard problems in a particular context. Modern software industry has widely adopted design patterns to reuse best practices and improve the quality of software systems. Each design pattern describes a generic piece of design that can be instantiated in different applications. Multiple design patterns can be integrated to solve different design problems. To precisely and unambiguously describe a design pattern, formal specification methods are used. Each design pattern presents extensible design that can evolve after the pattern is applied. While design patterns have been applied in many large systems, pattern-related information is generally not available in source code or even the design model of a software system. Recovering pattern-related information and visualizing it in design diagrams can help to understand the original design decisions and tradeoffs. In this article, we concentrate on the issues related to design pattern instantiation, integration, formalization, evolution, visualization, and discovery. We also discuss the research work addressing these issues.

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.

scholarly journals Reactor Design Pattern

TEM Journal ◽  
2021 ◽  
pp. 18-30
Author(s):  
Marko Mijač ◽  
Antonio García-Cabot ◽  
Vjeran Strahonja
Keyword(s):  
Message Passing ◽  
Design Pattern ◽  
Design Patterns ◽  
Ad Hoc ◽  
Object Oriented ◽  
Software Systems ◽  
State Change ◽  
Graph Data ◽  
Graphical Interfaces ◽  
Novel Design

In object-oriented (OO) applications, objects collaborate through message passing, which results in these objects being coupled and mutually dependent. These dependencies can be reactive, i.e. such that, for example, the state change of one object, requires automatic reaction in all dependent objects. Examples of such reactive dependencies can be found in various software systems, including rich graphical interfaces, spreadsheet systems, animation, robotics, etc. Unlike the reactive paradigm which natively provides abstractions and mechanisms for the management of reactive dependencies, the OO paradigm lacks proper support. Object-oriented applications developers often resort to the use of ad-hoc solutions or design patterns such as the well-known Observer pattern, which are not suitable for managing more complex scenarios. In this paper we offer a novel design pattern (REACTOR), which utilizes a graph data structure to improve the management of reactive dependencies in OO applications.

Methods of parallel computing for multilevel fuzzy Takagi – Sugeno systems

2016 ◽  
pp. 141-149
Author(s):  
S.V. Yershov ◽  
◽  
R.М. Ponomarenko ◽  
Keyword(s):  
Dynamic Models ◽  
Fuzzy Inference ◽  
Knowledge Bases ◽  
Comparative Characteristic ◽  
Software Systems ◽  
Scientific Papers ◽  
Speed Up ◽  
Diagnostic Software ◽  
Takagi Sugeno

Parallel tiered and dynamic models of the fuzzy inference in expert-diagnostic software systems are considered, which knowledge bases are based on fuzzy rules. Tiered parallel and dynamic fuzzy inference procedures are developed that allow speed up of computations in the software system for evaluating the quality of scientific papers. Evaluations of the effectiveness of parallel tiered and dynamic schemes of computations are constructed with complex dependency graph between blocks of fuzzy Takagi – Sugeno rules. Comparative characteristic of the efficacy of parallel-stacked and dynamic models is carried out.

Sign in / Sign up

Export Citation Format

Share Document