# Functional programming: What has caused its rise in popularity?

## Functional programming: What has caused its rise in popularity?

Functional programming has been constantly growing and is a real option for solving problems that other paradigms have not been able to rectify.  Here we talk about the advantages of functional programming and tackle the reasons behind its recent popularity.

When I started teaching programming paradigms, functional programming was only studied for academic or research purposes and was hardly used in industry. However, this has changed. The industry looks favorably on this paradigm, and it is present in all modern programming languages. To analyze this change, we must understand what functional programming is.

## What is functional programming?

Wikipedia tells us the following:

“In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions. It is a declarative programming paradigm in which function definitions are trees of expressions that map values to other values, rather than a sequence of imperative statements which update the running state of the program.”

The main distinguishing features of software development with functional programming are:

• Pure functions, which can compose new functions
• Avoidance of shared state, mutable data, and side effects
• The prevalence of a declarative rather than an imperative approach

Now, let’s discuss these points in more detail.

### Pure functions

They are deterministic functions without side effects. A deterministic function means that for the same set of input values, it returns the same result. The properties of such functions are very important. For example, pure functions have referential transparency. You can replace a function call with its final value without changing the program value. Also, function composition refers to the process of combining two or more functions to create a new function or perform calculations.

### Avoiding shared state

The main problem with shared state is that to understand the effects of a function, you must know the complete history of each shared variable used by the function. Therefore, functional programming avoids shared states, relying instead on immutable data structures and raw computation to extract new data from existing data. Another nuance that arises when working with shared states is that changing the order of function calls can lead to an avalanche of errors. Consequently, by avoiding shared states, you also avoid this problem.

Underlying all functional programming is immutability. Immutable objects cannot be changed at all. This is achieved by the deep freezing of variables.

With these tools, side effects are avoided, which means that in addition to returning a value, the function also interacts with the external mutable state. Why does functional programming avoid them? Because in this way, the effects of the program are much easier to understand and test. Haskell, for example, uses monads to isolate the side effects of pure functions.

### Declarative approach

The point is that the imperative approach works on the principle of control flow and answers the question of how to do it. The declarative approach describes the flow of data and answers the question of what to do. In addition, imperative code often relies on instructions (operators), while declarative code relies on expressions.

## Why functional programming matters

So, we have found out what functional programming is and what we need to know about it. Now, let’s look at the advantages of using it.

One of the most obvious benefits is the high-level abstractions that hide many of the details of routine operations, such as iteration. Because of this, the code is shorter and as a result, guarantees fewer errors that may be made.

In addition, functional programming contains fewer language primitives. Classes are simply not used, so instead of creating a single description of an object with operations in the form of methods, functional programming uses several basic language primitives that are well optimized internally.

Furthermore, functional programming allows the developer to bring the language closer to the problem, rather than vice versa, all at the expense of the flexible structures and versatility of the language. Functional programming offers developers new tools for solving complex problems as well.

To be honest, the list is too long to mention all the advantages of functional programming, and there really are many of them. However, I can say that working with functional languages provides accurate and fast code writing and makes testing and debugging easier. Programs are higher-level, and function signatures are more informative.

Functional programming allows for writing code to be more concise and predictable and is easier to test (although learning it is not easy).

## Reasons behind its popularity

In the IT world, nothing just happens. One thing is connected to another, and now, all the latest trends are interconnected.

If we remember the most sensational trends of 2016-2017, these were AI, IoT, Big Data, and Blockchain. They were and are still on everyone’s minds, because everyone knows their potential and key features. It is some of these trends that have catalyzed the growing popularity of functional programming among developers.

Today, the problem of parallel processing and working with large data streams has increased dramatically. By parallelizing the processing of this data, we can obtain the desired result in less time than with sequential processing. In addition, decentralized (distributed) computing, such as blockchains and others,  are quite complex mechanisms. For such calculations, functional code is more suitable because of all the principles of functional programming (such as pure functions). The use of all basic techniques facilitates the execution and maintenance of parallel and distributed code.

Moreover, functional programming was not only used to solve specific problems, given its increasing popularity, as it is now even applied to classical projects.

### WRAPPING UP

As you have learned here, you should not be afraid of functional programming.

Here are some tips for those who have decided to try a new paradigm and learn something radically new:

• It will be very complicated at first, considering that you will have to leave behind what you know and learn new approaches and principles.