Object-oriented design process model

Design is a first step in the development phase for any engineered product or system. It is defined as the process and strategies used to manage complexity. Software design process is an iterative process whereby the requirements are transformed into a “blueprint” for constructing the software. A design model is developed based on the combination of intuition and judgment, a set of principles and heuristics, and a process of iteration that leads to final design specifications. Without a proper design, a software system may fail to deliver its intended service and often will lead to some consuming maintenance activities. Therefore it is necessary for software developers to do the design process thoroughly before they start implementing the system. Object-oriented design is not an easy task. It is even difficult for a novice designer or for an experienced designer who wants to shift to object-oriented approach. Throughout literature, there are varying schools of thought on what constitutes object-oriented design. What is the process involved in this phase and what are components or structures? This paper presents four popular object-oriented design methods, and then a process model of object-oriented design for novice designer is proposed. The model consists of a process and four components. The process model is part of the model of a guidance system to assist novice designers in designing object-oriented systems

An Object Oriented Paradigm for Requirements Specifications.

Software engineering defines a formalized five-step life-cycle for software development. These steps are: requirements specification, design, implementation, testing and maintenance. The requirements specification phase of the software development life-cycle is responsible for determining the functionality of the proposed system. In this work, a methodology is developed that enhances the generation of accurate requirements specifications, utilizing an object-oriented paradigm. This research realizes four objectives. First, the process of information transferral between the user and the specification team is enhanced. Second, a working base of knowledge containing the domain-specific information within the initial requirements document is established for use by the specification team. Third, techniques for evaluating the overall quality of the initial requirements document are addressed. Specifically, the problems associated with document ambiguity, completeness, consistency and structure are examined. Finally, a specification paradigm is defined utilizing this knowledge-based specification environment. The paradigm permits the automatic generation of an object-oriented specification model. This model may then be used as an input for the design phase. This paradigm defines a methodology for the establishment and evaluation of the knowledge-based specification environment. The environment permits the incorporation of an object-oriented development strategy into the specification process. In addition, the concept of information traceability throughout the specification process is enhanced

Collected software engineering papers, volume 9

This document is a collection of selected technical papers produced by participants in the Software Engineering Laboratory (SEL) from November 1990 through October 1991. The purpose of the document is to make available, in one reference, some results of SEL research that originally appeared in a number of different forums. This is the ninth such volume of technical papers produced by the SEL. Although these papers cover several topics related to software engineering, they do not encompass the entire scope of SEL activities and interests. For the convenience of this presentation, the eight papers contained here are grouped into three major categories: (1) software models studies; (2) software measurement studies; and (3) Ada technology studies. The first category presents studies on reuse models, including a software reuse model applied to maintenance and a model for an organization to support software reuse. The second category includes experimental research methods and software measurement techniques. The third category presents object-oriented approaches using Ada and object-oriented features proposed for Ada. The SEL is actively working to understand and improve the software development process at GSFC

A Methodology to Support the Maintenance of Object -Oriented Systems Using Impact Analysis.

Object-Oriented (OO) systems are difficult to understand due to the complex nature of the relationships that object-orientation supports. Inheritance, polymorphism, encapsulation, information hiding, aggregation, and association combine to make maintenance of OO systems difficult. Due to the presence of these characteristics in OO systems, maintenance activities on OO systems often have unexpected or unseen effects on the system. These effects can ripple through system components, complicating maintenance and testing of the system. The ability to trace the effects of maintenance provides the maintainer with knowledge that assists in debugging and testing modified and affected components. In this research, we show that the architecture of an OO system provides an effective framework for determining the impact of system changes. We developed the Comparative Software Maintenance (CSM) methodology to support the maintenance of OO systems. Through this methodology, we model relationships and structures, analyze the models to determine components that change as a result of maintenance, and perform impact analysis to determine components that are candidates for re-testing as a result of maintenance activity. The methodology includes a new data model, called Extended Low-Level Software Architecture (ELLSA), that facilitates impact analysis. CSM locates potential side effects, ripple effects, and other effects of maintenance on class structures, methods, and objects. The comprehensive architecture model enables CSM to perform either predictive, pre-modification impact analysis or post-modification impact analysis. The improved impact analysis process found in the methodology determines impact of changes to the component level. We apply the results of impact analysis to determine component level testing requirements. CSM enhances program understanding through the use of ELLSA. It also provides assistance for capturing complex dependencies found in object-oriented code. The methodology is implemented in JFlex. The automation provided by JFlex makes the application of CSM feasible

CRUD-DOM: a model for bridging the gap between the object-oriented and the relational paradigms

Best Paper AwardObject-oriented programming is the most successful programming paradigm. Relational database management systems are the most successful data storage components. Despite their individual successes and their desirable tight binding, they rely on different points of view about data entailing difficulties on their integration. Some solutions have been proposed to overcome these difficulties, such as Embedded SQL, object/relational mappings (O/RM), language extensions and even Call Level Interfaces (CLI), as JDBC and ADO.NET. In this paper we present a new model aimed at integrating object-oriented languages and relational databases, named CRUD Data Object Model (CRUD-DOM). CRUDDOM relies on CLI (JDBC) and aims not only at exploring CLI advantages as preserving its performance and SQL expressiveness but also on providing a typestate approach for the implementation of the ResultSet interface. The model design aims to facilitate the development of automatic code generation tools. We also present such a tool, called CRUD Manager (CRUD-M), which provides automatic code generation with a complementary support for software maintenance. This paper shows that CRUD-DOM is an effective model to address the aforementioned objectives.(undefined

Extending the Knowledge Discovery Metamodel to Support Aspect- Oriented Programming

Software engineers often have to resort to various program analysis tools to analyze the structure and sometimes behavior of a system before they can make changes that preserve system reliability and other quality attributes. The Knowledge Discovery Metamodel (KDM) is an OMG standard which specifies a language-independent representation of the programs to be analyzed. The advantages of using KDM are numerous including an increase in productivity and a cut in overall costs during maintenance, as it allows for a reuse of available KDM compatible tools and expertise. Currently, KDM supports a number of procedural and object-oriented programming languages. However, no support currently exists for aspect-oriented programming languages. This thesis aims at filling this gap, by extending KDM to support AspectJ, perhaps the most popular aspect-oriented language. We show an application of the extended model to an aspect-oriented application

An Exploratory Investigation on the Invasiveness of Environmental Modeling Frameworks

Environmental modeling frameworks provide an array of useful features that model developers can harness when implementing models. Each framework differs in how it provides features to a model developer via its Application Programming Interface (API). Environmental modelers harness framework features by calling and interfacing with the framework API. As modelers write model code, they make framework-specific function calls and use framework specific data types for achieving the functionality of the model. As a result of this development approach, model code becomes coupled with and dependent on a specific modeling framework. Coupling to a specific framework makes migration to other frameworks and reuse of the code outside the original framework more difficult. This complicates collaboration between model developers wishing to share model code that ma y have been developed in a variety of languages and frameworks. This paper provides initial results of an exploratory investigation on the invasiveness of environmental modeling frameworks. Invasiveness is defined as th e coupling between application (i.e., model) and framework code used to implement the model. By comparing the implementation of an environmental model across several modeling frameworks, we aim to better understand the consequences of framework design. How frameworks present functionality to modelers through APIs can lead to consequences with respect to model development, model maintenance, reuse of model code, and ultimately collaboration among model developers. By measuring framework invasiveness, we hope to provide environmental modeling framework developers and environmental modelers with valuable in formation to assist in future development efforts. Eight implementations (six framework-based) of Thornthwaite, a simple water balance model, were made in a variety of environmental modeling frameworks and languages. A set of software metrics were proposed and applied to measure invasiveness between model implementation code and framework code. The metrics produced a rank ordering of invasiveness for the framework-based implementations of Thornthwaite. We compared model invasiveness results with several popular software metrics including size in lines of code (LOC), cyclomatic complexity, and object oriented coupling. To investigate software quality implications of framework invasiveness we checked for relationships between the Chidamber and Kemerer (1994) object oriented software metrics and our framework invasiveness measures. For the six framework-based implementations of Thornthwaite we found a five-fold variation in code size (LOC). We observed up to a seven-fold variation in total cyclomatic complexity, and a two to three-fold variation in object oriented coupling. For the model implementations we found that total size, total complexity, and total coupling all had a significant positive correlation. The raw count version of our invasiveness measures correlated with application size (LOC), total cyclomatic complexity, total efferent coupling (fan out) and total afferent coupling (fan in). Large size, complexity, and high levels of coupling between units (classes, modules) in a software system are often cited in software engineering as causes of high maintenance costs due to poor understandability and flexibility of the code. This study provides initial results but further investigation is desired to evaluate the utility of our invasiveness measurement approach as well as the software quality implications of framework invasiveness

DESAIN DAN IMPLEMENTASI PEMROGRAMAN BERORIENTASI-ASPEK STUDI KASUS : PERANGKAT LUNAK BANTU ADMINISTRASI KLINIK KEBIDANAN DAN PENYAKIT KANDUNGAN UMMI BENGKULU

ABSTRAKSI: Salah satu teknik pemrograman yang kini populer adalah pemrograman Berorientasi-Objek yang membungkus atribut dan operasi menjadi unit modularitas yang disebut objek. Pada teknik pemrograman ini terkadang ditemui crosscutting concern yang merupakan fungsionalitas yang tidak dapat dienkapsulasi ke dalam satu objek. Crosscutting concern dapat menyebabkan masalah dalam evolusi dan pemeliharaan perangkat lunak. Sayangnya pemrograman Berorientasi-Objek tidak menyediakan mekanisme khusus untuk menangani masalah ini.Tugas akhir ini menerapkan pemrograman Berorientasi-Aspek sebagai suatu cara membungkus crosscutting concern sehingga lebih mudah ditangani. Pembangunan perangkat lunak dimulai dengan analisis dan desain Berorientasi-Objek. Diagram kelas kemudian dikembangkan lebih lanjut untuk memodelkan aspek-aspek yang ditambahkan pada perangkat lunak. Implementasi pemrograman Berorientasi-Aspek dilakukan berdasarkan desain yang dilengkapi dengan pemodelan aspek. Sebagai studi kasus, tugas akhir ini menggunakan perangkat lunak bantu administrasi pada Klinik Kebidanan dan Penyakit Kandungan UMMI Bengkulu. Dari hasil analisis, didapatkan kesimpulan bahwa pemrograman Berorientasi-Aspek dapat meningkatkan reusabilitas, efisiensi (dalam hal ukuran kode program), serta mempermudah pengembangan dan pemeliharaan perangkat lunak.Kode program ditulis dalam Java dengan AspectJ sebagai pustaka tambahan untuk pemrograman Berorientasi-Aspek pada Java. Pemodelan dibuat dalam UML dengan menggunakan Rational Rose.Kata Kunci : objek, aspek, aspectj, java, crosscutting concernABSTRACT: One programming technique that popular nowadays is Object-Oriented programming which encapsulates attributes and operations into single unit called object. In this programming technique, we might find crosscutting concern, which is a functionality that can not be encapsulated into an object. Crosscutting concern can cause problems in evolution and maintenance of the software. Unfortunately, Object-Oriented programming does not provide any special mechanism to handle these problems.This final project applied Aspect-Oriented programming as a way to wrap crosscutting concerns so they become easier to handle. Software development began with Object-Oriented analysis and design. Then the class diagram was expanded to model the aspects which was added in software. Implementation with Aspect-Oriented Programming was done based on the design which had been extended with aspects modeling. As case study, this final project used administration software at Clinic of Obstetric and Gynecology UMMI Bengkulu. From the analysis, it had been concluded that Aspect-Oriented Programming can improve reusability, eficiency (in term of the size of the code), and also make it easier for program to evolve and maintain.The program was written in Java with AspectJ as extended library for Aspect-Oriented programming in Java. Modeling was made in UML by using Rational Rose.Keyword: object, aspect, aspectj, java, crosscutting concer

Object-Oriented Bayesian Networks (OOBN) for Aviation Accident Modeling and Technology Portfolio Impact Assessment

The concern for reducing aviation safety risk is rising as the National Airspace System in the United States transforms to the Next Generation Air Transportation System (NextGen). The NASA Aviation Safety Program is committed to developing an effective aviation safety technology portfolio to meet the challenges of this transformation and to mitigate relevant safety risks. The paper focuses on the reasoning of selecting Object-Oriented Bayesian Networks (OOBN) as the technique and commercial software for the accident modeling and portfolio assessment. To illustrate the benefits of OOBN in a large and complex aviation accident model, the in-flight Loss-of-Control Accident Framework (LOCAF) constructed as an influence diagram is presented. An OOBN approach not only simplifies construction and maintenance of complex causal networks for the modelers, but also offers a well-organized hierarchical network that is easier for decision makers to exploit the model examining the effectiveness of risk mitigation strategies through technology insertions

CRUD-DOM: a model for bridging the gap between the object-oriented and the relational paradigms : an enhanced performance assessment based on a case study

The development of database applications comprises three different tiers: application tier, database tier and finally the middle tier also known as the data access layer. The development of each tier per-se entails many challenges. Very often the most difficult challenges to be addressed derive from non-functional requirements, as productivity, usability, performance, reliability, high-availability and transparency. This paper is focused on defining and presenting a model for the data access layer aimed to integrate object-oriented application tiers and relational database tiers. The model addresses situations on which users need to explicitly write down complex static CRUD expressions and simultaneously get advantages regarding some non-functional requirements. The model, known as CRUD Data Object Model (CRUD-DOM), tackles the following non-functional requirements: performance, usability and productivity. The main contributions of this paper are threefold: 1) to present an extended model of CRUD-DOM; 2) to carry out an extended performance assessment based on a case study; 3) to present a tool, called CRUD Manager (CRUD-M), which provides automatic code generation with complementary support for software test and maintenance. The main outcome from this paper is the evidences that the pair CRUD-DOM and CRUD-M effectively addresses productivity, performance and usability requirements in the aforementioned context