Why is functional programming gaining popularity?

Comments

[Thomas]

I wrote an article about this topic 6 months ago. It's not so much about what has changed with languages, but rather what has changed with the world that is driving adoption of functional programming. Functional programming uses immutable constructs, which are easier to reason about (for humans), and safer in terms of concurrency, and in general. Lots of other reasons - you can read about them in my article.

"Elixir - Erlang didn't change, the world did"

So what happened? The world changed, and continues to change:

Moore’s law ends,
I am sitting in front of a 16 core SMP computer,
It has more memory than I could ever use,
It is fast,
I am writing simple networked services,
Reliable code, not just features, differentiates,
Scalability is standard, and not special.

tomjoro.github.io/2017-01-31-world...

[Adrian B.G.]

Mainly because it's now very underrepresented and underused,and slowly rises where it should be,on the same parity as OOP.

[Josh Warfield]

Others are doing great covering the actual practical reasons, which inevitably apply to some situations and not others. What applies universally is the psychology part of it, e.g.:

• it's a shiny new toy (many of us fell in love with programming because of the joy of learning new concepts)
• popularity is a positive feedback loop (gee, I'd better try to do something with FP because everyone seems to be talking about it)
• egotistical programmers love explaining arcane concepts to all the plebs who've never heard of them (do you have a few minutes to talk about our Lord and Savior the Maybe Monad?)
• those same egotistical programmers have convinced a fair number of people that it's a magical solution to all bugs (there's no side effects! sometimes side effects are accidental and cause bugs! remove all the side effects and there won't be any more bugs!)

[John Paul Ada]

Because of Javascript, I think.

And people like the advantages like being able to avoid doing things that you aren't supposed to happen because of function purity and immutability.

And lastly, because it's cool! :tada:

[John Paul Ada]

Also, it's data-driven. It's focused on the flow of the data. And you know all the craze about data science these days.

[Valentin Vago]

Because a lot of us miss PHP3.

[nihar]

Many people have mentioned about the multi-cores being a catalyst in encouraging the use of functional programming in the industry today. This is definitely one of the big motivating factors. But I think a more basic reason why FP is becoming more popular is the fact that we are developing more and more complex software these days and FP gives us the right tools to reason about our programs.

You can also learn a whole variety of programming languages here: hackr.io/

Using pure functional programming and decoupling the side-effecting parts of your program from the "pure" ones, you get the power to prove the correctness of your programs just like in mathematics. Richard Bird has written a great book Pearls of Functional Algorithm Design: Richard Bird: 9780521513388: Amazon.com: Books on this subject, where he mentions the following:

My aim in writing these particular pearls is to see to what extent algorithm design can be cast in a familiar mathematical tradition of calculating a result by using well established mathematical principles, theorems and laws.

This is the power of equational reasoning through composition of the powerful patterns of computation.

[Soulaymen Chouri]

A lot of people think that object oriented programming is dead and the future is functional programming. I would understand that. Functional programming does have some very nice features such as pure functions. This allows developers to write safer code and works very well with concurrency. Many OOP language recently adopted various aspects for functional programming such as C++ and Java's Lambdas for they make writing certain parts of applications much easier. So it seems that functional programming can co-exist with other paradigm, which is good. This gives programmers more flexibility and design choices.

So why is functional programming gaining popularity? Because it allows developers to model their application in a different manner and write safer code thanks to their persistent data types.

[Robert Johnson]

So much of modern development boils down to receiving data from one system, transforming the data in some fashion and then passing it on to another system. FP is better suited to this than OOP because FP embraces data rather than trying to abstract it away all the time. Big ironclad static OOP languages like C++, C# and Java work well if you are writing a thick client in which you are in control of all the external interfaces, but in this world of microservices and REST APIs this kind of application is becoming increasingly rare.

In short, FP is not a silver bullet, it is just better than OOP for the kinds of problems we are trying to solve today.

[saurabh.v]

I have started writing a series of blogs which describes advantages of functional programming. If you are interested you can visit the link here.

[Jess Lee]

Would you like to cross-post your articles on dev.to?

[saurabh.v]

Sure. I have posted my article on dev.to as well. You can visit it here

[Unfrozen Caveman Dev]

Everything else in computing from the 70s is coming back in style with a new wrapper, so why not? ;)

[Tiago Antao]

This is a bit of a side comment. I did a lot of Java and Python development in the past (I still do a lot of Python). With regards to FP, you see some developments in the JVM world (Clojure being my favorite), but hardly anything in Python.

I am amazed on how FP is gaining roots on the JavaScript world (this includes languages that compile to JavaScript, like Elm). I would say that it has gained enough critical mass that it will stay (as enough people can see the advantages).

I still follow lots of Python stuff and it is impressive how some high-profile members of the community there still think FP is just a academic thing.

My point is that some of the most interesting things in elegant and high-quality software development are happening around JavaScript (even if not in JavaScript). Especially FP, but not only: think for example all the stuff around transpiling.

This is one of the reasons that while I am a very seasoned Python programmer, I decided to self-train into JavaScript. That was a bit surprising: just a couple of years ago, I would think it would be ridiculous that anything interesting would happen around JavaScript.

I was wrong.

[d3rrila]

My own reason for switching to Rust from C++ is a philosophical one: I believe that objects in reality do not have inherent functions. Functions are either emergent or they are imposed on the object. Since I don't program for a living and just as a hobby, I can code in whatever language I want to, after all.

[Gabriel Domingos de Arruda]

Parallel programing is a huge deal too: I'm working with analytics using Apache Spark + Scala over Hadoop, so FP it's not a option in my case.

I don't have the theorical basis of FP, but I really like the way code feels, much more organized using a functional aproach. Even using other tools, I pretend to mantain a functional aproacch whenever is possible.

[Tomas Junnonen]

I'm a functional programming convert because I've seen the benefits first-hand.

Professionally I've gone from C, to C++, to Java, to Scala and most recently to JavaScript. Typically over the lifetime of a project an ever increasing share of the engineering effort will be spent on maintaining the codebase and paying down technical debt, until adding new functionality grinds to a halt. However, one of the most complex projects I've worked on was in Scala, and it was virtually bug-free. As in, I could count the number of known bugs on one hand. In my experience, almost all bugs come from either 1) unintended side-effects, or 2) inconsistencies caused by duplication of state and data at runtime. By adopting side-effect free code and data immutability, you trade a bit of discipline and a new way of thinking for massively reduced complexity and increased reliability and testability.

I've come to realize you can apply functional programming principles in almost any language, even C, and modern JS is in fact a great language to do so in. As with all things, moderation is best and you don't have to buy into FP 100% to see the benefits of it. If you've done frontend JS before, just applying for example the principles of something like React+Redux (single source of truth, state is read only, state changes are through pure functions) you can easily see benefits in any moderately sized codebase.

[David Bachowski]

FP is super useful for distributed computing. Managing state across hundreds of servers is a nightmare and forcing devs to reduce state and side effects to the barest minimum turns out to work pretty well in this domain.