Oriented Design Patterns Research Articles

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

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.

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.

A Composite Design Pattern for Service Injection and Composition of Web Services for Peer-To-Peer Computing with Serviceoriented Architecture

In this paper we present a Service Injection and composition De sign Pattern for Unstructured Peer -to-Peer networks, which is designed with Aspect -oriented design patterns, and amalgamation of the Strategy, Worker Object, and Check -List Design Patterns used to design the Self -Adaptive Systems. It will apply selfreconfiguration planes dynamically without the interruption or intervention of the administrator for handling service failures at the servers. When a client requests for a complex service, Service Composition should be done to fulfil the request. If a service is not available in the memory, it will be injected as Aspectual Feature Module code.We used Service Oriented Architecture (SOA) with Web Services in Java to Implement the composite Design Pattern. As far as we know, there are no studies on composition of design patterns for Peer-to-peer computing domain. The pattern is described using a java -like notation for the classes and interfaces. A simple UML class and Sequence diagrams are depicted.

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.

Design Pattern for Dynamic Reconfiguration of Component-based Autonomic Computing Systems using RMI

With the help of Autonomic Computing System characteristics, we can develop the applications to be more adaptive to the changes that take place at the run-time. When designing software, in most cases two or more patterns are to be composed to solve a bigger problem. In this paper we will propose a Design Pattern which is an amalgamation of Worker Object Aspect Oriented Design Pattern, Lookup Design Pattern, Row Data Gateway Design Pattern, Observer Design Pattern, Component Insertion and Component Removal Design Patterns for Dynamic Reconfiguration of Component-Based Systems using RMI. Our proposal mainly focuses on the efficient method of accessing the web services in a distributed environment. We were successful in providing the Self-Reconfiguration between the currently existing Components in the system and newly inserted/removed components within a system in a distributed environment. We have used the Asynchronous RMI distributed computing mechanism to successfully insert and remove the components within an application/system in run-times.

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.

Object-oriented design patterns in Fortran 90/95: mazev1, mazev2 and mazev3

This paper discusses the concept, application, and usefulness of software design patterns for scientific programming in Fortran 90/95. An example from the discipline of object-oriented design patterns, that of a game based on navigation through a maze, is used to describe how some important patterns can be implemented in Fortran 90/95 and how the progressive introduction of design patterns can usefully restructure Fortran software as it evolves. This example is complemented by a discussion of how design patterns have been used in a real-life simulation of Particle-in-Cell plasma physics. The following patterns are mentioned in this paper: Factory, Strategy, Template, Abstract Factory and Facade. Program summary Program title: mazev1, mazev2, mazev3 Catalogue identifier: AEAI_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEAI_v1_0.html Program obtainable from: CPC Program Library, Queen's University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 1958 No. of bytes in distributed program, including test data, etc.: 17 100 Distribution format: tar.gz Programming language: Fortran 95 Computer: PC/Mac Operating system: Unix/Linux/Mac (FreeBSD)/Windows (Cygwin) RAM: These are interactive programs with small (KB) memory requirements Classification: 6.5, 20 Nature of problem: A sequence of programs which demonstrate the use of object oriented design patterns for the restructuring of Fortran 90/95 software. The programs implement a simple maze game similar to that described in [1]. Solution method: Restructuring uses versions of the Template, Strategy and Factory design patterns. Running time: Interactive.

A new approach for the design of electric power system software using object oriented modeling

This work presents a new approach for the development of software for power systems, using object oriented modeling (OOM). The definition of class structures to represent power systems follows strictly the OOM paradigm and includes the reuse of well-tested software employed by electric utilities. The physical elements are classified as structural and composition elements, defining different modeling abstractions. Their physical and functional characteristics are grouped in distinct abstractions. The modeling of the physical elements of the power systems is independent of the applications to be designed. Object oriented design patterns are used to determine the structures, allowing that new functions be easily added to the structures, minimizing the impact on the existing class structure. This adds flexibility to the model, facilitating the integrated development of computing tools for the industry. A computational tool including a load-flow and a dynamics simulation application, developed according to the proposed approach, is presented.

AMDiS: adaptive multidimensional simulations

We describe how modular software design and well proven object oriented design patterns can help to implement a flexible software package for the efficient solution of partial differential equation...

AMDiS: adaptive multidimensional simulations

We describe how modular software design and well proven object oriented design patterns can help to implement a flexible software package for the efficient solution of partial differential equations. Today not only efficiency in the numerical solution is of utmost importance for practical use, efficiency in problem setup and interpretation of numerical results is of importance if modeling and computing comes closer and closer together. In order to demonstrate the possibilities of the software, we apply the tool to several non-standard problems.

OO overkill

Object oriented design patterns as popularized in [GHJV95] are intended to solve common programming problems and to assist the programmer in designing and developing robust systems. As first year courses increasingly emphasize object orientation, knowledge of design patterns and when to use them becomes an important component of the first year curriculum. Recent literature has focused on introducing the patterns to computer science educators, but not on the situations and contexts in which the patterns are appropriate. Design patterns and object orientation are parts of a methodology that scales to large systems. In this paper we show that these concepts do not always scale down. We analyze examples from current literature that would be simpler without patterns, and provide examples of when the same design patterns do make design and programs simpler.

A Pattern-Oriented Approach to a Methodical Evaluation of Modeling Methods

The paper describes a pattern-oriented approach to evaluate modeling methods and to compare various methods with each other from a methodical viewpoint. A specific set of principles (the patterns) is defined by investigating the notations and the documentation of comparable modeling methods. Each principle helps to examine some parts of the methods from a specific point of view. All principles together lead to an overall picture of the method under examination. First the core (method neutral) meaning of each principle is described. Then the methods are examined regarding the principle. Afterwards the method specific interpretations are compared with each other and with the core meaning of the principle. By this procedure, the strengths and weaknesses of modeling methods regarding methodical aspects are identified. The principles are described uniformly using a principle description template according to descriptions of object oriented design patterns. The approach is demonstrated by evaluating a business process modeling method.