Concepts of Programming Languages - Chapter 1 Preliminaries

Comprehensive vocabulary flashcards covering language evaluation criteria, domains, design trade-offs, architecture influences, and implementation methods from Chapter 1 Preliminaries.

Readability

The ease with which programs can be read and understood.

Writability

The ease with which a language can be used to create programs.

Reliability

Conformance to specifications (i.e., performs to its specifications).

Cost

The ultimate total cost of a programming language, including training, writing, compiling, executing, compiler availability, and reliability costs.

Orthogonality

A language evaluation criterion where a relatively small set of primitive constructs can be combined in a relatively small number of ways, and every possible combination is legal.

Support for Abstraction

The ability to define and use complex structures or operations in ways that allow details to be ignored.

Expressivity

A set of relatively convenient ways of specifying operations, referring to the strength and number of operators and predefined functions.

Type Checking

Testing for type errors in a programming language.

Exception Handling

The ability to intercept run-time errors and take corrective measures.

Aliasing

The presence of two or more distinct referencing methods for the same memory location.

Portability

The ease with which programs can be moved from one implementation to another.

Generality

The applicability of a programming language to a wide range of applications.

Well-definedness

The completeness and precision of the language's official definition.

Scientific Applications Domain

A programming domain characterized by large numbers of floating point computations and the use of arrays, prominently using Fortran.

Business Applications Domain

A programming domain focused on producing reports, using decimal numbers and characters, prominently using COBOL.

Artificial Intelligence Domain

A programming domain where symbols rather than numbers are manipulated using linked lists, prominently using LISP.

Systems Programming Domain

A programming domain requiring high efficiency due to continuous use, prominently using C.

Web Software Domain

An eclectic collection of languages including markup (e.g., XHTML), scripting (e.g., PHP), and general-purpose languages (e.g., Java).

Von Neumann Architecture

A computer architecture where memory stores both instructions and data separately from the CPU, piping instructions and data from memory to CPU.

Fetch-Execute Cycle

The process on a von Neumann architecture computer that initializes the program counter, then repeatedly fetches, increments, decodes, and executes instructions.

Imperative Languages

The dominant category of programming languages whose central features are variables, assignment statements, and iteration, modeled around von Neumann architecture.

Functional Languages

A category of programming languages where the main means of making computations is by applying functions to given parameters, such as LISP and Scheme.

Logic Languages

A rule-based category of programming languages where rules are specified in no particular order, such as Prolog.

Markup/Programming Hybrid

Markup languages extended to support some programming capability.

Compilation

An implementation method that translates high-level source programs into machine language, featuring slow translation but fast execution.

Lexical Analysis

The compilation phase that converts characters in the source program into lexical units.

Syntax Analysis

The compilation phase that transforms lexical units into parse trees representing the syntactic structure of the program.

Semantics Analysis

The compilation phase responsible for generating intermediate code.

Code Generation

The compilation phase where machine code is generated.

Load Module

An executable image consisting of the user and system code together.

Linking and Loading

The process of collecting system program units and linking them to a user program.

Von Neumann Bottleneck

The connection speed limitation between a computer's memory and processor, which serves as the primary limiting factor in computer speed.

Pure Interpretation

An implementation method where programs are interpreted directly by an interpreter without translation, resulting in easier error display but 10 to 100 times slower execution.

Hybrid Implementation Systems

An implementation method that compromises between compilers and pure interpreters by translating high-level programs to an intermediate language for easy interpretation.

Just-in-Time Implementation Systems

Systems that initially translate programs to an intermediate language, then compile subprograms into machine code when called, saving the machine code for subsequent calls.

Preprocessors

Tools that process a program immediately before compilation to expand embedded macros, such as expanding #include and #define in C.

UNIX

An older operating system and tool collection nowadays often used through a GUI (e.g., CDE, KDE, or GNOME) running on top of UNIX.

Microsoft Visual Studio.NET

A large, complex visual environment used to build Web applications and non-Web applications in any .NET language.

NetBeans

A software environment related to Visual Studio .NET, specifically designed for Web applications in Java.