1. 1 Chapter 5 Names Bindings Type Checking Scope

2. 2 High-Level Programming Languages Two main goals:Two main goals: –Machine independence –Ease of programming High-level programming language are independent of any particular instruction setHigh-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

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

4. 4 Naming Naming is the process by which the programmer associates a name with a potentially complicated program fragmentNaming 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 abstractionNaming provides abstraction –E.g. Mathematics is all about the formal notation (i.e. naming) that lets us explore more and more abstract concepts

5. 5 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

6. 6 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 user- defined name Variable Names

7. 7 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 Variable Names

8. 8 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)

9. 9 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 Categories of variables by lifetimes

10. 10 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

11. 11 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)

12. 12 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

13. 13 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

14. 14 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;... }

15. 15 Static Scoping Java exampleJava 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.mysteriousMethod(t)System.out.println(t);

16. 16 Nested Subroutines Closest Nested Subroutine Rule

17. 17 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

18. 18 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 Referencing Environments

19. 19 Control and Data Abstraction Control abstraction allows the programmer to hide an arbitrarily complicated code behind a simple interfaceControl 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 operationsData Abstraction allows the programmer to hide data representation details behind abstract operations –ADTs –Classes

20. 20 Binding Time A binding is an association between two thingsA 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 createdBinding 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

21. 21 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)

22. 22 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

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

24. 24 Events in the life of a bindingEvents 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 Object Lifetime Events in the life of an objectEvents in the life of an object –Creation –Destruction

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

26. 26 Storage Allocation Mechanisms In static allocation, (static) objects are given an absolute address that is retained throughout the program’s executionIn 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.In stack-based allocation, (stack) objects are allocated in last-in, first-out data structure, a stack. –E.g. Recursive subroutine parameters

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

28. 28 Storage Allocation Mechanisms In static allocation, (static) objects are given an absolute address that is retained throughout the program’s executionIn 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.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 timesIn heap-based allocation, (heap) objects may be allocated and deallocated at arbitrary times –E.g. objects created with C++ new and delete

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

30. 30 Heap Space Management In general, the heap is allocated sequentiallyIn general, the heap is allocated sequentially This creates space fragmentation problemsThis 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 collectionAutomatic de-allocation after an object has no bindings is called garbage collection –E.g. Java

31. 31 End of Lecture Read Chapter 5Read Chapter 5