Reference Desk & Glossary

References for further study and the course glossary.

Suggested references

Use current official documentation and reputable educational sources:

Language specifications and official documentation for Python, Java, C++, C#, JavaScript/TypeScript, Rust, Haskell, Prolog, and SQL dialects.

Textbooks on programming language concepts, semantics, type systems, and software design.

Documentation for the specific concurrency, reactive, stream-processing, and constraint-solving libraries used in the project.

Compiler and runtime documentation when studying evaluation strategy, optimization, and memory behavior.

This course provides a broad foundation; individual language features and library APIs change. Verify examples against the version used by your project.

Glossary

Abstraction: exposing essential behavior while hiding implementation details.

Actor: computational entity that processes messages and owns its state.

Aliasing: multiple references to the same object or storage.

AST: abstract syntax tree representing program structure.

Backpressure: coordinating production and consumption rates to avoid overload.

Callback: function invoked by another component at a later time or in response to an event.

Closure: function together with access to its lexical environment.

Concurrency: overlapping progress of multiple tasks.

Constraint: condition a valid solution must satisfy.

Dataflow: computation organized around dependencies between values.

Declarative: specifying desired result or relationships rather than all execution steps.

DSL: domain-specific language.

Effect: observable interaction beyond pure value computation.

Encapsulation: controlling access to state and implementation.

Evaluation strategy: rules determining when and how expressions are evaluated.

Functional programming: style centered on functions, composition, values, and controlled effects.

Generic programming: writing algorithms and structures parameterized by types.

Immutability: a value or object cannot be changed after creation, according to the relevant model.

Inheritance: deriving a type or implementation from another.

Logic programming: expressing facts and rules and querying relationships.

Metaprogramming: programs generating or inspecting programs.

Mutation: changing state in place.

OOP: object-oriented programming.

Parallelism: simultaneous execution of multiple computations.

Paradigm: broad model for expressing computation.

Polymorphism: using different implementations through a shared operation or contract.

Pure function: function whose result depends only on inputs and that has no observable side effects.

Reactive programming: modeling changing values or event streams and their dependencies.

Recursion: defining or solving a problem in terms of smaller instances of itself.

Referential transparency: an expression can be replaced by its value without changing program behavior under the relevant semantics.

State machine: model of states and permitted transitions.

Type inference: deriving types from program expressions.

Unification: finding substitutions that make logical terms match.

Variance: rules governing how subtyping relates through generic type constructors.