5 Programming Paradigms You Should Know About

5 Programming Paradigms You Should Know About

Pretty much the entire digital world that is so central to our lives today is built on computer programs. These are essentially how we instruct our devices to perform certain functions and solve problems. While machines work with binary code - just 0s and 1s - we humans have developed hundreds of programming languages that enable us to communicate with our computers. 

It’s not clear exactly how many programming languages exist today, but more are being created all the time. So it’s useful to organize these languages into categories that help us understand the similarities and differences between them. While there is no one definitive way to classify or group types of programming languages, one common approach is to divide them into core paradigms. These determine how your code is structured and organized.

Programming Paradigms

5 Programming Paradigms You Should Know About

The first distinction is between imperative and declarative programming languages.

Imperative programming expresses commands for the computer to perform - it is focused on the explicit process of how a program operates. For example, if you wanted to get the even numbers of an array, here’s what imperative code might look like:

5 Programming Paradigms You Should Know About

Declarative programming is higher-level, focused on logic and concepts rather than procedural flow. In other words, it is concerned with what needs to be done rather than exactly how it should be done. Using the same example as before, this is how declarative programming would solve the problem:

5 Programming Paradigms You Should Know About

We can also understand the difference between imperative and declarative with real-world examples. There are many out there, but here’s a simple one that we like:

Suppose a friend is coming to visit but doesn’t know where you live...

The imperative approach would be to give detailed directions for a particular route to your house.

The declarative approach would be to give your friend your address and let them decide which route they take to get there.

Now that we understand the key difference between imperative and declarative programming, we can look at some of the main programming paradigms in each category.

Imperative Paradigms


This language deals with procedure calls, which are also known as routines or functions. These contain a series of computational commands to be carried out to achieve a certain outcome. It is essentially like a recipe, with a list of step-by-step instructions for the computer program to follow. The code can easily be reused in different parts of the program. One benefit of this is that the code can be easy to learn and read in simple programs, though when dealing with something more complex you run the risk of ending up with a huge volume of code.

Examples: C, Pascal, BASIC.

Object-Oriented Programming (OOP)

This paradigm is based on the idea that code can be broken down into ‘objects’ that have different properties and perform different actions. Objects can interact with each other to achieve desired outcomes. A core principle of OOP is ‘encapsulation’, which involves wrapping all the object components (i.e. data and methods) into a single, self-sustaining unit (sometimes known as a ‘class’). OOP is a popular paradigm as it mimics our ‘real world’ view of objects, making it relatively simple to grasp. Due to encapsulation, objects/classes can be reused easily, while it is also scalable and secure.

Examples: C++, Java, Python.

Parallel Processing

The basic idea behind this paradigm is to break up different parts of a task among multiple processors, which simultaneously work on a problem. It’s like having someone make a sauce while you prepare the pizza base - you reduce the time it takes to complete the whole task. With a computer, this implies connecting multiple processors to memory, which is either pooled across all processors or distributed over a network. As such, this typically requires software and hardware resources. A number of programming languages can support parallel processing.

Examples: C, C++, MPI.


Declarative Paradigms


This programming is based on the notion of formal logic. Programs are written as a series of facts and rules that follow a logical structure (e.g. ‘X is true if Y and Z are true’). This logic serves as a knowledge framework through which computers can produce certain results - rather than being told explicitly what to do, a computer is given the boundaries for what it should be considering. Logic programming is primarily declarative as machines can use reason to solve a problem, though in some cases imperative commands can also be included in the code. Logic programming can be used for research and testing complex theorems - it is also closely connected to development of machine learning and artificial intelligence. Key benefits include flexibility and minimalist syntax. However, it can be confusing if the logical rules are not expressed well. 

Examples: Prolog, Datalog, Mercury.


As the name suggests, this paradigm is based on the execution of a series of mathematical functions, which form the building blocks of the program and perform all manner of tasks. These languages avoid flow controls like loops and instead favor recursive functions. This paradigm reduces code complexity and can be used to solve complex problems. However, it can be difficult to learn and tricky to scale for larger projects. As with the logic paradigm, some functional programming languages can also support imperative style programming if required. 

Examples: JavaScript, Haskell, Scala.


As with many things in software development, there is no objectively ‘right’ or ‘best’ programming paradigm. It all depends on what you need to do, what resources you have available, and who else is working on the project. Often, you’ll find that blending some declarative and imperative programming, which as we’ve seen is supported by some languages, is the optimal solution. 

Most important is finding a skilled and experienced programmer that knows when to use the different paradigms to maximize the benefits of each. And that is something that we at Jobsity can help you out with - just get in touch to find out how!


Interested in hiring talented Latin American developers to add capacity to your team? Contact Jobsity: the nearshore staff augmentation choice for U.S. companies.

Jun 03, 2021
Mauricio Lopez
Mauricio Lopez

Mauricio has been at the forefront of technology for 12 years. He is constantly integrating new technologies including frameworks, CMS, and standard industry models. He is a pragmatic problem-solver and customizes solutions based on the best schema/language/application for each project. As head of technology at Jobsity, he ensures that his team is always up to date with the latest advances in software development by researching the software ecosystem, implementing several professional development initiatives, and coordinating with new and existing clients about their needs.
He holds a BA in Business and Marketing from UTEG Ecuador

Subscribe for the updates


Better hires, more work, less stress. Join the Jobsity Community. Contact Us