The Difference Between OOPS, Functional, and Data

Decomposition Programming Paradigms

1. Object-Oriented Programming (OOPS)

OOPS is centered around the concept of objects. An object is a self-contained unit that bundles
together data (attributes) and the behavior (methods) that operates on that data.

 Core Idea: The world is made up of objects. Programming should model this reality by
creating software objects that represent real-world entities. For example, a Car object
might have attributes like color and speed, and methods like accelerate() and
brake().
 Key Principles:
o Encapsulation: Hiding the internal state of an object and only exposing a public
interface to interact with it. This protects the data from unauthorized access.
o Inheritance: Allowing new classes to inherit properties and methods from
existing classes, promoting code reuse. For example, a SportsCar class can
inherit from the Car class.
o Polymorphism: The ability of an object to take on many forms. This allows a
single interface to be used for different underlying data types. For example, a
shape object can have a draw() method, but the implementation of draw()
would be different for a circle versus a square.
o Abstraction: Focusing on the essential features of an object and hiding the
complex implementation details.
 Example: A program to manage a library might have objects like Book, Member, and
Librarian. The Book object would contain data like title and author, and methods
like checkOut() and checkIn().

2. Functional Programming

Functional programming is all about functions and immutability. It treats computation as the
evaluation of mathematical functions and avoids changing the state of the application.

 Core Idea: Program logic is a series of function applications. The primary focus is on
what needs to be computed, not on how to manage state.
 Key Principles:
o Immutability: Data is unchangeable. Once a variable is assigned a value, it
cannot be modified. This simplifies reasoning about the program's behavior and
eliminates side effects.
o First-Class Functions: Functions are treated as first-class citizens. They can be
assigned to variables, passed as arguments to other functions, and returned from
functions.
o Pure Functions: A function that, given the same input, will always return the
same output and has no side effects (e.g., doesn't modify global state, doesn't
perform I/O). This makes code easier to test and reason about.
o Declarative Style: The code describes what to do, rather than how to do it.
  Example: Calculating the sum of an array of numbers. In a functional approach, you
might use a higher-order function like reduce or fold that takes the array and a function
to apply to each element, returning the final sum without ever changing the original array.

3. Data Decomposition (Procedural Programming)

Data decomposition, often associated with procedural programming, focuses on procedures or

 Core Idea: Break down a problem into a series of steps or tasks. The program's logic is a
sequence of function calls that manipulate shared data.
 Key Principles:
o Procedures/Subroutines: The primary building blocks of the program. They are
a set of instructions designed to perform a specific task.
o Shared Data: Procedures operate on data that is often global or passed between
functions. This means that a procedure can modify data that other procedures also
use, which can sometimes lead to unexpected side effects.
o Sequential Execution: The program flows from one instruction to the next in a
linear fashion.
o Top-Down Design: The problem is broken down from a high-level view into
smaller and smaller sub-problems.
 Example: A program to calculate a student's grade. You might have a series of
procedures: readScores(), calculateAverage(), assignLetterGrade(), and
printResults(). Each procedure takes some data (e.g., the array of scores) and
performs a specific operation on it.

Summary Table

Data Decomposition
Feature OOPS Functional Programming
(Procedural)
Primary Functions (pure, Procedures (sequence of
Objects (data + behavior)
Focus immutable) instructions)
Encapsulation,
Immutability, First-class Sequential flow, shared
Core Principle Inheritance,
functions data
Polymorphism
Data is separate. Logic is a
Data and the functions that Data and logic are
series of function
Data & Logic operate on it are bundled separate. Functions
applications that transform
together in an object. manipulate shared data.
data.
State changes are avoided. State is often global and
State State is managed within
New data is created instead can be modified by any
Management objects.
of modifying existing data. procedure.
Mathematical reasoning
Model real-world entities Step-by-step, sequential
Reasoning and predictable function
and their interactions. logic.
behavior.
UI development, large- Data science, concurrent Scripting, simple
Common Use scale systems, game programming, event-driven utilities, embedded
development. systems. systems.