Programming Paradigms

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Students are expected to understand the term and meaning behind programming paradigms
Students should be able to demonstrate their understanding of the most common programming paradigms in their programming lab activities

Programming Paradigms

Programming Paradigms (1)

Different styles in which a program (or programming language) can be organised
It consists of certain structures, features and opinions on how common programming problems can be solved
There are many paradigms, with each being better suited for a given type of problem
- different paradigms may be used for different projects etc
Paradigms are not a language or a tool
- you do not build anything with a paradigm
- they are more akin to a set of ideals and guidelines
Paradigms are not mutually exclusive
- i.e. some languages may use more than one paradigm

Programming paradigms refer to a particular style of programming. It does not refer to a particular programming language, instead it refers to the way in which you would be programming. As you may know, there are many languages when it comes to programming, but all of them need to follow some sort of strategy when it comes to their implementation, this itself is a paradigm.

As there are many languages for programming, there is also a large number of paradigms; with each particular paradigm being better suited for a given type of problem. It is important to clarify that a paradigm is not a language or a tool used for solving a problem. Instead, it is better to see it as a set of ideas and/or guidelines to follow when providing a solution or the problem. You may actually use more than one type of paradigm when it comes to writing your solution as they are considered to not be mutually exclusive.

Programming Paradigms (2)

Programming Languages and Programming Paradigms

Programming languages are generally not tied to a specific paradigm
Some have been built with certain paradigms in mind
- e.g. Haskel and functional programming
There are languages with a “multi-paradigm” approach
- code can be adapted to fit one paradigm or another
- e.g. JavaScript and Python

As I have mentioned, programming languages are not tied to a specific paradigm; some of them have been built with a certain paradigm in mind. For example, the Haskel programming language has been designed in a manner that takes into account the functional paradigm (more on this later in the lecture).

However, there are languages with a multi-paradigm approach, some such examples you will be familiar with are Python and JavaScript. Each of these languages has been developed in a manner that they use multiple paradigms in the structure of their language. For example, Python utilises object orientation alongside the use of functional programming.

Programming Paradigms (3)

Types of Programming Paradigms

There are two types of paradigms:
1. Imperative
2. Declarative
Each paradigm depends upon the:
- programming language features
- style of organising the sourcecode

Imperative Paradigms

Imperative Paradigms (1)

This is a command-driven paradigm
The programming language directs the program execution
- executed as a sequence of statements, one-by-one
Consists of a set of program statements
- each statement will direct the computer to perform a specific task
The programmer elaborates each statement in detail, here each statement directs the following:
- what needs to be done?
- how will it be done?
Examples of imperative paradigm programming languages:
- e.g. Fortran, Pascal and Basic
There are several types of imperative paradigms:
1. Procedural Programming
2. Object-Oriented Programming
3. Parallel Processing Approach

sum = 0
sum += 1
sum += 2
sum += 3
sum += 4
sum += 5

The sum is: 15

The first type of programming paradigms we shall begin with are imperative paradigms. The word imperative comes from the Latin word “impero” meaning “I command”. It is the same word that “emperor” comes from, and in this instance it is quite fitting. You can consider yourself to be the emperor of the computer, and you shall give the computer orders to do. In return, the computer will act upon your orders one at a time and report back to you.

This type of paradigm consists of several statements, and after the execution of them all, the result is stored. In essence, we are concerned with writing a list of instructions to tell the computer what to do; step-by-step. The programmer will then elaborate upon each task in detail, telling the computer what needs to be done and how it will be done.

In an imperative programming paradigm, the order in which the steps are done can be considered crucial. A given step in the sequence will have different consequences depending upon the current values of the variables when the step is executed. Let’s have a look at an example.

In our example, we are concerned with summing the first five numbers in an imperative paradigm approach. We are telling the computer what to do line-by-line; in this instance, we keep summing up the next natural number in the order. Finally, in the end, we are storing the value and then printing it to the window.

Within the imperative programming paradigm, there are a few sub-paradigms, and these include: procedural, object-oriented programming, and the parallel processing approach. We shall now look at each type of paradigm in detail.

Imperative Paradigms (2)

Procedural Programming

Allows the splitting of instructions into procedures
Procedures are not functions
- functions return a value, whereas procedures do not
The primary purpose is to accomplish a given task
- intended to cause a desired side effect
Examples of procedural paradigm programming languages:
- e.g. C, C++, Java and Pascal
Advantages of procedural programming are:
- code is compact and reusable
- breaks problems into smaller problems
- utilises CPU storage effectively

sum = 0
for i in range(1, 6):
    sum += i

The sum is: 15

Procedural programming, which is a subclass of imperative programming, allows the splitting of instructions into procedures. It is important to note here that procedures are not a function, with the main difference between them being that a function would return a value and procedures do not. More specifically, functions should also be designed in a fashion that they have minimal side effects, and always produce the same output when given the same input.

In case you are not aware, a side effect is when a function relies upon (or modifies) something outside the function. For example, this may be reading or writing from variables outside its own arguments, such as a database or a file.

The primary purpose of a procedure is to accomplish a given task and cause a desired side effect. An example of this would be a control statement, i.e. a for loop. The loop’s main purpose is to cause side effects and not return a value. Let’s revisit our example from earlier and count the first five numbers using a procedural programming approach.

We can see from our example code on the screen that a control statement has been used to sum the first five numbers. Resulting in a similar output to the imperative programming approach, but simplifying the number of steps and orders that we need to present to the computer.

Some key advantages of using procedural programming are:

the code is often more compact and reusable, as such it does not have a need for large memory requirements
the problem can be broken into smaller problems, thus making them accessible and faster to solve

Imperative Paradigms (3)

Object-Oriented Programming

A common paradigm approach often used in programming
It consists of unique advantages, such as modularity of the code
Key characteristics of this approach are:
- classes, abstraction, encapsulation, inheritance and polymorphism
An object is an instance of a class
The object will consist of:
- attributes/states: the data associated with the object
- methods/behaviours: the actions/functions that the object can perform
Examples of object-oriented paradigm programming languages:
- e.g. C++, Java, Ruby, and Python

class Calculator:
    def __init__(self, n):
        self.n = n
        self.__sum = 0

    def add_numbers(self):
        for i in range(0, self.n + 1):
            self.__sum += i
        return self.__sum

The sum is: 15

You should remember the concept of object-orientation from the first year programming module. However, for those of you who may have forgotten about the concept, I shall briefly re-introduce the concept to you.

Object-orientation is one of the most popular paradigm approaches used due to its advantages, such as modularity of the code and the ability to directly associate real-world problems in terms of code. Some key characteristics of this paradigm are: classes, abstraction, encapsulation, inheritance and polymorphism.

Abstraction is concerned with separating the interface from its implementation, whilst encapsulation is the process of hiding the internal implementation of an object. Inheritance on the other hand enables a hierarchical relationship to be represented and refined; whereas polymorphism will allow objects of different types to receive the same message but respond in a different way. If you need to know more about object-orientation, I would recommend revisiting the first year programing modules lecture.

A class is considered to be a template or blueprint from which an object is created. An object will be an instance of this class and will contain attributes and methods. Attributes refer to the data associated with that object, and the methods are the actions that can be performed by that object.

Let’s have a look at our continuing example, summing up the first five numbers but this time in an object-oriented way. In the example on the right-hand-side of the screen, we have a class, aptly named calculator. The class consists of two attributes: n and sum. We also have a method that is called add_numbers which will return our variable called sum.

To use our class Calculator we need to create a new object. In this instance, we have named our object calc which will create an instance of class Calculator and pass through the value 5 as these are the range of numbers we want to add together. We can then use our newly created object to access the function add_numbers which will begin iterating through the sequence of numbers and summing them together.

It is important to note that in this example, I have set the variable sum to private by using two underscores at the beginning of the variable name. This means that the variable is not accessible from outside the object and from only inside it. To access this variable, it would need to either be returned from a function (as it is in add_numbers) or a separate function needs to be created to retrieve and or modify the value.

Imperative Paradigms (4)

Parallel Processing Approach

Concerned with processing of the instructions across multiple processors
Implies basic assumptions about the fundamental hardware components
- i.e. how are the processors and memory connected to one another?
Parallel computing always involves multiple processors
- could also refer to cores on a CPU
Two main methods of parallel programming:
1. Shared Memory
2. Distributed Memory

Refer to examples and demonstrations in the next lecture, Threading in Python

Parallel programming is concerned with splitting the tasks or instructions of a script across multiple processors. This can help computers or mobile phones with multitasking. For example, running multiple programs and the operating system simultaneously. When it comes to solving a problem for a project, it is concerned with splitting up the tasks into smaller subprojects and running each problem on a different processor.

Parallel processing makes basic assumptions about the fundamental hardware components inside the machine. One example of this is to determine how the processors and memory in the machine are connected to each other. This type of programming is always involved with multiple processors (sometimes referred to as the cores of a CPU). As mentioned before, we are concerned about how the memory of the machine is organised. If the machine only has a single processor, then it is clear that the processor will need to access all of this memory. However, when we have more than one processor, then we need to consider how these processors will be connected to the memory.

You may want to consider whether the memory is used in parallel, or should it remain as one and homogeneous. Similar to as if it was just a single processor. These are fundamental questions you need to ask when designing a project with parallel computing as it could have an enormous and expensive consequence for the hardware.

There are two main types of parallel programming: shared and distributed memory. Shared memory is where multiple processing units all have access to the same, shared, memory space. This is what is currently utilised on your computer and mobile phone with multiple CPU cores. A distributed memory model, the multiple processing units each have their own memory store, and the information is passed between them. This approach is typically used in a cluster of networked computers.

There is much more I can discuss in regard to parallel computing. You will find out more in the next lecture where we discuss how Python can go about parallel computing, otherwise known as threading.

Declarative Paradigms

Declarative Paradigms (1)

Focuses on the logic of the program and the result
The control flow is not an important element of the program
The opposite method of programming compared to imperative programming
- i.e. the programmer does not give instructions about how a task should be executed
The JavaScript language consists of some declarative functions
- i.e. filter, sort, reduce and map
There are a few common types of declarative programming:
1. Functional Programming
2. Logical Programming

We now move onto our next type of programming paradigms, declarative. This type of paradigm will often focus upon the logic of the program and its result. When it comes to this style of programming, we are generally not concerned about the control flow. The term control flow describes the order in which the computer will execute statements/instructions in the script.

With this type of programming, the programmer will define what needs to be accomplished by the program without the need of having to explicitly define how it needs to be implemented. Essentially, we focus upon what needs to be achieved rather than the instructions on how to achieve it.

Whereas imperative programming focuses upon telling the computer how to do something, it is different with declarative as we are concerned with telling the computer what to do instead. For example, the Javascript language consists of some declarative functions, such as filter, sort and reduce. The naming of the functions themselves is quite intuitive about the functionality they offer.

Within the declarative programming paradigm, there are a couple of sub-paradigms, and these include: functional and logical programming. We shall now look at each type of these paradigms over the next couple of slides.

Declarative Paradigms (2)

Functional Programming

Concerned about the software/script construction by creating pure functions
It avoids the concept of shared variables and mutable data
Has an emphasis on expressions and declarations
- instead of execution of statements
There are no local or global variables which in-turn reduce side effects
- i.e. changes cannot be made to variables outside the functions environment
Increased modularity of the code and a lack of side effects improves the code maintainability
Examples of object-oriented paradigm programming languages:
- e.g. JavaScript, Haskell and Python

def is_prime(n):
    if n < 1:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

is_prime(3) -> True

is_prime(15) -> False

The first declarative programming paradigm we shall be looking at is functional programming. With this type of paradigm, we are concerned with building our script with pure functions. This paradigm has its root in mathematics and is considered to be language independent. The key principal is executing a series of mathematical functions.

We structure our code in a fashion where it is encompassed within functions, and all the variables are scoped to the function. In this instance, there are no local or global variables which can reduce the number of side effects. The functions therefore do not modify any values that are outside the scope of the function, and the functions themselves are not affected by any values that are outside their scope.

Let’s have a look at an example together of functional programming. On the right-hand-side of the screen you can see a function, written in Python that determines whether a given number is a prime number or not. The parameter n is sent to the function and will not be affected by any other values that may exist outside the scope of the function. The function itself, is_prime, will always produce the same output, when given the same input. For example, when we feed value three to our function, we shall always get the response True and when we feed value 15 we shall always get the response False.

Functional programming is a great choice when you are working with mathematical functions, or with applications that are aimed at concurrency or parallelism.

Declarative Paradigms (2)

Logical Programming

A programming paradigm based upon logic and control
Foundations lay within the mathematical logic
- programming statements express facts and rules about problems in a system
- i.e. \(z\) is True if \(x\) and \(y\) are also True
It serves as a framework through which computers can produce certain results
Instead of being explicitly told what to do
- a computer is given boundaries within which it should be considering
It can be used to express knowledge that does not depend upon the implementation
- programs are more flexible, compressed and understandable

We shall now move on and look at our second declarative programming paradigm, logical programming. This paradigm is based upon solving a problem using formal logic. This paradigm does not follow the process of using instructions; instead it is made up of facts and clauses. For example, it would use everything it knows and tries to come up with the world where all of those facts and clauses are true.

An example of this is where z is true, if and only if x and y are also true. You may have come across this from your days of studying boolean algebra. This form of programming serves as a framework through which computers can produce certain results. Instead of instructing the computer on what to do, it is instead given a set of boundaries for it to operate within and what it should be considered. Thus, they can be used to express knowledge that does not depend upon the implementation. Resulting in programs/scripts that are more flexible, compressed and understandable.

Goodbye

Goodbye (1)

Questions and Support

Questions? Post them on the Community Page on Aula
Additional Support? Visit the Module Support Page
Contact Details:
- Dr Ian Cornelius, ab6459@coventry.ac.uk