Object-oriented Design Patterns Research Articles

Utilization of object-oriented programming, design patterns and java for simulating earthquake-induced poundings of base-isolated buildings

Base-isolated buildings experience large horizontal relative displacements during strong earthquakes due to the excessive fl exibility that is purposely incorporated, through seismic bearings, at their bases. When the available clearance around a base-isolated building is limited, there is a possibility of the building pounding against the surrounding moat wall or adjacent structures. Considering the nonlinearities involved in this structural impact problem, it is evident that the effects of potential pounding on the overall seismic response of base-isolated buildings during earthquake excitations should be investigated numerically through appropriate simulations. Object-oriented programming (OOP), design patterns (DPs), and the Java programming language have been utilized in order to design and implement a fl exible and extendable software application that can be effectively used to perform the necessary numerical simulations and parametric studies of base-isolated buildings that may experience structural poundings during earthquake excitations. The aim of this paper is twofold: (i) to explain the signifi cant advantages of utilizing OOP, DPs, and Java in structural analysis software and (ii) to use the developed software to study earthquake-induced poundings of base-isolated buildings.

What Do We Know about the Effectiveness of Software Design Patterns?

Context. Although research in software engineering largely seeks to improve the practices and products of software development, many practices are based upon codification of expert knowledge, often with little or no underpinning from objective empirical evidence. Software design patterns seek to codify expert knowledge to share experience about successful design structures. Objectives. To investigate how extensively the use of software design patterns has been subjected to empirical study and what evidence is available about how and when their use can provide an effective mechanism for knowledge transfer about design. Method. We conducted a systematic literature review in the form of a mapping study, searching the literature up to the end of 2009 to identify relevant primary studies about the use of the 23 patterns catalogued in the widely referenced book by the “Gang of Four.” These studies were then categorized according to the forms of study employed, the patterns that were studied, as well as the context within which the study took place. Results. Our searches identified 611 candidate papers. Applying our inclusion/exclusion criteria resulted in a final set of 10 papers that described 11 instances of “formal” experimental studies of object-oriented design patterns. We augmented our analysis by including seven “experience” reports that described application of patterns using less rigorous observational forms. We report and review the profiles of the empirical evidence for those patterns for which multiple studies exist. Conclusions. We could not identify firm support for any of the claims made for patterns in general, although there was some support for the usefulness of patterns in providing a framework for maintenance, and some qualitative indication that they do not help novices learn about design. For future studies we recommend that researchers use case studies that focus upon some key patterns, and seek to identify the impact that their use can have upon maintenance.

OREX-J: towards a universal software framework for the experimental analysis of optimization algorithms

The Operations Research EXperiment Framework for Java (OREX-J) is an object-oriented software framework that helps users to design, implement and conduct computational experiments for the analysis of optimization algorithms. As it was designed in a generic way using object-oriented programming and design patterns, it is not limited to a specific class of optimization problems and algorithms. The purpose of the framework is to reduce the amount of manual labor required for conducting and evaluating computational experiments: OREX-J provides a generic, extensible data model for storing detailed data on an experimental design and its results. Those data can include algorithm parameters, test instance generator settings, the instances themselves, run-times, algorithm logs, solution properties, etc. All data are automatically saved in a relational database (MySQL, http://www.mysql.com/ ) by means of the object-relational mapping library Hibernate ( http://www.hibernate.org/ ). This simplifies the task of analyzing computational results, as even complex analyses can be performed using comparatively simple Structured Query Language (SQL) queries. Also, OREX-J simplifies the comparison of algorithms developed by different researchers: Instead of integrating other researchers' algorithms into proprietary test beds, researchers could use OREX-J as a common experiment framework. This paper describes the architecture and features of OREX-J and exemplifies its usage in a case study. OREX-J has already been used for experiments in three different areas: Algorithms and reformulations for mixed-integer programming models for dynamic lot-sizing with substitutions, a simulation-based optimization approach for a stochastic multi-location inventory control model, and an optimization model for software supplier selection and product portfolio planning.

A Study of In-depth Issues Surrounding Object Oriented Languages using Object Oriented Design Patterns

In this competitive world, all enterprises depend on the IT as their active support for various purposes. As a result the software projects are becoming larger and more complex. Hence the developers face challenge of developing the complex software’s more quickly. The best solution to this is the concept of Reuse [1]. Through object oriented analysis pattern it is possible to solve the problems occurring in software development through its reusable capacity [1]. Good OO designs are reusable and stable nature, this provides the ability of this pattern to be used in Other applications which share the same knowledge[7]. Patterns show you how to build systems with good OO design qualities. The main aim of “object oriented analysis pattern” is to provide expert solution to recurring business problem and to produce more reliable conceptual design. In this paper, we formally give an overview on the state of Object-oriented modeling using patterns and classification of analysis pattern and development on analysis pattern and also the applications of analysis patterns General Terms Object Oriented Programming, Object Oriented Analysis Patterns.

Towards an object-oriented engineering design pattern language

The paper proposes a framework for building and using an object-oriented engineering design pattern language to enhance the cognitive performance of human designers. A design pattern is a set of recurrent design concepts represented as an object and a design pattern language is a network of objects structured by certain rules. An object-oriented network of both the recurrent and the non-recurrent design concepts can support human thinking. The network is constructed by combining the function analysis system technique (FAST) and TRIZ function modelling methods. The pattern language framework can exploit both object-oriented and object-relational features to complement and support the designer’s cognitive abilities.

An object-oriented serial implementation of a DSMC simulation package

This paper reports a scalar implementation of a multi-dimensional direct simulation Monte Carlo (DSMC) package named “Generalized Rarefied gAs Simulation Package” (GRASP). This implementation adopts a concept of simulation engine and it utilizes many Object-Oriented Programming features and software engineering design patterns. As a result, this implementation successfully resolves the problem of program functionality and interface conflictions for multi-dimensional DSMC implementations. The package has an open architecture which benefits further development and code maintenance. To reduce engineering time for three-dimensional simulations, one effective implementation is to adopt a hybrid grid scheme with a flexible data structure, which can automatically treat cubic cells adjacent to object surfaces. This package can utilize traditional structured, unstructured or hybrid grids to model multi-dimensional complex geometries and simulate rarefied non-equilibrium gas flows. Benchmark test cases indicate that this implementation has satisfactory accuracy for complex rarefied gas flow simulations.

Software Engineering Paradigm Independent Design Problems, GoF 23 Design Patterns, and Aspect Design

The aim of the paper is to investigate applicability of object-oriented software design patterns in the context of aspect-oriented design. The paper analyses which of the GoF 23 patterns have a meaning in this context and how they are affected by it. The main assumption is that there exist design patterns that solve software engineering paradigm independent design problems and that such patterns, in the contrast to the patterns solving paradigm-specific design problems, can be expressed in terms of any software engineering paradigm. However, the paper deals only with two paradigms: aspect-oriented (AO) paradigm and object-oriented (OO) paradigm. It proposes a classification of design problems based on this assumption and a technique for redesigning object-oriented patterns into pure aspect-oriented ones. It presents a number of examples how to apply this technique and discusses the results obtained. The results show that 20 of the GoF 23 design patterns solve such design problems that are common at least for both mentioned paradigms and demonstrate in which way these patterns can be adapted for the needs of aspect-oriented design.

Concurrency by modularity

General purpose object-oriented programs typically aren't embarrassingly parallel. For these applications, finding enough concurrency remains a challenge in program design. To address this challenge, in the Panini project we are looking at reconciling concurrent program design goals with modular program design goals. The main idea is that if programmers improve the modularity of their programs they should get concurrency for free. In this work we describe one of our directions to reconcile these two goals by enhancing Gang-of-Four (GOF) object-oriented design patterns. GOF patterns are commonly used to improve the modularity of object-oriented software. These patterns describe strategies to decouple components in design space and specify how these components should interact. Our hypothesis is that if these patterns are enhanced to also decouple components in execution space applying them will concomitantly improve the design and potentially available concurrency in software systems. To evaluate our hypothesis we have studied all 23 GOF patterns. For 18 patterns out of 23, our hypothesis has held true. Another interesting preliminary result reported here is that for 17 out of these 18 studied patterns, concurrency and synchronization concerns were completely encapsulated in our concurrent design pattern framework.

Creational Object-Oriented Design Pattern Applied to the Development of Software Tools for Electric Power Systems Dynamic Simulations

The development of software for dynamic simulation of electrical power systems requires a comprehensive range of complex studies, which encompasses many areas of electrical engineering as well as software engineering. This study aims at to develop an efficient strategy applied to the development of software tools for dynamic power systems simulations studies. The proposed strategy is based on the object-oriented creational pattern. This approach has the advantage of makes easy the application development process, by performing a mapping between block diagram model representation and the corresponding specialized classes. Firstly, a conceptual mapping between block diagram and the object-oriented paradigm, based on the Factory Method, is carried out. After that, some flexible strategies are presented in order to obtain an improved efficiency for the numerical routines, based on the Builder standard. This allows for the parameterization of the selected numerical integration techniques. The proposed strategy was evaluated by using a 4-generator multi-machine power system. The simulation results shown that the proposed strategy was able to provides a good power system dynamic performance.

Object construction and destruction design patterns in Fortran 2003

Abstract This paper presents object-oriented design patterns in the context of object construction and destruction. The examples leverage the newly supported object-oriented features of Fortran 2003. We describe from the client perspective two patterns articulated by Gamma et al. [1]: abstract factory and factory method. We also describe from the implementation perspective one new pattern: the object pattern. We apply the Gamma et al. patterns to solve a partial differential equation, and we discuss applying the new pattern to a quantum vortex dynamics code. Finally, we address consequences and describe the use of the patterns in two open-source software projects: ForTrilinos and Morfeus.

A Simulation System for Computational Cell Models Based on Object-Oriented Design Patterns

Reconstruction of biophysically detailed computer models for simulating electrical activities of heart cells provides a powerful tool to systematically investigate the ionic mechanisms underlying the genesis and control of cardiac rhythms. However, the fact that there is no unified or standard architecture for computational cell models, which were built by different research groups with specific purposes, obstructed profound applications of these models. In this study, we employed object-oriented design patterns to redesign and reconstitute the cell models and provided a more flexible, portable, and expansible infrastructure for modeling computational cell models. Meanwhile, using the proposed methods, a simulation platform has been developed for electrical activities of cell models with aims to offer a user-friendly interface to study the electrical activities of cardiac cells under various physiological and pathological conditions. Both the proposed design methods and the developed system were validated and effective by testing several typical cell models.

Exception Handling Patterns for Process Modeling

Process modeling allows for analysis and improvement of processes that coordinate multiple people and tools working together to carry out a task. Process modeling typically focuses on the normative process, that is, how the collaboration transpires when everything goes as desired. Unfortunately, real-world processes rarely proceed that smoothly. A more complete analysis of a process requires that the process model also include details about what to do when exceptional situations arise. We have found that, in many cases, there are abstract patterns that capture the relationship between exception handling tasks and the normative process. Just as object-oriented design patterns facilitate the development, documentation, and maintenance of object-oriented programs, we believe that process patterns can facilitate the development, documentation, and maintenance of process models. In this paper, we focus on the exception handling patterns that we have observed over many years of process modeling. We describe these patterns using three process modeling notations: UML 2.0 Activity Diagrams, BPMN, and Little-JIL. We present both the abstract structure of the pattern as well as examples of the pattern in use. We also provide some preliminary statistical survey data to support the claim that these patterns are found commonly in actual use and discuss the relative merits of the three notations with respect to their ability to represent these patterns.

Design patterns for multiphysics modeling in Fortran 2003 and C++

We present three new object-oriented software design patterns in Fortran 2003 and C++. These patterns integrate coupled differential equations, facilitating the flexible swapping of physical and numerical software abstractions at compile-time and runtime. The Semi-Discrete pattern supports the time advancement of a dynamical system encapsulated in a single abstract data type (ADT). The Puppeteer pattern combines ADTs into a multiphysics package, mediates interabstraction communications, and enables implicit marching even when nonlinear terms couple separate ADTs with private data. The Surrogate pattern emulates C++ forward references in Fortran 2003. After code demonstrations using the Lorenz equations, we provide architectural descriptions of our use of the new patterns in extending the Rouson et al. [2008a] Navier-Stokes solver to simulate multiphysics phenomena. We also describe the relationships between the new patterns and two previously developed architectural elements: the Strategy pattern of Gamma et al. [1995] and the template emulation technique of Akin [2003]. This report demonstrates how these patterns manage complexity by providing logical separation between individual physics models and the control logic that bridges between them. Additionally, it shows how language features such as operator overloading and automated memory management enable a clear mathematical notation for model bridging and system evolution.

Object-Oriented Optimal Power Flow: A New Approach Based on Design Patterns

A new approach based on the object-oriented design patterns is proposed for the development of object-oriented optimal power flow analysis software. Important design patterns, such as “Bridge,” “Flyweight,” and “Strategy,” are utilized to develop a comprehensive optimal power flow analysis program, which supports handling of different objective functions and interchanging of the solution techniques. Analysis independent object models of power system components are obtained by untying the attributes required for computation from the attributes representing the physical characteristics of an object. The computational objects modeled specifically for optimal power flow analysis have a feasibility to include new objective functions and solution techniques. The proposed object-oriented design of optimal power flow computation has been implemented in C++. The implementation details and performance of the developed program have been discussed in detail.

Compositional aspect-oriented design pattern properties

In this publication we analyze traditional object-oriented design pattern aspectual compositions implemented in object-oriented framework. The main task is to look whether the design pattern compositions present concern duplications, and if they do then what causes it and how to avoid it.

A mathematical approach to object oriented design patterns

The Journal of the National Science Foundation of Sri Lanka publishes the results of research in all aspects of Science and Technology. The journal also has a website at http://www.nsf.gov.lk/. 2020 Impact Factor: 0.515The JNSF provides immediate open access to its content on the principle that making research freely available to the public supports a greater global exchange of knowledge.

SU-GG-T-388: Design and Implementation of a Computing Framework for An Image Guided Adaptive Radiotherapy Research Program

Purpose: to develop a research computing framework for a large research program in IGART. The goals are to maximize reuse of code developed by cooperating research projects, to seamlessly integrate new types of research data with the database of a commercial treatment planning system (TPS), to allow for automated processing of large quantities of data, and to provide a robust software infrastructure for in‐house clinical implementation of research results. Method and Materials: The language of implementation is C++. The goal of reusability is achieved by dividing the framework into two software layers: Data Abstraction Layer (DAL), and Data Interface Layer (DIL). DAL consists of classes representing abstract data types. Research algorithms operate on DAL objects. The DIL consists of data readers implemented as classes inherited from the DAL parent. The DAL object factories retrieve data by reading data configuration files which specify the type, the format, and the physical location of data to be retrieved. An object factory instances a required DIL reader which is presented to the user as a DAL class. By this design one ensures that data processing algorithms are independent of data formats. The goal of integration with the TPS is achieved by creating a file based research database which parallels the TPS database. A data configuration file represents a database entry. The goal of automation is met by introducing a Database Interface Object (DIO) which aggregates object factories. A scripting interface allows users to retrieve data, call “user hook” function where data processing takes place, create DAL classes which are filled by the processed data, and write results into the database in user‐specified format. Results: We used object oriented design patterns to develop a robust research computing framework for IGART research. This work supported by NIH grant P01CA11602.

CORBA-based distributed software framework for the NIF integrated computer control system

The National Ignition Facility (NIF), currently under construction at the Lawrence Livermore National Laboratory, is a stadium-sized facility containing a 192-beam, 1.8 MJ, 500 TW, ultra-violet laser system together with a 10-meter diameter target chamber with room for nearly 100 experimental diagnostics. The NIF is operated by the Integrated Computer Control System (ICCS) which is a scalable, framework-based control system distributed over 800 computers throughout the NIF. The framework provides templates and services at multiple levels of abstraction for the construction of software applications that communicate via CORBA (Common Object Request Broker Architecture). Object-oriented software design patterns are implemented as templates and extended by application software. Developers extend the framework base classes to model the numerous physical control points and implement specializations of common application behaviors. An estimated 140,000 software objects, each individually addressable through CORBA, will be active at full scale. Many of these objects have persistent configuration information stored in a database. The configuration data is used to initialize the objects at system start-up. Centralized server programs that implement events, alerts, reservations, data archival, name service, data access, and process management provide common system wide services. At the highest level, a model-driven, distributed shot automation system provides a flexible and scalable framework for automatic sequencing of workflow for control and monitoring of NIF shots. The shot model, in conjunction with data defining the parameters and goals of an experiment, describes the steps to be performed by each subsystem in order to prepare for and fire a NIF shot. Status and usage of this distributed framework are described.

Recovery of Object-Oriented Design Patterns Using Static and Dynamic

Maintenance is undoubtedly an effort-consuming activity in the software process. The discovery of a collection of high level building blocks, such as design patterns, in a software artifact represents an important step in program understanding and, hence, can be extremely useful during maintenance. This paper presents a new approach that combines static and dynamic analyses to improve the precision and efficiency of recovering object-oriented design patterns. First, we recover pattern candidates, which adhere to the static structure of different patterns. The static recovery algorithms utilize new abstractions, called basic units, to improve the static identification efficiency. Then, two static constraints are enforced on the recovered candidates to improve the identification precision. Finally, we apply dynamic analysis through profiling to further improve the precision. For each pattern, only relevant methods, which characterize its dynamic behaviour, are traced. The overall analysis approach is automated and evaluated on several large-scale open-source case studies. Results of the case studies and the comparisons demonstrate the improved precision and efficiency of the presented approach.

Decision based examination of object-oriented programming and Design Patterns

On the basis of our examination experience of Design Patterns the existing interpretations and descriptions of Design Patterns do not realise a clear and understandable answer for their aims. The reason for this is that the existing interpretation of the object-oriented paradigms is used for their description and formulation. In order that clear answers could be found for the aims of using Design Patterns, a new conception of their interpretation has to be established. In order to create a new conception, we have to analyze object-oriented paradigms. According to our new conception the object-oriented methodology is based on the elimination of decision repetition, thus sorting the decisions to class hierarchy, with the help of which the data structure and methodology of decision options can be determined by the subclasses of the given class. Sorting the decisions and decision options to a class and its subclasses only the first decision case will be executed, which will be archived and enclosed by instantiation of one of the subclasses. For the following decision cases the archived decision result can be used without knowledge of which decision option was used, so to say which subclass was instantiated, because it is enclosed by using the type of the parent class. The aim of the object-oriented technology is the elimination of decision repetition, which can be realized by sorting the decisions. The derivations are the abstract definitions of decisions, so the derivations can be interpreted as decision abstractions. The Design Patterns offer recipes for sorting the decisions. With the help of the decision concept the aim of Design Patterns can be cleared and a more natural classification of Design Patterns can be realized.