Organization of Programming Languages Study Notes

A complete collection of vocabulary flashcards for reviewing Organization of Programming Languages definitions and glossary terms for midterm preparation.

Readability

How easily programs can be read and understood.

Writability

How easily a language can be used to create programs.

Reliability

Whether programs perform to their specifications under all conditions.

Cost

The total of training, writing, compiling, running, maintaining, and poor-reliability costs.

Simplicity

Few basic constructs and little feature multiplicity.

Orthogonality

A small set of primitives can be combined in a few ways, and every combination is legal.

Expressivity

Convenient ways of specifying computations (count++, for loops).

Aliasing

Two names referring to the same memory location.

Name (identifier)

A string that represents an entity in a program.

Binding

An association between an entity and an attribute, such as a variable and its type or value.

Binding time

The moment a binding is made.

Static binding

A binding that occurs before runtime and doesn't change.

Dynamic binding

A binding that occurs at runtime or can change during execution.

Language design time

When the language is defined (meaning of *, keywords).

Language implementation time

When the compiler or interpreter is built (int range, float format).

Compile time

When a program is translated (declared types, static scope).

Load time

When the program is loaded into memory (static variable addresses).

Runtime

While the program executes (values, stack-dynamic storage, dynamic types).

Scope

The range of statements in which a variable is visible.

Visible

A variable is visible in a statement if it can be referenced there.

Static scope

Which declaration a name refers to is decided at compile time from the program's textual structure.

Dynamic scope

Which declaration a name refers to is decided at runtime from the calling sequence.

Local variable

Declared inside the current function or block.

Nonlocal variable

Declared in an enclosing scope but visible in the current one.

Global variable

Declared outside all functions.

Hiding

A same-named inner variable blocks the outer one inside its scope.

Lifetime

The time during which a variable is bound to a memory cell.

Referencing environment

The collection of all names visible at a statement.

Named constant

A variable bound to a value only once, at binding time.

Static variable

Bound to memory before execution begins and kept until the program ends.

Stack-dynamic variable

Storage bound when its declaration is elaborated at runtime (on subprogram entry) and released on return.

Explicit heap-dynamic variable

Storage allocated and freed by explicit instructions (new, malloc/free).

Implicit heap-dynamic variable

Storage allocated automatically on assignment (Python lists).

Dynamic type binding

A variable's type is bound at runtime when a value is assigned.

Data type

A collection of data objects and a set of predefined operations on those objects.

Descriptor

The collection of attributes of a variable.

Primitive data type

A data type not defined in terms of other data types.

Object

An instance of a user-defined (abstract data) type.

Integer

An almost exact reflection of the hardware; Java has byte, short, int, and long.

Floating point

Models real numbers as approximations; at least float and double; IEEE 754 format.

Rational

A ratio of integers, stored as a pair of integers; supports precise arithmetic.

Complex

Two floats, a real part and an imaginary part.

Decimal

A fixed number of decimal digits stored in BCD, for business applications; accurate, but limited range and wastes memory.

BCD (binary coded decimal)

Each decimal digit gets its own binary code ($254 = 0010\,0101\,0100$). At least 4 bits per digit.

Boolean

Two values, true and false; could be bits, often bytes.

Character

Stored as numeric codings (ASCII, 16-bit Unicode, 32-bit Unicode).

Twos complement

A negative integer is stored as the complement of the positive number, plus one.

Precision

Accuracy of the fractional part of a float, measured in bits.

Range

The span of values, mostly set by the range of exponents.

Character string type

Values are character sequences.

Static length string

Length fixed at creation (COBOL, Java String).

Limited dynamic length string

A maximum is set, and a special code (0) marks the end of the content (C, C++).

Dynamic length string

No maximum (SNOBOL, Perl, JavaScript, Lisp, Python).

Ordinal type

A type whose possible values can be readily associated with the positive integers, with a distinct ordering.

Enumeration type

All possible values are named constants provided in the definition. No order implied.

Subrange type

An ordered contiguous subsequence of an ordinal type (e.g., 12..18 of integer).

Array

A homogeneous aggregate of data elements in which an individual element is identified by its position relative to the first element.

Access function

Maps subscript expressions to a memory address in a contiguous block.

Row-major order

Rows are stored one after another (most languages).

Column-major order

Columns are stored one after another (Fortran).

Static array

Subscript ranges and storage are bound statically (before runtime).

Fixed stack-dynamic array

Subscript ranges are static, but allocation happens at declaration time.

Stack-dynamic array

Subscript ranges and storage are bound dynamically.

Fixed heap-dynamic array

Like fixed stack-dynamic, but bound when requested and allocated from the heap.

Heap-dynamic array

Subscript ranges and storage bound dynamically, and the array can grow or shrink.

Array descriptor

The information an array needs: element type, index type, number of dimensions, index ranges, address.

Associative array

An unordered collection of values indexed by an equal number of keys (also hash tables, tables, dictionaries). Keys are arguments to a mapping function that gives the address of the value.

Set (Python)

An unordered collection of unique items. Items can be added and removed; frozenset is immutable.

Tuple (Python)

An ordered, non-changeable collection that can be indexed. Often used for returning multiple values.

Packing/unpacking

(x,y,z) = myTuple assigns each item to a variable.

Record

A possibly heterogeneous aggregate of elements identified by names.

Elliptical reference

Referencing a record field without naming the record.

Field offset

The distance of a field from the start of the record.

Bit vector

A set implementation using one bit per possible value.

Hash table

A structure where a hash function turns a key into a storage location.

Pointer

A variable whose values are memory addresses plus a special value, nil.

Dereferencing

Returning the value stored at the location the pointer holds.

Reference type

A pointer-like type; in Java, a reference to an object rather than a memory address.

Dangling pointer

A pointer to a heap-dynamic variable that has been deallocated.

Lost heap-dynamic variable

An allocated variable no longer accessible to the user program.

Heap

The area where storage is dynamically created.

Type checking

Ensuring that the operands of an operator are of compatible types.

Compatible type

One that is legal for the operator or can be implicitly converted by compiler-generated code.

Coercion

The compiler automatically converts an operand's type to one compatible with its operator.

Type error

Applying an operator to an operand of an inappropriate type.

Strongly typed

Type errors are always detected. Coercion can weaken it.

Name type equivalence

Two variables have equivalent types if they are in the same declaration or use the same type name. Easy to implement, but restrictive.

Structure type equivalence

Two variables have equivalent types if their types have identical structures. More flexible, but harder to implement.