Names and Bindings
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
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
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?
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
Variables
 Abstraction of a computer memory cell or collection of cells
 Made up of six attributes:
 Name
 Address
 Value
 Type
 Lifetime
 Scope
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
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 -2147483648 to 2147483647
 Arithmetic operations +, -,*, /,%
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
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
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
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
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
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?
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)
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
Type Inference
 Not by assignment, but by context
 E.g ML function declaration:
 Fun circumf(r) = 3.14159 * 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
Allocation and Deallocation
 Allocation
 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
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
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)
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)
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
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