[ad_1]
Functional programming uses expressions and higher-order functions, with advantages of readability, reliability, and component breakdown. Disadvantages include slow calculations and different syntax. Pure functional programming has referential transparency and lazy evaluation. While it can be difficult to learn, it is favored by academics for complex problems. Examples of pure languages are Haskell and Erlang, while cross-paradigm languages like Scala and F# support both functional programming and other styles.
Functional programming is a programming paradigm in which the basis of computation is the evaluation of expressions. Some features are the use of higher order functions, referential transparency and lazy evaluation. The advantages of the programming style include that programs are easy to read, are very reliable, and can be broken into components. The disadvantages are that the calculations can be slow and the style and syntax are completely different from other common programming styles. The functional programming style is more often adopted by academics than by computer science professionals.
As the name suggests, functions are a fundamental part of this programming paradigm. Functions can be nested inside other functions, called higher-order functions, and each higher-order function can be broken down into building block functions that are easy to understand and fix. Examples of some higher order features are Map and Nest. The Map function takes a function F and the list of variables, for example (x, y, z) and returns the result in a list: Map (F, (x, y, z)) = (F(x), F (y), F(z)). Nest takes the function F, the variable x, and the number of iterations: Nest( F, x, 3) = F(F(F(x))).
Pure functional programming takes an input and returns an output without ever changing the state of a variable. In other words, a function with the same input will always give the same results regardless of what happened earlier in the program. This is called referential transparency. Because math functions are referentially transparent, functional programming is intuitive to many mathematicians, engineers, and scientists.
Referential transparency of functions means that the order of evaluation of the function is not important. Thus functions should not be evaluated until their results are needed, which is called lazy evaluation. This is in complete contrast to imperative programming, where a program starts with the first command and iterates through the list to the last command. Lazy evaluation skips parts of the program that don’t follow logically or are superfluous, which automatically optimizes the program and can reduce computation time.
Functional programming has many advantages over other programming paradigms. Functions with clear input and output are easy to read and understand. Once a function has been thoroughly debugged, it can be used reliably in other applications. Multicore machines may be able to compute functions that are independently evaluated in parallel, dramatically improving program performance.
Unfortunately, not all programs lend themselves to parallel computation, and computation of functional programs can be quite slow. Functional programs rely heavily on recursion, which is often less efficient than using traditional looping or iteration methods. In fact, functional programming can be quite clunky and difficult to learn since it doesn’t resemble other more common paradigms such as object-oriented programming.
Academics tend to favor functional programming as it provides a clear and understandable way to program complex real-world problems. Some pure languages are Haskell and Erlang. Mathematica specializes in symbolic mathematics, R specializes in statistics, and J specializes in financial analysis. Cross-paradigm languages like Scala and F# support both functional programming and other programming styles.
