1. Names and Bindings

2. Names
A name is a string of characters used to identify some entity in a program
Several design choices are involved even in specifying allowable names
Case sensitivity
Minimum or maximum length
Connectors
Treatment of special words

3. Length If too short, names cannot be connotative
If too long, extra space required for the symbol table
Some examples:
FORTRAN I: maximum 6
COBOL: maximum 30
FORTRAN 90 and ANSI C: maximum 31
Ada and Java: no limit, and all are significant
C++: technically no limit, but implementers often impose one

4. Names continued
Most PLs have the same form for names: a letter followed by a string of letter, digits and underscores
Underscores very popular in 1970s and 1980s to represent spaces
Replaced in C-based languages by camel notation
Prior to Fortran90, names could contain spaces
C-based languages are case sensitive
Detriment to readability?
Writability questionable?

5. Special Words Aid in readability
Used to delimit or separate statement clauses
Keyword is special only in certain contexts
Fortran is the only remaining widely used language whose special words are keywords
Reserved words cannot be used as names
Cannot be redefined
Potentially less confusing, but too many means user has trouble making up new ones
Predefined names are between special words and user- defined names
Can be redefined

6. Variables Abstraction of a computer memory cell or collection of cells
Made up of six attributes:
Name
Address
Value
Type
Lifetime
Scope

7. Address of a Variable
The machine memory address with which a variable is associated
Can change during the course of execution
Different addresses at different times during execution
Different addresses at different locations in a program
Sometimes referred to as l-value
left-hand side of an assignment
Multiple variables can have the same address, in which case the variables are called aliases
Hindrance to readability
Can be created in several ways

8. Variable Type Determines range of values the variable can store
Determines the set of operations that are defined for values of that type
E.g. int of Java specifies:
Range of to
Arithmetic operations +, -,*, /,%

9. Variable Value
The contents of the memory cell or cells associated with the variable
Abstract memory cell has the size required by the variable with which it is associated
The value of each simple, non-structured type is considered to occupy a single abstract memory cell
E.g. Though a floating point number may occupy 4 physical bytes, the value is thought of as occupying a single abstract memory cell`
R-value, since this is what is required when used on the RHS of an assignment statement

10. Binding A binding is an association
Attribute and an entity
Operation and a symbol
The time when the association takes place is the binding time
Both binding and binding time are important for semantics of programming languages

11. Possible Binding Times
Language design time -- bind operator symbols to operations
Language implementation time -- bind floating point type to a representation
Compile time -- bind a variable to a type in C or Java
Load time -- bind a FORTRAN 77 variable to a memory cell (or a C static variable)
Runtime -- bind a nonstatic local variable to a memory cell

12. Java assignment example
Count = count + 5;
Type of count bound at compile time
Set of possible values bound at compiler design time
Meaning of + bound at compile time (when types of operands have been determined)
Internal representation of literal 5 bound at compiler design time
Value of count is bound at execution time with this statement

13. Static vs. Dynamic Bindings
Static binding
First occurs before run time AND
Remains unchanged throughout program execution
Dynamic binding
First occurs at run time OR
Can change in the course of program execution

14. Type Binding
Before a variable can be referenced in a program, it must be bound to a data type
Two questions:
When does type binding take place?
How is type specified?

15. Static Type Binding
Explicit declaration lists variable names and specifies that they are a particular type
Implicit declaration associates variables with types though default conventions
First appearance constitutes its implicit declaration
Both versions in use today
Advantage of implicit: writability
Disadvantage: reliability (though less so in Perl)

16. Dynamic Type Binding
Type of variable is determined when it is assigned a value
Advantage
Programming flexibility
Disadvantages
Reduced reliability
Cost
Usually implemented in languages with interpreters rather than compilers

17. Type Inference Not by assignment, but by context
E.g ML function declaration:
Fun circumf(r) = * r * r
Floating point (real) type inferred from the constant
Fun square(x) = x * x
Arithmetic operator * indicates numeric type, so return type and arguments are default numeric type int

18. Allocation and Deallocation
Process by which an available memory cell is taken from a pool of available memory and bound to a variable
Deallocation
Process of placing a memory cell that has been unbound from a variable back to the pool of available memory

19. Lifetime
The time during which the variable is bound to a specific memory location
Scalar variables fall into four categories based on their lifetimes:
Static
Stack-dynamic
Explicit heap-dynamic
Implict heap-dynamic

20. Static Variables
Bound to memory locations before program execution begins
Remain bound throughout the program execution
Advantages:
Efficiency through direct accessing
History sensitive subprogram support
Disadvantages
Reduced flexibility (no recursion, no shared storage)

21. Stack-Dynamic Variables
Storage bindings are created when their declaration statements are elaborated, but type is dynamically bound
Elaboration refers to the storage allocations and binding process indicated by the declaration
Occurs during run-time
If scalar, all attributes except address are statically bound
Advantages
Allows recursion, conserves storage
Disadvantages
Overhead of allocation and deallocation
Subprograms cannot be history sensitive
Inefficient references (indirect addressing)

22. Explicit Heap-Dynamic Variables
Allocated and deallocated 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

23. Implicit Heap-Dynamic Variables
Bound to heap storage only when they are assigned values (i.e. assignment statements)
E.g. all strings and arrays in Perl and JavaScript
Advantage
Extremely flexible
Disadvantage
Inefficient, since all attributes are dynamic
Loss of error detection