Functional Programming Paradigm

Lambda calculus, developed by Alonzo Church, is a minimal framework for studying computation through functions. It defines what is computable and is equivalent to a Turing machine in power. It offers a theoretical model for describing functions and their evaluation, and forms the foundation of most modern functional programming languages.

Fact: Alan Turing was a student of Alonzo Church who created Turing machine which laid the foundation of imperative programming style. 

Programming Languages that support functional programming: Haskell, JavaScript, Python, Scala, Erlang, Lisp, ML, Clojure, OCaml, Common Lisp, Racket. 

Concepts of Functional Programming

• Pure functions
• Recursion
• Referential transparency
• Functions are First-Class and can be Higher-Order
• Variables are Immutable

Pure Functions

These functions have two main properties.

• First, they always produce the same output for same arguments irrespective of anything else.
• Secondly, they have no side-effects i.e. they do not modify any arguments or local/global variables or input/output streams. Later property is called immutability. The pure function's only result is the value it returns. They are deterministic. 

Programs done using functional programming are easy to debug because pure functions have no side effects or hidden I/O. Pure functions also make it easier to write parallel/concurrent applications. When the code is written in this style, a smart compiler can do many things - it can parallelize the instructions, wait to evaluate results when needing them, and memorize the results since the results never change as long as the input doesn't change. 

Example of the Pure Function

sum(x, y)           // sum is function taking x and y as arguments
    return x + y    // sum is returning sum of x and y without changing them

Recursion

There are no “for” or “while” loop in functional languages. Iteration in functional languages is implemented through recursion. Recursive functions repeatedly call themselves, until it reaches the base case. 
example of the recursive function:  

fib(n)
    if (n <= 1)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);

Referential Transparency

In functional programs variables once defined do not change their value throughout the program. Functional programs do not have assignment statements. If we have to store some value, we define new variables instead. This eliminates any chances of side effects because any variable can be replaced with its actual value at any point of execution. State of any variable is constant at any instant. 

Example:  

x = x + 1 // this changes the value assigned to the variable x.
          // So the expression is not referentially transparent. 

Functions are First-Class and can be Higher-Order

First-class functions are treated as first-class variable. The first class variables can be passed to functions as parameter, can be returned from functions or stored in data structures. Higher order functions are the functions that take other functions as arguments and they can also return functions. 

Example: 

show_output(f)            // function show_output is declared taking argument f 
                          // which are another function
    f();                  // calling passed function

print_gfg()             // declaring another function 
    print("hello gfg");

show_output(print_gfg)  // passing function in another function

Variables are Immutable

In functional programming, we can’t modify a variable after it’s been initialized. We can create new variables – but we can’t modify existing variables, and this really helps to maintain state throughout the runtime of a program. Once we create a variable and set its value, we can have full confidence knowing that the value of that variable will never change.  

Advantages of Functional Programming

• Pure functions are easier to understand because they don’t change any states and depend only on the input given to them. Whatever output they produce is the return value they give. Their function signature gives all the information about them i.e. their return type and their arguments.
• The ability of functional programming languages to treat functions as values and pass them to functions as parameters make the code more readable and easily understandable.
• Testing and debugging is easier. Since pure functions take only arguments and produce output, they don’t produce any changes don’t take input or produce some hidden output. They use immutable values, so it becomes easier to check some problems in programs written uses pure functions.
• It is used to implement concurrency/parallelism because pure functions don’t change variables or any other data outside of it.
• It adopts lazy evaluation which avoids repeated evaluation because the value is evaluated and stored only when it is needed.

Disadvantages of Functional Programming  

• Sometimes writing pure functions can reduce the readability of code.
• Writing programs in recursive style instead of using loops can be bit intimidating.
• Writing pure functions are easy but combining them with the rest of the application and I/O operations is a difficult task.
• Immutable values and recursion can lead to decrease in performance.

Applications

• It is used in mathematical computations.
• It is needed where concurrency or parallelism is required.

Fact: Whatsapp needs only 50 engineers for its 900M users because Erlang is used to implement its concurrency needs. 
Facebook uses Haskell in its anti-spam system. 

Why Functional Programming Matters? 

Functional programming matters because it offers several benefits that align well with modern computing needs:

• Immutability and State Management: Functional programming uses immutable variables, reducing side effects and making programs easier to reason about. Immutability also helps manage state effectively, especially in concurrent and parallel environments.
• Concurrency and Parallelism: Side-effect-free functions are naturally safe for concurrency since they avoid shared variables, making functional programming well-suited for highly concurrent and parallel applications.
• Code Readability and Maintainability: Functional languages like Haskell encourage small, deterministic functions, improving readability, testing, and debugging. Higher-order functions and the absence of side effects make the code more modular and orthogonal.
• Lazy Evaluation: Many functional languages evaluate expressions only when needed, which can improve performance and avoid unnecessary computations.

Example of functional programming:

Functional programming is supported by several languages, each with unique features:

• Haskell: Functional language used for purely functional programming language with feature of strong type and lazy evaluation of expressions.
• JavaScript: Is also compatible with functional programming as well as with the others, thanks to which functions may be stored in variables and passed as parameters.
• Python: Comes with such functional programming constructs as higher order function and list comprehension in addition to imperative and object oriented.
• Scala: Supports both Functional and Object-oriented programming paradigms and offers good support for considerations of programming in a functional paradigm.
• Erlang: It is used for concurrency and distributed systems based on functional programming way to process a great number of concurrent processes.
• Lisp: It is one of the first functional languages with symbolical expression processing and rather free-formed macro system.
• Clojure: It is a dialect of Lisp which was originally developed in the late 1950s and early 1960s and it accentuates on functional programming and immutability.

Object-Oriented Programming vs Functional Programming

Object-Oriented Programming (OOP) and Functional Programming (FP) represent different approaches to software design: