On the Notion of Inheritance [Pdf]

Total Page:16

File Type:pdf, Size:1020Kb

On the Notion of Inheritance [Pdf] On the Notion of Inheritance ANTERO TAIVALSAARI Nokia Research Center One of the most intriguing—and at the same time most problematic—notions in object-oriented programming is inheritance. Inheritance is commonly regarded as the feature that distinguishes object-oriented programming from other modern programming paradigms, but researchers rarely agree on its meaning and usage. Yet inheritance is often hailed as a solution to many problems hampering software development, and many of the alleged benefits of object-oriented programming, such as improved conceptual modeling and reusability, are largely credited to it. This article aims at a comprehensive understanding of inheritance, examining its usage, surveying its varieties, and presenting a simple taxonomy of mechanisms that can be seen as underlying different inheritance models. Categories and Subject Descriptors: D.1.5. [Programming Techniques]: Object- Oriented Programming; D.3.2. [Programming Languages]: Language Classifications object-oriented languages; D.3.3. [Programming Languages]: Language Constructs and Features General Terms: Languages Additional Key Words and Phrases: Delegation, incremental modification, inheritance, language constructs, object-oriented programming, programming languages 1. INTRODUCTION only currently well-developed and widely accepted area seems to be the A characteristic feature of object-ori- theory of inheritance in terms of denota- ented programming is inheritance. In- tional semantics [Cook 1989a; Cook and heritance is often regarded as the fea- Palsberg 1989; Reddy 1988]. ture that distinguishes object-oriented Despite the fact that much effort has programming from other modern pro- been targeted on research into inheri- gramming paradigms, and many of the tance in the past years, it seems that alleged benefits of object-oriented pro- inheritance is still often inadequately gramming, such as improved conceptual understood. Many studies of inheritance modeling and reusability, are largely concentrate only on one specific view- accredited to it. Despite its central role point, such as type theory or conceptual in current object-oriented systems, in- modeling, and mostly ignore the other heritance is still quite a controversial possible viewpoints. Depending on the mechanism, and researchers tend to dis- viewpoint, inheritance is regarded ei- agree on its meaning and usage. The ther as a structuring or modeling mech- Author’s address: Nokia Research Center, P.O. Box 45, 00211 Helsinki; Finland; email: antero. [email protected]. Permission to make digital/hard copy of part or all of this work for personal or classroom use is granted without fee provided that the copies are not made or distributed for profit or commercial advantage, the copyright notice, the title of the publication, and its date appear, and notice is given that copying is by permission of the ACM, Inc. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee. © 1996 ACM 0360-0300/96/0900–0438 $03.50 ACM Computing Surveys, Vol. 28, No. 3, September 1996 On the Notion of Inheritance • 439 anism for reasoning about programs, or currently used synonyms for inheri- a mechanism for code sharing and re- tance in object-oriented systems are use. It seems that a more general, com- subclassing, derivation (in C11) and prehensive view of inheritance is still prefixing (in Simula and Beta); in some missing. The main motivation for this papers the term subtyping is also used article was the desire to reach a more in the same meaning [Halbert and thorough understanding of inheritance O’Brien 1987], although more commonly from different viewpoints. that term is reserved for another pur- This article provides a comprehensive pose, as will be discussed in Section introduction to inheritance, starting 2.2.2. from its history and conceptual back- The basic idea of inheritance is sim- ground, examining its intended and ac- ple. Inheritance allows new object defi- tual usage, and discussing its essence in nitions to be based upon existing ones; light of the current knowledge. Further- when a new kind of an object class is to more, the varieties of inheritance are be defined, only those properties that analyzed, and a simple taxonomy of in- differ from the properties of the speci- heritance mechanisms is presented. fied existing classes need to be declared This article is a continuation to an ear- explicitly, while the other properties are lier article on object-oriented program- automatically extracted from the exist- ming [Taivalsaari 1993a], and part of a ing classes and included in the new larger study of inheritance, published class. Thus, inheritance is a facility for as the author’s doctoral thesis [Taival- differential,orincremental program de- saari 1993c]. velopment. Formally, inheritance can be characterized as follows [Bracha and 2. INHERITANCE Cook 1990; Cook 1989a; Wegner and Zdonik 1988]: If I have seen a little farther than others, it is because I have stood on the shoulders of giants. R 5 P % DR. —ISAAC NEWTON In this maxim, R denotes a newly 2.1 Definitions defined object or class, P denotes the properties inherited from an existing In general, to inherit is to receive prop- object or class, DR denotes the incre- erties or characteristics of another, nor- mentally added new properties that dif- mally as a result of some special rela- ferentiate R from P (the delta part), and tionship between the giver and the Q denotes an operation to somehow receiver [Danforth and Tomlinson combine DR with the properties of P.As 1988]. This broad definition of inheri- a result of this combination, R will con- tance comes from the usage of the term tain all the properties of P, except that in the real world, and at the first con- the incremental modification part DR sideration it seems to have very little to may introduce properties that overlap do with computers. Nevertheless, in the with those of P so as to redefine or context of programming, inheritance defeat (cancel) certain properties of P; was introduced as early as in the end of thus, R may not always be fully compat- the 1960s as a central feature of the ible with P. Compatibility issues will be programming language Simula [Dahl et discussed in Section 2.2.2. al. 1968]. However, Simula’s inheri- There are certain terms and notions tance mechanism was originally known pertaining to inheritance that will be by a different name, concatenation used throughout the article. For in- [Dahl et al. 1972, pp. 202–204; Nygaard stance, in the maxim above, P is known and Dahl 1978], and the intuitively as R’s parent or immediate ancestor;in more appealing term inheritance was class-based systems the corresponding invented some years later. Well-known term is superclass. Similarly, R is P’s ACM Computing Surveys, Vol. 28, No. 3, September 1996 440 • Antero Taivalsaari Figure 1. A simple example of inheritance. child, immediate descendant,orin dow and adds a new variable called title class-based systems its subclass. Inher- plus a method that redefines frame itance relationships are transitive, so drawing. The actual implementation of that a parent or superclass may be a the methods is elided. child or subclass of another object or In its basic form, inheritance can be class. This implies that in addition to characterized formally as record combi- incrementally defined properties, an ob- nation [Bracha and Lindstrom 1992; ject will contain all the properties of its Cardelli 1984; Cook 1989a]. An object or parents, parents’ parents and so on. The a class that inherits the properties of terms ancestor and descendant are used another is viewed as a record which is in the obvious manner to denote the otherwise similar to its parent, but immediate and nonimmediate parents which has been extended with some ad- and children of a class. ditional properties. This record combi- Most modern object-oriented systems nation can take place in several differ- allow inheritance from several parents ent ways, however. For instance, in at the same time. Such inheritance is class-based object-oriented systems (see known as multiple inheritance,asop- Section 3.1) the properties of an object posed to single inheritance discussed are typically located physically in differ- above. As multiple inheritance offers ent places, and this tends to make the considerably more possibilities for in- analysis more complicated. Further- cremental modification than single in- more, other issues such as early binding heritance, a generally accepted view is and encapsulation also encumber the that a modern object-oriented language analysis of inheritance. In general, in- should support it, despite the fact that heritance is not an independent lan- multiple inheritance also introduces guage feature, but it usually operates in many conceptual and technical intrica- tight interaction with other language cies. Issues pertaining to multiple in- mechanisms. heritance will be discussed briefly in the following section. For different defini- 2.2 Conceptual View of Inheritance tions of inheritance, refer to Cardelli [1984]; Cook [1989a]; Wegner [1987]; To attain knowledge, add things every day; to Wegner and Zdonik [1988]. obtain wisdom, remove things every day. As an example of inheritance, con- —LAO-TZU, Tao Te Ching sider the following pseudocode defini- tion (Figure 1). In the example, two A programming language is a notation classes, Window and TitleWindow, are and, as such, serves to record and assist defined. Class Window defines one vari- the development of human thought in a able, frame, and two operations (meth- particular direction. For a notation to be ods) drawFrame and drawContents. effective, it must carry a mental load for Class TitleWindow inherits class Win- the user and must have, among other ACM Computing Surveys, Vol. 28, No. 3, September 1996 On the Notion of Inheritance • 441 properties, economy and the ability to at the basic conceptual modeling rela- subordinate detail [Marcotty and tionships in order to elucidate the role Ledgard 1991].
Recommended publications
  • Equal Rights for Functional Objects Or, the More Things Change, The
    ACM OOPS Messenger 4,4 (Oct. 1993), 2-27. Equal Rights for Functional Objects1 or, The More Things Change, The More They Are the Same2 Henry G. Baker Nimble Computer Corporation 16231 Meadow Ridge Way, Encino, CA 91436 (818) 986-1436 (818) 986-1360 FAX August, October, 1990, October, 1991, and April, 1992 This work was supported in part by the U.S. Department of Energy Contract No. DE-AC03-88ER80663 We argue that intensional object identity in object-oriented programming languages and databases is best defined operationally by side-effect semantics. A corollary is that "functional" objects have extensional semantics. This model of object identity, which is analogous to the normal forms of relational algebra, provides cleaner semantics for the value-transmission operations and built-in primitive equality predicate of a programming language, and eliminates the confusion surrounding "call-by-value" and "call-by-reference" as well as the confusion of multiple equality predicates. Implementation issues are discussed, and this model is shown to have significant performance advantages in persistent, parallel, distributed and multilingual processing environments. This model also provides insight into the "type equivalence" problem of Algol-68, Pascal and Ada. 1. INTRODUCTION Parallel, distributed and persistent programming languages are leaving the laboratories for more wide-spread use. Due to the substantial differences between the semantics and implementations of these languages and traditional serial programming languages, however, some of the most basic notions of programming languages must be refined to allow efficient, portable implementations. In this paper, we are concerned with defining object identity in parallel, distributed and persistent systems in such a way that the intuitive semantics of serial implementations are transparently preserved.
    [Show full text]
  • The Evolution of Lisp
    1 The Evolution of Lisp Guy L. Steele Jr. Richard P. Gabriel Thinking Machines Corporation Lucid, Inc. 245 First Street 707 Laurel Street Cambridge, Massachusetts 02142 Menlo Park, California 94025 Phone: (617) 234-2860 Phone: (415) 329-8400 FAX: (617) 243-4444 FAX: (415) 329-8480 E-mail: [email protected] E-mail: [email protected] Abstract Lisp is the world’s greatest programming language—or so its proponents think. The structure of Lisp makes it easy to extend the language or even to implement entirely new dialects without starting from scratch. Overall, the evolution of Lisp has been guided more by institutional rivalry, one-upsmanship, and the glee born of technical cleverness that is characteristic of the “hacker culture” than by sober assessments of technical requirements. Nevertheless this process has eventually produced both an industrial- strength programming language, messy but powerful, and a technically pure dialect, small but powerful, that is suitable for use by programming-language theoreticians. We pick up where McCarthy’s paper in the first HOPL conference left off. We trace the development chronologically from the era of the PDP-6, through the heyday of Interlisp and MacLisp, past the ascension and decline of special purpose Lisp machines, to the present era of standardization activities. We then examine the technical evolution of a few representative language features, including both some notable successes and some notable failures, that illuminate design issues that distinguish Lisp from other programming languages. We also discuss the use of Lisp as a laboratory for designing other programming languages. We conclude with some reflections on the forces that have driven the evolution of Lisp.
    [Show full text]
  • Comparative Studies of 10 Programming Languages Within 10 Diverse Criteria
    Department of Computer Science and Software Engineering Comparative Studies of 10 Programming Languages within 10 Diverse Criteria Jiang Li Sleiman Rabah Concordia University Concordia University Montreal, Quebec, Concordia Montreal, Quebec, Concordia [email protected] [email protected] Mingzhi Liu Yuanwei Lai Concordia University Concordia University Montreal, Quebec, Concordia Montreal, Quebec, Concordia [email protected] [email protected] COMP 6411 - A Comparative studies of programming languages 1/139 Sleiman Rabah, Jiang Li, Mingzhi Liu, Yuanwei Lai This page was intentionally left blank COMP 6411 - A Comparative studies of programming languages 2/139 Sleiman Rabah, Jiang Li, Mingzhi Liu, Yuanwei Lai Abstract There are many programming languages in the world today.Each language has their advantage and disavantage. In this paper, we will discuss ten programming languages: C++, C#, Java, Groovy, JavaScript, PHP, Schalar, Scheme, Haskell and AspectJ. We summarize and compare these ten languages on ten different criterion. For example, Default more secure programming practices, Web applications development, OO-based abstraction and etc. At the end, we will give our conclusion that which languages are suitable and which are not for using in some cases. We will also provide evidence and our analysis on why some language are better than other or have advantages over the other on some criterion. 1 Introduction Since there are hundreds of programming languages existing nowadays, it is impossible and inefficient
    [Show full text]
  • Structure of Programming Languages – Lecture 2A
    Structure of Programming Languages { Lecture 2a CSCI 6636 { 4536 February 4, 2020 CSCI 6636 { 4536 Lecture 2a. 1/19 February 4, 2020 1 / 19 Outline 1 Overview of Languages 2 Language Properties 3 Good or Bad: Fundamental Considerations 4 Homework CSCI 6636 { 4536 Lecture 2a. 2/19 February 4, 2020 2 / 19 Outline The Language Landscape Languages Come in Many Flavors. Possible Design Goals Design Examples Representation Issues CSCI 6636 { 4536 Lecture 2a. 3/19 February 4, 2020 3 / 19 Overview of Languages What is a Program? We can view a program two ways: Developer's view: A program is the implementation of a design (a model) for a piece of software. Coder's view: A program is a description of a set of actions that we want a computer to carry out on some data. Similarly, we can view a language more than one way: High level: It permits us to express a model. Low level: It permits us to define a correct set of instructions for the computer. CSCI 6636 { 4536 Lecture 2a. 4/19 February 4, 2020 4 / 19 Overview of Languages Aspects of a Language. To use a language effectively we must learn these four aspects: Syntax is the set legal forms that a sentence or program unit may take. During translation, if the syntax of a program unit is legal (correct), then we can talk about the semantics of the unit. Semantics is the science of meaning. Operational semantics is the set of actions when a program is executed. Style is a set of human factors.
    [Show full text]
  • Multiparadigm Programming with Python 3 Chapter 5
    Multiparadigm Programming with Python 3 Chapter 5 H. Conrad Cunningham 7 September 2018 Contents 5 Python 3 Types 2 5.1 Chapter Introduction . .2 5.2 Type System Concepts . .2 5.2.1 Types and subtypes . .2 5.2.2 Constants, variables, and expressions . .2 5.2.3 Static and dynamic . .3 5.2.4 Nominal and structural . .3 5.2.5 Polymorphic operations . .4 5.2.6 Polymorphic variables . .5 5.3 Python 3 Type System . .5 5.3.1 Objects . .6 5.3.2 Types . .7 5.4 Built-in Types . .7 5.4.1 Singleton types . .8 5.4.1.1 None .........................8 5.4.1.2 NotImplemented ..................8 5.4.2 Number types . .8 5.4.2.1 Integers (int)...................8 5.4.2.2 Real numbers (float)...............9 5.4.2.3 Complex numbers (complex)...........9 5.4.2.4 Booleans (bool)..................9 5.4.2.5 Truthy and falsy values . 10 5.4.3 Sequence types . 10 5.4.3.1 Immutable sequences . 10 5.4.3.2 Mutable sequences . 12 5.4.4 Mapping types . 13 5.4.5 Set Types . 14 5.4.5.1 set ......................... 14 5.4.5.2 frozenset ..................... 14 5.4.6 Other object types . 15 1 5.5 What Next? . 15 5.6 Exercises . 15 5.7 Acknowledgements . 15 5.8 References . 16 5.9 Terms and Concepts . 16 Copyright (C) 2018, H. Conrad Cunningham Professor of Computer and Information Science University of Mississippi 211 Weir Hall P.O. Box 1848 University, MS 38677 (662) 915-5358 Browser Advisory: The HTML version of this textbook requires a browser that supports the display of MathML.
    [Show full text]
  • Object-Oriented Type Inference
    Object-Oriented Type Inference Jens Palsberg and Michael I. Schwartzbach [email protected] and [email protected] Computer Science Department, Aarhus University Ny Munkegade, DK-8000 Arh˚ us C, Denmark Abstract The algorithm guarantees that all messages are un- derstood, annotates the program with type infor- We present a new approach to inferring types in un- mation, allows polymorphic methods, and can be typed object-oriented programs with inheritance, used as the basis of an optimizing compiler. Types assignments, and late binding. It guarantees that are finite sets of classes and subtyping is set in- all messages are understood, annotates the pro- clusion. Given a concrete program, the algorithm gram with type information, allows polymorphic methods, and can be used as the basis of an op- constructs a finite graph of type constraints. The timizing compiler. Types are finite sets of classes program is typable if these constraints are solvable. and subtyping is set inclusion. Using a trace graph, The algorithm then computes the least solution in our algorithm constructs a set of conditional type worst-case exponential time. The graph contains constraints and computes the least solution by least all type information that can be derived from the fixed-point derivation. program without keeping track of nil values or flow analyzing the contents of instance variables. This 1 Introduction makes the algorithm capable of checking most com- mon programs; in particular, it allows for polymor- phic methods. The algorithm is similar to previous Untyped object-oriented languages with assign- work on type inference [18, 14, 27, 1, 2, 19, 12, 10, 9] ments and late binding allow rapid prototyping be- in using type constraints, but it differs in handling cause classes inherit implementation and not spec- late binding by conditional constraints and in re- ification.
    [Show full text]
  • Type Inference for Late Binding. the Smalleiffel Compiler. Suzanne Collin, Dominique Colnet, Olivier Zendra
    Type Inference for Late Binding. The SmallEiffel Compiler. Suzanne Collin, Dominique Colnet, Olivier Zendra To cite this version: Suzanne Collin, Dominique Colnet, Olivier Zendra. Type Inference for Late Binding. The SmallEiffel Compiler.. Joint Modular Languages Conference (JMLC), 1997, Lintz, Austria. pp.67–81. inria- 00563353 HAL Id: inria-00563353 https://hal.inria.fr/inria-00563353 Submitted on 4 Feb 2011 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Typ e Inference for Late Binding. The SmallEiel Compiler. Suzanne COLLIN, Dominique COLNET and Olivier ZENDRA Campus Scientique, Bâtiment LORIA, Boîte Postale 239, 54506 Vando euvre-lès-Nancy Cedex France Tel. +33 03 83.59.20.93 Email: [email protected] Centre de Recherche en Informatique de Nancy Abstract. The SmallEiel compiler uses a simple typ e inference mecha- nism to translate Eiel source co de to C co de. The most imp ortant asp ect in our technique is that many o ccurrences of late binding are replaced by static binding. Moreover, when dynamic dispatch cannot b e removed, inlining is still p ossible. The advantage of this approach is that it sp eeds up execution time and decreases considerably the amount of generated co de.
    [Show full text]
  • Introduction to Object-Oriented Programming (OOP)
    QUIZ Write the following for the class Bar: • Default constructor • Constructor • Copy-constructor • Overloaded assignment oper. • Is a destructor needed? Or Foo(x), depending on how we want the initialization to be made. Criticize! Ch. 15: Polymorphism & Virtual Functions Virtual functions enhance the concept of type. There is no analog to the virtual function in a traditional procedural language. As a procedural programmer, you have no referent with which to think about virtual functions, as you do with almost every text other feature in the language. Features in a procedural language can be understood on an algorithmic level, but, in an OOL, virtual functions can be understood only from a design viewpoint. Remember upcasting Draw the UML diagram! We would like the more specific version of play() to be called, since flute is a Wind object, not a generic Instrument. Ch. 1: Introduction to Objects Remember from ch.1 … Early binding vs. late binding “The C++ compiler inserts a special bit of code in lieu of the absolute call. This code calculates the text address of the function body, using information stored in the object at runtime!” Ch. 15: Polymorphism & Virtual Functions virtual functions To cause late binding to occur for a particular function, C++ requires that you use the virtual keyword when declaring the function in the base text class. All derived-class functions that match the signature of the base-class declaration will be called using the virtual mechanism. example It is legal to also use the virtual keyword in the derived-class declarations, but it is redundant and can be confusing.
    [Show full text]
  • Run Time Polymorphism Against Virtual Function in Object Oriented Programming
    Devaendra Gahlot et al, / (IJCSIT) International Journal of Computer Science and Information Technologies, Vol. 2 (1) , 2011, 569-571 Run Time Polymorphism Against Virtual Function in Object Oriented Programming #1 2 #3 Devendra Gahlot , S. S. Sarangdevot# , Sanjay Tejasvee #Department of Computer Application, Govt. Engineering College Bikaner, Bikaner, Rajasthan, India. #Depertment of IT & CS, Janardan Rai Nagar Rajasthan Vidyapeeth University, Pratap Nagar, Udaipur, Rajasthan, India) # Department of Computer Application,Govt. Engineering College Bikaner,Bikaner ,Rajasthan,India. Abstract- The Polymorphism is the main feature of Object same name and the same parameter sets in all the super classes, Oriented Programming. Run Time Polymorphism is concept of subclasses and interfaces. In principle, the object types may be late binding; means the thread of the program will be unrelated, but since they share a common interface, they are often dynamically executed, according to determination of the implemented as subclasses of the same super class. Though it is not compiler. In this paper, we will discuss the role of Run Time required, it is understood that the different methods will also produce Polymorphism and how it can be effectively used to increase the similar results (for example, returning values of the same type). efficiency of the application and overcome complexity of overridden function and pointer object during inheritance in Polymorphism is not the same as method overloading or method Object Oriented programming. overriding.[1] Polymorphism is only concerned with the application of specific implementations to an interface or a more generic base 1. INTRODUCTION TO POLYMORPHISM IN OBJECT- class. Method overloading refers to methods that have the same name ORIENTED PROGRAMMING but different signatures inside the same class.
    [Show full text]
  • Oaklisp: an Object-Oriented Scheme with First Class Types
    Oaklisp: an Object-Oriented Scheme with First Class Types Kevin J. l,ang and llarak A. Peaflmutter Department of Computer Science Carnegie-Mellon University Pittsburgh, PA 15213 Abstract several implications that are not immediately obvious. Because • The Scheme papers demonstrated that lisp could be made simpler function can be applied at a point distant in time and space from ilz and more expressive by elevating functions to the level of first class point of origin, it must be able to remember the bindings of any objects. Oaklisp shows that a message based language can derive variables that were visible when it was made. This additional similar benefits from having first class types. complexity is offset by the ability to write many previously primitive control structures at the user level and by the fact that the special Introduction mechanisms that lisp ordinarily uses for defining and applying Oaklisp is a message based, multiple inheritence dialect of lisp. functions can be dispensed with. Programs are written using lisp syntax, and traditional lisp data types In lisp, the car position of a function call is treated as the name of a coexist with a Smalltalk style class hierarchy. This paper assumes that function which is looked up in a special table and then applied to the the reader is familiar with one of the many object-oriented lisp dialects values obtained by evaluating the arguments of the call. In Scheme, the of this sort. and will therefore concentrate on the unique aspects of car of a call is an evaluated position. Although any expression can Oaklisp which are mostly due to the influence of Scheme.
    [Show full text]
  • TAPS Working Group T. Pauly, Ed. Internet-Draft Apple Inc. Intended Status: Standards Track B
    TAPS Working Group T. Pauly, Ed. Internet-Draft Apple Inc. Intended status: Standards Track B. Trammell, Ed. Expires: 13 January 2022 Google Switzerland GmbH A. Brunstrom Karlstad University G. Fairhurst University of Aberdeen C. Perkins University of Glasgow P. Tiesel SAP SE C.A. Wood Cloudflare 12 July 2021 An Architecture for Transport Services draft-ietf-taps-arch-11 Abstract This document describes an architecture for exposing transport protocol features to applications for network communication, the Transport Services architecture. The Transport Services Application Programming Interface (API) is based on an asynchronous, event-driven interaction pattern. It uses messages for representing data transfer to applications, and it describes how implementations can use multiple IP addresses, multiple protocols, and multiple paths, and provide multiple application streams. This document further defines common terminology and concepts to be used in definitions of Transport Services APIs and implementations. Status of This Memo This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79. Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet- Drafts is at https://datatracker.ietf.org/drafts/current/. Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress." Pauly, et al. Expires 13 January 2022 [Page 1] Internet-Draft TAPS Architecture July 2021 This Internet-Draft will expire on 13 January 2022.
    [Show full text]
  • Imperative Programming
    Naming, scoping, binding, etc. Instructor: Dr. B. Cheng Fall 2004 Organization of Programming Languages-Cheng (Fall 2004) 1 Imperative Programming ? The central feature of imperative languages are variables ? Variables are abstractions for memory cells in a Von Neumann architecture computer ? Attributes of variables ? Name, Type, Address, Value, … ? Other important concepts ? Binding and Binding times ? Strong typing ? Type compatibility rules ? Scoping rules Organization of Programming Languages-Cheng (Fall 2004) 2 Preliminaries ? Name: representation for something else ? E.g.: identifiers, some symbols ? Binding: association between two things; ? Name and the thing that it names ? Scope of binding: part of (textual) program that binding is active ? Binding time: point at which binding created ? Generally: point at which any implementation decision is made. Organization of Programming Languages-Cheng (Fall 2004) 3 1 Names (Identifiers) ? Names are not only associated with variables ? Also associated with labels, subprograms, formal parameters, and other program constructs ? Design issues for names: ? Maximum length? ? Are connector characters allowed? (“_”) ? Are names case sensitive? ? Are the special words: reserved words or keywords? Organization of Programming Languages-Cheng (Fall 2004) 4 Names ? Length ? If too short, they will not be connotative ? Language examples: ? FORTRAN I: maximum 6 ? COBOL: maximum 30 ? FORTRAN 90 and ANSI C (1989): maximum 31 ? Ansi C (1989): no length limitation, but only first 31 chars signifi cant ?
    [Show full text]