Advances in Software Design Methods for Concurrent, Real-Time and Distributed Applications

Information Integrity(I*I) i.e. Accuracy, Consistency and Reliability of information is a fundamental requirement for strategic business advantage in complex and changing environment characterized by uncertainty. However, its implementation is a highly complex and costly activity. Software modeling and development techniques have by and large advocated divide and conquer as the typical approach to handle large and complex business systems. Object oriented modeling has been a major step towards building of large, flexible and evolving systems. Efforts and contributions to support flexibility have been made by database and programming language providers. The same can be witnessed if we trace down the evolution of databases and programming languages both now focusing on extensible and reusable patterns and components as main contributors to providing flexibility in otherwise statically designed software. Software patterns offer another area that has contributed significantly towards designing software with reasonable strengths and known weaknesses. Literature as well as practice has shown evidence of using design patterns, software patterns and business patterns for improved software quality. However, major focus of software and design patterns is still to meet functional and non-functional requirements of a software, whereas business patterns are largely implemented in a manual form. This paper adopts UML to define a framework built on I*I patterns that can be reused by system designers towards building systems that support I*I and its analysis. This paper is an attempt to further the knowledge area of I*I towards a way of implementing it in any size of software project thus reducing complexity as well as the cost of its implementation. Focus of the paper is not to offer a complete suite of I*I patterns but establish a guideline towards building one of such kind.

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.

This paper uses examples of realistic, ethically-charged decisions that computing professionals face, and explore how the the software engineering code of ethics is useful in making wise and creative decisions. We illustrate the ethical impacts of choice of software process model, architecture, and design patterns using real world examples including examples from Grady Booch. We practice some of the ethics training techniques that have successfully been used by some corporations in the computer-related industries.

Adopting Web 2.0 technologies and techniques in modern e-learning systems guarantees a more interactive e-learning experience. It leverages collaboration among learners and enhances accessibility to various learning resources. Providing such functionalities as web services within an integrated e-learning system achieves interoperability and reduces redundancy. Our aim in this paper is to identify recurrent Web 2.0 and Service-oriented architecture (SOA) design and architectural patterns that would provide reusable building blocks for any Web 2.0 based service-oriented e-learning system. The paper builds on induction theory techniques to validate taxonomy related to Web 2.0 and SOA behavioural and technological patterns. We identified 3 elementary design patterns, inter-connectivity, file sharing and content re-mixing, a well as 4 secondary design patterns, streaming, content authoring, content aggregation and tagging. The proposed design patterns share three elementary architecture types, client-server, peer-peer and SOA. The paper also builds on UML4SOA techniques in modelling requirements prior application of proposed patterns in the case study.

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

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.

In case you missed the signs, design patterns [2] have suddenly become a core programming topic. The Computing Curricula 2001 [1] includes the topic as a major part of SE1 "software design," and in a recent survey [4] software practitioners ranked "software design and patterns" as one of the areas of knowledge they consider most important to their work.Teaching design patterns, however, is not so easy. Patterns need to be studied in the context of a software design project; to do otherwise renders the topic asomatous. We have met with some success in using "musical composition" to teach a number of standard design patterns, including Composite, Decorator, Visitor, and Factory. The idea of musical composition comes from Paul Hudak's Haskore system [3].The project centers on the design of a "musical object," by which we mean either a note (with a pitch and duration), a rest (having just a duration), or a combination of musical objects. The combinations can be contemporaneous (as for a chord), or sequential (like a scale). The two primitive music types together with the combinators come together using the Composite inheritance pattern. Decorators can then be added to describe tempo changes (the scaling of the duration of all parts of a musical object), pitch transpositions, and to assign different instruments to parts of a composition.With the descriptive part of the system so formed, a Visitor can be used to traverse the musical tree and generate a linear sequence of "musical events," which can then be written as type 1 MIDI files for playback on most standard PC equipment. As well as learning about design patterns, students are given the opportunity to try their hand at transcription or composition. Some examples of their work can be found at http://www.cs.auckland.ac.nz/courses/ compsci360fc/ archive/1999/Ass2/PickOfTheBest/.

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.

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.

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.

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.

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.

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.

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.