Object-oriented System Design Research Articles

Ontological Modeling Rules for UML: An Empirical Assessment

The Unified Modeling Language (UML) is widely accepted as the de-facto standard for object-oriented information systems (IS) design and software modeling. Recent research has proposed to extend the use of UML to conceptual modeling of application domains. Conceptual models serve both as the basis for communication and domain understanding among analysts, and as the starting point for IS software design. Prior research has proposed a set of modeling rules to provide the analyst or modeler with guidelines for using UML for conceptual modeling.This paper provides an empirical assessment of the benefits derived from using these modeling rules. Using an experimental study involving 53 subjects, it examines the effects of different levels of modeling rule application on application domain understanding. The results show statistically significant differences in the level of domain understanding that was derived from the various models.

DEVELOPING A SECURE GEOSPATIAL VISUALIZATION AND COLLABORATION SYSTEM USING SOFTWARE ENGINEERING TECHNOLOGY

Developing secure web applications is a difficult task because the original purpose of the World Wide Web (WWW) was to freely share information. This paper presents a prototype for a platform-independent secure geospatial visualization and collaboration web application. This system is developed using object-oriented system design methodology. It integrates software engineering, web security, visualization and Java technologies with the WWW to enable production, dissemination, and use of imagery and geospatial information on a hierarchical level through the WWW. Several visualization modules on the client side are developed using the Model-View-Controller design pattern technology. These modules are plug-in and reusable components for other similar applications. A Visualization Web Bridge and Data Providers on the server side are designed and implemented to bridge the gap between the Internet users and the remote geospatial databases. Several Internet security mechanisms are implemented to secure system configuration, to authenticate and authorize data access, and to secure information sharing. The system is an open and extensible source. The application results demonstrate that this system provides a certain level of security, and that users have flexibility to query, visualize, manipulate, and analyze real-time remote geospatial data. It exhibits that multiple users in geographically dispersed organizations can conveniently collaborate and share information as well as 3D images through this system. It also demonstrates that using object-oriented system design and design pattern provides a great chance for software reuse and increases the system flexibility.

Developing A Secure Geospatial Visualization and Collaboration System Using Software Engineering Technology

Developing secure web applications is a difficult task because the original purpose of the World Wide Web (WWW) was to freely share information. This paper presents a prototype for a platform-independent secure geospatial visualization and collaboration web application. This system is developed using object-oriented system design methodology. It integrates software engineering, web security, visualization and Java technologies with the WWW to enable production, dissemination, and use of imagery and geospatial information on a hierarchical level through the WWW. Several visualization modules on the client side are developed using the Model-View-Controller design pattern technology. These modules are plug-in and reusable components for other similar applications. A Visualization Web Bridge and Data Providers on the server side are designed and implemented to bridge the gap between the Internet users and the remote geospatial databases. Several Internet security mechanisms are implemented to secure system configuration, to authenticate and authorize data access, and to secure information sharing. The system is an open and extensible source. The application results demonstrate that this system provides a certain level of security, and that users have flexibility to query, visualize, manipulate, and analyze real-time remote geospatial data. It exhibits that multiple users in geographically dispersed organizations can conveniently collaborate and share information as well as 3D images through this system. It also demonstrates that using object-oriented system design and design pattern provides a great chance for software reuse and increases the system flexibility.

Object-Oriented Design Patterns for Detailed Design.

This paper discusses the use of design patterns during the transition phase from analysis to design of object-oriented systems. Pattern mining, which is the process of finding and documenting design patterns, usually takes place during or after the development of a software system. This paper introduces several new design patterns that were discovered through the experience of teaching object-oriented analysis and design in both industry and academia. These are low level design patterns that can be used in almost every application. Finally, a tool will be proposed to automate the application of these patterns when creating a detailed design model.

A Practical E-learning System for an "Object-Oriented System Analysis and Design" Course

In this paper, a practical e-learning system, called project experience center (PEC), for an ”object-oriented system analysis and design” course is proposed. The goal of this system is to provide not only theories but also practical examples such that students can understand Unified Modeling Language (UML) easily. For this purpose, a project model and experience metadata set are designed to store the ”experiences” of students who have previously taken the same course. These ”experiences” could be diagrams drawn by using UML, documents for these diagrams, and program source codes. New learners who are not familiar with the UML diagrams could retrieve experiences from this system. They can use similar examples as references and practice their own works. We believe this process can expedite the UML learners to understand when and how to use the UML notations properly. This system was used and evaluated in a University in Taiwan. The results show that students were satisfied with the system's supports and found it is easier to use this system than to find examples from books or other resources.

Using UML to facilitate the teaching of object-oriented systems analysis and design

This paper discusses how UML, with the aid of a CASE (Computer Aided Systems Engineering) tool, can help teach an Object-Oriented Systems Analysis and Design (OOSAD) course. Today's students need to be actively involved in the learning process and must be able to apply a concept while it is being taught. Most OOSAD real-world problems are to complex to deal with in the classroom, so we have chosen a simpler problem - consisting of a university setting - that all students are familiar with. By using a CASE tool to draw UML diagrams students can visualize the object-oriented concepts and see the relevance of what is being taught. UML can help simplify OOSAD problems and at the same time actively engage students in the learning process thus increasing the general interest level of the student. The author's basic approach to teaching OOSAD material is to have the students emulate the instructor when working through a problem. With enough concrete practice like this, students soon build a strong foundation in UML diagrammatics and in the process gradually abstract out the underlying OOSAD concepts. The aim is to reach a point where students can make their own interpretation, apply OOSAD concepts independently, and ultimately devise their own extensions to UML to solve a problem.

An adaptive dependability model of component-based software

With the advancement and widespread use of object-oriented system design and web-based development, the use of CBSD (Component-Based Software Development) is on the rise. Software systems are being developed in a heterogeneous fashion using components developed in-house, or picked off-the-shelf, and hence it may be inappropriate to model and evaluate such systems on using traditional tools. We proposed an integrated and adaptive approach, which takes into account the diversity of dependability requirements, to model the dependability, the most important aspect of evaluation, of a heterogeneous software system based on its architecture and the failure behavior of its components. The basic constituent of our approach is BBNs (Bayesian Belief Networks), which are by far the best model that can handle integration of variables of process and product, relationships of genuine cause and effect, and other uncertain information.

On object systems and behavioral inheritance

We consider state-based behavior in object-oriented analysis and design, as it arises, for example, in specifying behavior in the UML using statecharts. We first provide a rigorous and analyzable model of object systems and their reactivity. The definition is for basic one-thread systems, but can be extended in appropriate ways to more elaborate models. We then address the notion of inheritance and behavioral conformity and the resulting substitutability of classes, whereby inheriting should retain the system's original behaviors. Inheritance is a central issue of crucial importance to the modeling, design, and verification of object-oriented systems, and the many deep and unresolved questions around it cannot be addressed without a precise definition of the systems under consideration. We use our definition to give a clear and rigorous picture of what exactly is meant by behavioral conformity and how computationally complex it is to detect.

OODS: an object-oriented design system — an example of electronics assemblies

Object-oriented design is viewed as a promising approach for handling a wide variety of design problems. However, little work has been done to date on developing object-oriented design systems that can handle a variety of design problems. This paper describes an object-oriented design system (OODS) that uses an object-oriented formalism called design with objects (DwO). The background to DwO is described including the DwO design model, the other design objects in DwO, the use of DwO methods and the resulting design process models. The decomposition of objects in OODS is then described, followed by a description of the configuration system object and the user interface (UI) object. The implementation of OODS is then detailed. This implementation uses the Internet to communicate between OODS and users, and with databases that may be geographically scattered. The use of OODS is illustrated by a description of an application as an example that involves the design of electronics assemblies. The contribution of this paper is threefold. First, a new object-oriented design formalism is presented. Second, an implementation architecture for this formalism is described, and, third, an example application is presented showing how this approach can be used.

An object-oriented prototyping tool for automated manufacturing systems

System prototyping is essential in the development of automated manufacturing systems (AMSs), and the value of prototyping depends largely on the effectiveness of the prototyping tool to represent a system design and also the prototyping results. This paper presents a windows-based prototyping tool that adopts a frame-based representation approach to build a prototype from an object-oriented system design specification. The tool provides a platform capable of executing the prototype under different constraints and operating conditions, and of presenting the prototyping results to facilitate the study of the behaviour of the AMS. Properties, such as the total cycle time, resource utilisation, potential conflicts, errors in design, and abnormal behaviours, can be readily derived. The tool's effectiveness is illustrated by prototyping a flexible manufacturing system, and examining the results obtained. Indeed, the prototyping tool proposed in this paper is shown to provide a convenient means for the design of AMSs.

Distance tutorials in a systems design course

An experiment with distance technology in a second-year Object-Oriented Systems Design course is described. Video and computer conferencing were used in tutorial sessions where a teacher and a student group developed and discussed solutions (both textual and graphical) to systems design problems. The experiment is evaluated, both from a technical, an economic and an educational point of view.

THE DESIGN AND IMPLEMENTATION OF A CUSTOMIZABLE FAULT TOLERANCE FRAMEWORK

While there have been significant advances in fault tolerance research, the effort has focused on the design of individual fault-tolerant systems or methodologies. Recently, some research has been initiated to develop techniques that can provide a spectrum of fault tolerance capabilities. In this paper, we present the design of a fault tolerance framework that can support a wide range of applications with various fault tolerance requirements, various criticality levels, and various system models. The framework is designed to be parameterizable so that the user can configure it to obtain the desired features. Also, the framework is designed to be an off-the-shelf component such that application programs can be integrated within it easily to obtain the fault-tolerant version of the application system. A specialized N-modular redundancy (SNMR) scheme has been developed to serve as the primary approach for achieving efficient and cost-effective fault tolerance for the framework. In most cases, the SNMR scheme yields better performance and lower cost in providing fault tolerance as compared with conventional NMR schemes. It also enhances the scalability and customizability of the general replication method. This paper discusses the main issues in the design and implementation of the SNMR framework, including the major concept of the SNMR framework, various SNMR algorithms that tolerate various types of faults, an object-oriented overall system design and the interface protocol class hierarchy. The interface protocol class hierarchy provides a nice paradigm for the implementation of customizable, highly reusable, and easily extensible SNMR framework.

Object-oriented design for LHD data acquisition using client-server model

The LHD data acquisition system handles >600 MB data per shot. The fully distributed data processing and the object-oriented system design are the main principles of this system. Its wide flexibility has been realized by introducing the object-oriented method into the data processing, in which the object sharing and class libraries will provide the unified way of data handling for the network client-server programming. The object class libraries are described in C++, and the network object sharing is provided through the commercial software named HARNESS. As for the CAMAC setup, the Java script can use the C++ class libraries and thus establishes the relationship between the object-oriented database and the WWW server. In LHD experiments, the CAMAC system and the Windows NT operating system are applied for digitizing and acquiring data, respectively. For the purpose of the LHD data acquisition, the new CAMAC handling software on Windows NT have been developed to manipulate the SCSI-connected crate controllers. The CAMAC command lists and diagnostic data classes are shared between client and server computers. A lump of the diagnostic data can be treated as part of an object by the object-oriented programming.

Fuzzy object-oriented system design

The fundamentals of object orientation are studied in the context of fuzzy sets. The main concepts such as inheritance are carefully analyzed in this setting with an intent to take full advantage of a linguistic generalization while retaining the key features of the object-oriented approach. As the admitted values of the attributes are linguistic, the proposed method hinges on a concept of linguistic approximation and computational enhancements stemming from the theory fuzzy neural networks. A numerical illustration comes from the realm of scene analysis and interpretation.

JWarp: a Java library for parallel discrete-event simulations

SUMMARY Java is a very promising language for use in the simulation of physical models due to its objectoriented nature, portability, robustness and support for multithreading. This paper presents JWarp, a Java library for discrete-event parallel simulations. It is based on an optimistic model for synchronization of the simulation entities: the Time Warp mechanism. We introduce the main features of the library and discuss some of the implementation details. ©1998 John Wiley & Sons, Ltd. In several areas like engineering, computer science, economics and military applications, simulation is used to study the behaviour of complex models. The execution of some of these simulation models can be a very time-consuming task. For statistical reasons, it might be necessary to simulate a model for quite a long time, or to perform the same simulation several times with different parameter values. A possible solution to reduce the execution times of long-running simulations is by using multiple processors operating in parallel[ 1]. A typical simulation model involves several components or entities. By exploiting this inherent model of parallelism, it would be possible to speed up the performance of the simulations by decomposing these components through several processors. Every simulation model is a specification of the corresponding physical model and is composed of a set of states and events. In a discrete event simulation, the state of the system only changes at discrete points in simulated time. A natural decomposition strategy can result in an object-oriented system design, where an object corresponds to some component of the real system and is represented by a computational task that is assigned to a processor for execution. In this way, every component of the model is simulated by a logical process (LP). A discrete-event simulation requires the existence of multiple LP entities, a time-ordered event list holding time stamped events to be processed in the future, a global discrete clock that indicates the current simulation time and a set of state variables that define the state of the simulation. The simplest way to manage the event list would be based on a centralized strategy. The list of events would be managed by a single process (master), and there would be a pool of slave processes running on the parallel system that would execute those events in a concurrent way. However, the existence of a centralized queue of events would represent a bottleneck to the simulation, thereby clearly reducing the potential for parallelism.

APSARA

Although a number of libraries of patterns have been developed for reuse, there is no mechanism for supporting automated design of object-oriented systems by the intelligent reuse of patterns from such libraries. We describe a web-based system, APSARA, the purpose of which is to create object-oriented designs based upon simple requirements descriptions. The system, developed in Java, implements a pattern retrieval and synthesis methodology that uses natural language processing and automated reasoning heuristics. The system is tested on multiple cases from different domains. The results are reported using metrics defined in the spirit of familiar measures such as recall, precision, coverage and spuriousness. These initial tests suggest that this is a feasible approach for the reuse of patterns in object-oriented design. The testing also reveals specific areas of concern and suggests a number of avenues for extending this research.

2.3.1 Object Oriented Systems Engineering – An Approach

ABSTRACTThis paper presents an approach for preparing an object oriented system design specified by object oriented specifications derived from functionally oriented customer requirements. The approach emphasizes review of each individual customer requirement to extract individual objects that may be called out or implied. Value type characteristics contained in the requirement are mapped to attributes of the objects. Interaction between objects is captured as associations and becomes the basis for scenarios or event message diagrams. By capturing the stated or implied objects, their attributes and their interactions, we find the entire requirement can be captured.The Object Based Systems Engineering methodology offers many benefits that should not be ignored including simplification of presentation, ease of preparing subordinate specifications, clear definition of interfaces, modularity in design, and smooth transition to software development.

OBJ-NET: An Object Oriented System Design Tool

Computer-based Systems are used in a wide range of complex systems like automobile assembly lines, power plants, etc. These systems consist of heterogeneous subsystems having a multitude of interactions with other subsystems and environments. Designing software for such systems is a difficult task due to the inherent complexity both at conceptual and implementation levels. When developing a large system, the constituent subsystems may be developed separately. Those subsystems may work well on their own, but may fail to work together with other subsystems and fail to respond to interfacing events. This paper presents OBJ-NET, an object oriented system design tool, which provides a suitable framework for the specification and simulation of complex dynamic systems. The theoretical basis of OBJ-NET is from Category Theory and Petri Nets. OBJ-NET helps users to integrate complex systems by modeling a system as a hierarchy of components. It accepts the flow of control from one set of objects to another and simulates the flow of control among the various components of the system. This will allow a user to validate the correctedness of design and interactively change the design to refine the working of the system. This paper describes the various components of OBJ-NET in detail and illustrates the application of OBJ-NET using, as a working example, the specification and simulation of an Automotive Dashboard System.

A generic multicast transport service to support disconnected operation

Many mobile computing applications can profit from process groups and reliable multicast communication to maintain replicated data, but most operating systems available today fail in providing the primitive operations needed by such applications. In this paper we describe a highly configurable, Generic Multicast Transport Service (GTS), which supports the implementation of group-based applications in wide-area settings. GTS is unique in that it offers fault-tolerant, order-preserving multicast on arbitrary communication protocols, including e-mail. As another distinguishing mark, messages can be sent to processes even when they are temporarily unavailable, which permits disconnected operation and mobility. We further propose an object-oriented system design consisting of adaptor objects interconnected to form a protocol tree. Adaptor objects offer a common interface to dissimilar communication protocols, and make it easy to incorporate new protocols into GTS. Currently, GTS is being used in a cooperative software engineering environment and in other projects. GTS is available for anonymous ftp.

Patterns in practice

Object-oriented systems often exhibit idiomatic and recurring structures of objects and classes that solve particular design problems and make systems more flexible, elegant, and ultimately reusable. Design patterns have been proposed as one way to represent, record and reuse these recurring design structures and associated design experience. Here we report on experiences in using design patterns during the design of object-oriented systems.