Principles of Programming Languages: Names, Bindings, Scopes, and Data Types

Comprehensive vocabulary flashcards covering language design issues, variable attributes, storage allocations, scoping rules, referencing environments, and elementary and structured data types.

Imperative Languages

Programming languages designed as abstractions of the von Neumann architecture, in which memory stores both instructions and data, and processors provide operations to modify memory contents.

Identifier

A name used to denote program entities such as constants, variables, procedures, functions, and types.

Keyword

A special word that has specific syntactic meaning only within certain contexts (for example, Real acting as a type specifier in Fortran declarations but permitted as a variable name elsewhere).

Reserved Word

A special word in a programming language that cannot be redefined or used as a user-defined name.

Variable

An abstraction of a computer memory cell characterized by six fundamental attributes: name, address, value, type, lifetime, and scope.

Anonymous Object

An object created without being bound to an identifier or variable name, typically generated using a constructor call such as new Greeting().

L-value

The memory address associated with a variable.

R-value

The data contents stored in the memory cell associated with a variable.

Variable Type

The attribute that determines the set of values a variable can hold, the operations defined on those values, and their floating-point precision.

Lifetime

The period of execution time during which a variable is bound to a specific memory cell, determined by when it is allocated and deallocated.

Allocation

The process of acquiring an available memory cell from a storage pool and binding it to a variable.

Deallocation

The process of unbinding a memory cell from a variable and returning it to the pool of available storage.

Static Variable

A variable bound to memory cells prior to program execution that remains bound to the identical location until execution terminates.

Stack-Dynamic Variable

A variable whose storage binding is created when its declaration statement is elaborated at runtime, allocated on the execution stack.

Elaboration

The process of executing the executable code associated with a variable declaration statement during program execution.

Scalar

A single data component that holds an individual numerical or string value and corresponds to one data item processed at a time.

Explicit Heap-Dynamic Variable

An anonymous variable allocated and deallocated on the heap via explicit programmer instructions (such as new and delete) and referenced solely via pointers or references.

Implicit Heap-Dynamic Variable

A variable whose memory binding to heap storage occurs automatically upon the execution of an assignment statement.

Scope

The range of program statements over which a variable is visible and accessible.

Local Variable

A variable declared explicitly inside a specific program unit, block, or subprogram.

Nonlocal Variable

A variable that is accessible and visible within a given program unit but was not declared within that unit.

Global Variable

A variable declared outside functions or blocks that is visible and accessible throughout the entire program.

Static Scope

A scope resolution method based entirely on the spatial textual structure of a program, allowing variable bindings to be determined prior to runtime (such as at compile time).

Static Parent

The nearest enclosing static scope surrounding a given program unit or block in static-scoped languages.

Dynamic Scope

A scope resolution method determined at runtime based on the calling sequence of subprograms rather than program text layout.

Referencing Environment

The collection of all identifiers and names that are visible and accessible within a specific executing statement.

Active Subprogram

A subprogram whose execution has commenced but has not yet completed and terminated.

Named Constant

A variable that is permanently bound to a specific value at the same time it is bound to storage.

Manifest Constant

A named constant whose binding of value to storage occurs statically at compile time.

Data Type

A collection of data objects combined with a predefined set of allowable operations that can be performed on those objects.

Ternary Operator

A conditional operator that takes three operands using the syntax OP1 ? OP2 : OP3, acting as an inline shorthand for an if-else decision.

Complex Number

A numerical value represented as $a + bi$, where $a$ is the real part, $bi$ is the imaginary part, and $i^2 = -1$.

Rational Number

A numeric value represented as an exact fraction $\frac{a}{b}$, where $a$ and $b$ are integers and $b \neq 0$, preventing rounding inaccuracies.

Vector

A one-dimensional, dynamically resizable container of homogeneous elements that stores items in contiguous memory and adjusts its size automatically.

Array

A homogeneous collection of a fixed number of elements in which each element is addressed by an explicit index or subscript representing its position relative to the start.

Row-Major Order

A multidimensional array storage arrangement where matrix elements are stored consecutively row by row in memory.

Column-Major Order

A multidimensional array storage arrangement where matrix elements are stored consecutively column by column in memory.

Record

A structured data type that aggregates components or fields of potentially differing data types under a single identifier, accessed via dot notation.

List

An ordered sequence of items commonly delimited with brackets and commas, capable of dynamic resizing and often supporting heterogeneous element types.

Pointer

A variable that stores the physical memory address of another variable rather than storing a direct data value.