Website uses cookies. Cookies remember your actions and preferences for a better online experience. We don`t share information with third parties without your knowledge.
Today on the BizUPLab blog we are going to look at the history of programming paradigms and, most importantly, we are going to try to understand how all these paradigms are combined and used in modern programming languages.

Programming paradigms are a set of methods, concepts, principles, techniques and tools that define the way a program is organised and executed in a programming language. In simple terms, a paradigm describes how and by what rules a developer should write code.

In the twentieth century, computer technologies were actively developing and the number of tasks that could be solved with their help was increasing in parallel. In order to solve these tasks, it was necessary to invent various methods and approaches to writing code that would simplify the development process considerably.

Programming Paradigms

This can be seen in the development of programming languages: low-level languages such as Assembler gradually faded into the background as high-level languages such as Java, C# and JavaScript became popular. Similarly, all these languages have been designed with the experience of previous generations in mind.

Imperative and structural paradigms
Imperative programming is at the heart of it all. It has a simple rule: use a set of instructions to describe the programme algorithm clearly and consistently.

The whole process was complicated by the fact that the programmer had only a conditional set of processor instructions at his disposal and had to write a large amount of code whose execution would produce a particular result. Assembler is a good example of this. All the code is a simple sequential set of instructions, each of which can take one or more arguments.

Then the control statements for branching and looping, otherwise known as if/then/else and do/until/while, were invented. All this led to the emergence of structured programming, also known as procedural programming. It also made it possible to break code into different logical parts and to structure the architecture of an application.

A prime example of a structured language is C, from the older languages Basic and Pascal. However, although C was created with the procedural programming paradigm in mind, it also belongs to the imperative paradigm. This is due to the fact that C maintains continuity: the instructions sequentially describe an algorithm that is executed from top to bottom.
Object Oriented Programming
The logical extension of the structural paradigm is the object-oriented paradigm. It emerged almost spontaneously. Several programmers working with the structural language Algol happened to notice that if you declare variables in a subroutine and place them not on the stack but in a memory area called the heap, then all nested subroutines can later refer to these variables. The subroutine in which the variables were declared became known as the class constructor. These ideas were further developed in languages such as Smalltalk, and later in C++. OOP took its more modern form with the advent of Java.

The advent of object-oriented programming gave a strong boost to the industry as a whole. Concepts such as class and object were introduced, and polymorphism of subtypes became possible, allowing programmers to develop similar implementations of program logic in different ways.

As a result, there are many progressive programming languages that incorporate some or all of the different paradigms. For example, Java quietly follows the imperative paradigm and also uses techniques from the structural paradigm, but not fully. A Java program cannot be written in a procedural style because it is completely object-oriented. A Java program always starts with a class, which must have a Main method, and if there is a class, then we are following the object-oriented paradigm.

At the same time, there is an opposite example - Python. It also has classes, it can safely be called an object-oriented language, but nobody forbids writing code completely in procedural style.

An important foundation is laid by the architect of a programming language when it is created, and depending on the paradigm's bias in favour of one or the other, you get different possibilities and programming styles that developers can use.
We help business people manage their resources efficiently and systematically achieve success.
1114 Budapest, Bartók Béla út 66. 3. em. 4.
Contact Info
Copyright © BizUPLab, 2023 - 2024