An executable formal semantics for UML-RT

We propose a formal semantics for UML-RT, a UML profile for real-time and embedded systems. The formal semantics is given by mapping UML-RT models into a language called kiltera, a real-time extension of the \(\pi \)-calculus. Previous attempts to formalize the semantics of UML-RT have fallen short by considering only a very small subset of the language and providing fundamentally incomplete semantics based on incorrect assumptions, such as a one-to-one correspondence between “capsules” and threads. Our semantics is novel in several ways: (1) it deals with both state machine diagrams and capsule diagrams; (2) it deals with aspects of UML-RT that have not been formalized before, such as thread allocation, service provision points, and service access points; (3) it supports an action language; and (4) the translation has been implemented in the form of a transformation from UML-RT models created with IBM’s RSA-RTE tool, into kiltera code. To our knowledge, this is the most comprehensive formal semantics for UML-RT to date.     

An object-oriented approach to application generation

The TUBA system consists of a set of integrated tools for the generation of business-oriented applications. Tools and applications have a modular structure, represented by class objects. The article describes the architecture of the environments for file processing, screen handling and report writing.     

Unified verification and monitoring of executable UML specifications

Software and Systems Modeling - The increasing complexity of embedded systems renders software verification more complex, requiring monitoring and formal techniques, like model-checking. However,...     

Lightweight and static verification of UML executable models

Executable models play a key role in many software development methods by facilitating the (semi)automatic implementation/execution of the software system under development. This is possible because executable models promote a complete and fine-grained specification of the system behaviour. In this context, where models are the basis of the whole development process, the quality of the models has a high impact on the final quality of software systems derived from them. Therefore, the existence of methods to verify the correctness of executable models is crucial. Otherwise, the quality of the executable models (and in turn the quality of the final system generated from them) will be compromised. In this paper a lightweight and static verification method to assess the correctness of executable models is proposed. This method allows us to check whether the operations defined as part of the behavioural model are able to be executed without breaking the integrity of the structural model and returns a meaningful feedback that helps repairing the detected inconsistencies.     

An operational semantics for object-oriented concepts based on the class hierarchy

The formalisation of object-oriented languages is essential for describing the implementation details of specific programming languages or for developing program verification techniques. However there has been relatively little formalisation work aimed at abstractly describing the fundamental concepts of object-oriented programming, separate from specific language considerations or suitability for a particular verification style. In this paper we address this issue by formalising a language that includes the core object-oriented programming language concepts of field tests and updates, methods, constructors, subclassing, multithreading, and synchronisation, built on top of standard sequential programming constructs. The abstract syntax is relatively close to the core of typical object-oriented programming languages such as Java. A novel aspect of the syntax is that objects and classes are encapsulated within a single syntactic term, including their fields and methods. Furthermore, class terms are structured according to the class hierarchy, and objects appear as subterms of their class (and method instances as subterms of the relevant object). This helps to narrow the gap between how a programmer thinks about their code and the underlying mathematical objects in the semantics. The semantics is defined operationally, so that all actions a program may take, such as testing or setting local variables and fields, or invoking methods on other objects, appear on the labels of the transitions. A process-algebraic style of interprocess communication is used for object and class interactions. A benefit of this label-based approach to the semantics is that a separation of concerns can be made when defining the rules of the different constructs, and the rules tend to be more concise. The basic rules for individual commands may be composed into more powerful rules that operate at the level of classes and objects. The traces generated by the operational semantics are used as the basis for establishing equivalence between classes.     

面向对象软件系统的一种度量方法及其应用

在面向对象系统分析和设计过程中，类的设计质量直接关系到软件系统质量。首先对类之间的关系进行了分析、说明和定义，并分为横向关系和纵向关系，给出了横向关系和纵向关系度量与质量评价，并在此基础上给出了改善类设计质量的方法。     

An object-oriented approach to the management of distributed application systems

General purpose distributed object-oriented environments exist to allow for the efficient construction of client/server software systems. Standard network and distributed systems management environments exist for the efficient operation of heterogeneous networked hardware and software systems. As distributed software systems get larger, the economies of systems development and the economies of software operation demand that we find an efficient way of integrating these two technologies. While the use of standardized distributed systems management for the management of distributed software applications seems reasonable, very little research has been done to confirm this. In this paper, we propose the integration of standardized distributed resource management technologies and distributed application software. In our work we have facilitated this integration using techniques based on mainstream object-oriented dynamic modeling. We will describe our techniques of integration as well as discuss the need for methodical engineered approaches when working in this area.     

Modular specification and verification of object-oriented programs

A method for modular specification and verification using the ideas of subtype and normal type is presented. The method corresponds to informal techniques used by object-oriented programmers. The key idea is that objects of a subtype must behave like objects of that type's supertypes. An example program is used to show the reasoning problems that supertype abstraction may cause and how the method resolves them. Subtype polymorphism is addressed, and specification and verification update is discussed. A set of syntactic and semantic constraints on subtype relationships, which formalize the intuition that each object of a subtype must behave like some object of each of its supertypes, is examined. These constraints are the key to the soundness of the method. To state them precisely, a formal model of abstract type specifications is used     

On the declarative and procedural semantics of deductive object-oriented systems

We present declarative and procedural semantics for a deductive object-oriented language, Gulog. The declarative semantics is based on preferred minimal models. We describe both bottom-up and top-down query evaluation procedures and show that they are sound with respect to the declarative semantics. The results contribute to our understanding of the interaction of inheritance, overriding and deduction in the presence of both functional and set-valued methods, and multiple inheritance.     

ACTL strong negation and its application to hybrid systems verification

Model checking procedures for verifying properties of hybrid dynamic systems are based on the construction of finite-state abstractions. If the property is not satisfied by the abstraction, the verification is inconclusive and the abstraction needs to be refined so that a less conservative model can be checked. If the hybrid system does not satisfy the property, this verify–refine procedure usually will not terminate. This paper introduces the concept of strong negation for ACTL formulas as an auxiliary condition that can be verified to obtain a conclusive negative verification result from a finite-state abstraction in certain cases. The concepts are illustrated with an example from automotive powertrain control.     

Specification and verification challenges for sequential object-oriented programs

The state of knowledge in how to specify sequential programs in object-oriented languages such as Java and C# and the state of the art in automated verification tools for such programs have made measurable progress in the last several years. This paper describes several remaining challenges and approaches to their solution.     

TeMIP的面向对象方法在电信网管中的应用

介绍了一种在UNIX和WINDOWS环境下，以Compaq公司的电信管理信息平台（TeMIP)V4.0版本为开发工具，运用C 语言，快速开发电信网管系统（TMN）的方法。描述了如何应用被管对象描述指南（GDMO）建立管理模型，TeMIP的开发流程，应用实例以及其先进的面向对象技术。     

The semantics and verification of timed service choreography

As a service composition and coordination language, the service choreography gives the global and neutral view on the collaboration among a collection of highly distributed services involving multiple different organizations or heterogeneous independent processes. In this paper, we extend the service choreography by introducing the explicit time activity, which can be used to specify and reason about the timed behaviour of Web service choreography. Then we explore an execution model for the proposed timed service choreography which possesses several novel features, such as timed activity, choreography composition, exception handling and finalization. Furthermore, a set of mapping rules is elaborately designed to translate the timed choreography into communicating sequential programs processes, thus the corresponding simulation and verification of Web services choreographies with timing restrictions can be carried out in the model checker process analysis toolkit. The case study shows that our approach is both effective and practical.     

An object-oriented multimedia database system for a news-on-demand application

We describe the design of a multimedia database management system for a distributed news-on-demand multimedia information system. News-on-demand is an application that uses broadband network services to deliver news articles to subscribers in the form of multimedia documents. Different news providers insert articles into the database, which are then accessed by users remotely, over a broadband, asynchronous transfer-mode (ATM) network. The particulars of our design are an object-oriented approach and strict adherence to international standards, in particular the Standard Generalized Mark-up Language (SGML) and Hy-Time. The multimedia database system has a visual query facility, which is also described in this paper. The visual query interface provides three major facilities for end users: presentation, navigation, and querying of multimedia news documents. The main focus, however, is the querying of multimedia objects stored in the database.     

Specification and verification of object-oriented programs using supertype abstraction

We present a formal specification language and a formal verification logic for a simple object-oriented programming language. The language is applicative and statically typed, and supports subtyping and message-passing. The verification logic relies on a behavioral notion of subtyping that captures the intuition that a subtype behaves like its supertypes. We give a formal definition for legal subtype relations, based on the specified behavior of objects, and show that this definition is sufficient to ensure the soundness of the verification logic. The verification logic reflects the way programmers reason informally about object-oriented programs, in that it allows them to use static type information, which avoids the need to consider all possible run-time subtypes.The work of both authors was supported in part by the National Science Foundation under Grant CCR-8716884, and in part by the Defense Advanced Research Projects Agency (DARPA) under Contract N00014-89-J-1988. While a graduate student at MIT, Leavens was also supported in part by a GenRad/AEA Faculty Development Fellowship, and at ISU he has been partially supported by the ISU Achievement Foundation and by the National Science Foundation under Grant CCR-9108654     

The stochastic semantics and verification for periodic control systems

Periodic control systems(PCS) are widely used in the embedded industry like aerospace and automotive.Such systems usually run periodic tasks and respond to the external signals.Based on our previous work on Mode diagram modeling(MDM) notations for specifying the periodic control system,we present the stochastic semantics for MDM in this paper.The stochastic semantics of MDM is based on the Markov chain.The semantics proposed here provides the basis for the satisfaction of formulae of the interval temporal logic(ITL) based specification language that is aimed to specify the properties of PCS.To verify whether the system satisfies the ITL-based properties,we apply the statistical model checking technique to efficiently estimate the probability of the system satisfying the given property with a desired level of confidence.The empirical experiments show that our approach is both effective and efficient.     

Axiomatic semantics of R-schemas and verification of graphic programs

We propose an approach to verification of programs in a graphic language in the programming R-technology and introduce an axiomatic semantics of R-schemas and of graphic Pascal. We justify the advantages of graphic representation of programs for correctness proving and describe a support system for this approach under RAFOS and MS-DOS.Translated from Kibernetika, No. 1, pp. 21–27, January–February, 1990.     

An object-oriented programming of an explicit dynamics code: application to impact simulation

During the last fifty years, the development of better numerical methods and more powerful computers has been a major enterprise for the scientific community. Recent advances in computational softwares have lead to the possibility of solving more physical and complex problems (coupled problems, nonlinearities, high strain and high strain rate problems, etc.). The development of object-oriented programming leads to better structured codes for the finite element method and facilitates the development, the maintainability and the expandability of such codes.This paper presents an implementation in C++ of an explicit finite element program dedicated to the simulation of impacts. We first present a brief overview of the kinematics, the conservative and constitutive laws related to large deformation inelasticity. Then we present the design and the numerical implementation of some aspects developed with an emphasis on the object-oriented programming adopted. Finally, the efficiency and accuracy of the program are investigated through some benchmark tests.