Multi-Paradigm Programming and Scripting

File:Some_important_programming_concepts.pdf

Why Multi-Paradigm Programming and Scripting?
Universal programming constructs (invariant of language), their functions, uses and how different paradigms/languages employ them. Improved background for choosing appropriate languages:
Content of this course
Programming Constructs: The compilation process Data types (strongly-typed, weakly-typed) Pointers Variables and Invariants Conditionals (Selection) Sequence Repetition Routines Concurrency	Programming Paradigms & Languages: Abstraction (machine to very-high-level) Mark-up Imperative & Declarative Procedural Parallel & Concurrent Functional Event-Driven Multi-Paradigm Languages Interpreted Languages Comparison of all to Object Oriented Paradigm	Scripting: Interpreters and system commands Shell Scripting (Linux/UNIX) PowerShell Scripting (Windows) System Programming & Scripting	Applications of Shell Scripting: Job Control Glue Code / Wrappers Automating Tasks Data Processing / Transformation System uses I/O tasks and functions

Some important programming concepts

High level - Low Level Programming

Compilation vs Interpretation

https://medium.com/@DHGorman/a-crash-course-in-interpreted-vs-compiled-languages-5531978930b6

https://guide.freecodecamp.org/computer-science/compiled-versus-interpreted-languages/

Speaking simplistically, compiled languages are those which are written in one language and, before being run, translated or "compiled" into another language, called the target language (typically in machine language that the processor can execute). Once the translation is complete, the executable code is either run or set aside to run later. Some common compiled languages include C, C++, Delphi and Rust.

The compiler translates the high-level source program into an equivalent target program (typically in machine language).

The alternative to using a compiler (for a compiled language) is using an interpreter (for interpreted languages). Interpreted languages are compiled at runtime. What this allows for is a lot more flexibility, especially when it comes to a program adaptively modifying its structure. This flexibility does have a cost; interpreted languages are considered significantly slower.

Interpreters will run through a program line by line and execute each command.

Advantages and Disadvantages

Compiled Languages:

• Advantages:

• Programs compiled into native code are faster than those translated at run time, due to the overhead of the translation process.

• Disadvantages:

• The compilation code usually will only be able to run in the platform where the program was compiled. This is solved in Java by the implementation of the Java Virtual Machine.

Interpreted Languages:

• Advantages:

• An Interpreted language gives implementations some additional flexibility over compiled implementations. Because interpreters execute the source program code themselves, the code itself is platform independent. Other features include dynamic typing, and smaller executable program size.
• Better diagnostics (error messages).

• Disadvantages:

• The most notable disadvantage is the execution speed, which is less compared to compiled languages.

Interpreted languages were once known to be significantly slower than compiled languages. But, with the development of just-in-time compilation, that gap is shrinking.

Phases of Compilation

Compiler operates in various phases each phase transforms the source program from one representation to another. Every phase takes inputs from its previous stage and feeds its output to the next phase of the compiler. https://www.guru99.com/compiler-design-phases-of-compiler.html

Phases of Compilation: https://www.guru99.com/compiler-design-phases-of-compiler.html

Phases of Compilations

• Lexical analysis:
• Syntax analysis:
• Semantic analysis:
• Intermediate code generator:
• Code optimizer:
• Code generator:

Subprogram - subroutines - Procedure - Function - Method - etc

In computer programming, a Subprograms is a sequence of program instructions that performs a specific task, packaged as a unit. This unit can then be used in programs wherever that particular task should be performed.

In different programming languages, a subroutine may be called a procedure, a function, a routine, a method, or a subprogram. https://en.wikipedia.org/wiki/Subroutine

Luego de revisar varias referencias. No creo que haya diferencias claras entre estos términos. Hay diferencias dependiendo del lenguaje de programación. Sólo he encontrado una diferencia que parece ser mencionada en varias fuentes:

• Functions return values and procedures do not. Sin embargo, no todas las fuentes concuerdan con esto. See this source: https://softwareengineering.stackexchange.com/questions/20909/method-vs-function-vs-procedure

You might say a function returns a value. Well, the following C function doesn't return a value:

void f() { return; }

...but I doubt you'd find anyone who would call it a procedure.

Sure, in Pascal, procedures don't return values and functions return values, but that's merely a reflection of how Pascal was designed. In Fortran, a function returns a value, and a subroutine returns multiple values. Yet none of this really allows us to come up with a "universal" definition for these terms.

In fact, the term "procedural programming" refers to a whole class of languages, including C, Fortran and Pascal, only one of which actually uses the term "procedure" to mean anything.

So none of this is really consistent.

The only exception is probably method, which seems to be used almost entirely with OO Languages, referring to a function that is associated with an object. Although, even this is not always consistent. C++, for example, usually uses the term "member function" rather than method, (even though the term "method" has crept into the C++ vernacular among programmers.)

The point is, none of this is really consistent. It simply reflects the terminology employed by whatever languages are en vogue at the time.

A real distinction is when we talk about a function in Functional programming. If you like to keep a function clean (just look at functional languages) you need to make sure a function does not have a side effect. However, in all the procedural or OOP languages we refer to functions that don't really meet the exact mathematical definition of a function that is used in Functional programming. https://stackoverflow.com/questions/721090/what-is-the-difference-between-a-function-and-a-procedure/721107

Subprogram header is the fist part of the definition including the name, the kind of subprogram, and the formal parameters.

The parameter profile (aka signature) of a subprogram is the number, order and types of its parameters.

The protocol is a subprogram parameter profile and, if it is a function, its return type.

There are tow categories of subprograms: (This is from Muhammad slides. I have already explained what I found in my research about the difference between Procedures and Functions).

• Procedures: Are collection of statements that define parameterized computations.
• Functions: Structurally resemble procedures but are semantically modeled on mathematical functions.

Design issues for Subprograms:

• Are local variables static or dynamic?
• What types of values can be returned from functions?
• How many values can be returned from functions?
• Can subprograms be overloaded?
• Can subprogram be generic?
• Is the language allowed nested subprograms?

Some important concepts around Subprograms are:

• Parameter-passing:

• Pass-by-Value (In Mode)
• Pass-by-Result (Out Mode)
• Pass-by-Reference (Inout Mode)

• Local referencing environments
• Generic subprograms
• Overloaded subprograms

Generic subprograms

A generic subprogram is one that takes parameters of different types on different activation.

Following example illustrates how we can print an array of different type using a single Generic method: https://www.tutorialspoint.com/java/java_generics.htm

public class GenericMethodTest {
   // generic method printArray
   public static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
      }
      System.out.println();
   }

   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("\nArray characterArray contains:");
      printArray(charArray);   // pass a Character array
   }
}

Overloaded subprograms

An overloaded subprogram is one that has the same name as another subprogram in the same referencing environment. However, every version of an overloaded subprogram has a unique protocol.

C++, Java, C#, and Ada include predefined overloaded subprograms. They allow users to write multiple versions of subprograms with the same name and different protocols. In Ada, the return type of an overloaded function can be used to disambiguate calls (thus two overloaded functions can have the same parameters)

Variables

A name is a string of characters used to identify some entity in a program. Variable names are the most common names in the programs.

• Are names case sensitive?
• Length?
• etc...

Names with special characters:

• PHP: All variable names must begin with dollar signs
• Perl: All variable names begin with special characters, which specify the variable's type
• Ruby: Variable names that begin with @ are instance variables; those that begin with @@ are class variables

Case sensitivity names:

• Names in the C-based languages are case sensitive. Not in others languages.

Variables

A variable is an abstraction of a memory cell.

Variables can be characterized as a sextuplet (six parts) of attributes:

• Name
• Address
• Value
• Type
• Lifetime
• Scope

Address: The memory address with which it is associated.

• A variable may have different addresses at different times during execution.
• A variable may have different addresses at different places in a program.
• If two variable names can be used to access the same memory location, they are called aliases.
• Aliases are created via pointers, reference variables, C and C++ unions
• Two pointer variables are aliases when they point to the same memory location. The same is true for reference variables.
• Aliases are harmful to readability (program readers must remember all of them).

Type: Determines the range of values of variables and the set of operations that are defined for values of that type; in the case of floating point, type also determines the precision

For example, the int type in Java specifies a value range of -2147483648 to 2147483647

Value: The value of a variable is the contents of the memory cell or cells associated with the variable:

• The l-value of a variable is its address
• The r-value of a variable is its value

Data type

A data type, in programming, is a classification that specifies which type of value a variable has and what type of mathematical, relational or logical operations can be applied to it without causing an error. A string, for example, is a data type that is used to classify text and an integer is a data type used to classify whole numbers.

Descriptor: It's the collection of the attributes of a variable.

Ex.:

Compile-time descriptor for a single-dimensional array

Compile-time descriptor for a multidimensional array

				Example
Primitive Data Types Primitive data types are those not defined in terms of other data types. Almost all programming languages provide a set of primitive data types	Integer	byte
		short
		int
		long
	Floating Point	float
		double
	Complex		Each value consists of two floats, the real part and the imaginary part
	Boolean
	Character		Stored as numeric codings Most commonly used coding: ASCII
Character Strings			Design issues Values are sequences of characters Is it a primitive type or just a special kind of array? Should the length of strings be static or dynamic?
Arrays			An array is a homogeneous aggregate of data elements in which an individual element is identified by its position in the aggregate, relative to the first element. Index Syntax Fortran and Ada use parentheses. Most other languages use brackets. Rectangular and Jagged Arrays: A rectangular array is a multi-dimensional array in which all of the rows have the same number of elements and all columns have the same number of elements A jagged matrix has rows with varying number of elements Possible when multi-dimensional arrays actually appear as arrays of arrays C, C++, and Java support jagged arrays F# and C# support rectangular arrays and jagged arrays Slices: A slice is some substructure of an array; nothing more than a referencing mechanis Slices are only useful in languages that have array operations. Ex. Python, Ruby	Slicing in Python: Python vector = [2, 4, 6, 8, 10, 12, 14, 16] mat = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] vector (3:6) is a three-element array mat[0][0:2] is the first and second element of the first row of mat Ruby supports slices with the slice method: list.slice(2, 2)
Associative Arrays			An associative array is an unordered collection of data elements that are indexed by an equal number of values called keys: Ex: Python: Dictionary C++: Associative arrays Perl: Associative Arrays	Associative Arrays in Perl # Names begin with %; literals are delimited by parentheses %hi_temps = ("Mon" => 77, "Tue" => 79, "Wed" => 65, ...); # Subscripting is done using braces and keys $hi_temps{"Wed"} = 83; # Elements can be removed with delete delete $hi_temps{"Tue"};
Record			A record is a possibly heterogeneous aggregate of data elements in which the individual elements are identified by names
Enumeration			All possible values, which are named constants, are provided in the definition. No enumeration variable can be assigned a value outside its defined range	C# example: enum days {mon, tue, wed, thu, fri, sat, sun};

Pointer

Pointers store address of variables or a memory location.

A pointer is a variable that stores the address of another variable. Unlike other variables that hold values of a certain type, pointer holds the address of a variable. For example, an integer variable holds (or you can say stores) an integer value, however an integer pointer holds the address of a integer variable. https://beginnersbook.com/2014/01/c-pointers/

• A pointer type variable has a range of values that consists of memory addresses and a special value, nil.

• Provide the power of indirect addressing

• Provide a way to manage dynamic memory

• A pointer can be used to access a location in the area where storage is dynamically created (usually called a heap)

Pointers in C and CPP

To use pointers in C, we must understand below two operators: & and *
Ampersand (&):	The unary operator & (ampersand) returns the address of that variable. For example &x gives us the address of the variable.	// The output of this program can be different in different runs. // Note that The program prints address of a variable and a variable // can be assigned different address in different runs. #include <stdio.h> int main() { int x = 10; // Prints address of x printf("%p", &x); return 0; }
Unary (Asterisk) (*) : It is used for two things:	To declare a pointer variable: When a pointer variable is declared in C/C++, there must have a * before its name.	// C program to demonstrate declaration of // pointer variables. #include <stdio.h> int main() { int x = 10; // 1) Since there is * in declaration, ptr becomes a pointer // varaible (a variable that stores address of another variable) // 2) Since there is int before *, ptr is pointer to an integer // type variable int *ptr; // & operator before x is used to get address of x. // The address of x is assigned to ptr. ptr = &x; return 0; }
	To access the value stored in the address. The unary operator (*) returns the value of the variable located at the address specified by its operand.	// C program to demonstrate use of * for pointers in C #include <stdio.h> int main() { // A normal integer variable int x = 10; // A pointer variable that holds address of var. int *ptr = &x; // This line prints the value at the address stored in ptr. // The Value stored is the value of variable "x" printf("Value of x = %d\n", *ptr); // The output of this line may be different in different // runs even on the same machine. printf("Address of x = %p\n", ptr); // We can also use ptr as lvalue (Left hand side of assignment) *ptr = 20; // Value at address is now 20 // This prints 20 printf("After doing *ptr = 20, *ptr is %d\n", *ptr); return 0; }	j = *ptr

Recursion

https://www.python-course.eu/recursive_functions.php

https://www.geeksforgeeks.org/recursion/

The process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called as recursive function. Using recursive algorithm, certain problems can be solved quite easily. Examples of such problems are Towers of Hanoi (TOH), Inorder/Preorder/Postorder Tree Traversals, DFS of Graph, etc.

A VERY VERY NICE example of recursion is the factorial function: https://www.geeksforgeeks.org/program-for-factorial-of-a-number/

Example:
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1
Replacing the calculated values gives us the following expression
4! = 4 * 3 * 2 * 1

Iterative solution (Java):

class Main{
    static int factorial(int n){
        int res = 1;
        for (int i=2 ; i<=n ; i++)
          res *= i;
        return res;
    }
    public static void main(String[] args){
        System.out.println(factorial(6));
    }
}

Recursive solution (Java):

class Main{

    static int factorial(int n){
        if (n == 0)
          return 1;
        return n*factorial(n-1);
    }

    public static void main(String[] args){
        System.out.println(factorial(5));
    }

}

One line Solution (Using Ternary operator) (Java):

class Main{ 
  
 int factorial(int n){
    return (n == 1 || n == 0) ? 1 : n * factorial(n - 1); 
  } 

  public static void main(String args[]){ 
    Main obj = new Main(); 
    System.out.println(obj.factorial(6));
  } 

}

Binding

A binding is an association between an entity and an attribute, such as between a variable and its type or value, or between an operation and a symbol.

Binding time is the time at which a binding takes place. Bindings can take place at:

• Language design time
• Language implementation time
• Compile time
• Load time
• Link time
• Run time

For example:

• The asterisk symbol (*) is usually bound to the multiplication operation at language design time. At compile time, a variable in a Java program is bound to a particular data type.
• Language design time: Bind operator symbols to operations
• Language implementation time: Bind floating point type to a representation
• Compile time: Bind a variable to a type in C or Java
• Load time: Bind a C or C++ static variable to a memory cell
• Runtime: Bind a nonstatic local variable to a memory cell

Static vs Dynamic Binding

https://techdifferences.com/difference-between-static-and-dynamic-binding.html

A binding is static if it first occurs before run time and remains unchanged throughout program execution.

A binding is dynamic if it first occurs during execution or can change during execution of the program.

Static vs Dynamic Binding in Java

https://www.geeksforgeeks.org/static-vs-dynamic-binding-in-java/

Static Binding:

The binding which can be resolved at compile time by compiler is known as static or early binding. Binding of all the static, private and final methods is done at compile-time .

Why binding of static, final and private methods is always a static binding?

Static binding is better performance wise (no extra overhead is required). Compiler knows that all such methods cannot be overridden and will always be accessed by object of local class. Hence compiler doesn’t have any difficulty to determine object of class (local class for sure). That’s the reason binding for such methods is static. Let’s see by an example:

public class NewClass 
{ 
    public static class superclass 
    { 
        static void print() 
        { 
            System.out.println("print in superclass."); 
        } 
    } 
    public static class subclass extends superclass 
    { 
        static void print() 
        { 
            System.out.println("print in subclass."); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        superclass A = new superclass(); 
        superclass B = new subclass(); 
        A.print(); 
        B.print(); 
    } 
}

Output:

print in superclass.
print in superclass.

As you can see, in both cases print method of superclass is called. Lets see how this happens:

• We have created one object of subclass and one object of superclass with the reference of the superclass.
• Since the print method of superclass is static, compiler knows that it will not be overridden in subclasses and hence compiler knows during compile time which print method to call and hence no ambiguity.

As an exercise, reader can change the reference of object B to subclass and then check the output.

Dynamic Binding:

In Dynamic binding compiler doesn’t decide the method to be called. Overriding is a perfect example of dynamic binding. In overriding both parent and child classes have same method . Let’s see by an example:

public class NewClass 
{ 
    public static class superclass 
    { 
        void print() 
        { 
            System.out.println("print in superclass."); 
        } 
    } 
  
    public static class subclass extends superclass 
    { 
        @Override
        void print() 
        { 
            System.out.println("print in subclass."); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        superclass A = new superclass(); 
        superclass B = new subclass(); 
        A.print(); 
        B.print(); 
    } 
}

Output:

print in superclass.
print in subclass.

Here the output differs. But why? Let’s break down the code and understand it thoroughly:

• Methods are not static in this code.
• During compilation, the compiler has no idea as to which print has to be called since compiler goes only by referencing variable not by type of object and therefore the binding would be delayed to runtime and therefore the corresponding version of print will be called based on type on object.

Important points

• Private, final and static members (methods and variables) use static binding while for virtual methods (In Java methods are virtual by default) binding is done during run time based upon run time object.
• Static binding uses Type information for binding while Dynamic binding uses Objects to resolve binding.
• Overloaded methods are resolved (deciding which method to be called when there are multiple methods with same name) using static binding while overridden methods using dynamic binding, i.e, at run time.

Statically and Dynamically typed languages

Statically typed languages:

A language is statically typed if the type of a variable is known at compile time. For some languages this means that you as the programmer must specify what type each variable is (e.g.: Java, C, C++); other languages offer some form of type inference, the capability of the type system to deduce the type of a variable (e.g.: OCaml, Haskell, Scala, Kotlin)

The main advantage here is that all kinds of checking can be done by the compiler, and therefore a lot of trivial bugs are caught at a very early stage.

Examples: C, C++, Java, Rust, Go, Scala

Dynamically typed languages:

A language is dynamically typed if the type is associated with run-time values, and not named variables/fields/etc. This means that you as a programmer can write a little quicker because you do not have to specify types every time (unless using a statically-typed language with type inference).

Examples: Perl, Ruby, Python, PHP, JavaScript

Most scripting languages have this feature as there is no compiler to do static type-checking anyway, but you may find yourself searching for a bug that is due to the interpreter misinterpreting the type of a variable. Luckily, scripts tend to be small so bugs have not so many places to hide.

Most dynamically typed languages do allow you to provide type information, but do not require it. One language that is currently being developed, Rascal, takes a hybrid approach allowing dynamic typing within functions but enforcing static typing for the function signature.

Reflection

http://tutorials.jenkov.com/java-reflection/index.html#java-reflection-example

https://docs.oracle.com/javase/tutorial/reflect/index.html

A programming language that supports reflection allows its programs to have runtime access to their types and structure and to be able to dynamically modify their behavior.

• The types and structure of a program are called metadata

• The process of a program examining its metadata is called introspection

• Interceding in the execution of a program is called intercession

Java Reflection makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection. http://tutorials.jenkov.com/java-reflection/index.html#java-reflection-example

Uses of reflection for software tools:

• Class browsers need to enumerate the classes of a program
• Visual IDEs use type information to assist the developer in building type correct code
• Debuggers need to examine private fields and methods of classes
• Test systems need to know all of the methods of a class

Downsides of Reflection:

• Performance costs
• Exposes private fields and methods
• Voids the advantages of early type checking
• Some reflection code may not run under a security manager, making code non-portable

Reflection in Java

• Limited support from java.lang.Class

• Java runtime instantiates an instance of Class for each object in the program

• The getClass method of Class returns the Class object of an object

float[] totals = new float[100];

Class fltlist = totals.getClass();

Class stg = "hello".getClass();

• If there is no object, use class field:

Class stg = String.class;

• Class has four useful methods:

getMethod searches for a specific public method of a class

getMethods returns an array of all public methods of a class

getDeclaredMethod searches for a specific method of a class

getDeclaredMethods returns an array of all methods of a class

The Method class defines the invoke method, which is used to execute the method found by getMethod

Here is a quick Java Reflection example to show you what using reflection looks like:

Method[] methods = MyObject.class.getMethods();

for(Method method : methods){
    System.out.println("method = " + method.getName());
}

This example obtains the Class object from the class called MyObject. Using the class object the example gets a list of the methods in that class, iterates the methods and print out their names. http://tutorials.jenkov.com/java-reflection/index.html#java-reflection-example

Languages evaluation criteria

https://www.cs.scranton.edu/~mccloske/courses/cmps344/sebesta_chap1.html

https://medium.com/@thisisfordeveloper/programming-language-evaluation-criteria-part-2-writability-reliability-cost-6c3029c9d957

Readability	Writability	Reliability	Cost	Other criteria
This refers to the ease with which programs (in the language under consideration) can be understood. This is especially important for software maintenance. Simplicity: Orthogonality: Data Types: Syntax Design:	This is a measure of how easily a language can be used to develop programs for a chosen problem domain. Simplicity and Orthogonality: Support for Abstraction: Expressivity:	This is the property of performing to specifications under all conditions. Type Checking: Aliasing:	The following contribute to the cost of using a particular language: Training programmers: cost is a function of simplicity of language Writing and maintaining programs: cost is a function of readability and writability. Compiling programs: for very large systems, this can take a significant amount of time. Executing programs: Having to do type checking and/or index-boundary checking at run-time is expensive. There is a tradeoff between this item and the previous one (compilation cost), because optimizing compilers take more time to work but yield programs that run more quickly. Language Implementation System: e.g., Java is free, Ada not Lack of reliability: software failure could be expensive (e.g., loss of business, liability issues)	Portability: the ease with which programs that work on one platform can be modified to work on another. This is strongly influenced by to what degree a language is standardized. Generality: Applicability to a wide range of applications. Well-definedness: Completeness and precision of the language's official definition.

Imperative vs Declarative programming paradigm

https://medium.com/front-end-weekly/imperative-versus-declarative-code-whats-the-difference-adc7dd6c8380

https://codeburst.io/declarative-vs-imperative-programming-a8a7c93d9ad2

• Imperative programming style:

• Focused on describe HOW the computer should accomplish the task.

• A more formal definition: Imperative programming is a programming paradigm that uses statements that change a program's state.

Your code focuses on creating statements that change program states by creating algorithms that tell the computer HOW TO DO THINGS. It closely relates to how hardware works. Typically your code will make use of conditinal statements, loops and class inheritence.

• Procedural and object-oriented programming belong under imperative paradigm: C, C++, C#, PHP, Java and of course Assembly.

• Example of imperative code in JavaScript:

class Number {

    constructor (number = 0) {
        this.number = number;
    }
  
    add (x) {
        this.number = this.number + x;
    }
    
}

const myNumber = new Number (5);
myNumber.add (3);
console.log (myNumber.number); // 8

• Declarative programming style:

• Focused on describe WHAT the computer should accomplish.

• A more formal definition: Declarative programming is a programming paradigm that expresses the logic of a computation without describing its control flow:

Declarative code focuses on building logic of software without actually describing its flow. You are saying WHAT TO DO WITHOUT ADDING HOW. For example with HTML you use to tell browser to display an image and you don’t care how it does that.

• Logic, functional and domain-specific languages belong under declarative paradigms and they are not always Turing-complete (they are not always universal programming languages). Examples: HTML, XML, CSS, SQL, Prolog, Haskell, F# and Lisp.

• Example of declarative code in JavaScript:

const sum = a => b => a + b;
console.log (sum (5) (3)); // 8

Procedural programming paradigm

Procedural vs Functional vs Object-Oriented Programming

https://medium.com/@sho.miyata.1/the-object-oriented-programming-vs-functional-programming-debate-in-a-beginner-friendly-nutshell-24fb6f8625cc

Can we do Object-Oriented Programming with ANSI-C? Yes! this book explains how to do it: https://www.cs.rit.edu/~ats/books/ooc.pdf

https://www.codecademy.com/articles/cpp-object-oriented-programming

https://owlcation.com/stem/Use-Of-Object-Oriented-Programming

https://searchapparchitecture.techtarget.com/definition/object-oriented-programming-OOP

https://www.geeksforgeeks.org/object-oriented-programming-oops-concept-in-java/

http://ee402.eeng.dcu.ie/introduction/chapter-1---introduction-to-object-oriented-programming

Scripting

https://www.geeksforgeeks.org/whats-the-difference-between-scripting-and-programming-languages/

A scripting language is a programming language designed for integrating and communicating with other programming languages. Some of the most widely used scripting languages are JavaScript, VBScript, PHP, Perl, Python, Ruby, ASP and Tcl.

Basically, all scripting languages are programming languages. The theoretical difference between the two is that scripting languages do not require the compilation step and are rather interpreted.