Programming Paradigms: A Comprehensive Overview
Programming Paradigms
Introduction
A paradigm is a fundamental model or scheme that organizes our views regarding a particular topic. Programming paradigms represent a particular approach or philosophy for building software. They set limits for problem-solving and influence the development of new solutions.
Common Paradigms
- Imperative: The most common paradigm, focusing on program state and statements that change the state. Examples include C, Pascal, and COBOL.
- Object-Oriented: Organizes programs around objects that combine data (state) and behavior (methods). Smalltalk is a fully object-oriented language.
- Functional: Based on lambda calculus, with programs composed solely of function definitions. Examples include LISP, Haskell, Scheme, and ML.
- Logical: Uses mathematical logic to infer relationships between values and calculate outputs from inputs. Prolog is a popular example.
- Event-Driven: Program structure and execution are determined by events, such as mouse clicks or network messages.
- Aspect-Oriented (AOP): Aims to separate concerns and minimize dependencies within a program, leading to cleaner, more maintainable code.
Imperative Programming
Imperative programming describes program execution as a sequence of instructions that modify program state. It’s closely related to real-world processes, like following a recipe. Data is often treated as an appendage to the program, primarily used for calculations.
- Structured Programming: Emphasizes modularity and avoids GOTO statements for improved code clarity and maintainability.
- Unstructured Programming: Uses GOTO statements, which can lead to more complex and harder-to-maintain code.
Object-Oriented Programming
Object-oriented programming (OOP) derives from concepts introduced by Simula. Objects combine data and methods, and programs are expressed as interactions between these objects. OOP languages define objects and send messages to them, instructing them to perform their methods.
Functional Programming
Functional programming is based on lambda calculus. Pure functional languages like Haskell and Miranda have properties like referential transparency and avoid variable assignments. Hybrid functional languages like Scheme, LISP, OCaml, and Standard ML combine functional and imperative features.
Logical Programming
Logical programming languages, based on predicate logic, define properties of objects and relationships between them using formulas. Prolog, while initially weak, has been extended to be more practical.
Values and Types
A value is any entity that exists during a computation. A type is a set of values with uniform behavior under associated operations.
Primitive Types
- Boolean (true, false)
- Integer
- Real
- Character
- Enumerated Types (e.g., months)
- Subrange Types (e.g., 28..31)
Composite Types
Composite types are structured data types built from simpler values. Examples include tuples, records, arrays, sets, strings, lists, and trees.
Type Systems
- Statically Typed: Variable types are fixed and checked at compile time (e.g., Pascal, C).
- Dynamically Typed: Values have fixed types, but variables can hold values of different types at runtime (e.g., Lisp, Smalltalk).
Expressions, Variables, and Commands
Expressions are evaluated to produce values. Variables hold values that can be inspected and updated. Commands update variables. These are fundamental building blocks of imperative programming.
Abstractions and Parameters
Abstraction separates what a program part does from how it’s implemented. Functions and procedures are common abstractions. Parameters allow abstractions to operate on different values. Parameter-passing mechanisms include value, result, value-result, and name binding.
Order of Evaluation
- Applicative (Eager): Parameters are evaluated at the point of call.
- Normal Order (Lazy): Parameters are evaluated only when needed.