Implementation Of Design Patterns Research Articles

The design of small architectural forms in the development of urban spaces based on Komi culture

The article examines a modern direction in the development of public spaces that includes the cultural code of the region and cultural identity in modern urban environment design. This is an important issue considering academic urban space projects in the educational process and work with urban communities. The article demonstrates a case of design pattern implementation based on Komi culture in relation to small architectural forms for the public space «Playground under the Clock» in Syktyvkar.

A Blockchain Approach to Extract Design Patterns From Source Codes

Design patterns are an effective technique for software development. However, lacking suitable documents often reduces traceability, and advantages remain unclear in source lines of code (SLOC). Design patterns are proven, reliable solutions to several frequent problems in object‐oriented software design. Detecting design patterns in a software system contributes to maintainability and reengineering and facilitates understanding codes. Furthermore, different design pattern implementations impede the detection of code pattern instances. A design pattern is a set of roles played by the code classes. Roles are the main details and determinants in patterns. A pattern can be detected in its defined role as it is an instance of a role. It is also of great importance in system documentation. The proposed method exploits blockchain‐based approaches for pattern mining and isolating design patterns in order to identify intercode relationships. The results demonstrate that the blockchain is effective and efficient in extracting the connections of features from source codes and adapting to design patterns with precision 97.2%.

Embracing Nature in the Built Environment: Evaluation of Biophilic Design Patterns in Selected Resorts

The integration of natural elements into the built environment, commonly referred to as biophilic design, has garnered interest due to its capacity to improve well-being and foster sustainable lifestyles. Resorts, which serve as temporary retreats for individuals seeking relaxation and leisure, offer a range of amenities and the opportunity to engage with nature. This paper aims to investigate the implementation of biophilic design patterns within selected resorts. Given its rich heritage and abundant natural resources, Ibadan, Nigeria was selected as the study location for this study. The research employed a quantitative methodology, employing convenience sampling to ensure a representative sample from the population. Questionnaires were distributed using a census sampling technique. The results of this study demonstrate a substantial implementation of biophilic design strategies in the chosen resorts. It is strongly advised to incorporate biophilic design strategies right from the inception of the design process, rather than considering them as an afterthought.

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 generic approach to detect design patterns in model transformations using a string-matching algorithm

Maintaining software artifacts is a complex and time-consuming task. Like any other program, model transformations are subject to maintenance. In a maintenance process, much effort is dedicated to the comprehension of programs. To this end, several techniques are used, such as feature location and design pattern detection. In the particular case of model transformations, detecting design patterns contributes to a better comprehension as they carry valuable information on the transformation structure. In this paper, we propose a generic approach to detect, semi-automatically, design patterns and their variations in model transformations. Our approach encodes both design patterns and transformations as strings and use a string-matching algorithm for the detection. The approach is able to detect complete and partial implementations of design patterns in transformations, which is useful to refactoring and improving model transformations.

Application of Pattern Language for Game Design in Pedagogy and Design Practice

Existing implementations of game design patterns have largely been confined to theoretical or research settings. Weaknesses in these implementations have prevented game design patterns from being properly evaluated as an educational and practical development tool. This paper examines these weaknesses, describes a method of developing and applying patterns that overcome the weaknesses, and evaluates use of the method for game design education and practice. Weaknesses in existing pattern implementations are: the omission of design problems, presumption of functional completeness at the level of pattern languages, narrow topical focus, and lack of a concise, repeatable method for pattern production. Several features of the proposed method were specifically built to address these weaknesses, namely the pattern template, the process for connecting patterns into a language and assessing the language’s scope, a rubric for assessing pattern confidence and interconnectivity confidence, and pattern-building exercises. This method was applied in a classroom setting. Results as assessed by the evaluation of student work suggest that creating patterns/pattern languages is an effective pedagogical approach. Designs produced using designer-created patterns closely align with existing design theory and are clearly understood by students. The above results may indicate that the path to gaining wider acceptance of pattern theory as a design framework within game design is not to produce a universal pattern language, but to facilitate the creation of case-specific languages by students and professional designers that use a shared ontology, and thus can be combined easily to solve the diverse sets of problems faced by these groups.

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.

Оцінка використання шаблонів проектування програмного забезпечення

The subject of study in the article is software development processes using design patterns. The aim is to improve the quality of modern software development projects through the use of experience and knowledge, to build software subsystems that are focused on infrastructure and work with an external client. Objectives: to review the methodology, programming paradigms and the possibility of their application at the design and coding stages of the software development life cycle; development of the concept of using design patterns in software design as knowledge available for reuse, propose an approach to the practical implementation of design patterns to node.js projects. The models used are the Composite design pattern, the Chain of responsibility design pattern. The used methodologies are object-oriented programming, as the most common programming paradigm, a unified modeling language UML for displaying the structure of design patterns. The following results are obtained. Modern methodologies and design paradigms are considered, a classification is formed in the form of a tree structure with a division into declarative and imperative subspecies, it is concluded that within the framework of the study we will use an object-oriented methodology as the most common design paradigm. An example of building an information system of the node.js project is considered. Analyzed the main errors that arise when developing and writing code for working with an external client. The elements of the node.js project and the concepts of structuring their relationship with existing design patterns are considered. An example of a practical implementation of a node.js project and its relationship with the Composite and Chain of responsibility design patterns is considered. In this connection, the work provides the structure of these templates. Findings. The scientific novelty of the results obtained is as follows: the model of design patterns was further developed through their use in the concept of building a node.js application, which makes it possible to improve the quality of interaction between the project team and reduce its execution time.

Design Patterns and Electric Vehicle Charging Software

The development and maintenance of complex software systems, with ever-changing requirements has benefited from the implementation of design patterns, which ensure a higher degree of maintainability. The present article illustrates the essential role of design patterns in sketching the software architecture for an electric vehicle charging management platform. We have integrated a series of design patterns to create a solid base structure for the API (Application Programming Interface). Furthermore, we have explored cloud design patterns in the deployment process to ensure a proper multi-tenant cloud application with the best possible tenant isolation for the cost. The aim of this paper is to offer readers an introduction in the case study theme, to describe a complex platform development through design patterns. With proper examples from real projects debated in the industry. The paper demonstrates the design patterns applicability from software level to cloud resources plan and advocates for a high-quality solution in every segment of project development. In conclusion, the results are promising, and the functionality of the established methods on this type of platforms will be evaluated during the implementation period. Overall, design patterns have proven to be essential in the development process, ensuring effective team communication and the delivery of qualitative software solutions.

Identification and Assessment of Software Design Pattern Violations

The validation of design pattern implementations to identify pattern violations has gained more relevance as part of re-engineering processes in order to preserve, extend, reuse software projects in rapid development environments. If design pattern implementations do not conform to their definitions, they are considered a violation. Software aging and the lack of experience of developers are the origins of design pattern violations. It is important to check the correctness of the design pattern implementations against some predefined characteristics to detect and to correct violations, thus, to reduce costs. Currently, several tools have been developed to detect design pattern instances, but there has been little work done in creating an automated tool to identify and validate design pattern violations. In this paper we propose a Design Pattern Violations Identification and Assessment (DPVIA) tool, which has the ability to identify software design pattern violations and report the conformance score of pattern instance implementations towards a set of predefined characteristics for any design pattern definition whether Gang of Four (GoF) design patterns by Gamma et al[1]; or custom pattern by software developer. Moreover, we have verified the validity of the proposed tool using two evaluation experiments and the results were manually checked. Finally, in order to assess the functionality of the proposed tool, it is evaluated with a data-set containing 5,679,964 Lines of Code among 28,669 in 15 open-source projects, with a large and small size of open-source projects that extensively and systematically employing design patterns, to determine design pattern violations and suggest refactoring solutions, thus keeping costs of software evolution. The results can be used by software architects to develop best practices while using design patterns.

VERIFICATION OF ACCURACY AND COST OF USE METHODS OF QUALITY ASSESSMENT OF IMPLEMENTATION OF DESIGN PATTERNS

Professional programmers use many additional tools over the Integrated Development Environment during their work. Very often they are looking for new solutions, while expecting that the new tool will provide accurate results, and the cost of use will fit within the planned budget. The aim of the article is to present the results of two comparative analyzes carried out in terms of accuracy and the cost of using the quality assessment method of implementation of design patterns.

Design and Implementation of Courseware Object Design Patterns to Improve the Reusability in Extensible Learning Support System

Design and Implementation of Courseware Object Design Patterns to Improve the Reusability in Extensible Learning Support System

An Online Learning Collaboratory to Address Multidisciplinary Learning Challenges at Scale

“Ensuring inclusive and quality education for all to promote lifelong learning” is among the United Nations’ global time-critical sustainable development challenges. Massive open online courses and other online learning systems can potentially address this challenge by fostering high quality online learning at scale. However, online learning introduces complex challenges that involve multiple disciplines, varied learning contexts, and diverse learner backgrounds. There are plenty of research initiatives that try to address this problem, but they are fragmented efforts that could benefit from a community effort. We propose an online learning collaboratory framework to leverage and connect ongoing research efforts. In this paper, we propose four objectives for the online learning collaboratory and discuss existing work aligned with such objectives, which are: evaluation and refinement of instructional designs, interdisciplinary communication through design patterns, design pattern implementation, and bridging communities of practice. The collaboratory should bridge different communities through design patterns and connect datadriven practices and tools to address multidisciplinary learning challenges at scale.

Visualizing statistical linked knowledge for decision support

In a global and interconnected economy, decision makers often need to consider information from various domains. A tourism destination manager, for example, has to correlate tourist behavior with financial and environmental indicators to allocate funds for strategic long-term investments. Statistical data underpins a broad range of such cross-domain decision tasks. A variety of statistical datasets are available as Linked Open Data, often incorporated into visual analytics solutions to support decision making. What are the principles, architectures, workflows and implementation design patterns that should be followed for building such visual cross-domain decision support systems. This article introduces a methodology to integrate and visualize cross-domain statistical data sources by applying selected RDF Data Cube (QB) principles. A visual dashboard built according to this methodology is presented and evaluated in the context of two use cases in the tourism and telecommunications domains.

Aspect oriented implementation of design patterns using metadata

Computer programming paradigms aim to provide better separation of concerns. Aspect oriented programming extends object oriented programming by managing crosscutting concerns using aspects. Two of the most important critics of aspect oriented programming are the “tyranny of the dominant signature” and lack of visibility of program's flow. Metadata, in form of Java annotations, is a solution to both problems. Design patterns are assumed as the general solutions for Object-Oriented matters. They assist in software complexity management and serve as a bridge among software designers as well. These properties have led the patterns to be introduced as a choice in order to prove new technologies. Successful implementations share a generic solution: the usage of annotation to configure and mark the participants, while the pattern's code is encapsulated in aspects. This loses the coupling between aspects and type signatures and between the code base and a specific AOP framework. Also, it increases the developer's awareness of the program's flow. In the present article, aspect oriented programming and design patterns are introduced and also taking the benefit of annotation equipment in java language is proposed as a solution to reduce tight coupling and increase program flow observation rate for aspect oriented programming. Keywords: aspect oriented programming, design patterns, object oriented programming, metadata.

Implementing design patterns as parametric aspects using ParaAJ: The case of the singleton, observer, and decorator design patterns

Implementation of a design pattern can take many forms according to the programming language being used. Most of the literature presents design patterns in their conventional object-oriented implementations. Several other studies show the implementation in aspect-oriented languages such as AspectJ, EOS, and Caesar. In this work, we compare the implementation of three design patterns: singleton, observer, and decorator design patterns in these languages and also discuss the possibility of implementing them in ParaAJ: an extension to the AspectJ language that implements the idea of parametric aspects. We found that ParaAJ helps in making the implementation of the singleton and observer patterns reusable but it fails to help in the decorator case. The problem with the decorator pattern exists because of the current translation mechanism of ParaAJ׳s aspects to normal AspectJ׳s aspects. This opens the door for further work in ParaAJ to better support the idea of parametric aspects.

Blending design patterns with aspects: A quantitative study

Design patterns often need to be blended (or composed) when they are instantiated in a software system. The composition of design patterns consists of assigning multiple pattern elements into overlapping sets of classes in a software system. Whenever the modularity of each design pattern is not preserved in the source code, their implementation becomes tangled with each other and with the classes’ core responsibilities. As a consequence, the change or removal of each design pattern will be costly or prohibitive as the software system evolves. In fact, composing design patterns is much harder than instantiating them in an isolated manner. Previous studies have found design pattern implementations are naturally crosscutting in object-oriented systems, thereby making it difficult to modularly compose them. Therefore, aspect-oriented programming (AOP) has been pointed out as a natural alternative for modularizing and blending design patterns. However, there is little empirical knowledge on how AOP models influence the composability of widely used design patterns. This paper investigates the influence of using AOP models for composing the Gang-of-Four design patterns. Our study categorizes different forms of pattern composition and studies the benefits and drawbacks of AOP in these contexts. We performed assessments of several pair-wise compositions taken from 3 medium-sized systems implemented in Java and two AOP models, namely, AspectJ and Compose*. We also considered complex situations where more than two patterns involved in each composition, and the patterns were interacting with other aspects implementing other crosscutting concerns of the system. In general, we observed two dominant factors impacting the pattern composability with AOP: (i) the category of the pattern composition, and (ii) the AspectJ idioms used to implement the design patterns taking part in the composition.

Code Search API, Base of Parallel Code Refactoring System For Safety Standards Compliance

New technologies of multi-core and massively parallel processors are becoming common parts of today’s desktop computers. These state-of-the-art technologies allow programming of parallel applications and systems, however, creating parallel applications puts higher demands on programmers’ skills,projectmaintenanceandmodificationofexistingsourcecodes.Program flaws entered on source codes could have fatal consequences, specifically in aviation or medicine systems, due to possible fatal impacts in case of systems failure. This paper describes the current status of aviation and medicine software safety standards, points out the common requirements of all these standards, specially the requirement for reliability. Reliability can be easily achieved using design patterns with verified reliable source code modules. In our research, we propose system for implementation of concurrency and synchronization design patterns into existing code. We have created parallel source code search API which is described in this paper, and which is planned to be used in our parallel code refactoring system for safety standards compliance. ThisAPI enables us to define appropriate places in source codes for introduction of parallel design patterns into existing parallel source codes. In next design iteration, the proposed system will provide suggestions of refactoring operations of found source codes, based on static code analysis and formal description of parallel design patterns.

A graph mining approach for detecting identical design structures in object-oriented design models

The object-oriented approach has been the most popular software design methodology for the past twenty-five years. Several design patterns and principles are defined to improve the design quality of object-oriented software systems. In addition, designers can use unique design motifs that are designed for the specific application domains. Another commonly used technique is cloning and modifying some parts of the software while creating new modules. Therefore, object-oriented programs can include many identical design structures. This work proposes a sub-graph mining-based approach for detecting identical design structures in object-oriented systems. By identifying and analyzing these structures, we can obtain useful information about the design, such as commonly-used design patterns, most frequent design defects, domain-specific patterns, and reused design clones, which could help developers to improve their knowledge about the software architecture. Furthermore, problematic parts of frequent identical design structures are appropriate refactoring opportunities because they affect multiple areas of the architecture. Experiments with several open-source and industrial projects show that we can successfully find many identical design structures within a project (intra-project) and between different projects (inter-project). We observe that usually most of the detected identical structures are an implementation of common design patterns; however, we also detect various anti-patterns, domain-specific patterns, reused design parts and design-level clones.

Model-based cache-aware dispatching of object-oriented software for multicore systems

In recent years, processor technology has evolved towards multicore processors, which include multiple processing units (cores) in a single package. Those cores, having their own private caches, often share a higher level cache memory dedicated to each processor die. This multi-level cache hierarchy in multicore processors raises the importance of cache utilization problem. Assigning parallel-running software components with common data to processor cores that do not share a common cache increases the number of cache misses. In this paper we present a novel approach that uses model-based information to guide the OS scheduler in assigning appropriate core affinities to software objects at run-time. We build graph models of software and cache hierarchies of processors and devise a graph matcher algorithm that provides mapping between these two graphs. Using this mapping we obtain candidate core sets that each software object can be affiliated with at run-time. These affiliations are determined based on the idea that software components that have the potential to share common data at run-time should run on cores that share a common cache. We also develop an object dispatcher algorithm that keeps track of object affiliations at run-time and dispatches objects by using the information from the compile-time graph matcher. We apply our approach on design pattern implementations and two different application program running on servers using CFS scheduling. Our results show that cache-aware dispatching based on information obtained from software model, decreases number of cache misses significantly and improves CFS’ scheduling performance.