Object-oriented Design Techniques Research Articles

Development of an integrated Web-based system with a pile load test database and pre-analyzed data

A Web-based pile load test (WBPLT) system was developed and implemented in this study. Object-oriented and concept-based software design techniques were adopted to integrate the pile load test database into the system. A total of 673 case histories of pile load test were included in the database. The data consisted of drilled shaft and driven precast concrete pile axial load tests in drained, undrained, and gravel loading conditions as well as pre-analyzed data and back-calculated design parameters. Unified modeling language, a standard software design tool, was utilized to design the WBPLT system architecture with five major concept-based components. These components provide the static structure and dynamic behavior of system message flows in a visualized manner. The open-source Apache Web server is the building block of the WBPLT system, and PHP Web programming language implements the operation of the WBPLT components, particularly the automatic translation of user query into structured query language. A simple search and inexpensive query can be implemented through the Internet browser. The pile load test database is helpful, and data can be easily retrieved and utilized worldwide for research and advanced applications.

Data clustering in C++: an object-oriented approach

Data clustering is a highly interdisciplinary field, the goal of which is to divide a set of objects into homogeneous groups such that objects in the same group are similar and objects in different groups are quite distinct. Thousands of theoretical papers and a number of books on data clustering have been published over the past 50 years. However, few books exist to teach people how to implement data clustering algorithms. This book was written for anyone who wants to implement or improve their data clustering algorithms. Using object-oriented design and programming techniques, Data Clustering in C++ exploits the commonalities of all data clustering algorithms to create a flexible set of reusable classes that simplifies the implementation of any data clustering algorithm. Readers can follow the development of the base data clustering classes and several popular data clustering algorithms. Additional topics such as data pre-processing, data visualization, cluster visualization, and cluster interpretation are briefly covered. This book is divided into three parts-- Data Clustering and C++ Preliminaries: A review of basic concepts of data clustering, the unified modeling language, object-oriented programming in C++, and design patterns A C++ Data Clustering Framework: The development of data clustering base classes Data Clustering Algorithms: The implementation of several popular data clustering algorithms A key to learning a clustering algorithm is to implement and experiment the clustering algorithm. Complete listings of classes, examples, unit test cases, and GNU configuration files are included in the appendices of this book as well as in the CD-ROM of the book. The only requirements to compile the code are a modern C++ compiler and the Boost C++ libraries.

Design of Six Freedom Vibration Acquisition System for Military Vehicle

Design and implementation of six freedom transportation vibration spectrum collection system is presented in this paper. The Attitude and Heading Reference System (AHRS) is used to capture signals including x, y, z, direction linear acceleration, angular rates around Z-axis and pitch, roll degree. The software’s architecture and modules for host computer is designed with object-oriented analysis and design techniques, and the software is implemented with VC++6.0. The test results show that the system was able to collect vehicular vibration information on time and the collection data was replayed on the vibration platform.

An experimental approach to the performance penalty of the use of classes in Fortran 95

Fortran 95 is used often for ''number crunching'': scientific and engineering applications where performance is important and which operate with large datasets. The language allows the implementation of certain elements of object oriented design, which facilitate code expansion, reuse and maintenance. In this paper we discuss two series of tests to measure how different object oriented design elements of Fortran 95 affect overall performance. The first series of tests consists of several implementations for multiplying two matrices. These tests are focused exclusively on computation time, not considering other parts of the object life cycle such as construction and destruction. The second series consists of computing a finite element matrix for a diffusion term. A more complex environment with different classes is studied. Here, we consider not only the time spent doing useful computations but the integral object life cycle. Results show that object oriented design comes at a cost in all cases. However, given the right compiler, using the right compiler optimization techniques and keeping the amount of objects and method calls low, Fortran 95 designs can benefit from object oriented design techniques with a less than 10% running time increase.

Usability Estimation of Software System by using Object-Oriented Metrics

Usability is one of the most important quality factors in the fields of software engineering and an important issue in the development of successful software applications. To develop efficient software systems, software developers need appropriate metrics. Object-oriented metrics can play important role in the development of successful and usable software applications because object-oriented design techniques have become one of the most powerful mechanisms to fulfill the demand of efficient software systems. Currently there are no comprehensive criteria for estimating usability by using object-oriented metrics. This paper focuses on usability and presents a comparative analysis of various usability models and metrics. It then analyzes the relationship between usability and object-oriented metrics.

Reconfigurable simulator using graphical user interface (GUI) and object-oriented design for OFDM systems

In this paper, a design of a new object-oriented simulation environment and graphical user interface (GUI) for versatile orthogonal frequency division multiplexing (OFDM) systems is presented. This is achieved using high-level design, parallelism and usability for the simulation environment. GUI interface can serve as a learning/research tool for students or practiced professionals to investigate particular designs. It is evident that OFDM systems intended to be used in dynamic environments must be tested under various conditions in order to be designed for optimality. Hence, a simulation design is proposed coupling the GUI, parallelism, and high-level object-oriented design techniques to be beneficial to the researcher. A high-level design and GUI layouts of the proposed simulator is shown in details. Important OFDM parameters needed for reconfiguration of transmitter components, channel condition parameters, and receiver components are discussed. In addition, this paper provides a simple technique to implement simulation partitioning for increased parallel performance of reconfigurable object-oriented OFDM simulators. This simple technique applies to scenarios where there is disproportionate simulation duration between different OFDM configurations. It is shown to decrease total simulation time considerably.

Assessment of usability metrics for object-oriented software system

The demand for efficient software is increasing day by day. For this reason software developers need appropriate metrics for the development of software applications. Usability is one of the most important fields in software engineering and a highly focused quality factor. It is a key factor in the development of successful software applications. Object-oriented design techniques have become one of the most powerful mechanisms to develop efficient software system. Object-oriented software can play important role in usability for software applications. It can not only help in reducing the cost but also in developing highly usable software systems. This paper focuses some important issues and analyzes the relationship between usability and object-oriented metrics

Designing systems using business components: a case study in call centre automation

Enterprise resource planning (ERP) systems have some inherent disadvantages as businesses become more complex and competition more intense. The mismatch between business processes that an organisation desires and the business process provided by ERP systems can be unproductive and dysfunctional due to the inherent lack of flexibility offered by ERP systems. Business components-based design provides the flexibility to enhance better matches between 'real' business processes and 'systems' embedded business processes. Although business component-based design affords more flexibility, there exist significant implementation challenges including the lack of availability of business components in the market. Traditional business components-based design use object oriented design techniques that use a bottom-up approach. In this research, we use a business process driven design approach using business components for customer relationship management (CRM) systems, a type of enterprise system. Using a case study, we demonstrate the benefits and challenges of using a business components-based design methodology to build CRM systems and apply it to the development of call centre automation (CCA) software.

Refinement and verification in component-based model-driven design

Modern software development is complex as it has to deal with many different and yet related aspects of applications. In practical software engineering this is now handled by a UML-like modelling approach in which different aspects are modelled by different notations. Component-based and object-oriented design techniques are found effective in the support of separation of correctness concerns of different aspects. These techniques are practised in a model-driven development process in which models are constructed in each phase of the development. To ensure the correctness of the software system developed, all models constructed in each phase are verifiable. This requires that the modelling notations are formally defined and related in order to have tool support developed for the integration of sophisticated checkers, generators and transformations. This paper summarises our research on the method of Refinement of Component and Object Systems (rCOS) and illustrates it with experiences from the work on the Common Component Modelling Example (CoCoME). This gives evidence that the formal techniques developed in rCOS can be integrated into a model-driven development process and shows where it may be integrated in computer-aided software engineering (CASE) tools for adding formally supported checking, transformation and generation facilities.

SIPs

SIPs is a new efficient and robust software package implementing multiple shift-and-invert spectral transformations on parallel computers. Built on top of SLEPc and PETSc, it can compute very large numbers of eigenpairs for sparse symmetric generalized eigenvalue problems. The development of SIPs is motivated by applications in nanoscale materials modeling, in which the growing size of the matrices and the pathological eigenvalue distribution challenge the efficiency and robustness of the solver. In this article, we present a parallel eigenvalue algorithm based on distributed spectrum slicing. We describe the object-oriented design and implementation techniques in SIPs, and demonstrate its numerical performance on an advanced distributed computer.

Having a BLAST

DNA analysis is a subject that is in the news almost every day, whether it be a new advance in medical research, a criminal trial, or some other application. BLAST (Basic Local Alignment Search Tool) is an important tool used by biologists worldwide to compare DNA and protein sequences and to infer functional and evolutionary relationships between them. This paper presents a project for CS2 based on BLAST. The primary goal for this project is to provide an interesting, real-world application that reinforces the data structures and algorithms presented in CS2. This project also demonstrates object-oriented design techniques, and introduces computer science students to the new field of bioinformatics.

Multilevel models in model-driven engineering, product lines, and metaprogramming

Model-driven engineering (MDE) aims to raise the level of abstraction in program specification and increase automation in program development. These are also the goals of product lines (a family of related programs) and metaprogramming (programming as computation). We show that the confluence of MDE, product lines, and metaprogramming exposes a multilevel paradigm of program development, and further, we can use object-oriented design techniques to represent programs, the metaprograms that produced these programs, and the meta-metaprograms that produced these metaprograms, recursively. The paradigm is based on a small number of simple and well-known ideas, scales to the synthesis of applications of substantial size, and helps clarify concepts of MDE.

Lazy Types: Automating Dynamic Strategy Selection

Since the early days of structured methodologies, design techniques have evolved to facilitate the representation of real-world entities in software systems. Although object-oriented modeling and design techniques have made developing complex applications easier, many applications deal with data and behavioral requirements that conventional design models have difficulty accommodating. We introduce a novel OOP extension, merging both philosophies (adaptive programming and semistructured data management), that you can use transparently in current programming platforms. Lazy types model variability without increasing implementation complexity. In situations where the use of standard design patterns could hinder design understandability, lazy types deal with complexity by keeping track of a unique type while avoiding the artificial multiplication of types traditional OOP solutions introduce. The reflective technique of lazy typing - deferring the exact definition of object methods until the last possible moment - can help programmers more easily and consistently deal with partial or incomplete data.

Teaching medical image analysis with the Insight Toolkit

We present several case studies which examine the role that the Insight Toolkit (ITK) played in three medical image analysis courses and several conference tutorials. These courses represent the first use of ITK in a teaching environment, and we believe that a discussion of the teaching approach in each case and the benefits and challenges of ITK will be useful to future medical image analysis course development. ITK was found to provide significant value in a classroom setting since it provides both working “canned” algorithms, including some recently developed methods that are unavailable elsewhere, as well as a framework for developing new techniques and applications. Several areas of difficulty, particularly in regards to code complexity and advanced object-oriented design techniques, have been identified which may make the learning curve of ITK somewhat more complex than a language such as Matlab™.

Application of the object-oriented principles for hardware and embedded system design

As the complexity of hardware (HW) and embedded system design is constantly increasing, the researchers are seeking to develop new more abstract and productive design methods or adapt the existing ones from other domains such as software design. This paper addresses the problem of using the object-oriented (OO) design techniques in HW domain. The main OO design techniques are as follows: abstraction, separation of concerns, composition and generalization. The application of the OO design paradigm has many aspects: high-level specification of HW models using OO formal notations such as Petri Nets and UML diagrams, HW description using OO HW description languages such as VHDL extensions and SystemC, HW design using OO HW architectures, platforms and design patterns. In this paper, we present a comprehensive overview of the application of the OO design paradigm in HW and embedded system design domains and formulate its main principles, discuss the current achievements in the area, and outline the future trends.

Buffer pools and file processing projects for an undergraduate data structures course

This paper presents a family of programming projects appropriate to a sophomore-level data structures course, centered around the concept of a buffer pool serving as the access intermediary to a disk file. These projects provide a meaningful vehicle for practicing object-oriented design techniques and teach fundamental material on file processing and manipulating binary data. I begin with a concrete example, a heap stored on disk and mediated by a buffer pool. Several important intellectual concepts introduced by such a project are enumerated. Significant extensions and alternatives to the basic project are then described. I conclude with some observations on the role of file processing in modern CS curricula, and the significance of recent trends away from coverage of these topics.

EJB 환경에서 객체지향 상속 관계 설계 패턴

소프트웨어 개발 생산성 향상과 유지 보수성 향상을 위한 객체지향 분석 및 설계는 학계와 산업계의 기본적인 패러다임으로 자리 잡고 있다. Enterprise Java Beans(EJB)는 높은 이식성을 제공하고 신속한 어플리케이션 개발 환경을 제공하기 때문에, 널리 사용되는 플랫폼중 하나 이다. EJB 객체지향 패러다임을 지원하지만, 객체지향 모델을 EJB 모델로 상세 설계 및 구현 할 때 고려할 사항들이 있다. 그 중 한 가지가 상속 문제이다. 본 논문에서는 객체지향 모델에서 나타날 수 있는 클래스 상속의 유형을 세 가지로 분류하고, 상속을 EJB 모델로 구현할 때 나타날 수 있는 문제점을 규명하며 상속을 지원하는 세 가지 패턴을 제시한다. 또한 제안된 패턴들에 대해서 객체지향 상속 유형별로 적용 가능한 패턴들과 지침을 제시한다. Software development methodology using object-oriented analysis and design techniques for improving productivity and maintainability has acquired a substantial acceptance in both academia and industry as a fundamental paradigm. Enterprise Java Beans (EJB) is widely used in both academia and industry because it provides high unability and rapid application development. EJB supports object-oriented paradigm, but there are several things to consider when designing detail model of object-oriented model or implementing object-oriented model with EJB model. One of them is inheritance problem. In this paper, we classify the types of class inheritance which is shown upon in object-oriented model into three types and identify the problems which can happen when implementing the inheritance mechanism with EJB model. And this paper proposes three patterns for realizing the inheritance in EJB. Moreover, applicable patterns and guidelines for each object-oriented inheritance types for the proposed patterns are suggested.

Refactoring reusable business components

Object evangelists have long heralded software reuse as a bonus for applying object-oriented analysis, design, and programming techniques, but the benefits have been less dramatic than anticipated. Designing reusable software systems is difficult because a complete understanding of the software under consideration is only available toward the project's end. An appropriate alternative, then, is to refactor for reuse, restructure the completed system without modifying or adding to its behavior. We describe a refactoring effort undertaken at a Delaware-Valley-based financial firm. This firm sought to reuse components from a large Web-based system.

Cohesive design of personalized Web applications

Good software engineering practices, such as separating concerns and identifying patterns, simplify the critical design decisions in building personalized Web applications. The authors use the object-oriented hypermedia design method (OOHDM) for constructing customized Web applications. Incorporating well-known object-oriented design structures and techniques, OOHDM produces flexible Web application models. Designers can add personalized behavior to these models with minimal code manipulation, and reasoning over design objects yields better insight into the personalization process. Although this article casts the discussion in terms of the OOHDM primitives, the ideas presented can be easily applied to other design approaches, such as WebML.

The Difficulties of Learning Object-Oriented Analysis and Design: An Exploratory Study

Object-oriented analysis and design (OOAD) techniques are becoming increasingly popular. Advocates argue that OOAD produces systems that are more maintainable, more reusable, and of higher quality. In addition, OOAD proponents argue that OOAD is easier because the techniques are more “natural.” However, recent research suggests that learning OOAD is difficult. Moreover, no clear pedagogy has emerged to assist instructors in industry and at universities in teaching OOAD.Here we report our efforts to understand students' difficulties in learning object-oriented concepts of OOAD. We studied students' perceptions of their understanding of OOAD concepts with a questionnaire. Students reported more difficulty in understanding and modeling the behavioral aspects of OOAD than the structural aspects. We learned that subjects' overall confidence in understanding OOAD depended on understanding object behavior and the models used in OOAD. On the basis of these findings we make several recommendations to improve OOAD instruction.