## What is Functional Programming?

Functional Programming is a way of writing applications using only pure functions and immutable values. In this, a function has no side-effect. This helps find bugs easily and helps to know what the function will perform, finding the error.

Functional programming is a significant paradigm shift in the software world over the past 10 years.

Here, the function should be Parametric. Everything happens within the function, and any outside expression does not alter the function. It is crucial for Parallelism and Concurrency. Learn more about Functional Programming in Stream Analytics here.

## Functional Programming Language

For a language to be known as a Functional Programming Language, it must follow the following methodologies.

### Pure Functions

These functions help achieve a safe way of programming. In Functional Programming, it is all about pure functions. These functions only work on their input parameters, thus, limiting the scope of errors. Pure Functions can be lazy. You can know about what the function implements by just looking at the signature of the Pure Functions. Few things that one needs to keep in mind while implementing a pure function is:

1. The pure function must take at least one parameter.
2. Pure functions never change the output, given that the input is kept the same too. This helps in predicting the behavior up to some extent.
3. Pure functions do not have side effects. Thus, debugging is quite easy.

### Immutability

In Functional Programming, a variable can never be mutable; it has to stick with its value for life. Immutability is used at it makes code simpler and safer. Immutability is a must-have while dealing with data.

### Refactoring

This helps make a function generalized so that one function could be used at multiple spots. This helps reduce the usage of boilerplate coding.

### High-Order Functions

In Functional Programming, a function is a first-class citizen, i.e., functions are treated the same as any other value like a variable. High-Order Functions either takes functions as parameters, return functions, or both.

### Functional Composition

In this, we take care of the fact that functions combine to become the final application. Therefore, we write functions for specific tasks and combine them to form the final product. This also helps in making the code reusable. In this, we create a way to make a smaller, reusable function that later is combined to construct more complex programs.

### Currying

It allows turning a function that expects 2 arguments into a function that expects only one, and that function returns a function that expects the second argument and thus, creating a chain of functions.

### Referential Transparency

This states that the function’s parameter should be made as such that they are compatible with the value of any kind (data type).

## Summing Up Functional Programming

Keeping these all points in mind while making a code using the Functional Programming paradigm will result in a better application, easy to understand, easy to debug, reusable, without any side-effect, and code that could be used parallelly and concurrently.