Abstract not found

Introduction From an object-oriented point of view, software systems are considered to be dynamic collections of autonomous objects that interact with each other. Autonomy means that each object encapsulates all features needed to act as an independent computing agent: individual attributes (data), methods (operations) , behavior (process), and communication facilities. And each object has a unique identity that is immutable throughout lifetime. Coincidentally, objectorientation comes with an elaborate system of classes and types, facilitating structuring and reuse of software. The object approach is widely accepted in software technology, and there are object-oriented programming languages, database systems, and software development methods. The basic idea is not new, because essential features were already present in the programming language Simula [DMN67]. Wider acceptance came with Smalltalk [KG76, GR83]. While the object approach is success

. In this paper, we present two logics that allow for specifying distributed information systems, emphasizing communication among sites. The low-level logic D 0 offers features that are easy to implement but awkward to use for specification, while the high-level logic D 1 offers convenient specification features that are not easy to implement. We show that D 1 specifications may be automatically translated to D 0 in a sound and complete way. In order to prove soundness and completeness, we define our translation as a simple map of institutions. Our result may be useful for making implementation platforms like Corba easier accessible by providing high-level planning and specification methods for communication. 1 Introduction Two logics are presented that allow for specifying distributed information systems, emphasizing communication among sites. The low-level logic D 0 offers features that are easy to implement but awkward to use for specification, while the high-level logic D 1 offers...

Information systems are open, reactive, and often distributed systems that maintain persistent data. The Troll and omTroll languages aim at specifying information systems on a high level of abstraction, supported by tools integrated in the Tbench. The development is rooted in abstract data types, conceptual modeling, behavior modeling, specification of reactive systems, and concurrency theory.

. We discuss some formal and informal issues regarding requirements

The aim of our work is the modelling and design of information systems in the object-oriented setting. An object-oriented specification covers structural as well as behavioural aspects of the system.

FOOPS is a concurrent object-oriented specification language for which an operational semantics has been provided. This paper gives an equivalent distributed semantics which describes how FOOPS objects co-operate in evaluating a program. The distributed semantics is presented using transition systems. We relate transition systems and sheaves to also give a sheaf-theoretic semantics. By implementing the distributed semantics in Eqlog, we obtain a FOOPS simulator. Thus, our distributed semantics is both axiomatic and executable. 1 Introduction This paper gives a distributed operational semantics to FOOPS, a concurrent object-oriented specification language, uses transition systems and sheaf theory in formalising it and proves its equivalence to (a subset of) an already existing operational semantics of FOOPS. FOOPS (Functional and Object Oriented Programming System) combines the functional and object-oriented paradigms in order to offer both a declarative style of design and a notion of...

Modern programs make extensive use of reusable software libraries. For example, a study of a number of large Java applications shows that between 17 % and 30 % of the classes in those applications use container classes defined in the java.util package. Given this extensive code reuse in Java programs, it is important for the interfaces of reusable classes to be well documented. An interface is well documented if it satisfies the following requirements: (1) the documentation completely describes how to use the interface; (2) the documentation is clear; (3) the documentation is unambiguous; and (4) any deviation between the documentation and the code is machine detectable. Unfortunately, documentation in natural language, which is the norm, does not satisfy the above requirements. Formal specifications can satisfy them but they are difficult to develop, requiring significant effort on the part of programmers. To address the practical difficulties with formal specifications, we describe and evaluate a tool to help programmers write and debug algebraic specifications. Given an algebraic specification of a class, our interpreter generates a prototype which can be used within an application just like any regular Java class. When running an application that uses the prototype, the interpreter prints error messages that tell the developer in which way the specification is incomplete or inconsistent with a hand-coded implementation of the class. We use case studies to demonstrate the usefulness of our system.

In this paper we investigate the notion of transaction in object-oriented specification.

Abstract. Object-Gofer is a small, practical extension of the functional programming language Gofer incorporating the following ideas from the object-oriented community: objects and toplevel classes, subtype and implementation inheritance, method redefinition, late binding and self type specialization. The semantics of Object-Gofer is defined by translation into pure Gofer. Although this restricts the design space, it turns out that using a suitable framework of monads, higher-order polymorphism, and overloading, objects smooth well with functions. 1 Case for Functional Object-oriented Programming Object-oriented concepts are ubiquitous in programming. Objects may model real life entities, or may represent system artifacts like stacks. Objects provide a way to structure a system and to control the computation. The most characteristic feature of object-oriented programming is inheritance, which allows new classes to be defined as increments of existing ones. Inheritance comes with late binding, inclusion polymorphism (subtyping), method redefinition, and method