Jang-Eui Hong

Software modeling and analysis using a hierarchical object-oriented Petri net

Abstract Petri net is used widely to analyze and model various systems formally. Recently, many Petri nets mania devote their efforts to enhancing and extending the expressive power of Petri nets. One such effort is to extend Petri nets with object-oriented concepts. An object-oriented paradigm provides excellent concepts to model real-world problems. Object-oriented concepts allow us to build software systems easily, intuitively, and naturally. Although several high-level Petri nets with the concept of objects are suggested, these nets do not fully support the object-oriented concepts. In this paper, we propose a hierarchical object-oriented Petri net (HOONet). The formal syntax and semantics of HOONet are explained in detail. HOONet supports a wide range of object-oriented features including abstract, encapsulated and modularized objects, object interaction by message passing, inheritance, and ploymorphism. HOONet also supports a variety of modeling and analysis mechanisms such as incremental modeling of evolving systems, unfolding the HOONet to lower level Petri net, and incremental reachability analysis for HOONet models. We demonstrate the usefulness of HOONet by applying it to modeling and analysis with an example.

Behavioral Dependency Measurement for Change-Proneness Prediction in UML 2.0 Design Models

During the development and maintenance of object-oriented (OO) software, the information on the classes which are more prone to be changed is very useful. Developers and maintainers can make a more flexible software by modifying the part of classes which are sensitive to changes. Traditionally, most change-proneness prediction has been studied based on source codes. However, change-proneness prediction in the early phase of software development can provide an easier way for developing a stable software by modifying the current design or choosing alternative designs before implementation. To address this need, we present a systematic method for calculating the behavioral dependency measure (BDM) which helps to predict change-proneness in UML 2.0 models. The proposed measure has been evaluated on a multi-version medium size open-source project namely JFreeChart. The obtained results show that the BDM is an useful indicator and can be complementary to existing OO metrics for change-proneness prediction.

A component composition model providing dynamic, flexible, and hierarchical composition of components for supporting software evolution

Component composition is one of the practical and effective approaches for supporting software evolution. However, existing component composition techniques need to be complemented by advanced features which address various sophisticated composition issues. In this paper, we introduce a set of features that supports and manages dynamic as well as flexible composition of components in a controlled way. We also propose a component composition model that supports these features. The proposed model enables dynamic, flexible, and hierarchical composition of components by providing and manipulating dedicated composition information, which in turn increases reusability of components and capabilities for supporting software evolution. To show the benefits of our model concretely, we provide a Hotel Reservation System case study. The experimental results show that our model supports software evolution effectively and provides efficient and modular structures, refactoring, and collaboration-level extensions as well.

Measuring behavioral dependency for improving change-proneness prediction in UML-based design models

Several studies have explored the relationship between the metrics of the object-oriented software and the change-proneness of the classes. This knowledge can be used to help decision-making among design alternatives or assess software quality such as maintainability. Despite the increasing use of complex inheritance relationships and polymorphism in object-oriented software, there has been less emphasis on developing metrics that capture the aspect of dynamic behavior. Considering dynamic behavior metrics in conjunction with existing metrics may go a long way toward obtaining more accurate predictions of change-proneness. To address this need, we provide the behavioral dependency measure using structural and behavioral information taken from UML 2.0 design models. Model-based change-proneness prediction helps to make high-quality software by exploiting design models from the earlier phase of the software development process. The behavioral dependency measure has been evaluated on a multi-version medium size open-source project called JFlex. The results obtained show that the proposed measure is a useful indicator and can be complementary to existing object-oriented metrics for improving the accuracy of change-proneness prediction when the system contains high degree of inheritance relationships and polymorphism.

High-level Petri net for incremental analysis of object-oriented system requirements

To complement the weakness of Petri nets in terms of naturalness, modularity, and reusability, high-level Petri nets with object concepts have been suggested. It is difficult to apply these nets to the requirements specification of object-oriented software systems because of insufficient support for the object-oriented concepts. A hierarchical object-oriented Petri net (HOONet) is developed to complement the weakness of the existing formalisms and formally define its syntax and semantics. A reachability analysis method is provided to check such behavioural properties as boundedness, liveness and persistence of the HOONet models. The HOONet provides incremental modelling and analysis of the requirements with the support of object-oriented concepts.

Interaction-based behavior modeling of embedded software using UML 2.0

Many prior approaches in UML-based embedded software design incorporate state-based behavior modeling. However, interaction-based behavior modeling provides more intuitive view of a system. In this paper, we propose an approach to interaction-based behavior modeling of embedded software using UML 2.0. We use the interaction overview diagrams and the sequence diagrams to model the behavior. We present the method of constructing interaction-based behavior model with an example. We also briefly describe the idea of generating executable code from it

INCREMENTAL SCENARIO MODELING USING HIERARCHICAL OBJECT-ORIENTED PETRI NET

Scenario-based modeling is emerging as a key technology in software development because scenarios are easy to describe and understand, naturally describing the real world, and highly used in several development phases. Scenario-Based Software Modeling (SBSM) represents scenarios with a formal method, and then integrates each scenario into a global one excluding redundant, incomplete, and inconsistent elements. An issue which is not yet proposed a clear solution in SBSM is the handling of different abstraction levels. In the existing proposals, this problem is hidden with an implicit assumption that all such scenarios have the same abstraction levels, which we believe to be unrealistic. In our research, we propose a Hierarchical Object-Oriented Petri Net (HOONet) as a method to specify the scenarios, and also suggest a method to integrate scenarios including different abstraction levels as well as redundancy, incompleteness, and inconsistency. Coordinating abstraction levels of scenarios can be achieved by considering scenario models as state-based transition models and verifying the transition models with respect to behavioral equivalence. In order to show the effectiveness of our suggestion, overall processes of SBSM using HOONet are explained with a practical example.

Developing platform specific model for MPSoC architecture from UML-based embedded software models

In this paper, we describe a technique to design UML-based software models for MPSoC architecture, which focuses on the development of the platform specific model of embedded software. To develop the platform specific model, we define a process for the design of UML-based software model and suggest an algorithm with precise actions to map the model to MPSoC architecture. In order to support our design process, we implemented our approach in an integrated tool. Using the tool, we applied our design technique to a target system. We believe that our technique provides several benefits such as improving parallelism of tasks and fast-and-valid mapping of software models to hardware architecture.

Towards Reusable Colored Petri Nets

Reuse has long been recognized as a key technology that can bring about signi cant productivity gains in software development. Code-level reuse is wellunderstood and frequently practiced. However, reuse in software requirements, another phase where much bene t can be expected, remains inadequately addressed. Hierarchical Colored Petri Net (HCPN) formalism has been successfully used on several large-scale industrial projects, and it includes features designed to enhance modularity and understandability of the model. Unfortunately, such features fall short of making HCPN reusable. In this paper, we provide formal de nitions of RCPN as a reuse extension to the HCPN. RCPN can reduce complexity and cost of modeling and analysis in requirements engineering phase and increase software development productivity. We demonstrate an application of RCPN by demonstrating how a RCPN component for water level monitoring system (WLMS) can be reused in a co ee vending machine (CVM) model.

Developing distributed software systems by incorporating meta-object protocol (diMOP) with unified modeling language (UML)

Although object-oriented paradigm is becoming a more realistic approach to the development of large-scale software systems, the existing object-oriented notations and methodologies do not fully support the development of distributed object systems. In this paper, we integrate Meta-Object Protocol (MOP) into a de facto standard object-oriented modeling language UML together to build a software architecture for distributed object systems. We propose a high-level extension of conventional MOPs, called diMOP which helps to develop distributed object systems by realizing a reflective architecture. To incorporate diMOP with UML, we introduce two new specification languages: Class Diagram Supporting diMOP (CDSM) and Dynamically Configurable Object-oriented Statemachine (DCOS), which are proposed to replace the class diagram and the state diagram of UML. The two specification languages support the specification of dynamic configuration behaviors as well as incorporating the diMOP. This paper gives a methodology to develop efficiently distributed object systems through UML.