# What is Functional programming

##### Introduction to Functional Programming

Functional programming is a type of programming model where the code is written that involves declaring and manipulating functions. The primary focus of functional programming is to create applications by combining basic functions and operations. It has been gaining popularity lately due to its unique approach to problem-solving. Functional programming emphasizes on performing computations using mathematical functions and completely avoids changing the state of the system.

Functional programming has a valuable programming paradigm that differs from the traditional imperative programming paradigm. Functional programming includes the following features:

• Programming with straight functions: The basic building block of functional programming is a function. The function in functional programming is characterized by the functions' usage without changing the state of the system.
• Pure Functions: In the functional programming paradigm, the pure functions are written without any side effects. It means that nothing other than the function's input and output is changed when a pure function is executed.
• Immutable State: State that can't be changed is treated as immutable in functional programming. Data structures that can't be modified after their creation are termed as immutable data structures.
• First-class Functions: Functions in functionally programming have the same properties essential to other values of the programming languages. Functions can be passed as arguments to other functions, and even the functions can be returned by other functions.
• Higher-order Functions: It is a functional programming technique that enables passing functions as arguments to other functions. This technique helps to write versatile functions that can be applied to a broad range of programs.
• Declarative Programming: Programming paradigm where the description of the outcome required rather than specifying the steps required to achieve it.

One major advantage of functional programming over the traditional imperative programming approach lies in handling concurrency. Since functional programming doesn’t allow changing the state of the system, it means that the code in functional programming is free from race conditions that plague the conventional concurrent programming approach. Here are some of the benefits of functional programming:

• Writing Cleaner Code: Functional programs tend to be concise and efficient, which makes the code cleaner and more readable.
• Concurrency: With its immutable state and side-effect free approach, functional programming is suited to concurrent programming unlike other programming paradigms like object-oriented programming.
• Testing and Debugging: Since pure functions have the same input and output, it becomes easier to isolate specific functions during testing and debugging.
• More Efficient Code: Functional programming enabled by an idiomatic sequence of transformations of data that lead to optimized code.

As with any programming model, functional programming has some drawbacks or challenges that need to be considered, including:

• Learning Curve: Using functional programming often requires an entirely new mindset and way of thinking. This dramatically increases the learning curve, and beginners may find it challenging to adapt.
• Efficiency: While functional programming tends to be more efficient, as we earlier mentioned, it may not be optimal for certain tasks, namely systems that require a lot of input/output (I/O) and applications that require real-time simulation and interactive games.
• New Tools and Languages: Functional programming uses languages that are less mainstream; therefore, you may need to learn new systems and languages, compared to the more traditional languages such as Java and C++.
##### Functional Programming Concepts:

Functional programming has several concepts that you should get familiar with if you are considering diving into this programming language. Here are some of the primary concepts:

###### 1. Pure Functions:

Pure functions are the heart of functional programming. For a function to be pure, it should meet these two requirements:

• The function should return the same output given the same input. This property is referred to as referential transparency.
• The function should not cause any side effects. For instance, it should not communicate with any database or read/write any file.

Pure functions tend to be easy to test, and you can call them multiple times without affecting the program's results.

###### 2. Immutability:

Immutability is critical in functional programming since variables do not change. The function need not provide or return any values rather than those you want, which will keep the code predictable and deterministic. As the name suggests, immutable objects or types cannot be mutated, for instance, by adding new attributes or changing existing ones.

###### 3. Recursion:

In functional programming, programmers often use recursion, which is a technique whereby a function calls itself to solve a particular problem. Recursion allows breaking down complex tasks into smaller, more manageable tasks.

###### 4. Higher-order Functions:

Higher-order functions or HOFs, are functions that accept other functions as arguments or return a function as a result. The primary advantage of using HOFs is that they can promote code reusability and even help reduce the amount of boilerplate code. For instance, you can create a generic function that computes the total price of an array of goods despite their relative prices.

###### 5. Currying:

Currying is a technique that involves transforming higher-order functions that take multiple arguments into a series of functions with each taking a single parameter. Curried functions often yield partial application, which allows you to reuse code and create new functions on the fly by passing a single argument. When coupled with higher-order functions and functional composition, currying can massively reduce the amount of code you write while boosting code readability.

##### Examples of Functional Programming in the Industry:

Functional programming is fast becoming a mainstream programming paradigm in the industry, particularly in companies that require greater scalability, particularly those with a higher demand for big data and the internet of things (IoT). Here are some of the real-world examples of functional programming:

###### 1. WhatsApp:

WhatsApp is the world's most prominent instant messaging app, with well over a billion users worldwide. The application is built entirely with Erlang, a functional programming language. Erlang provides excellent support for building large distributed systems, and it has been documented that WhatsApp uses this programming language to handle about 50 billion messages per day.

Facebook has been a strong advocate of functional programming, which reflects in their choice of languages. For instance, Facebook's lightweight machine learning library called Prophet is written in R, a functional programming language. Facebook also plays a huge role in the development of the React.js web framework, which is a prominent example of functional programming.

###### 3. Netflix:

Netflix has been a pioneer in the usage of functional programming, and they've contributed massively to Scala, one of the most prominent functional languages. According to a Netflix survey, more than 20% of the company's back-end services are written in the Scala language.

##### Conclusion:

Functional programming has its roots in mathematical expressions and it is an unconventional but logical approach to programming. As we’ve mentioned before, a key benefit of the functional programming paradigm is its association with parallel processing. Nonetheless, it is worth noting that functional programming is not a new concept, and it has been around since the 1950s. It is currently gaining recognition among modern software developers who want to write more streamlined and efficient code. In summation, functional programming is a new, novel approach to solving problems using a different mindset, and it is worth exploring! If you're interested in learning more, we recommend reading some beginners to advanced guides or even diving into specific language documentations, like that associated with JavaScript, Lisp, Haskell or Ruby.