Information Integrity Analysis and Design: A UML Based Approach

Software Design Patterns (SDPs) are core solutions to the recurring problems in software. However, adopting SDPs without taking into account their value implications may result in breach of social values and ultimately lead to user dissatisfaction, lack of adoption, and financial loss. An example is the airline system that overcharged people who were trying to escape from the Hurricane Irma. Although not intentional, overlsight of social values in the design of the airline system resulted in significant customer dissatisfaction and loss of trust. To mitigate such value breaches in software design we propose taking social values into account in SDPs explicitly. To achieve this, we outline a collaborative framework that allows for (i) specifying the value implications of SDPs, (ii) developing or extending SDPs for integrating social values, (iii) providing guidance on the value-conscious adoption of design patterns, (iv) collecting and analyzing insights from collaborators, (v) maintaining an up-to-date library of the valufied design patterns, and (vi) incorporating lessons learned from the real-world adoption of the valuefied design patterns into the proposed framework for its continuous improvement in integrating social values into software.

To address practical challenges in teaching "Software Design Patterns" courses-including complex content, disconnect between theory and practice, and implementation difficulties-this study explores an OBE (Outcome-Based Education) approach. Through discovery-based exploration with classroom implementation as the ultimate goal, we developed implementation-oriented projects that integrate software design patterns with commercial software development. These projects enable students to learn the advantages of modular programming through software development, cultivating design pattern thinking. By adopting OBE principles in teaching "Software Design Patterns," students gain precise understanding of design patterns' value in commercial software development, enhancing learning engagement and improving course effectiveness.

This paper describes the advances in software design methods for concurrent, real-time and distributed applications from structured methods for centralized systems to distributed, object-oriented, component-based and service-oriented systems and product lines. The influence of software architectural and design patterns is also described. Current challenges for designing service-oriented architectures, adaptive software design, and evolutionary software design are also discussed.

Software design patterns are solutions to common software problems that are proven to work adequately in particular scenarios. Deciding which design pattern to use for a given software problem often requires practical knowledge acquired with experience in a similar domain and can be highly subjective and error-prone. Further, for novice programmers, an automated approach would be of tremendous help as it would provide practical knowledge required for deciding which design pattern to use for a particular software problem. The majority of research in software design pattern prediction involves using software structure and features in determining which design pattern to implement. However, there are circumstances where software engineers would prefer to know which design pattern to be used by looking at the design problem during or before the implementation phase. Existing design pattern prediction tools cannot be utilized in this scenario due to the absence of code and class structures. To address this issue, this paper proposes a new approach that analyzes the context of the software problem from text and predicts a suitable design pattern for the given problem context using feature learning, neural embedding, and classification. We evaluate our approach on a case study from Stack Overflow with more than 66,000 questions that discuss problems and consequences related to 23 design patterns. Results show that our approach can predict design patterns from the text with 82% overall accuracy.

Software design patterns are documented best practice solutions that can be applied to recurring problems. Although well documented, there are often opportunities to apply them which are overlooked by software designers. This can be the result of inexperience, the sheer complexity of the system, or the fact that design patterns do not always constitute intuitive designs. In this paper, we present a structured methodology for semi-automating the detection of areas within a UML design of a software system that are good candidates for the use of design patterns. This is achieved by the definition of detection rules formalized using the OCL and using a decision tree model. The approach is illustrated on an example GoF design pattern. A prototype tool was developed to show the feasibility of the approach in practical situations, and is used on a case study, producing encouraging results

Formal inference processes in all kinds of engineering designs are based on the cognitive process and means of abstraction. This paper presents a formal treatment of system design. It first discusses the differences of system designs in abstract and concrete systems. A hierarchical abstraction model of system descriptivity (HAMSD) is developed that explains the abstract levels of entities and artifacts in both the concrete world and the abstract world. The HAMSD model classifies the design of a system at five levels known as the levels of (1) analogue objects, (2) diagrams, (3) natural languages, (4) professional notations, and (5) mathematics from the bottom up. According to the HAMSD model, an architectural, functional, or behavioral design of a system should adopt a higher-level abstract means to describe the system at a given abstract level, in order to obtain more powerful descriptivity and higher accuracy. Therefore, a mechanical system may be designed by using diagrams; while an information or software system can not be precisely described by diagrams. The reason is that the former is at an abstract level lower than the descriptive means of diagrams, but not so is the latter. Applications of the above findings in dealing with complicated problems in large-scale software system designs are discussed in the context of software engineering. Real-time process algebra (RTPA) is adopted as a highly abstract means in case studies on formal methodologies of software system design and modeling for software objects and design patterns.

Software design patterns classification and selection using text categorization approach

The Visitor pattern is a behavioral software design pattern where different objects represent an operation to be performed on elements of an object structure. Despite the benefits of the Visitor pattern, its rigid structure has limitations. Owing to the Visitor pattern's usefulness and importance to software design, many researchers have extended and modified the original Visitor pattern to overcome its limitations. Researchers have even replaced the Visitor pattern with more refined design patterns e.g., Reflective Visitor pattern, Java Walkabout Class, and Dynamic Dispatcher that bear minimal resemblance to the original Visitor pattern's structure while retaining its major advantages e.g., ability to add new operations to an object structure without changing the classes of objects, localizing related behavior, and accumulating state. This article therefore provides a comprehensive survey of the Visitor pattern for software practitioners. Within the survey, we focus on major enhancements that have been made to the original Visitor pattern to overcome its limitations. On the basis of our survey results, we found that variations of the Visitor pattern can be separated into two categories: extended Visitor patterns where the original Visitor pattern structure stays intact and alternative Visitor patterns where the structure of the original Visitor pattern is altered. Copyright © 2012 John Wiley & Sons, Ltd.

Object oriented design patterns (DP) are meant to provide a common structure for solving common software development problems. Applying those patterns is expected to improve the software systems maintainability, comprehensibility, and provide a common language for developers to understand and effectively communicate. However, this was not always the case, where some studies have shown that using design patterns may lead to a system harder to maintain and understand and more error prone; as compared to same systems without the use of design patterns. This variation is referred to the features of the system on hand, and the experience of the developers who are capable to know what design patterns to use and when. Considering the video game development, the use of software design pattern is still at low scale, and still; there is no recipe on what and when to use design patterns. In the meantime, there are different game design frameworks that define different aspects which need to be considered when developing a game. In this paper, we propose a framework that integrates some creational and behavioral DP, with a specific game design framework. In this way, we claim that the developers will have some hints on what DP to use with the main game aspects. This framework is suitable for games which can be developed after the first course of game design, regardless of the game engine used for development. The framework can be extended with more DP, for larger scale and more sophisticated game.

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.

Since they were first introduced by architect Christopher Alexander in his classic book The Timeless Way of Building, design patterns have offered a powerful yet simple way to conceptualize and communicate designs in many disciplines. Design patterns became widely used for software development by the 1990's. These software design patterns have subsequently been shown to be of great value in improving the reliability and reducing the cost of software. Given that virtually all large-scale agent-based models are ultimately implemented in software, there is great potential for software design patterns to improve the practice of agent-based modeling. Several authors have discussed the use of patterns for agent-based modeling or agent-oriented software. This paper's contribution is that it provides an extensive set of both existing and new agent-based modeling design patterns, each of which is substantiated with at least three successful published example uses in models or modeling platforms.

Software design patterns are used to improve the software quality. There are distinct kinds of software, as well as design patterns. One of them is patterns for enterprise application architecture. Although enterprise design patterns are said to be able to improve the software quality, there is a lack of literature that discusses the evidence of the impact. This preliminary study proposes a method to assess the impact of enterprise software design pattern on maintainability. We use the Academic Information System (AIS) of Institut Teknologi Sepuluh Nopember (ITS) as a case study. It is enterprise software which is frequently maintained and need to be evolved. The software maintainability is measured by using C&K metrics. Then we calculate the relative change and evaluate it based on viewpoints of the metrics. Transaction Script pattern is selected to verify the method. As a result, it decreases the maintainability instead of improving it. The result of this preliminary study shows that design patterns did not improve the software maintainability. Based on the previous researches, it depends on several factors which may be studied in the future work. Thus, we need to propose a method to select the appropriate patterns or whether we use design patterns or not.

Code refactoring is a technique that improves the existing code in order to make software easier to understand and more extensible without changing the external behavior. Software design patterns, programming language independent reusable solutions to comment problems, are well-known in Java communities. On one hand, the refactoring using design patterns brings many benefits such as cost saving, flexibilities, and maintainability. On the other hand, it potentially causes bugs or changes execution behavior of Java programs. This paper proposes a new approach to checking behavior preservation properties of Java programs after applying design patterns. We present new definitions to compute pre/post conditions of program behavior. In the next step, the paper makes use of Java Modeling Language (JML) to represent and check if the refactored program neglects to preserve the external behavior. A motivating example of Adaptive Road Traffic Control (ARTC) is given to illustrate the approach in detail.

Driven by the success of Internet of Things, the number of embedded systems is constantly increasing. Reducing power consumption and improving energy efficiency are among the key challenges for battery-powered embedded systems. Additionally, threats like climate change clearly illustrate the need for systems with low resource usages. Due to the impact of software applications on the system’s power consumption, it is important to optimize the software design even in early development phases. The important role of the software layer is often overlooked because energy consumption is commonly associated with the hardware layer. As a result, existing research mainly focuses on energy optimization at the hardware level, while only limited research has been published on energy optimization at the software design level. This work presents a novel approach to propose an energy-aware software design pattern framework description, which takes power consumption and time behavior into account. We evaluate the expressiveness of the framework by defining design patterns, which use elaborated power-saving strategies for various hardware components to reduce the overall energy consumption of an embedded system. Furthermore, we introduce a dimensionless numerical efficiency factor to make energy savings quantifiable and a comparison for design patterns applied in various use cases possible.

Based on the words about why we must study software architecture, this article analyzed what the idea of building software architecture based on design patterns acts on the process of software development, discussed the development trend of software architecture and design patterns, and pointed to the problems which need to pay your attention during the term of building software architecture based on design patterns. In addition this paper described how the MVC pattern works in J2EE and explained what responsibilities the various parts in MVC have.