Chapter 5 Names Bindings Type Checking Scope 1

High-Level Programming Languages • Two main goals: – Machine independence – Ease of programming • High-level programming language are independent of any particular instruction set – But compilation to assembly code requires a target instruction set – There is a trade-off between machine independence and efficiency » E. g. Java vs. C 2

Ease of Programming • The driving problem in programming language design – Names – Control Flow – Types – Subroutines – Object Orientation – Concurrency – Declarative Programming Language 3

Naming • Naming is the process by which the programmer associates a name with a potentially complicated program fragment – The goal is to hide complexity – Programming languages use name to designate variables, types, classes, methods, operators, … • Naming provides abstraction – E. g. Mathematics is all about the formal notation (i. e. naming) that lets us explore more and more abstract concepts 4

Variable Names Design issues - What should the maximum length be? Are connector characters allowed? Are names case sensitive? Are special words reserved words or keywords? Length - FORTRAN I: maximum 6 COBOL: maximum 30 FORTRAN 90 and ANSI C: maximum 31 Ada: no limit, and all are significant C++: no limit, but implementers often impose one 5

Variable Names Case sensitivity Disadvantage: readability (names that look alike are different) • C, C++, Java, and Modula-2 names are case sensitive • The names in other languages are not Special words A keyword is a word that is special only in certain contexts Disadvantage: poor readability A reserved word is a special word that cannot be used as a userdefined name 6

Variable Names A variable is an abstraction of a memory cell Variables can be characterized as a collection of attributes: name, address, value, type, lifetime, and scope Name - not all variables have them Address - the memory address with which it is associated • A variable may have different addresses at different times during execution • A variable may have different addresses at different places in a program • If two variable names can be used to access the same memory location, they are called aliases 7

Categories of variables by lifetimes Static--bound to memory cells before execution begins and remains bound to the same memory cell throughout execution. e. g. C static variables Advantage: efficiency (direct addressing) Disadvantage: lack of flexibility (no recursion) Stack-dynamic--Storage bindings are created for variables when their declaration statements are elaborated. Advantage: allows recursion; conserves storage Disadvantages: - Overhead of allocation and de-allocation - Subprograms cannot be history sensitive - Inefficient references (indirect addressing) 8

Categories of variables by lifetimes Explicit heap-dynamic--Allocated and de-allocated by explicit directives, specified by the programmer, which take effect during execution • Referenced only through pointers or references e. g. dynamic objects in C++ (via new and delete) all objects in Java Advantage: provides for dynamic storage management Disadvantage: inefficient and unreliable Implicit heap-dynamic--Allocation and de-allocation caused by assignment statements Advantage: flexibility Disadvantages: - Inefficient, because all attributes are dynamic - Loss of error detection 9

Type Checking Type checking is the activity of ensuring that the operands of an operator are of compatible types A compatible type is one that is either legal for the operator, or is allowed under language rules to be implicitly converted, by compiler -generated code, to a legal type. This automatic conversion is called a coercion. A type error is the application of an operator to an operand of an inappropriate type • If all type bindings are static, nearly all type checking can be static • If type bindings are dynamic, type checking must be dynamic A programming language is strongly typed if type errors are always detected 10

Strong Typing Allows the detection of the misuses of variables that result in type errors. C and C++ don’t have strong typing: parameter type checking can be avoided; unions are not type checked (Java is similar) 11

Type Compatibility Type compatibility by name means the two variables have compatible types if they are in either the same declaration or in declarations that use the same type name - Easy to implement but highly restrictive - Sub-ranges of integer types are not compatible with integer types - Formal parameters must be the same type as their corresponding actual parameters (Pascal) Type compatibility by structure means that two variables have compatible types if their types have identical structures - More flexible, but harder to implement 12

Scope The scope of a variable is the range of statements over which it is visible The non-local variables of a program unit are those that are visible but not declared there The scope rules of a language determine how references to names are associated with variables Static scope Based on program text. To connect a name reference to a variable, the compiler must find the declaration. Search process: search declarations, first locally, then in increasingly larger enclosing scopes, until one is found for the given name Enclosing static scopes (to a specific scope) are called its static ancestors; the nearest static ancestor is called a static parent 13

Scope Variables can be hidden from a unit by having a "closer" variable with the same name C++ allows access to these "hidden" variables Blocks - a method of creating static scopes inside program units Examples: C and C++: for (. . . ) { int index; . . . } 14

Static Scoping • Java example Time t = new Time(“Feb 1 2002”); System. out. println(t); t = new Time(“Jan 30 2002”); System. out. println(t); t = new Time(“Jan 28 2002”); Time. mysterious. Method(t) System. out. println(t); 15

Nested Subroutines Closest Nested Subroutine Rule 16

Referencing Environments The referencing environment of a statement is the collection of all names that are visible in the statement In a static scoped language, that is the local variables plus all of the visible variables in all of the enclosing scopes A subprogram is active if its execution has begun but has not yet terminated In a dynamic-scoped language, the referencing environment is the local variables plus all visible variables in all active subprograms 17

Referencing Environments A named constant is a variable that is bound to a value only when it is bound to storage Advantages: readability and modifiability The binding of values to named constants can be either static (called manifest constants) or dynamic Variable Initialization The binding of a variable to a value at the time it is bound to storage is called initialization Initialization is often done on the declaration statement 18

Control and Data Abstraction • Control abstraction allows the programmer to hide an arbitrarily complicated code behind a simple interface – Subroutines – Classes • Data Abstraction allows the programmer to hide data representation details behind abstract operations – ADTs – Classes 19

Binding Time • A binding is an association between two things – E. g. Name of an object and the object • Binding time is the time at which a binding is created – Language design time – Language implementation – Program writing time – Compile Time – Link Time – Load Time – Run Time 20

Static vs. Dynamic Binding A binding is static if it occurs before run time and remains unchanged throughout program execution. A binding is dynamic if it occurs during execution or can change during execution of the program. Type Bindings 1. How is a type specified? 2. When does the binding take place? • An explicit declaration is a program statement used for declaring the types of variables • An implicit declaration is a default mechanism for specifying types of variables (the first appearance of the variable in the program) 21

Dynamic Type Binding Advantage: flexibility (generic program units) Disadvantages: 1. High cost (dynamic type checking and interpretation) 2. Type error detection by the compiler is difficult Type Inferencing (ML, Miranda, and Haskell) Rather than by assignment statement, types are determined from the context of the reference Storage Bindings Allocation - getting a cell from some pool of available cells Deallocation - putting a cell back into the pool The lifetime of a variable is the time during which it is bound to a particular memory cell 22

Binding Time Impact • Binding times have a crucial impact in programming languages – They are a fundamental design decision • In general, early binding is associated with greater efficiency – E. g. C string vs. Java’s String. Buffer • In general, late binding is associated with greater flexibility – E. g. Class method vs. Subroutine • Compiled languages tend to bind names earlier than interpreted languages 23

Object Lifetime • Events in the life of an object – Creation – Destruction Object Lifetime • Events in the life of a binding – Creation – Destruction » A binding to an object that no longer exists is called a dangling reference – Deactivation and Reactivation 24

Storage Allocation Mechanisms • In static allocation, objects are given an absolute address that is retained throughout the program’s execution – E. g. Global variables, Non-recursive Subroutine Parameters 25

Storage Allocation Mechanisms • In static allocation, (static) objects are given an absolute address that is retained throughout the program’s execution – E. g. Global variables, Non-recursive Subroutine Parameters • In stack-based allocation, (stack) objects are allocated in last-in, first-out data structure, a stack. – E. g. Recursive subroutine parameters 26

Static Allocation Example • Calculator language example Memory read A read B sum : = A + B write sum Size of Integer A B sum 27

Storage Allocation Mechanisms • In static allocation, (static) objects are given an absolute address that is retained throughout the program’s execution – E. g. Global variables , Non-recursive Subroutine Parameters • In stack-based allocation, (stack) objects are allocated in last-in, first-out data structure, a stack. – E. g. Subroutine parameters • In heap-based allocation, (heap) objects may be allocated and deallocated at arbitrary times – E. g. objects created with C++ new and delete 28

Heap-based Allocation • The heap is a region of storage in which sub-block can be allocated and deallocated – This not the heap data structure 29

Heap Space Management • In general, the heap is allocated sequentially • This creates space fragmentation problems – Internal fragmentation » If size of object to allocated is larger than the size of the available heap – External fragmentation » If size of object to allocated is not larger than the size of the available heap, but the available space in the heap is scaterred through the head in such a way that no contiguous allocation is possible • Automatic de-allocation after an object has no bindings is called garbage collection – E. g. Java 30

End of Lecture • Read Chapter 5 31