Programming Paradigms

There are multiple programming paradigms:

Functional Programming

Functional programming is a computer science paradigm that revolves around building programs through the application and composition of functions.

It emphasizes a declarative approach, where function definitions form expression trees that transform input values into output values, as opposed to a series of imperative statements that alter the program's state.

Modular Programming

Separating the functionality of a program into independent, interchangeable modules, such that each contains everything necessary to execute only one aspect of the desired functionality.

Object Oriented Programming (OOP)

Concept of "objects" (sometimes objects of the real world like Person, Employee, Car, Truck) , which can contain data, , in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods).

‍Classes contain data and procedures.
Objects are instances of classes.

OOP idea inherently encompasses modular programming.

‍Features :

• Encapsulation
  ‍
  ‍Hiding fields (properties) of objects from outside interference. Using them with object procedures (methods) .
  ‍
• Inheritance
  
  ‍All the data and methods available to the parent class also appear in the child class with the same names.
  Allows easy re-use of the same procedures and data definitions, in addition to potentially mirroring real-world relationships in an intuitive way.
  
  Subclasses can override the methods defined by superclasses.
  
  ‍Abstract classes cannot be instantiated into objects; they exist only for the purpose of inheritance into other "concrete" classes which can be instantiated.
  
  ‍Interface generally defines the set of methods that an instance of a class that has that interface could respond to.
  
  A class can inherit only from 1 class but can inherit from multiple interfaces.
  ‍
• Object Composition
  
  ‍Objects can contain other objects in their instance variables
• Polymorphism
  
  Using same objects as their parent object (like instances of Employee and Manager classes stores in array of Person class.)
  
  With this you can call all parent class methods but in order to call for child class methods, you need to check if it is type/instance of child class and then cast to child class and call to child class methods.
  ‍
• Open Recursion
  
  ‍Object methods can call other methods on the same object (including themselves), typically using a special variable or keyword called this or self.
  
  This variable is late-bound; it allows a method defined in one class to invoke another method that is defined later, in some subclass thereof.

Structured Programming

Write with structures like statements (if-else), loops, blocks, subroutines.

Parallel Programming

Asynchrony is occurrence of events independent of the main program flow and synchrony is the opposite.
Use asynchrony with multithreading or multiprocessing.

‍Classifications of parallel programming models can be divided broadly into two areas: process interaction and problem decomposition.

Process Interaction

Process interaction relates to the mechanisms by which parallel processes are able to communicate with each other.

‍Shared memory is an efficient means of passing data between processes.
In a shared-memory model, parallel processes share a global address space that they read and write to asynchronously.
Asynchronous concurrent access can lead to race conditions, and mechanisms such as locks, semaphores and monitors can be used to avoid these (for example, 2 processes writing to file at the same time cause bug, so write to file using lock. Another example is print to screen with lock).

In a message passing model, parallel processes exchange data through passing messages to one another.
These communications can be asynchronous, where a message can be sent before the receiver is ready, or synchronous, where the receiver must be ready.

‍Implicit Interaction - In an implicit model, no process interaction is visible to the programmer and instead the compiler and/or runtime is responsible for performing it.

Problem Decomposition

Problem decomposition relates to the way in which the constituent processes are formulated.

‍Task Parallelism - A task-parallel model focuses on processes, or threads of execution. These processes will often be behaviourally distinct, which emphasises the need for communication.

‍Data Parallelism - A data-parallel model focuses on performing operations on a data set, typically a regularly structured array.
A set of tasks will operate on this data, but independently on disjoint partitions.

‍Implicit Parallelism - As with implicit process interaction, an implicit model of parallelism reveals nothing to the programmer as the compiler, the runtime or the hardware is responsible.