Names

1
Chapter 5
Names Bindings Type Checking Scope
2
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

3
Ease of Programming

• The driving problem in programming language
  design
• Names
• Control Flow
• Types
• Subroutines
• Object Orientation
• Concurrency
• Declarative Programming

4
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

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
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 user-defined name

7
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

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
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
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
Strong Typing
Allows the detection of the misuses of variables
that result in type errors. C and C dont have
strong typing parameter type checking can be
avoided unions are not type checked (Java is
similar)
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
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
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
Static Scoping

• Java example

Time t new Time(Feb 1 2002) System.out.print
ln(t) t new Time(Jan 30 2002) System.out.p
rintln(t) t new Time(Jan 28
2002) Time.mysteriousMethod(t) System.out.prin
tln(t)
16
Nested SubroutinesClosest Nested Subroutine Rule
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
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
19
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

20
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

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
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
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. Javas StringBuffer
• 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

24
Object Lifetime

• Events in the life of an object
• Creation
• Destruction

• 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

25
Storage Allocation Mechanisms

• In static allocation, objects are given an
  absolute address that is retained throughout the
  programs execution
• E.g. Global variables, Non-recursive Subroutine
  Parameters

26
Storage Allocation Mechanisms

• In static allocation, (static) objects are given
  an absolute address that is retained throughout
  the programs 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

27
Static Allocation Example

• Calculator language example

Memory
read A read B sum A B write sum
A
B
sum
28
Storage Allocation Mechanisms

• In static allocation, (static) objects are given
  an absolute address that is retained throughout
  the programs 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

29
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

30
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

31
End of Lecture

• Read Chapter 5