1.
Binding (static, dynamic):
o Static Binding: Associations made at compile time, fixed before the program
runs.
o Dynamic Binding: Associations determined during runtime, offering
flexibility but increasing runtime costs
2. Binding Time: The time when an association is created. It can occur during
language design, implementation, program writing, compilation, linking, loading, or
execution
3. Scope (static, dynamic):
o Static Scope: Defined by the structure of the program code; determined at
compile time.
o Dynamic Scope: Determined by the calling sequence of functions; depends
on runtime behavior
4. Static Allocation: Memory allocation with fixed addresses that do not change
during program execution
5. Frame (Activation Record): A structure on the stack containing a subroutine’s local
variables, arguments, and bookkeeping data
6. Local Referencing Environment (LRE): The set of name-to-object bindings
accessible in the current execution context
7. Heap: Memory used for dynamic allocation. It can have issues such as internal and
external fragmentation
8. Fragmentation:
o External Fragmentation: Free memory is divided into non-contiguous
blocks, making it unusable for large allocations.
o Internal Fragmentation: Allocated memory blocks include unused space
9. Overloading: Using the same name for different functions or operators distinguished
by context, parameter types, or numbers
10. Side Effect: An operation that modifies some state outside its scope or observable
state beyond returning a value
11. Short-Circuit Evaluation: Logical operators that evaluate only as much of an
expression as necessary to determine the result
12. Strong Typing: A language characteristic where type errors are detected and
prevented, either at compile or runtime
13. Data Type (discrete, ordinal, scalar): Categories for types.
Discrete Types: Finite countable values.
Ordinal Types: Sequentially ordered values.
Scalar Types: Single value types
14. Type Equivalence (Name vs. Structure):
Name Equivalence: Types are equivalent only if explicitly declared the same.
Structure Equivalence: Types are equivalent if their structures match.
15. Type Compatibility: Rules for when and how values of one type can be used as
another
16. Coercion (Implicit Type Conversion): Automatic conversion between compatible
types during assignment or operations
17. Casting (Explicit Type Conversion): Explicitly converting a value from one type to
another
18. Row Major, Column Major: Ways of storing multi-dimensional arrays in memory.
Row-major stores rows consecutively; column-major stores columns consecutively
19. Lost Heap Variable: A situation where a heap-allocated object is inaccessible due
to all references being lost
20. Dangling Pointers: Pointers referencing deallocated memory
21. Exception Handling: Exceptions refer to conditions that require a program to "back
out" to a context where it can recover, triggered when a component cannot fulfill its
"contract." Many modern languages provide an exception-handling mechanism,
where a handler is appended to computations that might raise exceptions to allow for
recovery
22. Co-Routine: A program component that generalizes subroutines to allow multiple
entry points and cooperative multitasking
Co-routines are mentioned as part of the continuations discussion in some
programming languages like Scheme, where a continuation captures the context and
can implement control flow constructs such as co-routines
23. Nameless Function: Lambda expressions, used heavily in functional programming,
provide a concise way to represent nameless functions. For example, in Scheme or
C#, lambda expressions enable the creation of anonymous functions with specific
syntax
24. Higher-Order Functions Functions that operate on other functions, either by taking
them as arguments or returning them. Examples include functions that manipulate
other functions to encapsulate context or computation
25. Unification: A process in logic programming (e.g., Prolog) used to determine if two
terms can be made identical by finding suitable substitutions for their variables. It
underpins operations like type inference in other languages
26. Slice or Section (of Array): A slice typically refers to a subset of an array or data
structure. This concept wasn’t explicitly detailed in the snippets, but slicing is a
standard operation in many programming languages like Python and MATLAB
27. Display: A structure for efficiently accessing variables in nested scopes
28. Generic Subroutine: A subroutine that can operate on data of different types. For
instance, Ada provides a generic mechanism allowing subroutines to accept types
and operations as parameters, enabling polymorphism
29. Lambda Calculus: Lambda calculus underpins functional programming, offering a
formal system for expressing computation via function abstraction and application. It
is the theoretical basis for many functional languages like Scheme and Haskell
