Two semantic models of object-oriented languages
Uday Reddy1994, Theoretical Aspects of Object-Oriented …
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
We present and compare two models of object-oriented languages. The first we call the closure model because it uses closures to encapsulate side effects on objects, and accordingly makes the operations on an object a part of that object. It is shown that this denotational framework is adequate to explain classes, instantiation, and inheritance in the style of Simula as well as Smalltalk-80. The second we call the data structure model because it mimics the implementations of data structure languages like CLU in representing objects by records of instance variables, while keeping the operations on objects separate from the objects themselves. This yields a model which is very simple, at least superficially. Both the models are presented by way of a sequence of languages, culminating in a language with Smalltalk-80-style inheritance. The mathematical relationship between them is then discussed and it is shown that the models give equivalent results. It will emerge from this discussion that more appropriate names for the two models might be the fixed-point model and the self-application model. * To appear in Gunter, C. and Mitchell, J. C. (eds) Theoretical aspects of Object-Oriented Programming, MIT Press, 1993. 1 "Smalltalk-80" is a trademark of ParcPlace Systems. We use here a language called "SmallTalk" (with different capitalization) as an abstraction of Smalltalk-80.
Related papers
Objects as closures: abstract semantics of object-oriented languages
1988
We discuss denotational semantics of object-oriented languages, using the concept of closure widely used in (semi) functional programming to encapsulate side effects. It is shown that this denotational framework is adequate to explain classes, instantiation, and inheritance in the style of Sirnula as well as SMALLTALK-80. This framework is then compared with that of Kamin, in his recent denotational definition of SMALLTALK-80, and the implications of the differences between the two approaches are discussed.
A Denotational
Semantics of Inheritance
This thesis develops a semantic model of inheritance and investigates its applications for the analysis and design of programming languages. Inheritance is a mechanism for incremental programming in the presence of self-reference. This interpretation of inheritance is formalized using traditional techniques of fixed-point theory, resulting in a compositional model of inheritance that is directly applicable to object-oriented languages. Novel applications of inheritance revealed by the model are illustrated to show that inheritance has wider significance beyond object-oriented class inheritance. Constraints induced by self-reference and inheritance are investigated using type theory and yield a formal characterization of abstract classes and a demonstration that the subtype relation is a direct consequence of the basic mechanism of inheritance. The model is proven equivalent to the operational semantics of inheritance embodied by the interpreters of object-oriented languages like Smalltalk. Concise descriptions of inheritance behavior in several object-oriented languages, including Smalltalk, Beta, Simula, and Flavors, are presented in a common framework that facilitates direct comparison of their features.
The object-oriented paradigm
Computing science notes, 1994
In this paper we discuss the fundamental concepts present in the object-oriented methodology. First we concentrate on the notion of an object, the key concept in this approach. A (software) object is the abstract representation of a physical or conceptual object. It consists of a name, a specified set of data-elements and methods. Data-elements can have values attached to them. Data-hiding is the feature that certain data and methods can be kept invisible (= hidden) for the outside of an object, thus facilitating its description. Only knowledge on the nature of the visible data-elements and methods is required to make proper use of the object. This is called data-abstraction. A related concept is encapsulation, a technique for achieving both data-hiding and data-abstraction. A class is a template for a number of similar objects. Classes do not prescribe values for the data-elements nor fixed implementations for their methods. A class can be seen as a set of objects that satisfy the same specification for data-elements and method-behavior. An alternative grouping of objects may take place by means of object types, as we will describe. A type is a set of objects that satisfy the same ezternai specification, i.e., specification of the visible data-elements and methods. Thus, a classification via types differs from an ordering into classes, as we shall explain. The notion of type brings along a notion of subtyping. We also discuss different forms of inheritance between classes. By means of inheritance a class can use data-and method-descriptions from another class. We describe, among other things, single inheritance, multiple inheritance and overriding. We also discuss mUltiple preferred inheritance and runtime inheritance. Finally, we show how actual programming can take place in an object oriented approach. For that we need a description of inter-object communication by means of messages. Relevant aspects are: synchronous and asynchronous message passing, scheduling and delegation. The paper concludes with an overview and a number of summarizing remarks. "'This paper originates from Marc van der Kammen's master's thesis "The logic of objects; object oriented programming in a logical perspective". It is the revised version of his chapter 0, which contains an overview of the most important basic notions concerning object-oriented programming.
A Semantics of Object-Oriented Sets
1994
An account is given of extending the well-known object-oriented type system of Luca Cardelli with set constructs and logical formalism. The system is based on typed -notation, employing a subtyping relation and a powertype construct. Sets in this system are value expressions and are typed as some powertype. Sets are built up in a very general manner; in particular, sets can be described by ( rst-order) predicates. The resulting system, called LPT, is statically typecheckable (in a context of multiple inheritance) and is provided with a set-theoretic semantics. LPT can be used as a mathematical foundation for an object-oriented data model employing sets and constraints.
A generalized object model
ACM SIGPLAN Notices, 1986
Since the introduction of Smalltalk, the object-oriented paradigm has become a popular technique for the organization of data and programs. In this paradigm, objects (collections of data and programs) are organized in a class hierarchy. These classes collect similar objects and serve as a repository for methods (programs) shared by those objects. We present a new simple model of objects that allows multi-dimensional inheritance. Objects, in our model, behave like communicating processes in Hoare's CSP language, but with a different message-passing mechanism. This leads to a simple formal semantics for objects and inheritance.
Open Issues in Object-Oriented Programming
SUMMARY We discuss a number of open issues within object-oriented programming. The central mechanisms of object-oriented programming appeared with Simula developed more than 30 years ago including class, subclass, virtual function, active object and the first application framework, Class Simulation. The core parts of object-oriented programming should be well understood, but there are still a large number of issues where there is no consensus. The term object-orientation has been applied to many subjects such as: analysis, design implementation, data modeling in databases, and distribution. In this paper the term object-oriented programming is meant to cover all these subjects, since one of the advantages of object-orientation is that it provides a unified approach to these subjects. The issues being discussed in this paper are: modeling versus reuse as the main benefit of object-orientation; the need for a language independent conceptual framework; abstraction mechanisms for suppor...
A Survey of Object-Oriented Programming Languages
International Journal of Scientific Research in Computer Science, Engineering and Information Technology, 2019
Object oriented programming has become a very important programming CONCEPT of our times.The time it was brought into existence by Simula. It directly support the object notions of classes, inheritance, information hiding, and dynamic binding. There is a variety of implementations for each of these concepts, and there is no general agreement as to how a particular concept must be interpreted. This survey takes a detailed look at the concepts which are fundamental to object-orientation, namely inheritance and polymorphism. Different aspects of inheritance and polymorphism are implemented in various popular Object oriented program language. We conclude that there is still lot of work to be done to reach a common ground for these to achieve features of OOPs. This survey presents a comparison of Java, C++, C# , Eiffel, Smalltalk, Ruby and Python in terms of their inheritance and polymorphism implementations. The paper also presents a compilation of the observations made by several surveys [1].
An Approach to Algebraic Semantics of Object-Oriented Languages
2003
Studying the semantics of programming languages has a long tradition in computer science. Various approaches use various formalisms with various objectives. In the last two decades, algebraic specifications have frequently been used to study functional as well as imperative languages, and, in particular, object-orientated ones, thereby often focusing on specific aspects and concepts of this programming paradigm. In this paper, we follow this tradition and develop an algebraic semantics of a sample object-oriented language. We thereby distinguish between the object-oriented concepts of the language to structure code, and the imperative ones to implement functionality and thus the algorithmic parts of the language. Therefore, our approach encompasses two steps: first, we develop an algebraic semantics of basic object-oriented principles, into which, secondly, the semantics of the language’s imperative parts is embedded. Static semantic aspects are captured by structured algebraic spec...
Related topics
Related papers
The equivalence of two semantic definitions for inheritance in object-oriented languages
Lecture Notes in Computer Science, 1992
A simple language is presented which supports inheritance in object-oriented languages. Using rids language, the definitions for the semantics of inheritance given in [CHC90] and [Mit90] are compared and shown to be equivalent. The equivalence is shown by presenting and comparing two denotational semantics of the simple language which capture the essence of each of the earlier semantics.
Semantic Primitives for Object-Oriented Programming Languages
1996
Abstract The-calculus is given an operational semantics in terms of the SECD machine. This is then extended with built-in operators and new transition rules to produce the-calculus which characterises object-oriented programming languages. Although there are many languages which can be called object-oriented, they are di cult to compare because the operations which provide facilities such as inheritance and message passing are hidden behind linguistic abstractions which make the languages rigid and di cult to modify.
Concepts and paradigms of object-oriented programming
ACM SIGPLAN OOPS Messenger, 1990
We address the following questions for object-oriented programming: What is it? What are its goals? What are its origins? What are its paradigms? What are its design alternatives? What are its models of concurrency? What are its formal computational models? What comes after object-oriented programming? Starting from software engineering goals, we examine the origins and paradigms of object-oriented programming, explore its language design alternatives, consider its models of concurrency, and review its mathematical models to make them accessible to nonmathematical readers. Finally, we briefly speculate on what may come after object-oriented programming and conclude that it is a robust component-based modeling paradigm that is both effective and fundamental. This paper expands on the OOPSLA 89 keynote talk.
A relational model for object-oriented designs
Programming Languages and Systems, 2004
This paper develops a mathematical characterisation of object-oriented concepts by defining an observation-oriented semantics for an object-oriented language (OOL) with a rich variety of features including subtypes, visibility, inheritance, dynamic binding and polymorphism. The language is expressive enough for the specification of object-oriented designs and programs. We also propose a calculus based on this model to support both structural and behavioural refinement of object-oriented designs. We take the approach of the development of the design calculus based on the standard predicate logic in Hoare and He's Unifying Theories of Programming (UTP). We also consider object reference in terms of object identity as values and mutually dependent methods.
A semantics for object-oriented systems
1998
Current object-oriented design notations such as OMT 14], Booch 3] and UML 16] are syntax-bound and semantic-free in the sense that they typically employ a large and rigorously enforceable collection of construction rules, but rarely provide a model to explain what is being constructed.
Understanding Object-Oriented Languages: Semantics and Types
Lecture Notes, December, 1998
In this document we hope to explore the foundations of object-oriented programming languages by providing a way of understanding these languages via a translation to an extended typed lambda calculus. We will start with a quite simple encoding of objects and classes, and then see that support for such features as subclasses and parametric polymorphism will push us into more complex encodings. Moreover these encodings will suggest the addition of new extensions (eg, MyType) to object-oriented programming ...
What is ''Object-Oriented Programming''? (1991 revised version)
Object-Oriented Programming'' and ''Data Abstraction'' have become very common terms. Unfortunately, few people agree on what they mean. I will offer informal definitions that appear to make sense in the context of languages like Ada, C + +, Modula-2, Simula, and Smalltalk. The general idea is to equate ''support for data abstraction'' with the ability to define and use new types and equate ''support for object-oriented programming'' with the ability to express type hierarchies. Features necessary to support these programming styles in a general purpose programming language will be discussed. The presentation centers around C + + but is not limited to facilities provided by that language.
Towards a Precise Semantics for Object-Oriented Modeling Techniques
Lecture Notes in Computer Science, 1998
In this paper, we present a possible way h o w a precise semantics of objectoriented modeling techniques can be achieved, and what the possible bene ts are. We outline the main modeling techniques used in the SysLab project, sketch, how a precise semantics can be given, and how this semantics can be used during the development process.
OPUS: a Calculus for Modelling Object-Oriented Concepts
We propose a very concise calculus for modelling object-oriented concepts such as objects, message sending, encapsulation and incremental modification. We show how to deal with recursion and provide some object-oriented examples. State and encapsulated inheritance are modelled by means of an incremental modification operator.
An algebraic semantic framework for object oriented languages with concurrency (extended abstract)
Formal Aspects of Computing, 1996
This paper presents an algebraic semantics schema for object oriented languages including concurrent features. A class, the basic syntactic unit of an object oriented language, in our approach denotes a set of algebras determined by an algebraic specification. This specification describes a system of (possibly active) objects interacting via method calls. Extending other approaches, structured classes are modelled in a fully compositional way. This means that the semantic counterpart of class combinators such as inheritance and clientship are specification combinators. A model of records with sharing allows us to describe typical object oriented features like object sharing, inheritance polymorphism and dynamic binding. For modelling the dynamic behaviour of objects, we rely on an algebraic description of labelled transition systems.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.