TL;DR
Why FP matters anyway? (Functional programming and multicore architecture)
Functional programming minimizes or eliminates side effects and thus is better suited to distributed programming. i.e. multicore processing.
In other words, lots of pieces of the puzzle can be solved independently on separate cores simultaneously without having to worry about one operation affecting another nearly as much as you would in other programming styles.
One of the hardest things about dealing with parallel processing is locking data structures to prevent corruption. If two threads were to mutate a data structure at once without having it locked perfectly, anything from invalid data to a deadlock could result.
In contrast, functional programming languages tend to emphasize immutable data. Any state is kept separate from the logic, and once a data structure is created it cannot be modified. The need for locking is greatly reduced.
Another benefit is that some processes that parallelize very easily, like iteration, are abstracted to functions. In C++, You might have a for loop that runs some data processing over each item in a list. But the compiler has no way of knowing if those operations may be safely run in parallel — maybe the result of one depends on the one before it. When a function like
map()orreduce()is used, the compiler can know that there is no dependency between calls. Multiple items can thus be processed at the same time.
https://lawrencecpaulson.github.io/2023/03/08/Fun_Semantics.html
https://en.wikiversity.org/wiki/Foundations_of_Functional_Programming/The_λ-cube