A Case Study on Design Patterns and Software Defects in Open Source Software

Design patterns are object oriented software design practices for solving common design problems and they affect software quality. In this study, we investigate the relationship of design patterns and software defects in a number of open source software projects. Design pattern instances are extracted from the source code repository of these open source software projects. Software defect metrics are extracted from the bug tracking systems of these projects. Using correlation and regression analysis on extracted data, we examine the relationship between design patterns and software defects. Our findings indicate that there is little correlation between the total number of design pattern instances and the number of defects. However, our regression analysis reveals that individual design pattern instances as a group have strong influences on the number of defects. Furthermore, we find that the number of design pattern instances is positively correlated to defect priority. Individual design pattern instances may have positive or negative impacts on defect priority.

Application of Design Patterns in Process of Large-Scale Software Evolving

To search for the Design Patterns’ influence on the software, the paper abstracts the feature models of 9 kinds of classic exiting design patterns among the 23 kinds and describes the features with algorithm language. Meanwhile, searching for the specific structure features in the network, the paper designs 9 matching algorithms of the 9 kinds design patterns mentioned above to research on the structure of the design patterns in the software network. At last, the paper analyzes the evolving trends of the software scale and the application frequency of the 9 kinds of design patterns as the software evolves, and search for the rules how these design patterns are applied into 4 kinds of typical software.

Software Composition Using Behavioral Models of Design Patterns

Given a set of requirements structured as design problems, we can apply design patterns to solve each problem individually. Much of the published literature on design patterns addresses this problem—pattern association;however, there is no systematic and practical way that shows how to integrate those individual solutions together. We propose a compositional model based on design patterns by abstracting their behavioral model using role modeling constructs. This approach describes how to transform a design pattern into a role model that can be used to assemble a software application. The role model captures the behavioral relationship between participant components in the design pattern. Our approach offers a complete practical design and implementation strategies, adapted from DCI (Data, Context, and Interaction) architecture. We demonstrate our technique by presenting a simple case study complete with design and implementation code. We also present a simple to follow process that provides guidelines of what to do and how to do it.

Software Frameworks, Architectural and Design Patterns

Software systems can be among the most complex constructions in engineering disciplines and can span into years of development. Most software systems though implement in part what has already been built and tend to follow known or nearly known architectures. Although most software systems are not of the size of say Microsoft Windows 8, complexity of software development can be quick to increase. Thus among these methods that are the most important is the use of architectural and design patterns and software frameworks. Patterns provide known solutions to re-occurring problems that developers are facing. By using well-known patterns reusable components can be built in frameworks.Software frameworks provide developers with powerful tools to develop more flexible and less error-prone applications in a more effective way. Software frameworks often help expedite the development process by providing necessary functionality “out of the box”.?Providing frameworks for reusability and separation of concerns is key to software development today. In this study I take a look at the state of art and the impact of frameworks and patterns in software development.

New Approach for Hardware/Software Embedded System Conception Based on the Use of Design Patterns

This paper deals with a new hardware/software embedded system design methodology based on design pattern approach by development of a new design tool called smartcell. Three main constraints of embedded systems design process are investigated: the complexity, the partitioning between hardware and software aspects and the reusability. Two intermediate models are carried out in order to solve the complexity problem. The partitioning problem deals with the proposed hardware/software partitioning algorithm based on Ant Colony Optimisation. The reusability problem is resolved by synthesis of intellectual property blocks. Specification and integration of an intelligent controller on heterogeneous platform are considered to illustrate the proposed approach.

Detecting Design Patterns in Object-Oriented Program Source Code by Using Metrics and Machine Learning

Detecting well-known design patterns in object-oriented program source code can help maintainers understand the design of a program. Through the detection, the understandability, maintainability, and reusability of object-oriented programs can be improved. There are automated detection techniques;however, many existing techniques are based on static analysis and use strict conditions composed on class structure data. Hence, it is difficult for them to detect and distinguish design patterns in which the class structures are similar. Moreover, it is difficult for them to deal with diversity in design pattern applications. To solve these problems in existing techniques, we propose a design pattern detection technique using source code metrics and machine learning. Our technique judges candidates for the roles that compose design patterns by using machine learning and measurements of several metrics, and it detects design patterns by analyzing the relations between candidates. It suppresses false negatives and distinguishes patterns in which the class structures are similar. As a result of experimental evaluations with a set of programs, we confirmed that our technique is more accurate than two conventional techniques.

A Design Method of Business Application Framework Based on Software Patterns

This paper discusses design and implementation method of Business Application Framework based on software patterns, and then presents MVC pattern of architecture and the method of dynamical update promulgation for Business Application Framework. We discuss adaptation of Abstract Factory for the kernel functionality of Business Application Framework, such as data creation, manipulation, composition, etc. It also presents class model and its class structure of Abstract Factory pattern. Finally, we briefly discuss the update, modification, and reconstruction method of Business Application Framework.

Using Reusable Design Patterns in Distributed Systems

The article revealed the software design issues for the object-oriented distributed system. By surveying several existed design is-sues, the solution of common design issues is conducted which is compromised by design patterns. Each pattern is described according to itsfunctionality which could be valuable for objected-oriented distributed system developer.

DESIGN METHODOLOGY OF NETWORKED SOFTWARE EVOLUTION GROWTH BASED ON SOFTWARE PATTERNS

Recently, some new characteristics of complex networks attract the attentions of scientist, in different fields, and lead to many kinds of emerging research directions. So far, most of the researcl work has been limited in discovery of complex network characteristics by structure analysis in large-scale software systems. This paper presents the theoretical basis, design method, algorithms and experiment results of the research. It firstly emphasizes the significance of design method of evolution growth for network topology of Object Oriented （OO） software systems, and argues that the selection and modulation of network models with various topology characteristics will bring un-ignorable effect on the process, of design and implementation of OO software systems. Then we analyze the similar discipline of ＂negation of negation and compromise＂ between the evolution of network models with different topology characteristics and the development of software modelling methods. According to the analysis of the growth features of software patterns, we propose an object-oriented software network evolution growth method and its algorithms in succession. In addition, we also propose the parameter systems for OO software system metrics based on complex network theory. Based on these parameter systems, it can analyze the features of various nodes, links and local-world, modulate the network topology and guide the software metrics. All these can be helpful to the detailed design, implementation and performance analysis. Finally, we focus on the application of the evolution algorithms and demonstrate it by a case study. Comparing the results from our early experiments with methodologies in empirical software engineering, we believe that the proposed software engineering design method is a computational software engineering approach based on complex network theory. We argue that this method should be greatly beneficial for the design, implementation, modulation and metrics of functionality, structure and performance in large-scale OO software complex system.

Blockchain software patterns for the design of decentralized applications:A systematic literature review

A software pattern is a reusable solution to address a commonly occurring problem within a given context when designing software.Using patterns is a common practice for software architects to ensure software quality.Many pattern collections have been proposed for a large number of application domains.However,because of the technology's recentness,there are only a few available collections with a lack of extensive testing in industrial blockchain applications.It is also difficult for software architects to adequately apply blockchain patterns in their applications,as it requires deep knowledge of blockchain technology.Through a systematic literature review,this paper has identified 120 unique blockchain-related patterns and proposes a pattern taxonomy composed of multiple categories,built from the extracted pattern collection.The purpose of this collection is to map,classify,and describe all the available patterns across the literature to help readers make adequate decisions regarding blockchain pattern selection.This study also shows potential applications of those patterns and identifies the relationships between blockchain patterns and other non-blockchain software patterns.

基于Design Patterns的大型工控软件研究与实践

针对大型工控软件开发面临的各种难题 ,提出了基于设计模式 (Design Patterns)的工控软件设计的解决方案 .在大型电力系统监控软件设计中 ,采用设计模式进行工控软件框架和工位的设计 ,实现了功能模块的松耦合关系 ,降低了代码的复杂度 ,从而提高了运行效率 ,同时也加快了系统开发、调试的效率 .论证了设计模式在工控软件设计中应用的潜力 ,提出了大型工控软件设计的新思路 .

Exploration on 5E Teaching Principle-based Education for the Object-oriented Software Construction Course

Most current object-oriented programming courses offered by domestic colleges and universities generally focus on the object-oriented programming language itself,i.e.,the programming grammar of the language,but ignore the design pattern.However,design patterns are essential to software engineering because they can solve common problems in software design and improve code reuse,readability,extensibility,and reliability.Our Object-oriented Software Construction Course is creative since it aims at cultivating students’object-oriented thinking as well as basic abilities required to construct high-quality,object-oriented software.Specifically,we exploit the 5E teaching principle during the education of this course,and present the whole pipeline in the paper.We also provide one case of the factory pattern to further demonstrate the implementation of the 5E teaching principle in the course.The effect of the 5E teaching principle has also been demonstrated.

Role Modeling: A Modeling Method for Software Pattern at Knowledge Level

Based on dominant degree of role model among the viewpoints for object oriented modeling process, it dissertates that role modeling is a modeling method for software pattern at knowledge level. After giving some examples for modeling design pattern and analysis pattern at knowledge level using role model, it presents a process for refining design pattern from role model to class model and event trace diagram of UML. In this paper, we advocate the opinion that role modeling before object modeling of UML.

Empirically Validated Software Efficiency Estimation Model: Product Operation Perspective

The quality element of a design class is important as it has a substantial listed influence on overall required quality of the software. The complexity and lengthy codes of program severely affect several quality measures, especially efficiency of the final delivered software. This paper does an appropriate review on efficiency of object oriented software, and suggests some relevant information about class design level efficiency. Program efficiency is an important factor to software quality. Moreover, if software efficiency analysis has been done in the early steps of the software creation process then it assures as a criterion to software quality. This article proposes a comprehensive research idea for estimation of the efficiency index. Subsequently, it does an extremely methodical review on design efficiency of software. After that, a design metric based efficiency estimation model at the design time has been proposed by creating the link between design properties of the program and efficiency criteria. Furthermore, the correlation is mapped among all with the help of statistical values for selected design properties and efficiency criteria. In addition, efficiency estimation model is empirically validated with try-out data.

Abstract security patterns and the design of secure systems

During the initial stages of software development,the primary goal is to define precise and detailed requirements without concern for software realizations.Security constraints should be introduced then and must be based on the semantic aspects of applications,not on their software architectures,as it is the case in most secure development methodologies.In these stages,we need to identify threats as attacker goals and indicate what conceptual security defenses are needed to thwart these goals,without consideration of implementation details.We can consider the effects of threats on the application assets and try to find ways to stop them.These threats should be controlled with abstract security mechanisms that can be realized by abstract security patterns(ASPs),that include only the core functions of these mechanisms,which must be present in every implementation of them.An abstract security pattern describes a conceptual security mechanism that includes functions able to stop or mitigate a threat or comply with a regulation or institutional policy.We describe here the properties of ASPs and present a detailed example.We relate ASPs to each other and to Security Solution Frames,which describe families of related patterns.We show how to include ASPs to secure an application,as well as how to derive concrete patterns from them.Finally,we discuss their practical value,including their use in“security by design”and IoT systems design.

Do Rules and Patterns Affect Design Maintainability?

At the present time, best rules and patterns have reached a zenith in popularity and diffusion, thanks to the software community＇s efforts to discover, classify and spread knowledge concerning all types of rules and patterns. Rules and patterns are useful elements, but many features remain to be studied if we wish to apply them in a rational manner. The improvement in quality that rules and patterns can inject into design is a key issue to be analyzed, so a complete body of empirical knowledge dealing with this is therefore necessary. This paper tackles the question of whether design rules and patterns can help to improve the extent to which designs are easy to understand and modify. An empirical study, composed of one experiment and a replica, was conducted with the aim of validating our conjecture. The results suggest that the use of rules and patterns affect the understandability and modifiability of the design, as the diagrams with rules and patterns are more difficult to understand than non-rule/pattern versions and more effort is required to carry out modifications to designs with rules and patterns.

Measuring Structural Quality of Object-Oriented Softwares via Bug Propagation Analysis on Weighted Software Networks

The quality of a software system is partially determined by its structure（topological structure）,so the need to quantitatively analyze the quality of the structure has become eminent.In this paper a novel metric called software quality of structure（SQoS） is presented for quantitatively measuring the structural quality of object-oriented（OO） softwares via bug propagation analysis on weighted software networks（WSNs）.First,the software systems are modeled as a WSN,weighted class dependency network（WCDN）,in which classes are nodes and the interaction between every pair of classes if any is a directed edge with a weight indicating the probability that a bug in one class will propagate to the other.Then we analyze the bug propagation process in the WCDN together with the bug proneness of each class,and based on this,a metric（SQoS） to measure the structural quality of OO softwares as a whole is developed.The approach is evaluated in two case studies on open source Java programs using different software structures（one employs design patterns and the other does not） for the same OO software.The results of the case studies validate the effectiveness of the proposed metric.The approach is fully automated by a tool written in Java.

Software design pattern mining using classification-based techniques

Design patterns are often used in the development of object-oriented software. It offers reusable abstract information that is helpful in solving recurring design problems. Detecting design patterns is beneficial to the comprehension and maintenance of object-oriented software systems. Several pattern detection techniques based on static analysis often encounter problems when detecting design patterns for identical structures of patterns. In this study, we attempt to detect software design patterns by using software metrics and classification-based techniques. Our study is conducted in two phases： creation of metrics-oriented dataset and detection of software design patterns. The datasets are prepared by using software metrics for the learning of classifiers. Then, pattern detection is performed by using classification-based techniques. To evaluate the proposed method, experiments are conducted using three open source software programs, JHotDraw, QuickUML, and JUnit, and the results are analyzed.

Quantifying Reusability of Object Oriented Design: A Testability Perspective

The quality factor of class diagram is critical because it has a significant influence on overall quality of the product, delivered finally. Testability analysis, when done early in the software creation process, is a criterion of critical importance to software quality. Reusability is an important quality factor to testability. Its early measurement in object oriented software especially at design phase, allows a design to be reapplied to a new problem without much extra effort. This research paper proposes a research framework for quantification process and does an extensive review on reusability of object oriented software. A metrics based model “Reusability Quantification of Object Oriented Design” has been proposed by establishing the relationship among design properties and reusability and justifying the correlation with the help of statistical measures. Also, “Reusability Quantification Model” is empirically validated and contextual significance of the study shows the high correlation for model acceptance. This research paper facilitates to software developers and designer, the inclusion of reusability quantification model to access and quantify software reusability for quality product.