一种表单驱动的面向对象的逆向建模方法

本文提出一种表单驱动的面向对象的逆向工程建模方法,该方法由五个阶段组成：表单使用分析、表单对象切片、对象结构建模、脚本设计以及模型集成。该方法利用表单结构知识和用户接口信息提取应用的系统的语义。     

Automated object design: the client-server case

As more enterprises move to client-server environments, object technology is gaining favour as a means of migrating legacy applications. The object paradigm is well suited for modeling real world business processes and has the flexibility to integrate emerging technologies. However, the most difficult aspect of object-oriented applications development is not programming but technical design. This article explores a methodology that formalizes and automates object-based technical design in the domain of information management systems     

An object-oriented database management system for computer-aided design of tall buildings

An effective database and database management system is the key to the success of an integrated approach to software engineering applications in general, and Computer-Aided Design (CAD) for structural applications in particular. Due to the inherent nature of CAD data such as dynamic modeling, a wide range of data types, large data volume, etc., the traditional database models, such as hierarchical, network and relational models, are unable to handle the aforementioned applications satisfactorily. An object-oriented data modeling is known to be the most effective approach. However, many of the commercial object-oriented databases are designed for information management, and they are inadequate for CAD application due to the different features of the object-hierarchy and varying data management objectives during the design cycles. This paper presents a hierarchical index-based object-oriented database management model for CAD applications. To deal with the object hierarchy encountered in CAD for the design of tall buildings, the proposed database consists of several salient features: a hierarchical object model, its related storage structure, a data dictionary, a class factory and an index system. The proposed database management model has been implemented into an integrated CAD system for design application of tall buildings.     

A methodology to infer and refactor an object‐oriented model from C applications

When analyzing legacy code, generating a high‐level model of an application during the reverse engineering process helps the developers understand how the application is structured and how the dependencies relate the different software entities. Within the context of procedural programming languages (such as C), the existing approaches to get a model of the code require documentation and/or implicit knowledge that stakeholders acquire during the software building. These approaches use the code itself to build a syntactic model where we see the different software artifacts, such as variables, functions, and modules. However, there is no supporting methodology to detect and analyze if there are relationships/dependencies between those artifacts, such as which variable in a module is declared using an abstract data type described in another one, or which are the functions that are using parameters typed with an abstract data type; or any design decision taken by original developers, such as how the developer has implemented functions in different modules. On the other hand, current developers use object‐oriented (OO) paradigm to implement not only business applications but also useful methodologies/tools that allow semiautomatic analysis of any application. We must remark the legacy procedural code still has worth and is working in several industries, and as any evolving code, the developers have to be able to perform maintenance tasks minimizing the limitations offered by the language. Based on useful properties that the OO paradigm (and their supporting analysis tools) provide, such as UML models, we propose M2K as a methodology to generate a high‐level model from legacy procedural code, mainly written in Ansi C. To understand how C‐based applications were implemented is not a new problem in software reengineering. However, our contribution is based on building an OO model and suggesting different refactorings that help the developer to improve it and to eventually guide a new implementation of the target application. Specifically, the methodology builds cohesive software entities mapped from procedural code and makes the coupling between C entities explicit in the high‐level model. The result of our methodology is a set of refactored class candidates: a structure that groups a set of variables and a set of functions obtained from the C applications. Based on the class candidate model, we propose refactorings based on OO design principles to improve the design of the application. The most relevant design improvements were obtained with algorithm abstraction by applying the strategy pattern, attributes/methods relocalization, variables types generalization, and removing/renaming methods/attributes. Besides a methodology and the supporting tool, we provide 14 case studies based on real projects implemented in C, and we showed how the results validate our proposal.     

Extending the Object-Oriented Paradigm for Supporting Complex Objects

In this paper a generalized object-oriented approach for complex object modeling is proposed,which ischaracterized by adding the concept of Meta-Class into the object-oriented paradigm for unifying thehandling of object types and primary data models,and also characterized by integrating the modeling ofobject type hierarchy and object configuration hierarchy.Concepts such as Compositional RelationshipObject,Face,Object Configuration Schema Expression,Object Skeleton are introduced to specify objectstructure,to support high degree of object sharing and to offer high degree of data independence.Operationson the class hierarchy,the object configuration structures and the object instances are developed respectivelywith distinguished semantics.This approach provides an extended object-oriented framewerk for handlingcomplex objects in any AI or database system(?).     

Modeling and designing processes in e-commerce applications

State-of-the-art Web applications include both navigational elements and business processes, but most Web application design methods treat business processes as just another kind of navigation. The authors' extensions to the object-oriented hypermedia design method (OOHDM) aim to remedy this situation. Rather than using navigation to emulate business processes, their new mechanisms allow developers to specify and implement processes explicitly by dealing with activity semantics and states. We describe proposed extensions to OOHDM and explore their use at an online retail store.     

Development of CORBA-based engineering applications from legacy Fortran programs

A majority of scientific and engineering applications in aerodynamics and solid mechanics are written in Fortran. To reduce the high cost of software development, NASA researchers reuse most of the legacy Fortran codes instead of developing them from scratch in the numerical propulsion system simulation project. In this paper, we present an efficient methodology for integrating legacy applications written in Fortran into a distributed object framework. Issues and strategies regarding the conversion and wrapping of Fortran codes into common object request broker architecture objects are discussed. Fortran codes are modified as little as possible when they are decomposed into modules and wrapped as objects. We implement a wrapper generator which takes the Fortran application as input and generates the C++ wrapper files and interface definition language file. Tedious programming tasks for wrapping the codes can therefore be reduced.     

Mapping Procedural Patterns to Object-Oriented Design Patterns

This paper presents a new approach to the use of design patterns for the reengineering of legacy code, using a mapping from procedural design patterns to object-oriented patterns. We show also how object-oriented design patterns can be formalised and correctness conditions for their application derived, in order to justify the preservation of functionality in the reengineering process. We give examples taken from case studies of reengineering legacy COBOL applications.     

基于业务行为与业务对象约束的业务规则研究

研究了一类基于业务行为与业务对象约束的业务规则。从业务需求的复杂业务规则出发，探讨了这类复杂业务规则的含义，以及业务行为和业务对象、业务约束的关系。在此基础上，对此类业务规则提出了一种形式化描述。提出了此类业务规则驱动的面向对象建模方法。实例表明，该方法较好地解决了由于类之间关系改变使得应用程序频繁变化的问题。     

Translating update operations from relational to object-oriented databases

In migrating a legacy relational database system to the object-oriented (OO) platform, when database migration completes, application modules are to be migrated, where embedded relational database operations are mapped into their OO correspondents. In this paper we study mapping relational update operations to their OO equivalents, which include UPDATE¹, INSERT and DELETE operations. Relational update operation translation from relational to OO faces the touchy problem of transformation from a value-based relationship model to a reference-based model and maintaining the relational integrity constraints. Moreover, with a relational database where inheritance is expressed as attribute value subset relationship, changing of some attribute values may lead to the change of the position of an object in the class inheritance hierarchy, which we call object migration. Considering all these aspects, algorithms are given mapping relational UPDATE, INSERT and DELETE operations to their OO correspondents. Our work emphasize in examining the differences in the representation of the source schema's semantics resulting from the translation process, as well as differences in the inherent semantics of the two models.     

Specifying business rules in object-oriented analysis

A major purpose of analysis is to represent precisely all relevant facts, as they are observed in the external world. A substantial problem in object-oriented analysis is that most modelling languages are more suitable to build computational models than to develop conceptual models. It is a rather blind assumption that concepts that are convenient for design can also be applied during analysis. Preconditions, postconditions and invariants are typical examples of concepts with blurred semantics. At the level of analysis they are most often used to specify business rules. This paper introduces proper concepts for modelling business rules and specifies their semantics.     

逆向工程技术研究

遗留系统的现代化改造成为软件工程领域研究的重点。文章介绍了逆向工程的基本概念以及阐明程序理解是遗留系统演化的最有效的途径,同时引进了程序理解的马蹄铁模型。     

An object-oriented approach to formally analyze the UML 2.0 activity partitions

Nowadays, UML is the de-facto standard for object-oriented analysis and design. Unfortunately, the deficiency of its dynamic semantics limits the possibility of early specification analysis. UML 2.0 comes to precise and complete this semantics but it remains informal and still lacks tools for automatic validation. The main purpose of this study is to automate the formal validation, according a value-oriented approach, of the behavior of systems expressed in UML. The marriage of Petri nets with temporal logics seems a suitable formalism for translating and then validating UML state-based models. The contributions of the paper are threefold. We first, consider how UML 2.0 activity partitions can be transformed into Object Petri Nets to formalize the object dynamics, in an object-oriented context. Second, we develop an approach based on the object and sequence diagram information to initialize the derived Petri nets in terms of objects and events. Finally, to thoroughly verify if the UML model meets the system required properties, we suggest to use the OCL invariants exploiting their association end constructs. The verification is performed on a predicate/transition net explored by model checking. A case study is given to illustrate this methodology throughout the paper.     

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     

ODE: a tool for distributing object-oriented applications

Object-oriented applications are increasingly being deployed in distributed computing environments. Technologies, such as Java RMI, and architectures, such as CORBA, DCOM, and Enterprise Java Beans, are facilitating and enhancing this trend. The performance and eventual success of these applications is dependent on distribution decisions made by the application designer. This decision is a complex one, involving a large number of alternatives and multiple conflicting criteria. Rigorous approaches for effective distribution of object-oriented applications are still lacking. This paper describes the implementation of a practical and effective approach for distributing object-oriented applications. A prototype decision support system—object distribution environment (ODE)—that implements the approach in the form of a user-friendly tool for the design of distributed object-oriented applications is described. ODE has been successfully used in the distribution of a real world distributed object-oriented system.     

Web应用开发平台的元建模研究

传统的Web应用开发方法面临系统复杂度增加、需求不断变更等挑战,导致开发效率低下,系统难重用。本文基于MDA方法学,采用标准建模语言UML和元建模语言MOF,定义了针对Web应用的面向对象建模语言UML-EBP。通过分析UML-EBP元模型结构、语义以及相关模型实例的表述,表明UML-EBP元模型可以很好地应用于Web应用系统开发过程,从而快捷简便地实现Web应用系统开发,并使得系统容易扩展、复用。     

Object-oriented query language access to relational databases: A semantic framework for query translation

This research investigates and approach to query processing in a multidatabase system that uses an objectoriented model to capture the semantics of other data models. The object-oriented model is used to construct a global schema, defining an integrated view of the different schemas in the environment. The model is also used as a self-describing model to build a meta-database for storing information about the global schema. A unique aspect of this work is that the object-oriented model is used to describe the different data models of the multidatabase environment, thereby extending the meta database with semantic information about the local schemas. With the global and local schemas all represented in an object-oriented form, structural mappings between the global schema and each local schema are then easily supported. An object algebra then provides a query language for expressing global queries, using the structural mappings to translate object algebra queries into SQL queries over local relational schema. The advantage of using an object algebra is that the object-oriented database can be viewed as a blackboard for temporary storage of local data and for establishing relationships between different databases. The object algebra can be used to directly retrieve temporarily-stored data from the object-oriented database or to transparently retrieve data from local sources using the translation process described in this paper.     

Colony: An Artificial Life Model for Active Autonomous Objects

Appropriate aids on top of the primitive object-oriented model will help promote better understanding of the semantics of applications and allow us to focus better on the various aspects of given problems. This study focuses on the exploration of a design model and the corresponding programming framework for the modelling and implementation of applications involving active autonomous objects based on the object technology. The proposed design model is an artificial life model based on the colony phenomenon in nature. This model can naturally be mapped onto an object-oriented implementation. The colony model favours a predicate-based object communication/coordination pattern as opposed to the navigational message-passing paradigm seen in programming languages such as C+ +. The proposed model is particularly appealing to us, for it presents a unifying conceptual design model and programming framework for a wide class of applications including neural networks, genetic algorithms and fuzzy expert systems. The ideas presented are illustrated through a genetic algorithm problem.