Application Of Design Patterns Research Articles

Performance analysis of .Net and Spring Boot microservices on Microsoft Azure

This article compares the efficiency of microservices written in Java and C#, using Spring Cloud for Java and Consul for C#. The measurements were carried out in three stages, such as basic service implementation, application of design patterns, and deployment on the Microsoft Azure cloud platform. The results illustrate that Java microservices are generally more efficient, although that difference diminishes on the cloud platform where .Net shows better optimization with Microsoft Azure.

A research paper on software design patterns

This article affords another exhaustive examination of software design patterns, discussing their importance, the classification system, and the influence on software architecture and design. It looks at how existing practices handle predictable problems, make things more easily serviceable, and increase developer collaboration. The article goes further and explains the use of design patterns and elaborates on real-life examples of design patterns and the difficulties and drawbacks of using them. Further, it expands on future possibilities, such as applying design patterns for cloud-new architectures, AI incorporation, serverless, and Agile/DevOps. From these trends, the article lays down the argument that design patterns are not insulated from change but are continually being adapted to fit into the software development processes of today's complex and sophisticated world and that to be relevant in the designing of today's complex, large and intelligent software-based systems, developers should be familiar with both the recognized and emergent design patterns.

Implementation of a Universal Framework Using Design Patterns for Application Development on Microcontrollers.

This article focuses on the area of software development for microcontrollers and details the implementation of modern programming practices and principles in embedded systems and IoT applications. This article explains how we implemented previously unimplemented principles and applied design patterns for quality software design on microcontrollers, which are currently only used for developing applications on the higher layers of the IoT reference model. A custom modular framework for microcontrollers is presented, based on applying SOLID principles and adapting design patterns specific to the microcontrollers' application development needs. The implemented framework enables independent communication between modules and flexible integration of hardware components. It is designed with platform independence in mind, contributing to its wide adaptability and ease of use in diverse development environments. By applying these technological approaches, we can create applications that are not only testable and extensible in terms of application logic but also allow for easy adaptation to changes in these hardware resources. Utilizing these capabilities represents an innovative approach to development for microcontrollers that fundamentally improves the long-term sustainability and scalability of applications.

Application of game design pattern: Gradual generation of usable sub-mechanisms from core mechanism

Among the many commendable creations presented by game developers, the design of game mechanics generally shares common components. This observation can also be validated by using some less impressive works as counterexamples; however, there is currently a lack of comprehensive summarization of these systems. Through analysis, this paper extracts the game mechanic design patterns present in these successful games. The paper explores the practical application of a game design pattern that originates from a core game mechanism and progressively generates usable sub-mechanisms. This pattern involves selecting a specific core gameplay element and introducing auxiliary mechanisms to expand its dimensions. Through a systematic exploration of various combinations and interactions, this approach aims to create diverse sub-mechanisms that enrich gameplay and level design. The paper discusses the benefits and challenges of this design pattern and provides illustrative examples.

Analysis of The Impact of Software Detailed Design on Mobile Application Performance Metrics

The rapid development of mobile applications in recent years has forced developers to develop their applications quickly. Application quality must be one of the top concerns of developers since poor application design will affect the quality of the application. Performance is one of the important quality attributes that determine the quality of an application. One approach that can be used to overcome performance problems is the design pattern. However, as the research progressed, other approaches were discovered such as refactoring code smells and design principles. In this study, a detailed design analysis was carried out on the source code of the mobile application by applying design patterns, refactoring the code smells, and implementing design principles to determine their impact on the application's performance. To measure the application performance, Central Processing Unit (CPU) usage, memory usage, and frame rate metrics are used. Based on the implementation design patterns, refactoring the code smells, and applying design principles, the result found that design patterns can affect application performance depending on the design pattern used. The Strategy pattern and Visitor pattern optimize memory usage by 1%, while the Bridge pattern increases memory usage by 2%. Meanwhile, the result of refactoring the code smells can optimize CPU usage by 35% and memory usage by 2%, and design principles can optimize CPU usage by 25% and application frame rates by 5 frame per second (fps).

A CPPS-architecture and workflow for bringing agent-based technologies as a form of artificial intelligence into practice

Abstract Due to the increase in Artificial Intelligence in the production systems domain, Industry 4.0 (I4.0) experts must collaborate with autonomous systems. Industrial AI raises several concerns about existing standards, which provide guidelines and design patterns. One way to realize I4.0 systems are Industrial Agents (IAs) due to their inherent autonomy and collaboration. Multi-Agent Systems (MASs) are well suited for realizing distributed AI in I4.0 components. Considering the properties of IAs and existing standards, an MAS architecture is presented for flexible and intelligent Cyber-Physical Production Systems. The article compares I4.0 standardization efforts relevant to adapt AI in the form of IAs, illustrates how IA design patterns can be used, and introduces the Multi-Agent aRchitecture for Industrial Automation applying desigN patterNs practicEs “MARIANNE”. An implementation guideline is presented to put this CPPS into practice.

Strategy Design Pattern Applied on a Mobile App Building

This paper provides the importance and application of design patterns in software engineering, particularly focusing on the Strategy Design Pattern. It outlines how design patterns offer efficient, flexible, and reusable solutions to common problems in object-oriented software development. The paper presents a case study of Strategy Design Pattern’s application in a mobile app builder, emphasizing its role in creating adaptable and maintainable software architecture. Additionally incorporates commentary on the SOLID Open and Close principle, explaining how it allows software entities to be extendable without modifying existing code, thus enhancing the scalability and robustness of the application. The OC principle integration with the Strategy Design Pattern demonstrates its practicality in promoting flexible and stable software development.

Implementation of Model View Controller Architecture in Object Oriented Programming Learning

This study aims to provide an overview of the application of software design patterns, namely Model View Controller (MVC) in object-oriented programming learning. In the software development industry, most application development uses frameworks. MVC architecture is a design pattern that is widely used by various frameworks. Students as prospective programmers or software developers must master and be able to translate object-oriented programming concepts into programming languages. In this study, the Java programming language is used to apply the object-oriented concept and implement the MVC architecture. This research resulted in an increase in students' programming skills and abilities as well as being able to apply the MVC architecture in developing applications using Java.

Refactoring for reuse: an empirical study

Refactoring is the de-facto practice to optimize software health. While several studies propose refactoring strategies to optimize software design through applying design patterns and removing design defects, little is known about how developers actually refactor their code to improve its reuse. Therefore, we extract, from 1,828 open source projects, a set of refactorings that were intended to improve the software reusability. We analyze the impact of reusability refactorings on the state-of-the-art reusability metrics, and we compare the distribution of reusability refactoring types, with the distribution of the remaining mainstream refactorings. Overall, we found that the distribution of refactoring types, applied in the context of reusability, is different from the distribution of refactoring types in mainstream development. In the refactorings performed to improve reusability, source files are subject to more design level types of refactorings. Reusability refactorings significantly impact, high-level code elements, such as packages, classes, and methods, while typical refactorings, impact all code elements, including identifiers, and parameters. These findings provide practical insights into the current practice of refactoring in the context of code reuse involving the act of refactoring.

Biophilic Design Patterns for Primary Schools

Existing frameworks for biophilic design have similar strategies and attributes as useful checklists for designers; however, the focus has been on adults rather than children, and there remains the need for more guidance related to school design by extension. The application of biophilia would be a design resolution in schools because of its impact on children’s health and well-being, which has been more important since the pandemic started; however, it remains quite unexplored in school design in many countries, including the UK. Biophilic design patterns can be used in school buildings and grounds for greater connectivity between spaces and nature in order to promote children’s well-being. This paper focuses on ten biophilic design patterns under two categories of ‘nature in the space’ and ‘natural analogues.’ This study presents the findings of case studies in various countries. The analysis focuses on the manifestations of biophilia to inform the application of biophilic design patterns for primary schools. Finally, this paper suggests how primary school children could be involved in a co-design process in order to evaluate biophilic design patterns.

An Extensible Compiler for Implementing Software Design Patterns as Concise 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.

Penerapan Biophilic Design pada Bangunan Unit Pelaksana Teknis Daerah Perlindungan Perempuan dan Anak Kota Bekasi

Title: Application of Biophilic Design in Regional Technical Implementation Unit for the Protection of Women and Children of Bekasi City Based on data from the National Commission for Women and Children in 2019, Bekasi City occupies the second position in the number of cases of violence against women and children after Jakarta. The response that has been done by the Bekasi City Government is to establish the Regional Technical Implementation Unit for the Protection of Women and Children (UPTD PPA) which provides services and psychological recovery for victims. Regarding psychological recovery, researchers agreed that nature plays a major role in the human psychological recovery process. So the design concept of this building is restoration through nature by incorporating natural features in the form of green space into the building. In designing the method applied is through the Biophilic Design approach with 14 Patterns of Biophilic Design as a guide in designing. The results of the research are the application of biophilic design patterns to the landscape, exterior, and interior buildings.

Cyberphysical Security Through Resiliency: A Systems-Centric Approach

Cyber-physical systems (CPS) are often defended in the same manner as information technology (IT) systems -- by using perimeter security. Multiple factors make such defenses insufficient for CPS. Resiliency shows potential in overcoming these shortfalls. Techniques for achieving resilience exist; however, methods and theory for evaluating resilience in CPS are lacking. We argue that such methods and theory should assist stakeholders in deciding where and how to apply design patterns for resilience. Such a problem potentially involves tradeoffs between different objectives and criteria, and such decisions need to be driven by traceable, defensible, repeatable engineering evidence. Multi-criteria resiliency problems require a system-oriented approach that evaluates systems in the presence of threats as well as potential design solutions once vulnerabilities have been identified. We present a systems-oriented view of cyber-physical security, termed Mission Aware, that is based on a holistic understanding of mission goals, system dynamics, and risk.

From Domain-Specific Language to Code: Smart Contracts and the Application of Design Patterns

Due to the conceptual discrepancy between legal contract terms and code, understanding and creating smart contracts without errors can be difficult. This article proposes smart contract design patterns and their automated application through (the use of) a domain-specific language and code generation.

A large scale study on how developers discuss code smells and anti-pattern in Stack Exchange sites

Abstract Context: In this paper, we investigate how developers discuss code smells and anti-patterns across three technical Stack Exchange sites. Understanding developers perceptions of these issues is important to inform and align future research efforts and direct tools vendors to design tailored tools that best suit developers. Method: we mined three Stack Exchange sites and used quantitative and qualitative methods to analyse more than 4000 posts that discuss code smells and anti-patterns.Results: results showed that developers often asked their peers to smell their code, thus utilising those sites as an informal, crowd-based code smell/anti-pattern detector. The majority of questions (556) asked were focused on smells like Duplicated Code, Spaghetti Code, God and Data Classes. In terms of languages, most of discussions centred around popular languages such as C # (772 posts), JavaScript (720) and Java (699), however greater support is available for Java compared to other languages (especially modern languages such as Swift and Kotlin). We also found that developers often discuss the downsides of implementing specific design patterns and ‘flag’ them as potential anti-patterns to be avoided. Some well-defined smells and anti-patterns are discussed as potentially being acceptable practice in certain scenarios. In general, developers actively seek to consider trade-offs to decide whether to use a design pattern, an anti-pattern or not.Conclusion: our results suggest that there is a need for: 1) more context and domain sensitive evaluations of code smells and anti-patterns, 2) better guidelines for making trade-offs when applying design patterns or eliminating smells/anti-patterns in industry, and 3) a unified, constantly updated, catalog of smells and anti-patterns. We conjecture that the crowd-based detection approach considers contextual factors and thus tend to be more trusted by developers than automated detection tools.

The enslaved ontology: Peoples of the historic slave trade

We present the Enslaved Ontology (V1.0) which was developed for integrating data about the historic slave trade from diverse sources in a use case driven by historians. Ontology development followed modular ontology design principles as derived from ontology design pattern application best practices and the eXtreme Design Methodology. Ontology content focuses on data about historic persons and the event records from which this data can be taken. It also incorporates provenance modeling and some temporal and spatial aspects. The ontology is available as serialized in the Web Ontology Language OWL, and carries modularization annotations using the Ontology Pattern Language (OPLa). It is available under the Creative Commons CC BY 4.0 license.

The Enslaved Ontology: Peoples of the Historic Slave Trade

We present the Enslaved Ontology (V1.0) which was developed for integrating data about the historic slave trade from diverse sources in a use case driven by historians. Ontology development followed modular ontology design principles as derived from ontology design pattern application best practices and the eXtreme Design Methodology. Ontology content focuses on data about historic persons and the event records from which this data can be taken. It also incorporates provenance modeling and some temporal and spatial aspects. The ontology is available as serialized in the Web Ontology Language OWL, and carries modularization annotations using the Ontology Pattern Language (OPLa). It is available under the Creative Commons CC BY 4.0 license.

User interface design pattern modeling for designing mobile-based scheduling activity application for senior citizen

Design patterns are explanations or templates that show how to solve problems that can then be used in different discussions. Design patterns are also a good solution for repetitive design problems, such as those given in activity scheduling applications for the elderly. Based on the results of literature studies conducted, related to the problem of compiling the elderly to scheduling activities on applications designed for the community because the elderly have special characteristics. From this recurring debate, a Design Pattern is required to request applications for the elderly. In this research, there is a modeling flow consisting of four processes, namely creating new design solutions that produce design patterns, user research using the User-Centered Design method that results in user needs analysis, creating new design solutions that produce prototypes, and finally from this research Testing design solutions are. From this modeling flow, the User Interface Design Pattern and Activity Scheduling application prototype for the senior citizen can be produced that can help to achieve the objectives of carrying out daily activities.

Guiding assurance of architectural design patterns for critical applications

Abstract Development of critical systems nowadays is hardly achievable without reuse of previous knowledge. Design patterns have an important role in the design of such systems as they define and document common solutions to recurring design problems. However, critical systems such as those that are safety or security related, often require specific assurances that the system is adequate to operate in a given environment. Just as with any other reused knowledge in such systems, the reuse via application of design patterns needs to be assured every time. In this paper, we present a methodology for assuring the application of design patterns in critical domains. In particular, we enrich the design patterns template to support their further assurance. We define the aspects that should be tackled during the assurance of a design pattern application. We use the information specified in the design pattern template to guide the automated instantiation of the argumentation for each design pattern application in the system. We provide tool-support for our methodology in the context of the AMASS tool-platform and evaluate it in an automotive case study.

An Overview of Design Patterns for Self-Adaptive Systems in the Context of the Internet of Things

The Internet of Things (IoT) requires the integration of all available, highly specialized, and heterogeneous devices, ranging from embedded sensor nodes to servers in the cloud. The self-adaptive research domain provides adaptive capabilities that can support the integration in IoT systems. However, developing such systems is a challenging, error-prone, and time-consuming task. In this context, design patterns propose already used and optimized solutions to specific problems in various contexts. Applying design patterns might help to reuse existing knowledge about similar development issues. However, so far, there is a lack of taxonomies on design patterns for self-adaptive systems. To tackle this issue, in this paper, we provide a taxonomy on design patterns for self-adaptive systems that can be transferred to support adaptivity in IoT systems. Besides describing the taxonomy and the design patterns, we discuss their applicability in an Industrial IoT case study.