Programming Paradigm: Guide (Complete list)

I hope you enjoy reading this!
Don’t forget to share this blog with your friends.

Table of Contents
Programming Paradigm Guide (Complete list)

Programming doesn’t mean solving problems programming means solving the problems in the right way.

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

― Martin Fowler

What is Programming Paradigm

While solving problems, the way you structure your program is called a programming paradigm. The programming paradigm is not dependent on the programming language. The most popular programming paradigm is OOPs but the best programming paradigm is that which reduces the complicity of the understanding and debugging process.

Put simply,
Programming Paradigm is a way or style of your program.

List of Programming Paradigms

Tons of programming paradigms were developed and continually evolving.
Here I mention almost all of the programming paradigms.

  1. Object-oriented programming (OOPs)
  2. Functional programming
  3. Procedural programming
  4. Imperative programming
  5. Declarative programming
  6. Logic programming
  7. Structured programming
  8. Event-driven programming
  9. Modular programming
  10. Aspect-oriented programming
  11. Prototype-based programming
  12. Data-driven programming

Programming Paradigms

Object-oriented programming (OOPs)

OOPs is the most common term in programming. This is the most common paradigm.

What is Object-oriented programming?

OOPs (Object Oriented Programming system)
OOPs (Object Oriented Programming system)

Object-Oriented programming system (OOPs) is a programming paradigm that is based on the concept of classes and objects. It is used to structure a complex program into simple, reusable blocks of code classes, which are used to create individual instances of objects.
Example (in C++):

class MyClass {       // The class
  public:             // Access specifier
    int myNum;        // Attribute (int variable)
    string myString;  // Attribute (string variable)
};

int main() {
  MyClass myObj;  // Create an object of MyClass

  // Access attributes and set values
  myObj.myNum = 15; 
  myObj.myString = "Some text";

  // Print attribute values
  cout << myObj.myNum << "n";
  cout << myObj.myString;
  return 0;
}

Languages that support:

  • Java
  • JavaScript
  • Python
  • C++
  • Visual Basic .NET
  • Ruby
  • Scala
  • PHP

Functional programming

In recent years, functional programming has become so popular because of Javascript.

What is Functional programming?

Functional programming is a programming paradigm where programs are constructed by applying and composing functions, avoiding shared state, mutable data, and side effects. Functions mode of data and methods, methods can modify the value of data itself.

Example in Javascript:

function isPrime(number){
 for(let i=2; i<=Math.floor(Math.sqrt(number)); i++){
  if(number % i == 0 ){
   return false;
  }
 }
 return true;
}
isPrime(15); //returns false

Languages that support:

  • JavaScript
  • Haskell
  • OCaml
  • Scala
  • Clojure
  • Racket

Procedural programming

Procedural programming (which is also imperative) splitting those instructions into procedures.

What is Procedural programming?

Procedural programming is a programming paradigm that is derived from imperative programming. This paradigm uses a linear top-down approach and treats data and procedures as two different entities, based on the concept of the procedure call. Procedures simply contain a series of computational steps to be carried out.

Example in C:

#include <stdio.h>

int main()
{
    int sum = 0;
    int i =0;
    for(i=1;i<11;i++){
        sum += i;
    }
    
    printf("The sum is: %dn", sum); //prints-> The sum is 55

    return 0;
}

Languages that support:

  • C
  • Java
  • C++
  • Pascal
  • ColdFusion


Imperative programming

Imperative programming (from the Latin word, imperare = command) is the oldest programming paradigm. A program based on this paradigm is made up of a clearly defined sequence of instructions to a computer.

What is Imperative programming?

Imperative programming is a programming paradigm that uses commends or statements that change a program’s state. In much the same way that the imperative mood in natural languages expresses commands, an imperative program consists of commands for the computer to perform.

Example in C:

int main()
{
    int sum = 0;
    sum += 1;
    sum += 2;
    sum += 3;
    sum += 4;
    sum += 5;
    sum += 6;
    sum += 7;
    sum += 8;
    sum += 9;
    sum += 10;
    
    printf("The sum is: %dn", sum); //prints-> The sum is 55

    return 0;
}

Languages that support:

  • C
  • C#
  • C++
  • Python
  • Fortran
  • Java
  • Pascal
  • ALGOL
  • Assembler
  • BASIC
  • COBOL
  • Ruby

Declarative programming

Declarative programming is a style of building programs that express the logic of a computation without talking about its control flow.

What is declarative programming?

Declarative programming is a programming paradigm. The declarative property is where there can exist only one possible set of statements that can express each specific modular semantic. The imperative property3 is dual, where semantics are inconsistent under composition and/or can be expressed with variations of sets of statements.

Example in SQL:

SELECT * FROM Users WHERE Country='Mexico';

Languages that support:

  • SQL
  • Haskell
  • Prolog
  • Lisp
  • Miranda
  • Erlang

Logic programming (Constraint)

The logic programming paradigm is based on formal logic.

What is logic programming?

Logic programming is a programming paradigm where program statements express facts and rules about problems within a system of formal logic. Rules are written as logical clauses with a head and a body; for instance, “H is true if B1, B2, and B3 are true.” Facts are expressed similar to rules, but without a body; for instance, “H is true.”

Example:

/*We're defining family tree facts*/
father(John, Bill).
father(John, Lisa).
mother(Mary, Bill).
mother(Mary, Lisa).

/*We'll ask questions to Prolog*/
?- mother(X, Bill).
X = Mary 

Languages that support:

  • Absys
  • ALF (algebraic logic functional programming language).
  • Algorithmic program debugging
  • ASP (Answer Set Programming)
  • Logtalk
  • Parlog
  • Planner
  • PROGOL
  • Prolog
  • Prolog++
  • Prova
  • .QL

Structured programming

What is structured programming?

Structured programming is a programming paradigm that makes extensive use of the structured control flow constructs of selection (if/then/else) and repetition (for and while), block structures, and subroutines in contrast to using simple tests and jumps such as the go to statement, which can lead to “spaghetti code” that is potentially difficult to follow and maintain.

Example in BASIC:

DIM I 
FOR I = 0 TO 9 
  PRINT "HELLO" 
NEXT

Languages that support:

  • C
  • C++
  • C#
  • BASIC
  • PHP
  • Ruby
  • PERL
  • ALGOL
  • Pascal
  • PL/I
  • Ada

Event-driven programming

What is event-driven programming?

Event-driven programming is a programming paradigm in which the flow of program execution is determined by events – for example, user action such as a mouse click from the OS or another program. An event-driven application is designed to detect events as they occur and then deal with them using an appropriate event-handling procedure.

Example in Python:

import turtle

turtle.setup(400,500)                # Determine the window size
wn = turtle.Screen()                 # Get a reference to the window
wn.title("Handling keypresses!")     # Change the window title
wn.bgcolor("lightgreen")             # Set the background color
tess = turtle.Turtle()               # Create our favorite turtle

# The next four functions are our "event handlers".
def h1():
   tess.forward(30)

def h2():
   tess.left(45)

def h3():
   tess.right(45)

def h4():
    wn.bye()                        # Close down the turtle window

# These lines "wire up" keypresses to the handlers we've defined.
wn.onkey(h1, "Up")
wn.onkey(h2, "Left")
wn.onkey(h3, "Right")
wn.onkey(h4, "q")

# Now we need to tell the window to start listening for events,
# If any of the keys that we're monitoring is pressed, its
# handler will be called.
wn.listen()
wn.mainloop()

Languages that support:

  • Python
  • Javascript
  • C++
  • Java
  • VB
  • .NET

All object-oriented and visual languages support event-driven programming.

Modular programming

What is modular programming?

We have a separate article about modular programming that you might like: click here to view.

Example:

What is modular programming
What is modular programming

Languages that support:

  • Javascript
  • Python
  • Java
  • Go
  • C++
  • C#
  • Dart
  • Ruby

Almost all high-level lanuages

Aspect-oriented programming

What is Aspect-oriented programming?

Aspect-oriented programming is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns. It does by adding behavior to existing code without modifying the code itself, instead separately specifying which code is modified via a “pointcut” specification.

Example in Java:

void transfer(Account fromAcc, Account toAcc, int amount, User user,
    Logger logger, Database database) throws Exception {
  logger.info("Transferring money...");
  
  if (!isUserAuthorised(user, fromAcc)) {
    logger.info("User has no permission.");
    throw new UnauthorisedUserException();
  }
  
  if (fromAcc.getBalance() < amount) {
    logger.info("Insufficient funds.");
    throw new InsufficientFundsException();
  }

  fromAcc.withdraw(amount);
  toAcc.deposit(amount);

  database.commitChanges();  // Atomic operation.

  logger.info("Transaction successful.");
}

Languages that support:

  • .NET Framework languages
  • C / C++
  • Groovy
  • Haskell
  • Java
  • AspectJ
  • JavaScript
  • Lua
  • Perl
  • PHP
  • Python
  • Ruby
  • XML

Prototype-based programming

Prototype-based programming is a style of programming in which already-created objects are cloned and reused to construct a program or applications.

What is prototype-based programming?

Prototype-based programming is a programming paradigm. Prototype-based programming is a style of object-oriented programming in which classes are not explicitly defined, but rather derived by adding properties and methods to an instance of another class or, less frequently, adding them to an empty object.

Example in Javascript:

var a = {a: 1}; 
// a ---> Object.prototype ---> null

var b = Object.create(a);
// b ---> a ---> Object.prototype ---> null
console.log(b.a); // 1 (inherited)

var c = Object.create(b);
// c ---> b ---> a ---> Object.prototype ---> null

var d = Object.create(null);
// d ---> null
console.log(d.hasOwnProperty); 
// undefined, because d doesn't inherit from Object.prototype
// Base Object always has hasOwnProperty

Languages that support:

  • Javascript
  • Python
  • Ruby
  • Typescript
  • Lua

Data-driven programming

What is Data-driven programming?

Data-driven programming is a programming paradigm where the data itself controls the flow of the program and not the program logic. It is a model where you control the flow by offering different data sets to the program where the program logic is some generic form of flow or of state changes.

Example:

from User import User
from EmailService import EmailService

#
# rules data
#
rule_set = [
    {
        "country": ["fr"],
        "subject": "Bonjour et bienvenue sur notre site",
        "content": "Bonjour et Bienvenue sur notre tout nouveau site. Contactez l'équipe de support si vous avez des..."
    },
    {
        "country": ["us", "ca"],
        "subject": "Welcome to our site",
        "content": "Hello and Welcome to our brand new site. Contact support team if you have any questions."
    },
    {
        "min_age": 18,
        "subject": "Important reminder",
        "content": "Important: Please note that user under the age of 18 must provide a signed waiver from a parent ..."
    },
    {
        "payment_status": "Unverified",
        "subject": "Reminder about your payment status",
        "content": "Please don't forget to update your payment information on our site"
    }
]

#
# main function
#
def main():

    #
    # Fetch the current user
    #
    user = User()
    user.load_from_session()

    #
    # Process the config data and fire actions
    #
    for rule in rule_set:

        # Process country rule
        if "country" in rule and user.country in rule["country"]:
            EmailService.send(user.email, rule["subject"], rule["content"])

        # Process minimum age rule
        if "min_age" in rule and user.age < rule["min_age"]:
            EmailService.send(user.email, rule["subject"], rule["content"])

        # Process payment status rule
        if "payment_status" in rule and user.payment_status == rule["payment_status"]:
            EmailService.send(user.email, rule["subject"], rule["content"])

#
# run main
#
if __name__ == "__main__":
    main()

Languages that support:

  • Python
  • Oz
  • Perl
  • sed
  • Lua
  • Clojure
  • fdm
  • maildrop
  • procmail
  • Sieve

Conclusion

Programming paradigms reduce the complexity of programs. Programmers must know the programming paradigm approach. Each programming paradigm has its advantages and disadvantages.

Please feel free to let me know if you have any questions.

Thank you for reading.

Leave a Comment

Your email address will not be published. Required fields are marked *

Get an AMAZING ARTICLE for FREE that cost me 100$
Get an AMAZING ARTICLE for FREE that cost me 100$
Get inside Data of your Industry for FREE
You are only 2 steps away from complete research-based data.
This site uses cookies to improve your user experience.