Untitled

• Imperative languages are abstractions of von Neumann architecture.
• Memory and processors are components of the von Neumann architecture.
• Variables are characterized by scope, lifetime, type checking, initialization, and type compatibility.

Names

• Design issues for names include case sensitivity and reserved words or keywords.
• Names that are too short cannot be connotative.
• FORTRAN 95 allows a maximum name length of 31 characters.
• C99 has no name length limit, but only the first 63 characters are significant; external names are limited to 31 characters.
• C#, Ada, and Java have no limit on name length, and all characters are significant.
• C++ has no limit on name length, but implementers often impose one.
• In PHP, all variable names must begin with dollar signs.
• In Perl, all variable names begin with special characters that specify the variable's type.
• In Ruby, variable names that begin with @ are instance variables, while those that begin with @@ are class variables.
• Case sensitivity in names can reduce readability because names that look alike are treated as different.
• C-based languages use case-sensitive names, while other languages do not.
• Special words aid readability and delimit or separate statement clauses.
• A keyword is special only in certain contexts, as in Fortran.
• A reserved word cannot be used as a user-defined name.
• COBOL has 300 reserved words, potentially leading to collisions.

Variables

• A variable is an abstraction of a memory cell.
• Variables are characterized by the sextuple of attributes: name, address, type, value, lifetime, and scope.
• Not all variables have names.
• Address is the memory address the variable is associated with.
• A variable may have different addresses at different times during execution or in different places within a program.
• Aliases occur when two variable names can access the same memory location, and are created via pointers, reference variables, and C/C++ unions.
• Aliases can harm readability.
• Type determines the range of values for a variable and the set of operations defined for values of that type, including precision for floating-point types.
• The value is the contents of the location with which the variable is associated.
• The "l-value" of a variable is its address.
• The "r-value" is the value of a variable.
• An abstract memory cell is the physical cell or collection of cells associated with a variable.

The Concept of Binding

• Binding is an association between an entity and an attribute.
• Binding time is the time at which a binding takes place.
• Language design time involves binding operator symbols to operations.
• Language implementation time involves binding floating-point types to a representation.
• Compile time involves binding a variable to a type in C or Java.
• Load time involves binding a C or C++ static variable to a memory cell.
• Runtime involves binding a nonstatic local variable to a memory cell.
• A binding is static if it occurs before runtime and remains unchanged throughout program execution.
• A binding is dynamic if it first occurs during execution or can change during execution.

Type Binding

• Static types may be specified by explicit or implicit declarations.
• Explicit declaration is a program statement used for declaring the types of variables.
• Advantage of explicit declaration is reliability.
• Implicit declaration is a default mechanism for specifying types of variables through default conventions.
• Writability is an advantage of implicit declaration.
• Reliability is a disadvantage of implicit declaration.
• In C#, a variable can be declared with var and an initial value, where the initial value sets the type through type inferencing.
• Visual BASIC 9.0+, ML, Haskell, F#, and Go use type inferencing to determine types of variables based on context.
• Dynamic type binding, used in JavaScript, Python, Ruby, PHP, and C#, flexibility is achieved through assignment statements.
• Dynamic type binding disadvantage is high cost due to dynamic type checking and interpretation, also type error detection by the compiler is difficult.

Variable Attributes

• Allocation is getting a cell from some pool of available cells for storage bindings and lifetime.
• Deallocation is putting a cell back into the pool of available cells for storage bindings and lifetime.
• The lifetime of a variable concerns storage bindings and is defined as the time during which it is bound to a particular memory cell.
• Static variables are bound to memory cells before execution begins and remain bound to the same memory cell throughout execution (e.g., C and C++ static variables in functions).
• Static variable advantages include efficiency (direct addressing) and history-sensitive subprogram support.
• Static variable disadvantages include lack of flexibility (no recursion).
• Stack-dynamic variables have storage bindings created when their declaration statements are elaborated, elaborated means code is only executed upon declaration.
• Stack-dynamic advantages include recursion and conserved storage.
• Stack-dynamic disadvantages include overhead of allocation and deallocation, also inefficient references from the indirect addresing.
• Explicit heap-dynamic variables are allocated and deallocated by explicit directives, specified by the programmer, and take effect during execution.
• Explicit heap-dynamic, can only be referenced only through pointers or references, e.g., dynamic objects in C++ (via new and delete) and all objects in Java.
• Explicit heap-dynamic advantages include enables dynamic storage management.
• Explicit heap-dynamic disadvantages include inefficiency and unreliability.
• Implicit heap-dynamic variable allocation and deallocation are caused by assignment statements.
• Implicit heap-dynamic variables are all variables in APL and all strings/arrays in Perl, JavaScript, and PHP.
• Implicit heap-dynamic advantages include flexibility (generic code).
• Implicit heap-dynamic disadvantages include inefficiency because all attributes are dynamic.

Variable Scope

• Scope is the range of statements over which it is visible.
• Local variables belong to a program unit if they are declared in that Unit.
• Nonlocal variables in a program unit are those that are visible in the unit but not declared there.
• Global variables are a special category of nonlocal variables.
• The scope rules of a language determine how references to names are associated with variables.
• Static scoping is based on program text.
• You connect a name/variable reference within the declaration.
• Search process: search declarations first locally, then look at 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.
• Some languages allow nested subprogram definitions, which create nested static scopes (e.g., Ada, JavaScript, Common LISP, Scheme, Fortran 2003+, F#, and Python).
• Variables can be hidden from a unit by having a "closer" variable with the same name.
• Ada allows access to these "hidden" variables, for example via unit.name.
• Blocks are a method of creating static scopes inside program units (originating from ALGOL 60).
• Using C:

  void sub() {
  int count;
  while (...) {
  int count;
  count++;
  ...
  }
  }
  

• The above example, while legal in C and C++, is not permitted in Java and C# due to its error-prone nature.
• C99, C++, Java, and C# allow variable declarations to appear anywhere a statement can appear.
• In C99, C++, and Java scopes of local variables run from declaration of end block.
• The declaration order in C# shows that scope of variable in block contains declaration.
• However, variables must be declared before they are used.
• In C++, Java, and C#, variables can be declared in for statements.
• The scope of such variables is restricted to the for construct.
• C, C++, PHP, and Python support a program structure that consists of a sequence of function definitions in a file.
• These languages allow variable declarations to appear outside function definitions.
• C and C++ have both declarations (just attributes) and definitions (attributes and storage).
• A declaration outside a function definition specifies that it is defined in another file.
• With PHP, programs are embedded in HTML markup documents, in any number of fragments, some statements and some function definitions.
• The scope of a variable declared in a function is local to the function in PHP.
• The scope of a variable declared outside functions is from the declaration to the end of the program, but skips over any intervening functions.
• Global variables in PHP can be accessed in a function through the $GLOBALS array or by declaring it global.
• In Python, a global variable can be referenced in functions, but can be assigned in a function only if it has been declared to be global in the function.
• Static scoping has issues in programs related to how often initial structures change/get reworked.
• Often static scoping access is too permissible on structures and sub programs.
• Dynamic scope is based on calling sequences of program units, not their textual layout (temporal versus spatial).
• References to variables are connected to declarations by searching back through the chain of subprogram calls that forced execution to this point.

Example of Scope

function big() {
function sub1() {
var x = 7;
sub2();
}
function sub2() {
var y = x;
}
var x = 3;
sub1();
}

• In the above Javascript example, big calls sub1, which calls sub2; and sub2 uses x.
• Under static scoping, the reference to x in sub2 relates to big's x.
• Using dynamic scoping, the reference to x in sub2 relates to sub1's x.
• Dynamic scoping has an advantage of convenience.
• Dynamic scoping has numerous disadvantages.
  • Disadvantage of dynamic scoping is that variables in subprograms are visisble to all subprograms it calls
  • Disadvantage of dynamic scoping is that statically type checking is impossible.
  • Disadvantage of dynamic scoping is poor readability due to being unable to statically determine variable details.
• Lifetime of a variable concerns the time a variable is bound to a specific memory location.
• Scope and lifetime are sometimes associated, are different concepts.
• Scope and lifetime can be best contrasted when considering static variables in a C++ function.
• The referencing environment of a statement is the collection of all names that are visible in the statement.
• In a static-scoped language, it includes local variables plus all visible variables in all enclosing scopes.
• A subprogram is active if its execution has begun but has not yet terminated and a variable has been declared.
• With dynamic scoping that has a language, the variable is defined locally and is referenced.

Named constants

• With named constants, the a variable is bound in storage to one value.
• Advantages of named constants are readability and modifiability.
• Named constants are used to to parameterize programs.
• Manifest constants or dynamic named constants allows values to be changed Languages vary in the implementation of explicit constants.
• Ada, C++, and Java named constants are expressions of any kind, dynamically bound.
• C# has two levels of constants readonly and const.
• When const is specified, the named constant is bound at compile time.
• When readonly is specified, the named constant is bound dynamically.