Object-oriented Design Patterns Research Articles

Resolving the Java Representation Exposure Problem with an AST-Based Deep Copy and Flexible Alias Ownership System

Encapsulation is a critical factor in object-oriented programming languages and design patterns. Nevertheless, programs written in languages like Java may encounter broken encapsulation due to the lack of sufficient supply for ownership and immutability. As a result, this paper introduces SlimeJava, an ownership system extension based on abstract syntax trees and annotation utilization of Java that aims to help programmers prevent representation exposure. We show the features of the proposal with a motivating example using the Memento pattern. We then discuss how the utilization of annotations realizes ownership and why it is effective in avoiding representation exposure issues by comparing it with existing approaches. In the end, a quantitative performance evaluation was conducted to prove that SlimeJava does not cause a substantial overhead in execution time compared to native Java.

A mapping study of language features improving object-oriented design patterns

A mapping study of language features improving object-oriented design patterns

Electronic problem book on design patterns: Implementation and use

The article is dedicated to the problems associated with organizing the practical component of object-oriented programming (OOP) courses. A review of current learning resources for OOP courses reveals a lack of learning assignments related to design patterns, which are essential components of modern OOP theory. To solve this problem, the author proposes using a specialized training resource — an electronic problem book on object-oriented design patterns. The features of the design patterns e-taskbook are described in detail and an example of its implementation is given: the Programming Taskbook for OOP, which includes tasks related to 21 classic design patterns, as well as an introductory group of tasks dedicated to the principles and techniques of OOP.The article emphasizes the novelty of this approach, noting that unlike traditional problem books, the Programming Taskbook for OOP not only contains the wording of tasks, but also provides the courseware with input data and automatic verification of the proposed solution. Another important feature of the book is its versatility: the tasks can be performed in different languages and different programming environments, which allows to easily adapt the book for use in various undergraduate and graduate courses. Finally, the author presents his experience using the Programming Taskbook in OOP courses.

A Systematic Mapping Study of Suggested Improvements to Object-Oriented Design Patterns

A Systematic Mapping Study of Suggested Improvements to Object-Oriented Design Patterns

Mining knowledge graphs to map heterogeneous relations between the internet of things patterns

<span lang="EN-US">Patterns for the internet of things (IoT) which represent proven solutions used to solve design problems in the IoT are numerous. Similar to object-oriented design patterns, these IoT patterns contain multiple mutual heterogeneous relationships. However, these pattern relationships are hidden and virtually unidentified in most documents. In this paper, we use machine learning techniques to automatically mine knowledge graphs to map these relationships between several IoT patterns. The end result is a semantic knowledge graph database which outlines patterns as vertices and their relations as edges. We have identified four main relationships between the IoT patterns-a pattern is similar to another pattern if it addresses the same use case problem, a large-scale pattern uses a small- scale pattern in a lower level layer, a large pattern is composed of multiple smaller scale patterns underneath it, and patterns complement and combine with each other to resolve a given use case problem. Our results show some promising prospects towards the use of machine learning techniques to generate an automated repository to organise the IoT patterns, which are usually extracted at various levels of abstraction and granularity.</span>

PRINCIPLES FOR DEVELOPMENT OF PROGRAM INTERFACES IN INDUSTRIAL INFORMATION, MEASURING, AND CONTROLLING SYSTEMS

Industrial information, measuring, and controlling systems have a program module designed to convert measurement results into data for display and control signals. A program module interconnected to other modules by program interfaces. In this case, data transformations are necessary when they are sent between modules. Object-oriented design patterns can be used when programming data transformations. When converting measurement results to objects, the Adapter design pattern can be applied. Programming the Command pattern is intended for converting objects into control signals. Data processing should be separated from their representation, storage and transmission. Functions between modules can be divided using the Model–View–Controller pattern. The use of design patterns reduces the development time and subsequent modification of software for both information, measuring, and control systems, as well as systems in other subjects of science and economics.

On the Usability of Object-Oriented Design Patterns for a Better Software Quality

Abstract Software design patterns incarnate expert knowledge distilled from the practical experience in object-oriented design, in a compact and reusable form. The article presents a quantitative study of the usability of the object-oriented software design patterns (known as Gang of Four patterns) applied for improving the testability, maintainability, extendibility, readability, reliability, and performance efficiency of software applications. We received 82 usable responses from software professionals in Bulgaria, with 65 of them addressing both the usability and recognition of each one of the Gang of Four patterns, together with their impact on important software quality characteristics. As well, we studied the approach of each software developer in choosing a particular design pattern to use in order to solve a problem. We found statistically significant differences between the most recognized and most useful patterns and between the most unrecognized and most useless patterns, split into creational, structural, and behavioral groups.

Towards a more complete object-orientation in graph-based design languages

In this paper an extension of the design method graph-based design languages is proposed. This is realized by adding object-oriented class methods and interface mechanisms to the design method. Additionally, graphical mechanisms for modeling and calling the methods are proposed. This allows object-oriented design patterns to be transferred to the product design, where they improve the handling of complexity in the product engineering. As result, the proposed extension enables modularization and reuse of engineering knowledge, the integration of engineering domains is enhanced and multi-stakeholder collaboration with security access control (information security) becomes feasible.

Emulator for data analytics and IoT development projects

One of the difficulties for the development and testing of data analysis applications used by IoT devices is the economic and temporary cost of building the IoT network, to mitigate these costs and expedite the development of IoT and analytical applications, it is proposed NIOTE, an IoT network emulator that generates sensor and actuator data from different devices that are easy to configure and deploy over TCP/IP and MQTT protocols, this tool serves as support in academic environments and conceptual validation in the design of IoT networks. The emulator facilitates the development of this type of application, optimizing the development time and improving the final quality of the product. Object-oriented programming concepts, architecture, and software design patterns are used to develop this emulator, which allows us to emulate the behavior of IoT devices that are inside a specific network, where you can add the number of necessary devices, model and design any network. Each network sends data that is stored locally to emulate the process of transporting the data to a platform, through a specific format and will be sent to perform Data Analysis.

Applying Patterns to E-Government

This paper present design patterns which simplifies the process of developing, deploying, and managing complex, integrated, and standards-compliant E-government applications. The patterns can be used at different levels and layers of E-government’s architecture. Architecture Patterns are the highest layer patterns and have a high level of abstraction. Their aim is to present the different system components and their collaboration through a conceptual model. In the middle layer are design patterns. In e-government, security and object-oriented design patterns are most used. The design patterns application allows to improve the performance of the existing solution, the flexibility and scalability, security and to keep the applications up to date and to incorporate the new requirements. E-government web design patterns allow to create intuitive websites that are suitable for different user categories.

UML generator – use case and class diagram generation from text requirements

This research mainly is focused on automation of Unified Modeling Language (UML) diagrams from the analyzed requirement text using Natural Language Processing (NLP). The looks and styles of software engineering have been completely changed in the recent times. Presently, software engineering follows the rules of Object Oriented design patterns. All phases of software engineering are deviating from the conventions and new paradigms are more popular these days. Same is the case with Software analysis process which uses Unified Modeling Language to map and model the user requirements. Analysis is the key process of building modern information system applications and base for the robust and vigorous software application’s design and development. Nowadays everybody needs a quick and reliable service. It was necessary to have some sort of quick, accurate and intelligent software for generating UML based documentations to save time and budget of both the user and system analyst

Comparación de Uso del Patrón de Diseño Decorator y la Programación Orientada a Aspectos en .NET para Modularizar Incumbencias Cruzadas

Looking for modular .NET software solutions, this article describes and illustrates how to produce modular .NET solutions through the use of the object-oriented software design pattern Decorator and the aspectoriented programming (AOP) tool PostSharp for the crosscutting concerns modularization of an application. The application is a base and traditional crosscutting concerns example (logging example). This article presents solutions of logging by the use of Decorator and PostSharp for the modularization of its crosscutting concerns. It also gives details of the advantages and disadvantages of both solutions. Furthermore, this article specifies AOP information that is part of PostSharp and proposes applying PostSharp and Decorator to achieve higher modularity level solutions.

Design patterns for multi-agent programming

Various agent-based programming languages and frameworks have been proposed to support the development of autonomous agents and multi-agent systems. They have provided a valuable contribution to the identification and operationalisation of agent concepts and abstractions by proposing specific programming constructs. Unfortunately, these contributions have not yet been widely adopted by industry. In this paper, we follow the argument that multi-agent programming technology can find its way to industry by providing a methodology that guides the development of autonomous agents and multi-agent systems in standard programming technology. The proposed methodology explains how some characteristic concepts and abstractions related to autonomous agents and multi-agent systems can be implemented in object-oriented technology. This is done by initiating a Java library of object-oriented design patterns for some characteristic but established programming constructs that have been developed in some agent-based programming languages.

Identification of best fit parameters of void nucleation and growth model using particle swarm technique

The void nucleation and growth (NAG) model describes fracture as a result of nucleation and growth of voids in the ductile materials at the microscopic scales. This model involves five material-dependent parameters, best-fit values of which must be determined by matching with atomistic simulations (MD). This is done by minimizing the difference between the temporal evolution of void volume yielded by MD and by the NAG model. The NAG model represents a real valued, non-linear and non-continuous optimization problem. Therefore, an swarm intelligence based technique, particle swarm optimization (PSO) is used for optimum parameters search. The search algorithm is developed on PSO to iteratively search optimum point, starting with a given reference search space and improving it based on the location of best searched point in each iteration. The PSO code is developed using object oriented design patterns so that the same can be extended for other materials without a base change. The paper discusses the code details, best fit parameters for Niobium (Nb) and Molybdenum (Mo) crystals and algorithmic parameters tuning of the modified algorithm. It has been shown that parameter tuning has shown improved results in terms of lower computing cost. It is seen that the MD results match the NAG model with a root mean square error of 7% and 15% for perfect crystal Nb and Mo and 10% and 17% for Nb and Mo crystal with edge dislocation, respectively. Novel features of the work includes the systematic movement of search-space boundaries to aid convergence in an unknown search-space. The sensitivity of the best result to algorithmic parameters and comparative analysis against other PSO variants has also been studied.

Object-oriented and ontology-alignment patterns-based expressive Mediation Bridge Ontology (MBO)

The Semantic Web is dependent on extensive knowledge management by interlinking resources on the web using matching techniques. This role is played by the progressing domain of ontology matching, by introducing ontology-matching tools. The focus of these matching tools is limited to matching techniques and automation, rather than expressive formal representation of alignments. We propose Mediation Bridge Ontology (MBO), an expressive alignment representation ontology used to store correspondences between matching ontologies matched by our ontology-matching tool, System for Parallel Heterogeneity Resolution (SPHeRe). The MBO utilizes object-oriented design patterns and the proposed ontology-alignment design patterns to provide extendibility and reusability factors to SPHeRe system. We compared our proposed system with existing systems using Coupling Factor, Number of Polymorphic methods and Rate of Change metrics to support extendibility and reusability. These factors contribute to the overall objective of interoperability for knowledge management in the Semantic Web.

Intelligent polar cyberinfrastructure: enabling semantic search in geospatial metadata catalogue to support polar data discovery

Polar regions have garnered substantial research attention in recent years because they are key drivers of the Earth’s climate, a source of rich mineral resources, and the home of a variety of marine life. Nevertheless, global warming over the past century is pushing the polar systems towards a tipping point: the systems are at high-risk from melting snow and sea ice covers, permafrost thawing, and acidification of the Arctic oceans. To increase understanding of the polar environment, the National Science Foundation established a Polar Cyberinfrastructure (CI) program, aimed at utilizing advanced software architecture to support polar data analysis and decision-making. At the center of this Polar CI research are data resources and data discovery components that facilitate the search and retrieval of polar data. This paper reports our development of a semantic search tool that supports the intelligent discovery of polar datasets. This tool is built on latent semantic analysis techniques, which improves search performance by identifying hidden semantic associations between terminologies used in the various datasets’ metadata. The software tool is implemented using an object-oriented design pattern and has been successfully integrated into a popular open source metadata catalog as a new semantic search support. A semantic matrix is maintained persistently within the catalogue to store the semantic associations. A dynamic update mechanism was also developed to allow automated update of semantics once more metadata are loaded into or removed from the catalog. We explored the effects of rank reduction to the effectiveness of this semantic search module and demonstrated its better performance than the traditional search techniques.

Software Development Process for Automation System of Large Solar Vacuum Telescope

The paper describes experience of software development for automated system for Large Solar Vacuum Telescope. Most attention is given to the work evolution on the different stages of this process. Automated system software has been developed using Object-Oriented Programming, Design Patterns and Qt tools to achieve reusable code, that can be used in other telescopes and be portable to different operating systems

Design Patterns for Sparse-Matrix Computations on Hybrid CPU/GPU Platforms

We apply object-oriented software design patterns to develop code for scientific software involving sparse matrices. Design patterns arise when multiple independent developments produce similar designs which converge onto a generic solution. We demonstrate how to use design patterns to implement an interface for sparse matrix computations on NVIDIA GPUs starting from PSBLAS, an existing sparse matrix library, and from existing sets of GPU kernels for sparse matrices. We also compare the throughput of the PSBLAS sparse matrix–vector multiplication on two platforms exploiting the GPU with that obtained by a CPU-only PSBLAS implementation. Our experiments exhibit encouraging results regarding the comparison between CPU and GPU executions in double precision, obtaining a speedup of up to 35.35 on NVIDIA GTX 285 with respect to AMD Athlon 7750, and up to 10.15 on NVIDIA Tesla C2050 with respect to Intel Xeon X5650.

Software Quality: Issues, Concerns and New Directions

Software metrics and quality models have a very important role to play in measurement of software quality. A number of well-known quality models and software metrics are used to build quality software both in industry and in academia. Development of software metrics is an ongoing process with new metrics being continuously tried out. However, during our research on measuring software quality using object oriented design patterns, we faced many issues related to existing software metrics and quality models. For a particular situation of interest, any established metric can be used. If none is found to be appropriate, a new metric can be devised. In this paper, we discuss some of these issues and present our approach to software quality assessment.

On the use of feature-oriented programming for evolving software product lines — A comparative study

Feature-oriented programming (FOP) is a programming technique based on composition mechanisms, called refinements. It is often assumed that feature-oriented programming is more suitable than other variability mechanisms for implementing Software Product Lines (SPLs). However, there is no empirical evidence to support this claim. In fact, recent research work found out that some composition mechanisms might degenerate the SPL modularity and stability. However, there is no study investigating these properties focusing on the FOP composition mechanisms. This paper presents quantitative and qualitative analysis of how feature modularity and change propagation behave in the context of two evolving SPLs, namely WebStore and MobileMedia. Quantitative data have been collected from the SPLs developed in three different variability mechanisms: FOP refinements, conditional compilation, and object-oriented design patterns. Our results suggest that FOP requires few changes in source code and a balanced number of added modules, providing better support than other techniques for non-intrusive insertions. Therefore, it adheres closer to the Open–Closed principle. Additionally, FOP seems to be more effective tackling modularity degeneration, by avoiding feature tangling and scattering in source code, than conditional compilation and design patterns. These results are based not only on the variability mechanism itself, but also on careful SPL design. However, the aforementioned results are weaker when the design needs to cope with crosscutting and fine-grained features.