Imperative Languages

Languages designed around state changes and statement sequences that directly reflect the underlying von Neumann computer architecture[cite: 4]

Functional Languages

Languages structured around expression evaluation and mathematical functions without relying on state mutation or assignment statements[cite: 4]

Logic Languages

Languages based on formal symbolic logic where computation is expressed as declarative rules and relationships rather than sequential algorithms[cite: 4]

Scripting Languages

Languages originally designed for automating tasks gluing existing applications together or manipulating dynamic environments[cite: 4]

Von Neumann Architecture

The foundational computer architecture featuring memory cells and a fetch-decode-execute cycle that heavily influenced imperative language design[cite: 4]

Structured Design

A software design methodology that manages complexity by decomposing large programs into smaller independently callable subprograms[cite: 4]

Object-Oriented Design

A design methodology that bundles data and behavior together into objects and supports features like inheritance and polymorphism[cite: 4]

Compilation

An implementation method where high-level source code is fully translated into native machine code before execution for maximum runtime speed[cite: 4]

Interpretation

An implementation method where source code is parsed and executed line-by-line without an ahead-of-time binary build step[cite: 4]

Hybrid Implementation

An implementation method where source code is compiled into intermediate bytecode and then executed by a virtual machine[cite: 4]

Readability

A language evaluation criterion measuring how easily programs can be read and understood by developers[cite: 4]

Writability

A language evaluation criterion measuring how easily a language can be used to write programs for a specific domain[cite: 4]

Reliability

A language evaluation criterion measuring whether a program performs according to its specification without failing[cite: 4]

Cost

A language evaluation criterion considering overall financial and resource expenses including development execution and compilation time[cite: 4]

Simplicity

A language characteristic affecting readability and writability by avoiding excessive feature counts or multiple ways to perform the same task[cite: 4]

Orthogonality

A design characteristic where a small set of primitive constructs can combine consistently without unexpected special cases[cite: 4]

Expressivity

A language characteristic that provides powerful concise constructs allowing complex tasks to be written in fewer lines[cite: 4]

Lexemes

The smallest syntactic units or tokens in a grammar such as identifiers operators or literals[cite: 3]

Tokens

Classes or categories of lexemes such as identifier additive_operator or int_literal[cite: 3]

Language Generator

A formal syntax mechanism that takes a grammar and produces all possible legal sentences in the language[cite: 3]

Language Recognizer

A tool like a compiler parser that takes a sentence and determines whether it is syntactically legal[cite: 3]

Chomsky Hierarchy

A classification of formal grammars into four types ranging from unrestricted type 0 to context free type 2 and regular type 3[cite: 3]

BNF

Backus-Naur Form a context-free metalanguage used to formally describe programming language syntax using rules and terminals[cite: 3]

Terminal Symbols

The actual literal characters or keywords in a BNF grammar that cannot be further expanded[cite: 3]

Non-Terminal Symbols

Variables or rule names in a BNF grammar that expand into combinations of terminals and non-terminals[cite: 3]

Ambiguous Grammar

A grammar that can generate two or more distinct parse trees for the exact same sentence[cite: 3]

Operator Precedence

A static semantic rule enforced in BNF by placing higher priority operators lower down in the rule hierarchy[cite: 3]

Operator Associativity

The evaluation order of operators of equal precedence determined by whether a BNF rule is left-recursive or right-recursive[cite: 3]

Left-Recursive Rule

A BNF rule where the left-hand non-terminal appears on the far left of the right-hand side enforcing left-associativity[cite: 3]

Static Semantics

Language rules and meaning enforced at compile time that cannot easily be specified using context-free BNF rules[cite: 3]

Attribute Grammars

BNF grammars augmented with attributes and semantic functions to enforce static semantic rules like type matching[cite: 3]

Synthesized Attributes

Attributes in an attribute grammar passed upward in a parse tree from child nodes to parent nodes[cite: 3]

Inherited Attributes

Attributes in an attribute grammar passed downward or across in a parse tree from parent or sibling nodes[cite: 3]

Lexical Analysis

The compiler phase that uses regular expressions to process raw character streams into a stream of tokens[cite: 3]

Parsing

The compiler phase that checks a token stream against context-free BNF rules to build a valid parse tree[cite: 3]

Variable Attributes

The six fundamental characteristics that define a variable: name address value type lifetime and scope[cite: 2]

Static Binding

A binding that first occurs before runtime begins and remains unchanged throughout program execution[cite: 2]

Dynamic Binding

A binding that first occurs during runtime or can change during the course of program execution[cite: 2]

Reserved Words

Special words in a language that can only be used for one specific built-in purpose and cannot be redefined[cite: 2]

Keywords

Special words that are parsed and interpreted based on context rather than being globally restricted[cite: 2]

Functional Side Effect

An unexpected state change outside a function caused by modifying an aliased parameter or reference[cite: 2]

Explicit Declaration

A statement that explicitly lists variable names and specifies their data type before use[cite: 2]

Implicit Declaration

A mechanism that binds a variable to a type automatically by default rules or initial assignment without formal declaration[cite: 2]

Declaration Elaboration

The runtime process of binding memory cells and attributes to stack-dynamic variables when execution enters their block[cite: 2]

Static Variables

Variables bound to memory before runtime that retain their value across function calls and prevent recursion support[cite: 2]

Stack-Dynamic Variables

Variables bound to storage on the program stack during declaration elaboration when execution reaches their block[cite: 2]

Explicit Heap-Dynamic Allocation

Heap storage allocated at runtime by explicit programmer commands like new or malloc[cite: 2]

Implicit Heap-Dynamic Allocation

Heap storage allocated automatically when a variable is assigned a value without explicit memory commands[cite: 2]

Static Scoping

Visibility of variables determined at compile time based on the physical spatial nesting structure of the program text[cite: 2]

Dynamic Scoping

Visibility of variables determined at runtime based on the dynamic call sequence of subprograms[cite: 2]

Referencing Environment

The complete collection of all variables visible to a program statement at a specific point in execution time[cite: 2]

Variable Lifetime

The duration of execution time during which a variable remains bound to a specific memory location[cite: 2]

Variable Scope

The range of program statements in which a variable is accessible and visible[cite: 2]

Data Type

A collection of valid data values and a set of predefined operations on those values[cite: 1]

Type Descriptor

A formal memory structure representing variable attributes like element type bounds and array size[cite: 1]

Primitive Data Types

Data types in a language that are not defined in terms of other data types such as int float or boolean[cite: 1]

BCD

Binary Coded Decimal an encoding that stores two decimal digits per byte used for exact financial accuracy without float errors[cite: 1]

Enumeration Types

User-defined discrete scalar types consisting of an ordered list of named constants[cite: 1]

Name Type Equivalence

A rule where two variables have equivalent types only if declared in the same statement or with the exact same type name[cite: 1]

Structure Type Equivalence

A rule where two variables have equivalent types if their internal memory layouts and component structures match[cite: 1]

Row-Major Order

A multi-dimensional array memory layout where consecutive elements of each row are stored adjacent in memory[cite: 1]

Column-Major Order

A multi-dimensional array memory layout where consecutive elements of each column are stored adjacent in memory[cite: 1]

Static Array

An array whose subscript ranges and memory allocation are statically bound before runtime[cite: 1]

Fixed Stack-Dynamic Array

An array whose subscript ranges are statically bound but whose storage is allocated on the stack at elaboration[cite: 1]

Fixed Heap-Dynamic Array

An array whose subscript ranges and heap storage allocation are bound at runtime upon explicit request[cite: 1]

Heap-Dynamic Array

An array whose subscript ranges are dynamic and can grow or shrink continuously during program execution[cite: 1]

Associative Array

An unordered collection of data elements indexed by key values rather than numeric positions also called a hash or dict[cite: 1]

Tuple

An ordered collection of elements that is immutable once created in languages like Python[cite: 1]

Record

A collection of non-homogeneous elements usually referenced by distinct field names[cite: 1]

Dangling Pointer

A pointer holding the memory address of a dynamic storage location that has already been deallocated[cite: 1]

Memory Leak

A condition where allocated heap dynamic variables lose all pointer references and can no longer be accessed or freed[cite: 1]

Strong Type Checking

A language design quality where all type errors are reliably caught either statically at compile time or dynamically at runtime[cite: 1]