Backfield - Becoming Functional

Some people might wonder why Im not including any Java 8 right now. As of this writing, Java 7 is the currently stable and widely used version. Because I want everyone, not just early adopters, to be able to take something from this book, I thought starting from Java 7 would be most accessible.

Those using Java 8 will be able to use some of the Groovy concepts, such as higher-order functions, without actually transitioning into Groovy.

Because functional programming is so closely tied to mathematics, lets go over some basic mathematical notation.

Functions in mathematics are represented with a name ( parameters ) = body style. The example in shows a very simple function. The name is f , the parameter list is x , the body is x + 1 , and the return is the numeric result of x + 1.

Equation 1. A simple math function

if statements in math are represented by the array notation. shows a set of statements to be evaluated. The function abs(x) will return x * -1 if our x is less than 0; otherwise, it will return x.

Equation 2. A simple math if statement

We also use a summation , the sigma operator, in our notation. shows a simple summation. The notation says to have a variable n starting at 0 (defined by the n=0 below the sigma) and continuing to x (as defined by the x above the sigma). Then, for each n we add it to our sum (defined by the body, n in our case, to the right of the sigma).

Equation 3. A simple math summation

There are quite a few paradigms, each with its own pros and cons. Imperative, functional, event-drivenall of these paradigms represent another way of programming. Most people are familiar with the imperative style because it is the most common style of programming. Languages such as Java and C languages are all imperative by design. Java incorporates object-oriented programming (OOP) into its language, but it still primarily uses an imperative paradigm.

One of the most common questions Ive heard during my time in software is why should I bother learning functional programming? Because most of my new projects have been in languages like Scala, the easiest response I can give is that is what the project is written in. But lets take a step back and actually answer the question in depth.

Ive seen quite a bit of imperative code that requires cryptographers to fully understand what it does. Generally, with the imperative style, you can write code and make it up as you go. You can write classes upon classes without fully understanding what the implementation will be. This usually results in a very large, unsustainable code base filled with an overuse of classes and spaghetti code.

Functional programming, on the other hand, forces us to better understand our implementation before and while were coding. We can then use that to identify where abstractions should go and reduce the lines of code we have written to execute the same functionality.