Programming Language Paradigms – Chapter 1 Vocabulary

A vocabulary deck of 55 flashcards covering key terms from Chapter 1: Preliminaries of Programming Language Paradigms.

Programming Language Paradigms

Distinct models or styles of programming (e.g., imperative, functional, logic) that shape how programs are written and executed.

Ambiguous Grammar

A grammatical structure that allows multiple valid parses for the same sentence, common in natural languages but avoided in programming languages.

Alphabet (of a language)

The complete set of symbols or characters from which strings of the language are formed.

Lexicon

The vocabulary of a language—the full set of valid words or tokens.

Syntax

Formal rules that govern how words and symbols combine to form valid phrases, statements, or programs.

Grammar (formal)

The overall system of rules (syntax + formation principles) that define which strings belong to a language.

Semantics

The meaning or interpretation assigned to syntactically correct strings in a language.

Orthography

The writing conventions of a language, including spelling and punctuation.

Morphology

The study of the internal structure and formation of words.

Phonology

The study of sound patterns and phonetic elements within a language.

Typology

The classification of languages based on shared structural or functional features.

Natural Human Language

Languages that evolved naturally among people, such as English or Mandarin, characterized by ambiguous grammar.

Constructed Human Language

A deliberately invented language (e.g., Esperanto, Klingon) often designed for specific goals or experimentation.

Programming Language

A formal, unambiguous language used to instruct computers through precisely defined syntax and semantics.

Noam Chomsky

Theoretical linguist who introduced formal language hierarchies that influence programming language grammar design.

John Backus

Computer scientist who led the creation of FORTRAN and invented Backus–Naur Form (BNF) for formal syntax description.

Reasons for Studying PL Concepts

Benefits such as improved idea expression, better language choice, easier learning of new languages, and advancement of computing.

Associative Array

A data structure storing (key, value) pairs, also called a map or dictionary.

Readability

The ease with which humans can read and understand a program’s source code.

Writability

The ease with which a language allows programmers to create programs for a problem domain.

Reliability (language criterion)

The degree to which programs written in a language perform according to specifications under all conditions.

Cost (language evaluation)

The total expense of using a language, including training, compilation, execution, maintenance, and reliability impacts.

Orthogonality (in languages)

Design principle where a small set of primitive constructs can be combined consistently, reducing exceptions and complexity.

Operator Overloading

Allowing an operator symbol to have different behaviors based on operand types, potentially impacting readability.

Type Checking

The process of verifying that operands in expressions are of compatible types, either at compile time or runtime.

Exception Handling

Language facilities for intercepting and managing runtime errors to allow continued program execution.

Aliasing

The situation where multiple names reference the same memory location, potentially reducing reliability.

von Neumann Architecture

Stored-program computer model where program instructions and data share memory, influencing imperative languages.

von Neumann Bottleneck

Performance limitation caused by the limited data transfer rate between CPU and memory in von Neumann machines.

Imperative Programming

Programming paradigm centered on statements that change program state through assignments and control flow.

Procedural Programming

Subset of imperative programming that structures code into subroutines or procedures for reuse and clarity.

Functional Programming

Paradigm that treats computation as evaluation of mathematical functions and avoids mutable state.

Logic Programming

Paradigm based on declaring facts and rules; computation is performed by automated theorem proving (e.g., Prolog).

Declarative Language

Language category in which the programmer specifies what the program should accomplish, not how (includes functional and logic languages).

Markup/Programming Hybrid

A markup language enhanced with programming constructs (e.g., JSTL, XSLT) often used in web contexts.

Data Abstraction

The ability to define complex data structures while hiding implementation details from the user.

Process Abstraction

The ability to encapsulate a sequence of operations (e.g., subprogram) so details can be ignored by callers.

Compilation

Implementation method that translates source code into machine language before execution, yielding fast runtime performance.

Pure Interpretation

Execution method where source statements are executed directly by an interpreter without a prior translation step.

Hybrid Implementation System

Approach that compiles source code to an intermediate language, which is then interpreted or further compiled (e.g., Java bytecode).

Just-In-Time (JIT) Compilation

Runtime technique that compiles intermediate code into machine code on demand, combining interpretation flexibility with compilation speed.

Linking

Process of combining object files and libraries into a single executable program.

Load Module

The final executable image (e.g., .exe) produced after linking, ready to be loaded into memory.

Preprocessor

Tool that processes source files before compilation, expanding directives like #include and #define.

Java Virtual Machine (JVM)

Platform-independent runtime environment that interprets or JIT-compiles Java bytecode.

Expressivity

A language’s capacity to concisely express a wide range of computations and ideas.

Support for Abstraction

Language features (e.g., classes, modules, functions) that facilitate hiding complexity and managing large systems.

Simplicity (evaluation criterion)

Measure of how few and consistent the constructs of a language are, aiding in readability and writability.

Overall Simplicity

Language design goal of having a manageable feature set with minimal redundancy and operator multiplicity.

Language Trade-Off: Reliability vs Cost

Design balance where safety features increase reliability but may slow execution or raise development costs.

Language Trade-Off: Readability vs Writability

Situation where concise, flexible code may reduce readability, or verbose clarity can hinder rapid writing.

Embedded Systems Domain

Programming domain focused on software for dedicated hardware with limited resources (e.g., automotive controllers).

3-D Graphics Domain

Programming area involving high-resolution rendering for film or games, emphasizing performance in languages like C/C++.

Scripting Language

High-level, often interpreted language designed for quick development and automation (e.g., Python, PHP, JavaScript).

Lambda Calculus

Formal system for expressing computation via function abstraction and application; theoretical basis of functional languages.