Object-oriented Specification Language Research Articles

Generating Python Code from Object-Z Specifications

Object-Z is an object-oriented specification language which extends the Z language with classes, objects, inheritance and polymorphism that can be used to represent the specification of a complex system as collections of objects. There are a number of existing works that mapped Object-Z to C++ and Java programming languages. Since Python and Object-Z share many similarities, both are object-oriented paradigm, support set theory and predicate calculus moreover, Python is a functional programming language which is naturally closer to formal specifications, we propose a mapping from Object-Z specifications to Python code that covers some Object-Z constructs and express its specifications in Python to validate these specifications. The validations are used in the mapping covered preconditions, post-conditions, and invariants that are built using lambda function and Python's decorator. This work has found Python is an excellent language for developing libraries to map Object-Z specifications to Python.

Generating Python Code from Object-Z Specifications

Object-Z is an object-oriented specification language which extends the Z language with classes, objects, inheritance and polymorphism that can be used to represent the specification of a complex system as collections of objects. There are a number of existing works that mapped Object-Z to C++ and Java programming languages. Since Python and Object-Z share many similarities, both are object-oriented paradigm, support set theory and predicate calculus moreover, Python is a functional programming language which is naturally closer to formal specifications, we propose a mapping from Object-Z specifications to Python code that covers some Object-Z constructs and express its specifications in Python to validate these specifications. The validations are used in the mapping covered preconditions, post-conditions, and invariants that are built using lambda function and Python's decorator. This work has found Python is an excellent language for developing libraries to map Object-Z specifications to Python.

An Object Oriented Perspective of Context – Aware Monitoring Strategies for Cloud based Healthcare Systems

This paper surveys various context aware monitoring strategies developed for healthcare systems for the past 15 years. Also, the paper demonstrates the significant advantages and disadvantages of each strategy in the evolution of cloud based health care monitoring. The overview of working of FP-Growth Algorithm with illustrative examples from the literature is also depicted and certain inferences from the above study is also presented. Furthermore, it is illustrated how the well-known object-oriented specification language unified modeling language can be adopted, to provided an adequate formalization of its semantics, to describe structural and behavioral aspects of the system related to both logical and physical parts. Flaw in modeling process can substantially contribute to the development cost and time. The operational efficiency may be affected as well. Hence, in this paper, the proposed context aware monitoring system is viewed through a lens of object oriented perspective. This paper would promote a lot of research in the area of cloud assisted healthcare systems.

Formalization of Federated Schema Architectural Style Variability

Data integration requires managing heterogeneous schema information. A federated database system integrates heterogeneous, autonomous database systems on the schema level, whereby both local applications and global applications accessing multiple component database systems are supported. Such a federated database system is a complex system of systems which requires a well-designed organization at the system and software architecture level. A specific challenge that federated database systems face is the organization of schemas into a schema architecture. This paper provides a detailed, formal investigation of variability in the family of schema architectures, which are central components in the architecture of federated database systems. It is shown how the variability of specific architectures can be compared to the reference architecture and to each other. To achieve this, we combine the semi-formal object-oriented modeling language UML with the formal object-oriented specification language Object-Z. Appropriate use of inheritance in the formal specification, as enabled by Object-Z, greatly supports specifying and analyzing the variability among the studied schema architectures. The investigation also serves to illustrate the employed specification techniques for analyzing and comparing software architecture specifications.

Static Class Elements for Object-Z

Static variables and methods are part of almost every modern object-oriented programming language. Static elements are for instance indispensable for certain kinds of design patterns applied during programming. Object-oriented specification formalisms on the other hand lack such concepts. This can prevent writing formal specifications close to the actual implementation, and can thus hamper a refinement-based stepwise development.In this paper, we extend the state-based object-oriented specification language Object-Z with a concept for static class elements. We furthermore show how refinement can introduce static elements into a specification.

Patterns for Automatic Generation of Soft Real-time System Models

Worst-case assumptions about the timing of systems are often too conservative when analyzing distributed soft real-time systems as they lead to over-dimensioned and expensive products. For these systems, a certain percentage of deadline misses is often affordable. Instead of a binary answer regarding the schedulability of such a system, a more interesting metric is the degree to which the system meets the timing requirements. For this, an appropriate model that realistically expresses the behavior of a soft real-time system when deployed on a multiprocessor platform should be built and analyzed. In this article, we present such a modeling approach based on the formal modeling language POOSL (parallel object-oriented specification language). Moreover, to alleviate the process of modeling, we present a pattern-based description language that allows an application, together with the multiprocessor platform and the deployment to be described in a concise way. Such a pattern-based description can be translated automatically into an executable POOSL model through which performance properties can be analyzed based on simulations. The suitability of our approach is demonstrated by exploring the design space of a distributed in-car radio navigation system.

DeSpec: Modeling the Windows Driver Environment11This work was partially supported by the Czech Academy of Sciences project 1ET400300504 and the Grant Agency of the Czech Republic project GD201/05/H014.

This paper introduces a new object-oriented specification and modeling language called DeSpec. The language targets primarily model checking in the Windows NT kernel driver environment. It integrates the majority of Zing modeling language features and adds means for defining parameterized abstractions of the environment at varying levels of detail. The DeSpec language also enables capturing constrains imposed on drivers by the Windows kernel in a form of quantified temporal logic patterns – easy-to-read templates of LTL formulae introduced by the Bandera toolset.

Semantics, calculi, and analysis for object-oriented specifications

We present a formal semantics for an object-oriented specification language. The formal semantics is presented as a conservative shallow embedding in Isabelle/hol and the language is oriented towards ocl formulae in the context of uml class diagrams. On this basis, we formally derive several equational and tableaux calculi, which form the basis of an integrated proof environment including automatic proof support and support for the analysis of this type of specifications. We show applications of our proof environment to data refinement based on an adapted standard refinement notion. Thus, we provide an integrated formal method for refinement-based object-oriented development.

Faithful mapping of model classes to mathematical structures

ion techniques are indispensable for the specification and verification of the functional behaviour of programs. In object-oriented specification languages like Java Modeling Language, a powerful abstraction technique is the use of model classes, that is, classes that are only used for specification purposes and that provide object-oriented interfaces for essential mathematical concepts such as sets or relations. Although the use of model classes in specifications is natural and powerful, they pose problems for verification. Program verifiers map model classes to their underlying logics. Flaws in a model class or the mapping can easily lead to unsoundness and incompleteness. This article proposes an approach for the faithful mapping of model classes to mathematical structures provided by the theorem prover of the program verifier at hand. Faithfulness means that a given model class semantically corresponds to the mathematical structure it is mapped to. This approach enables reasoning about programs specified in terms of model classes. It also helps in writing consistent and complete model-class specifications as well as in identifying and checking redundant specifications.

On the Use of UML for Modeling Mechatronic Systems

This paper describes a modeling language that aims to provide a unified framework for representing control systems, namely, physical plants coupled with computer-based control devices. The proposed modeling methodology is based on the cardinal principle of object orientation, which allows describing both control software and physical components using the same basic concepts, particularly those of capsules, ports, and protocols. Furthermore, it is illustrated how the well-known object-oriented specification language unified modeling language can be adopted, provided an adequate formalization of its semantics, to describe structural and behavioral aspects of control systems, related to both logical and physical parts. Note to Practitioners-The development of an automated system within an industrial setting is a complex task, whose successful result depends on the joint efforts of a team of designers with different scientific backgrounds and specialized knowledge. In fact, an automated system is typically composed of a mechanical assembly, which must be precisely designed and manufactured, and a set of sensors and actuators (e.g., electrical drives, pneumatic systems, etc.), which are, on their turn, controlled most of the time by means of digital processors. Of course, both electrical parts and control algorithms (e.g., proportional, integral, and derivative (PID) regulators, logic and supervisory control, reference trajectories for mechanical motions, etc.) should be designed with the same care given to mechanical aspects. Moreover, it is undeniable that none of the various parts composing the automated system design specification can, on their own, allow engineers to understand the actual behavior of the whole system, especially without a common description language that is understandable for all of the designers. The present paper introduces a unified language which aims to support integrated design specifications of automated systems, including the dynamics of heterogeneous physical assemblies, the discrete-event behavior of distributed control software, and the specification of interface ports between the plant and the control system. With the proposed language, it is possible to obtain a complete picture of the automated system suitable for its simulation, documentation, and validation. The modeling language described in the paper supports the principles of object orientation. This choice moves in the direction of enhancing modularity and reusability properties of design specifications, which are aspects of great importance in the design practice. Moreover, the object-oriented approach to automated systems design proposed in the paper aims to introduce the concept of "design by extension" in the manufacturing industry. This means that the definition of specialization relationships between classes of components implies that those components should be designed in order to be substitutable with each other, especially from a dynamic point of view. This aspect will be the subject of further papers illustrating other practical insights on the use of object-oriented models for automated systems

Performance modelling of a network processor using POOSL

The increasing complexity of innovative real-time hardware/software systems forced industry to consider system-level design methods. Before actually implementing a system with hardware and software components, system-level design methods enable analysing the performance of different design alternatives that realise the required functionality. In order to develop performance models early in the design process, the parallel object-oriented specification language (POOSL) can be used. POOSL is an expressive modelling language for analysing complex real-time distributed hardware/software systems. Being equipped with a formal semantics, POOSL ensures unambiguous execution of models and proper application of performance analysis techniques. This paper discusses the use of POOSL for analysing the performance of a network processor. A network processor consists of components that perform their behaviour in a synchronously concurrent way, whereas POOSL is based on an asynchronous modelling paradigm. In this paper, we illustrate that constructing abstract models of synchronous systems for the purpose of performance analysis may benefit from an asynchronous modelling approach.

Declarative Reflection and its Application as a Pattern Language

The paper presents the reflection facilities of the specification language Slam-sl. Slam-sl is an object oriented specification language where class methods are specified by pre and postconditions. The reflection capabilities allow managing these pre and postconditions in specifications what means that semantic reflection is possible. The range of interesting applications is very wide: formal specification of interfaces and abstract classes, specification of component based software, formalization of design pattern, using Slam-sl as a pattern language, etc. The paper discusses the last two advantages in some detail.

A Maude specification of an object-oriented model for telecommunication networks

This paper presents an object-oriented model for broadband telecommunication networks, which can be used both for network management and for network planning purposes. The object-oriented model has been developed using the parallel object-oriented specification language Maude, which allows us to define not only structural aspects of the model but also procedural aspects. The reflective properties of rewriting logic are applied to control the rewriting process, using a strategy language that can be specified internally to the logic. Several modeling approaches are compared, emphasizing the definition of the object relationships and the benefits obtained from using reflection as opposed to the extra effort required to control the process at the object level itself.

A methodology for certification of modeling and simulation applications

Certification of modeling and simulation (M&S) applications poses significant technical challenges for M&S program managers, engineers, and practitioners. Certification is becoming increasingly more important as M&S applications are used more and more for military training, complex system design evaluation, M&S-based acquisition, problem solving, and critical decision making. Certification, a very complex process, involves the measurement and evaluation of hundreds of qualitative and quantitative elements, mandates subject matter expert evaluation, and requires the integration of different evaluations. Planning and managing such measurements and evaluations requires a unifying methodology and should not be performed in an ad hoc manner. This paper presents such a methodology. The methodology consists of the following body of methods, rules, and postulates: (a) employment of subject matter experts, (b) construction of a hierarchy of indicators, (c) relative criticality weighting of indicators using the analytic hierarchy process, (d) using a rule-based expert knowledge base with an object-oriented specification language, (e) assignment of crisp, fuzzy, and nominal scores for the indicators, (f) aggregation of indicator scores, (g) graphical representation of the indicator scores and weights, (h) hypertext certification report, and (i) interpretation of the results. The methodology can be used for certification of any kind of M&S application either throughout the M&S development life cycle or after the development is completed.

ODP enterprise viewpoint specification

The Open Distributed Processing (ODP) standardisation initiative has led to a framework by which distributed systems can be modelled using a number of viewpoints. These include an enterprise viewpoint, which focuses on the objectives and policies of the enterprise that the system is meant to support. Although the ODP reference model provides abstract languages of relevant concepts, it does not prescribe particular techniques that are to be used in the individual viewpoints. In particular, there is a need to develop appropriate notations for ODP enterprise specification, in order to increase the applicability of the ODP framework. In this paper, we tackle this concern and develop a specification language to support the current draft of the enterprise viewpoint. In doing so, we analyse the current definition of the ODP enterprise viewpoint language. Using the Unified Modelling Language ( uml), a meta-model of the core concepts and their relationships is constructed, and we also investigate to what extent the uml can be used for enterprise viewpoint specification. We, then, focus on the expression of enterprise policies that govern the behaviour of enterprise objects. We develop a policy language, which is a combination of structured English and simple predicate logic and is built on top of the formal object-oriented specification language Object-Z, into which the complete language is translated. We illustrate the ideas in the paper with a case study that presents an enterprise specification of a library support system.

Demand Priority Protocol simulation and evaluation

A new network protocol (Demand Priority Protocol) environment can provide more satisfying service for different urgent transmission requests. In this paper, in order to provide guidance for the selection of environment of multimedia data transmission in Computer Supported Cooperative Work better, an object-oriented protocol specification language based on C++ is used to design a virtual environment of multiworkstation of computer cooperative work and to simulate execution of demand priority network protocol and then the performances of various transmission requests are analyzed. Finally, an evaluation of the demand priority LAN is given.

Viewpoints and consistency: translating lotos to Object- z

This paper presents a translation between the formal description technique lotos and the object-oriented specification language Object- z. The need for such a translation lies in the use of formal methods in viewpoint specification, and in particular in the Open Distributed Processing standard. The use of viewpoints as a set of partial interlocking specifications brings an obligation to check the consistency of these partial specifications, and to do so we need to relate specifications written in differing languages. The work presented here aims to support the consistency checking of viewpoints written using formal methods by defining a translation from lotos to Object- z. A lotos specification describes both an ADT component and a behavioural model, the former is translated into the z type system, and the behavioural specification is translated into a collection of Object- z classes where we relate lotos actions to operations in the Object- z specification. A case study is presented, illustrating the translation and consistency checking techniques discussed in the paper.

A FRAMEWORK FOR OBJECT-ORIENTED REVERSE ENGINEERING OF LEGACY INFORMATION SYSTEMS

There is every indication that an object-oriented view of an information system is a solid foundation for understanding its legacy organization, for relating it to the environment in which it is embedded and for guiding its reengineering. In this paper we present a framework based upon the formal object-oriented specification language TROLL, which provides an object-oriented view of legacy information systems. The aim is to combine existing methods and keep results in a common and suitable description base which provides the appropriate form for deriving object specifications from the legacy IS. We usethe language TROLL not only as description language, but also as a framework to support the maintenance engineers in their reverse engineering tasks by giving hints about what to do next to complete the object specifications. The result of the approach is a formal object-oriented specification of the legacy IS that is suitable both for developing a new IS or for reengineering the legacy system.

Formalizing and Executing Message Sequence Charts via Timed Rewriting

Message Sequence Charts (MSC) is a graphical trace language for describing and specifying the communication behaviour of distributed systems by means of message interchange. (Timed) Maude is a formal object-oriented specification language which combines algebraic specification techniques for describing complex data structures with (timed) term rewriting to deal with dynamic behaviour. In this paper we show first how to formalize MSC in Timed Maude. Then we give a translation of timed rewriting to untimed rewrite systems and use this translation to execute Message Sequence Charts with the Elan system, a powerful tool which combines Rewriting Logic with a language of rewriting strategies. We illustrate our approach with the bench mark example of a railroad crossing.

Guest Editor's introduction: Selected papers from the 4th USENIX Conference on Object-Oriented Technologies and Systems

Hewlett-Packard Laboratories, 1501 Page Mill Road, Palo Alto, CA 94304, USA Introduction The USENIX Conference on Object-Oriented Technologies and Systems (COOTS) is held annually in the late spring. The conference evolved from a set of C++ workshops that were held under the auspices of USENIX, the first of which met in 1989. Given the growing diverse interest in object-oriented technologies, the C++ focus of the workshop eventually became too narrow, with the result that the scope was widened in 1995 to include object-oriented technologies and systems. COOTS is intended to showcase advanced RD the architecture and implementation of distributed object systems (e.g. CORBA, DCOM, RMI); object-oriented programming and specification languages; object-oriented design and analysis. The 4th meeting of COOTS was held 27 - 30 April 1998 at the El Dorado Hotel, Santa Fe, New Mexico, USA. Several tutorials were given. The technical program proper consisted of a single track of six sessions, with three paper presentations per session. A keynote address and a provocative panel session rounded out the technical program. The program committee reviewed 56 papers, selecting the best 18 for presentation in the technical sessions. While we solicit papers across the spectrum of applications of object-oriented technologies, this year there was a predominance of distributed, object-oriented papers. The accepted papers reflected this asymmetry, with 15 papers on distributed objects and 3 papers on object-oriented languages. The papers in this special issue are the six best distributed object papers (in the opinion of the program committee). They represent the diversity of research in this particular area, and should give the reader a good idea of the types of papers presented at COOTS as well as the calibre of the work so presented. The papers The paper by Jain, Widoff and Schmidt explores the suitability of Java for writing performance-sensitive distributed applications. Despite the popularity of Java, there are many concerns about its efficiency; in particular, networking and computation performance are key concerns when considering the use of Java to develop performance-sensitive distributed applications. This paper makes three contributions to the study of Java for these applications: it describes an architecture using Java and the Web to develop MedJava, which is a distributed electronic medical imaging system with stringent networking and computation requirements; it presents benchmarks of MedJava image processing and compares the results to the performance of xv, which is an equivalent image processing application written in C; it presents performance benchmarks using Java as a transport interface to exchange large medical images over high-speed ATM networks. The paper by Little and Shrivastava covers the integration of several important topics: transactions, distributed systems, Java, the Internet and security. The usefulness of this paper lies in the synthesis of an effective solution applying work in different areas of computing to the Java environment. Securing applications constructed from distributed objects is important if these applications are to be used in mission-critical situations. Delegation is one aspect of distributed system security that is necessary for such applications. The paper by Nagaratnam and Lea describes a secure delegation model for Java-based, distributed object environments. The paper by Frolund and Koistinen addresses the topical issue of providing a common way for describing Quality-of-Service (QoS) features in distributed, object-oriented systems. They present a general QoS language, QML, that can be used to capture QoS properties as part of a design. They also show how to extend UML to support QML concepts. The paper by Szymaszek, Uszok and Zielinski discusses the important issue of efficient implementation and usage of fine-grained objects in CORBA-based applications. Fine-grained objects can have serious ramifications on overall application performance and scalability, and the paper suggests that such objects should not be treated as first-class CORBA objects, proposing instead the use of collections and smart proxies for efficient implementation. The paper by Milojicic, LaForge and Chauhan describes a mobile objects and agents infrastructure. Their particular research has focused on communication support across agent migration and extensive resource control. The paper also discusses issues regarding interoperation between agent systems. Acknowledgments The editor wishes to thank all of the authors, reviewers and publishers. Without their excellent work, and the contribution of their valuable time, this special issue would not have been possible.