What are Programming Paradigms?

A programming paradigm is a style or approach used to write and organize programs.

In simple words, a programming paradigm describes how programmers think about solving problems using code.

Different paradigms use different ideas. Some focus on step-by-step instructions, some focus on objects, some focus on functions, some focus on events, and some focus on declaring the desired result.

Easy Real-Life Example

Step-by-step recipe       → Imperative / Procedural
Food items as objects     → Object-Oriented
Reusable transformations  → Functional
Order final dish          → Declarative
React to customer order   → Event-driven

Similarly, programming paradigms provide different ways to solve the same problem.

Why Should Students Learn Different Paradigms?

Students should learn different programming paradigms because real-world programming is not limited to one style.

Modern programming languages often support multiple paradigms. For example, a program may use imperative logic for loops, object-oriented design for structure, functional style for data transformation, declarative queries for database operations, and event-driven programming for user interfaces.

Major Programming Paradigms

In this course, we compare the following important programming paradigms:

1. Imperative Programming

Imperative programming is a style where the programmer writes exact step-by-step instructions for the computer.

It focuses on how to solve the problem.

Example

/*
Imperative style:
Calculate total marks step by step.
*/

ENTRY POINT
    DECLARE marks AS LIST = [80, 70, 90]
    DECLARE total AS INTEGER = 0

    FOR EACH mark IN marks
        SET total = total + mark
    END FOR

    DISPLAY total
END ENTRY POINT

Expected Output

240

2. Procedural Programming

Procedural programming is based on procedures or functions.

It is closely related to imperative programming, but it improves organization by dividing the program into smaller reusable parts.

Example

/*
Procedural style:
Use functions to organize logic.
*/

FUNCTION calculateTotal(marks)
    DECLARE total AS INTEGER = 0

    FOR EACH mark IN marks
        SET total = total + mark
    END FOR

    RETURN total
END FUNCTION

ENTRY POINT
    DECLARE marks AS LIST = [80, 70, 90]
    DISPLAY calculateTotal(marks)
END ENTRY POINT

Expected Output

240

3. Object-Oriented Programming

Object-Oriented Programming, or OOP, organizes code around objects.

An object contains data and behavior. Data describes the object, and behavior describes what the object can do.

Example

/*
Object-oriented style:
Represent student as an object.
*/

CLASS Student
    PROPERTY name
    PROPERTY marks

    METHOD calculateTotal()
        DECLARE total AS INTEGER = 0

        FOR EACH mark IN marks
            SET total = total + mark
        END FOR

        RETURN total
    END METHOD
END CLASS

ENTRY POINT
    CREATE student WITH name = "Aman" AND marks = [80, 70, 90]
    DISPLAY student.calculateTotal()
END ENTRY POINT

Expected Output

240

4. Functional Programming

Functional programming organizes programs around functions.

It encourages pure functions, immutability, avoiding shared state, and composing small functions to build larger logic.

Example

/*
Functional style:
Use a function to transform or reduce data.
*/

FUNCTION add(a, b)
    RETURN a + b
END FUNCTION

ENTRY POINT
    DECLARE marks AS LIST = [80, 70, 90]

    DECLARE total AS INTEGER = REDUCE marks USING add

    DISPLAY total
END ENTRY POINT

Expected Output

240

5. Declarative Programming

Declarative programming focuses on describing what result is needed.

The programmer describes the desired result, and the system, language, or tool decides how to produce it.

Example

/*
Declarative style:
Describe the desired result.
*/

marks = [80, 70, 90]

total = SUM marks

DISPLAY total

Expected Output

240

6. Event-driven Programming

Event-driven programming is a style where program execution depends on events.

An event can be a button click, key press, form submission, timer completion, message arrival, or system notification.

Example

/*
Event-driven style:
Run code when button is clicked.
*/

FUNCTION handleCalculateButtonClick()
    DECLARE marks AS LIST = [80, 70, 90]
    DECLARE total AS INTEGER = SUM marks

    DISPLAY total
END FUNCTION

ENTRY POINT
    REGISTER handleCalculateButtonClick FOR calculateButton click event

    WAIT FOR EVENTS
END ENTRY POINT

Expected Output After Button Click

240

Side-by-Side Comparison

Same Problem Solved Using Different Paradigms

Let us solve one problem in different styles:

Imperative Style

marks = [35, 60, 48, 75, 90]
passingMarks = []

FOR EACH mark IN marks
    IF mark >= 50 THEN
        ADD mark TO passingMarks
    END IF
END FOR

DISPLAY passingMarks

Procedural Style

FUNCTION getPassingMarks(marks)
    passingMarks = []

    FOR EACH mark IN marks
        IF mark >= 50 THEN
            ADD mark TO passingMarks
        END IF
    END FOR

    RETURN passingMarks
END FUNCTION

DISPLAY getPassingMarks([35, 60, 48, 75, 90])

Object-Oriented Style

CLASS MarkManager
    PROPERTY marks

    METHOD getPassingMarks()
        passingMarks = []

        FOR EACH mark IN marks
            IF mark >= 50 THEN
                ADD mark TO passingMarks
            END IF
        END FOR

        RETURN passingMarks
    END METHOD
END CLASS

CREATE manager WITH marks = [35, 60, 48, 75, 90]
DISPLAY manager.getPassingMarks()

Functional Style

marks = [35, 60, 48, 75, 90]

passingMarks = FILTER marks USING isPassing

FUNCTION isPassing(mark)
    RETURN mark >= 50
END FUNCTION

DISPLAY passingMarks

Declarative Style

marks = [35, 60, 48, 75, 90]

passingMarks = FILTER marks WHERE mark >= 50

DISPLAY passingMarks

Event-driven Style

FUNCTION handleShowPassingMarksClick()
    marks = [35, 60, 48, 75, 90]
    passingMarks = FILTER marks WHERE mark >= 50
    DISPLAY passingMarks
END FUNCTION

REGISTER handleShowPassingMarksClick FOR button click event

Final Output in All Cases

[60, 75, 90]

Imperative vs Declarative

This is one of the most important comparisons.

Create result list.
Loop through values.
Check condition.
Add matching values.

Give values that match this condition.

Procedural vs Object-Oriented

Procedural programming organizes logic into functions, while object-oriented programming organizes logic around objects.

Object-Oriented vs Functional

Object-oriented programming focuses on objects and state, while functional programming focuses on functions and transformations.

Functional vs Declarative

Functional programming often uses declarative style, but they are not exactly the same.

Event-driven vs Other Paradigms

Event-driven programming is different because it focuses on when code should run.

It can work together with other paradigms.

Button click event happens
        ↓
Event handler runs
        ↓
Handler may use:
    - Imperative logic
    - Procedural functions
    - OOP objects
    - Functional transformations
    - Declarative queries

Choosing the Right Paradigm

Can Paradigms Be Mixed?

Yes. Many real-world programs mix multiple paradigms.

This is called multi-paradigm programming.

A web application may use:

Object-Oriented Programming
    → To model users, products, orders

Functional Programming
    → To filter and transform data

Declarative Programming
    → To query database or define UI

Event-driven Programming
    → To handle button clicks and form submissions

Imperative Programming
    → To write step-by-step business logic

Advantages of Learning Multiple Paradigms

Limitations of Each Paradigm

Common Beginner Mistakes

Best Practices for Comparing Paradigms

Prerequisites Before Learning This Topic

Students should understand the following topics before comparing programming paradigms:

Trace Table Example: Same Output, Different Thinking

Let us compare how different paradigms think about the same task:

Practice Activity: Match the Paradigm

Identify the most suitable paradigm for each situation.

1. A button click should submit a form.
2. A student object should store name and marks.
3. A list of marks should be filtered to show only passing marks.
4. A database query should return students with grade A.
5. A program should calculate total using a loop.
6. A function should calculate average marks and be reused many times.

Sample Answers

1. Event-driven Programming
2. Object-Oriented Programming
3. Functional or Declarative Programming
4. Declarative Programming
5. Imperative Programming
6. Procedural Programming

Mini Quiz

Interview Questions on Comparing Programming Paradigms

Quick Summary