Why Functional Programming Should Be The Future Of Software Development

By Author: Motivity Labs
Total Articles: 12
Comment this article

WHY FUNCTIONAL PROGRAMMING SHOULD BE THE FUTURE OF SOFTWARE DEVELOPMENT

Like many other things in the tech world, the approach to writing software has evolved over time. Earlier, software programs were written mostly in imperative-style programming. This paradigm uses a top-down approach where the complete functionality is written as a single algorithm, step by step and each line of code is a command to the computer that specifies how to solve the problem. With the advent of high-level languages, structured programming came into existence where the software program is divided into different “blocks” or “units”. Notable examples of these blocks are if.. then, do-while loop, for loop, etc. Later, the software programmers realized that a piece of software code written in the program can be reused when needed and thus born procedural programming or modular programming. This procedural programming still follows an imperative linear top-down approach with just the ability to use a certain part of the code repeatedly when required. The main focus of these paradigms is on how to solve a given problem, step by step through ...
... blocks, units, procedures, and functions!

Then came one of the most influential and revolutionary software programming paradigms, object-oriented programming structure, OOPS, which also evolved from structured programming. OOPS concept is based on classes and objects derived from real-world entities. A class is nothing but a “model” or a “blueprint”. An instance of this model is an object. In a real-world scenario, if a vehicle is considered a class, then a car is an object of the class vehicle. Just like a vehicle has its attributes like color, make, speed limit, etc., classes have attributes, and just like a specific car has its specific attributes like some special features that are specific only to that particular car, an object too, has attributes specific to that object. This particular designing of classes and subsequent declaration of their instances as objects has led to many simplifications in software programming as this paradigm concentres on what to solve rather than how to solve! When a class(vehicle) is declared somewhere and all of its attributes and functionality are encapsulated, anyone can simply create an object(car) and can use all of its functionalities like starting the car, accelerating, braking, and stopping the car without worrying on how to achieve those functionalities because those functionalities have already been written. Here, the software programmer can simply concentrate on what to achieve with the object car rather than worrying about how to achieve it!

Even though the OOPS concept is still relevant and largely used in software programming paradigms, the concept of functional programming is fast catching up with software programmers nowadays. The concept is not new and was there since the late 1950s when the first high-level functional programming language LISP was developed by John McCarthy at MIT. Functional programming is based on the principle that every computation can be expressed as an abstract function, which is the basic premise for lambda calculus. So, functional programming is based on lambda calculus, a mathematical system for explaining the relation between functional abstraction and functional application. Due to its complexity, functional programming has overlapped with other programming paradigms which are easy, but again resurfaced as the pros it offers overweigh the cons it possesses. There are certain principles to be followed for writing functional programming and the most important ones are discussed below.

Pure functions:

The first and foremost principle to writing functional programming is to write pure functions. A pure function is one that always returns the same output for the same input without any side effects. The result of a pure function always depends on the input parameters and doesn’t impact any of the other variables, objects, or methods, besides returning the value. This is called immutability which produces no side effects. For example, when a global variable is called inside a function and is changed inside the function, it leads to producing unwanted results every time the function is called which is a side effect, rendering the function impure. A function becomes pure when all the inputs are declared as parameters and the only return value is the output. In simple words, the parameters passed into the function should not have any dependency whatsoever and the output shouldn’t affect any local/global variables or input/output streams. Pure functions are isolated, independent, generalized, and abstract functions!

This concept of pure functions is in contrast to procedural programming and OOPS as in both these methods the state of the program and the object members are manipulated from inside the function.

Referential transparency:

When a function is called with the same values, the function should always return the same result. This is called referential transparency and is one of the major traits of functional programming. In functional programming, referential transparency of an expression is the ability to remain the same when replaced with corresponding values without changing the program’s behavior. If x is 3 and y is 2, the expression x +y should always be 5 and you can always replace x+3 with 5! Now, let’s look at a function that isn’t referentially transparent. A function that returns the current time is not referentially transparent as every time you run the function, you will get a different output!

Immutability:

As discussed earlier, immutability is the ability of a variable to remain constant throughout the program after its initialization. In functional programming, none of the elements in an object should be modified directly as it leads to problems while testing the same. Suppose an array is there and you need to sort the elements of the array in ascending order. When you sort the array within itself, it is changed and the old values are now replaced with the sorted values. If you want to have the original unsorted array at a later point in the program, you cannot have it because you have replaced the original array with the sorted one. Leaving the original array and storing the sorted elements in a new array is what is called immutability in this case.

In functional programming, the variables once defined do not change throughout the program as there are assignment statements. A new variable is defined whenever a value is to be stored to eliminate the side effect and thus the state of a variable is always maintained. So you do not see statements like x = x++ or x = x + 1 in functional programming as in the case of other programming paradigms.

First-class / Higher-order functions:

First-class functions are those functions that can be treated as a variable and can be passed as a parameter to other functions, stored in a data structure, can be returned as an output to other functions, and can even assign to some variable as a value. Higher-order functions take other functions as arguments and parameters and can return functions as output. In functional programming, there is no restriction on how a function can be created or used and is treated just like any other variable.

Recursive functions:

In functional programming, the flow of the program is controlled by recursions to avoid altering the state of the variables and other objects which is the case with traditional loops like “do while” or “for”. Recursive functions are the ones that call themselves repeatedly during execution till the specified condition is met, with each iteration producing a result which usually passed as an argument to the next iteration.

Lambda functions:

Also called an anonymous function, a lambda function is a small, single-line function with no name and is not bound to an identifier, and is used only once in the program. These “throwaway” single-line functions are usually used to do some quick calculations or serve as input to some higher-order functions. These lambda functions make the code easier to decipher without any complexity.

The above principles are the pillars on which functional programming stands and there are many programming languages that support only functional programming like Haskell, Scala, Erlang, Clean, F#, and Closure while some other programming languages support both functional and non-functional programming like C++, Javascript, Python, and Ruby. As you can see, the essence of all the principles of functional programming is to “mind its own business without affecting anything else outside and giving the output it is expected of”. Let’s look at some of the most important benefits of functional programming.

• Since functional programming uses pure functions, debugging the same would be easy, eliminate side effects, and increases stability and compiler optimization.

• Functional programming follows a lazy evaluation strategy which is to delay the evaluation of an expression until its value is needed which reduces repeated evaluation of inputs. This strategy also eliminates temporary computations which in turn speeds up the function process.

• As functional programming allows functions to be treated as variables that can be passed on to other functions as parameters, the readability of the whole program would be enhanced and the code can be easily understood.

• Testing and debugging would be easier with functional programming because of its immutability nature.

• Functional programming supports seamless parallel programming as the variables are static and don’t change the outside data and exclusively depend on the input.

Most of the above features and benefits are exclusive to only functional programming. Even though a little complex at first, once it’s mastered, you realize that you can solve any programming task with the use of mathematical expressions and functions that functional programming support which isn’t the case with other programming paradigms. The other programming paradigms, especially the ones with high-level languages are easy to write but become extremely difficult to understand at later stages when changes, extensions, and modifications are to be made. In today’s fast-changing world, it is expected of a computer program to be easily altered at will. Writing pure and recursive functions requires a certain skill but once you discover the enormous benefits of functional programming, you would definitely opt for it over other programming paradigms. The clumsiness in other programming styles has led developers to go back to functional programming whose motto is to offer more with less coding! And that is precisely why functional programming will surely be the future of software development!