IT 005 - Module 1.2

Programming Paradigm

A style or "way" of programming; not a language itself, but an approach a language may support.

Imperative Programming

Programming using an explicit sequence of commands that change the program's state step by step.

Declarative Programming

Programming by stating what result you want, not how to get it; no loops or explicit steps.

Structured Programming

A type of imperative programming using clean, nested loops/conditionals instead of "goto" statements.

Procedural Programming

Imperative programming that uses procedure (function) calls to organize code.

Functional Programming (Applicative)

Programming using function calls with no assignment statements or global state changes.

Function-Level Programming (Combinator)

Programming with no variables at all; functions are combined directly using other functions (functionals).

Object-Oriented Programming (OOP)

Programming by creating objects that send messages to each other; each object has its own private state and public interface.

Class-based OOP

A type of OOP where objects get their state and behavior from belonging to a class.

Prototype-based OOP

A type of OOP where objects get their behavior directly from another object (a prototype), not a class.

Event-Driven Programming

Programming built around emitters (that send events) and listeners (that respond) for asynchronous actions.

Flow-Driven Programming

Programming where separate processes communicate with each other through predefined channels.

Logic Programming (Rule-based)

Programming by defining facts and rules; an engine automatically figures out the answers (e.g., Prolog).

Constraint Programming

Programming by specifying a set of constraints (conditions); an engine finds values that satisfy them all.

Aspect-Oriented Programming

Programming style where cross-cutting concerns (like logging or security) are applied automatically across the program.

Reflective Programming

Programming where the program can inspect or modify its own elements (code, classes, etc.) while running.

Array Programming

Programming using powerful array/vector operators, which usually removes the need for explicit loops.

Goto Statement

An old-style command that jumps program execution directly to another labeled line of code; avoided in structured programming.

Lexical Scope

When a variable is only accessible within the specific block of code where it was defined.

Simula-67

The first object-oriented programming language.

Smalltalk (paradigm context)

Considered the first "pure" object-oriented language, where everything (even numbers and control flow) is an object.

Pure Paradigm Language

A language that follows one paradigm 100%, with no mixing of other styles; very rare in practice.

Multi-Paradigm Language

A language purposely designed to support and make easy more than one programming paradigm (e.g., Scala, Python).

Map (function)

A function that applies another function to every item in a list, producing a new list of results.

Filter (function)

A function that selects only the items in a list that meet a certain condition.

Reduce/Fold (function)

A function that combines all items in a list into a single result (e.g., summing all numbers).

Function Composition

Combining two functions so the output of one becomes the input of the other, written as (f o g)(x) = f(g(x)).

Unification (Logic Programming)

The automatic process in logic programming where the engine matches facts/rules to find a solution to a goal.

List Comprehension

A short, readable way to combine "map" and "filter" operations into a single expression.