What Is Functional Programming?

A different paradigm for different programming needs

There are so many programming languages out there that we need some sort of classification for them. Of course, the tech community has plenty of classifications for them but one of the most widely used involves programming paradigms.

A programming paradigm is basically a way to classify languages depending on their features. Thus, some paradigms focus on the implications of their execution models, while others are more about the code’s organizations or the syntax and grammar styles.

There are several programming paradigms out there but probably the most widely known is object-oriented programming. OOP is so popular that people who have a very tangential relationship with the programming world surely have heard about it.

The reason for that popularity? OOP has modularization for easier troubleshooting, allows for code reuse through inheritance, boasts flexibility through polymorphism, and is great for problem-solving. Some of the biggest languages in the world support object-oriented programming, including Java, C++, Python, and JavaScript.

However, OOP isn’t the best solution for every development problem. That’s precisely when functional programming comes into play.

What Is Functional Programming?

Functional programming is a paradigm through which developers write programs using a combination of pure functions, which are developed in such a way that they don’t have side effects (more on that later).

If the word “functions” reminds you of math, that’s because functional programming evolved from lambda calculus, a formal system for expressing computations based on function abstraction.

It’s worth noting that functional programming is part of a broader programming category called “declarative programming” (opposed to “imperative programming,” which is the most widely supported paradigm in programming).

Declarative programming is when the code tells the program what the result looks like without telling it how to get to those results.
Imperative programming is when the code tells the program exactly what to do at all times (in other words, the code provides the program with the instructions it needs to perform to achieve a specific result).

According to that classification, functional programming is declarative because it uses math functions that don’t care how the language or program performs the task. However, it’s important to mention that the most popular languages are often multi-paradigm. The few specialized functional languages include Haskell, Scala, and Ocaml.

Concepts of Functional Programming

To truly understand what functional programming is all about, it’s important to define some of its key concepts. We’ve already mentioned pure functions but we also have to dive into terms like “recursion” and “immutability” to completely grasp what functional programming can provide you.

Pure Functions

Functional programs don’t use just any function, but rather pure functions. A math function is considered to be pure if it meets 2 criteria:

It has referential transparency, which means that a specific input will always provide the same output.
It doesn’t have side effects, which means that they take actions that don’t relate to their outputs (such as manipulating an outside variable or printing a value).

Pure functions work independently from everything outside of them, especially states. That means that they don’t rely on variables that are outside.

Recursion

Since functional programming uses pure functions (which don’t have side effects) it can’t use popular iterative techniques like the for or while loops. That’s because using them would mean using mutable states—which are side effects. So, to perform iterative tasks, functional languages use recursion.

In recursion, a function doesn’t need states because it employs ready-only arguments and write-only return values. Thus, recursion has a function running repeatedly until it reaches its base case.

First-Class Functions

In functional programming, first-class functions can be used like any other value. In other words, you can use first-class functions to create function arrays, use them as arguments for other functions, and even store them in variables for later use. This is necessary for ensemble programs in functional programming.

Higher-Order Functions

Higher-order functions are also essential for building programs in functional programming. These functions are closely related to first-class functions, as both allow functions as arguments and results of other functions. But they aren’t the same, because higher-order functions take at least one first-class function as a parameter (or return one first-class function as a result), while first-class functions are treated like variables or objects.

Immutability

Functional programming relies on immutable objects to get things done. An immutable object is one whose state can’t be modified after its creation—it’ll be forever in the state in which you built it. What’s important about this is that immutable objects don’t generate side effects (i.e., they don’t change their state over time). Given that they don’t have side effects, they are perfect for functional programming.

Immutability is critical for functional programming because it makes the code simple, testable, and ready for multithreaded systems. That’s because objects don’t change over time, which means that you can easily spot the ones causing bugs or use them in any thread you like without having to worry about breaking other threads.

Benefits of Functional Programming

Even when object-oriented programming is highly popular, developers know that functional programming can provide them with advantages no other paradigm could give them. Some of the most notable ones include:

Best programming practices
Functional programming is very strict in how it works, which translates to several constraints that force developers to code in very specific ways. In other words, functional programming pushes engineers to adopt good programming practices , such as using modularity or building programs with small components.
Clean code
Given that functional programming combines pure functions that are organized components that work with one another, the code ends up being fairly clean. Everything does precisely what it needs to do, which, in turn, helps in organizing the codebase.
Modular code
We mentioned modularity as a best practice mainly because modular code leads to small functions that can be reused over and over with the conviction that they won’t change how they work or won’t be affected by changes in other functions.
Robust programs
Functional programs can be more robust than other applications (mainly from a mathematical standpoint). That’s because functional applications don’t have as many moving parts (such as mutable variables and hidden states) as other applications. This means functional applications are less complex, which makes them more efficient.
Easy debugging
Since the values of data and the functions are immutable, you’ll always know what’s what and who does what in functional programming. That means you can easily pinpoint the module responsible for any issues you might encounter during debugging.
Computational efficiency
Using functions allows you to distribute them throughout multiple cores without worrying about multithreading programs. That can help you leverage the power of those cores, which, in turn, can provide you with more computational efficiency for your programs.

The best thing about functional programming is that you don’t have to ditch other programming paradigms to enjoy all these benefits. That’s because functional principles are present in many non-functional languages, which makes it easier to enjoy these advantages. Of course, you can always go for a purely functional language to boost the benefits, but, in practice, it’s fairly pointless to do so.

Issues of Functional Programming

While functional programming advocates might have you believe that it’s a flawless paradigm, the reality is that it has some issues. First and foremost, pure functional programming is very hard to find in practice, mainly because developers often have to resort to other paradigms to get their programs to do what they want. And then, there are some other issues, including:

Easy to break
Functional programming is so contrived that developers have to tiptoe their way when using it. That’s because they always have to adhere to strict functional requirements. If they fail to do so, then the application breaks down and doesn’t work.
Code can be hard to read
While functional programming offers clean and organized code, it also works with a level of abstraction so high that it might end up being very hard to decipher what a functional code is actually trying to achieve. That’s especially true for projects that rely too much on functional programming libraries and point-free syntax.
Steep learning curve
Because functional programming is so deeply rooted in math, it can be challenging for uninitiated developers to have a good grasp of its conventions and practices. Additionally, functional programming involves highly specific terminology (such as “pure functions” and “referential transparency”) that requires a lot of study to be fully understood.
Complicated function integration
Building specific features through pure functions can be an easy task once you understand how to do it. However, integrating pure functions into a larger application is always a challenge. That’s because you have to devise ways in which these pure (no side effects) functions can collaborate with one another to achieve your desired result (which can be very tricky given pure functional programs’ reluctance to work with I/O components).
Lack of recursive loops
While and for loops are so popular for a reason—they greatly simplify iterative tasks. But since functional programming doesn’t use them, developers have to resort to pure recursion, which many people don’t feel is completely natural.

When to Use Functional Programming

As it happens with any programming paradigm, any expert will tell you that you can use functional programming for virtually anything you want. And that’s true to some extent! In fact, functional programming is so strict and its programs are so robust that anyone working on a project with zero tolerance for bugs should use it. Arguably, all projects could benefit from the best possible quality, but using the functional approach also means that the development team takes a lot of time to get the application right.

In light of the above, it’s important to pick the right projects to use functional programming. Given the lack of tolerance for bugs, this paradigm is perfect for systems for which a bug could bring disastrous consequences, such as navigational systems or financial platforms.

Generally speaking, functional programming is great for projects that fall into some of the following groups:

Applications that require solving complex mathematical problems
Projects with tasks that need to process native and formal languages (parsers, DSLs, code analysis, and generation)
Systems that require high levels of concurrency and parallelism
Platforms with complex data structures
Dataflow programming
Projects that call for extreme precision and correctness

It’s important to say one final thing about using functional programming. While you can definitely tackle most projects with it, you should study the viability of doing so (even for the tasks mentioned above). Why? Because there are other factors that come into play when selecting a programming paradigm, including infrastructure, libraries and resources, maintenance, and developers with knowledge of said paradigm.

All in all, functional programming and its related languages are nothing but tools at your disposal that you can use when it’s more convenient. You don’t have to choose one over the other, as different projects call for different solutions. Don’t know if functional programming applies to your project? Contact BairesDev and let our experts help you!