This presentation will show you how you can become a better programmer by learning functional programming and using those concepts and constructs in your day to day work.

Most of my examples will be in C# but it should be comprehensible by any Java programmer also.

Let's use a scenario that we can come back to through the talk.

While you think about that I will talk about some of the history of functional programming.

It all began in the 1930's with Alonzo Church when he created the lambda calculus. He wanted to discribe the world in functions.

• This is a function that squares a number.
• We can call this with the number nine
• If you type out it, it will become 9 * 9
• The result is of course 81

The point here is the function and that we can reuse it with other arguments.

• Here's a function that takes two arguments, x and op. op is a function that operates on x and takes two arguments.
• We can call this with the number 9 and operation (+)
• This of course prints out as 9 + 9
• And the result is 18

LISP was created 1958 as the first functional language, at the same time as COBOL and Fortran two imperative programming languages.

LISP pioneered computer science paradigms that we still use today, tree data structures, dynamic typing and self hosting compiler.

Here's some code that will calculate interest for an amount of money over a couple of years in lisp. It reads like this

							if year = 0 then
								return amount
							else
								calc
									amount + (amount * interest / 100)
									year--
									interest
						

Imperative programming includes state. You have a state and you modify it until you're satified with the result.

It's like making pancakes. You start with an empty bowl. You had flour, eggs, and milk. You take the contents and put it into a frying pan and after 2 minutes you have a pancake.

Imperative programming is having a state and mutating it into completeness.

Remember Ada and Pascal? They're going to calculate the average age of everyone in their group. Ada goes for a purely imperative approach. She sums up everyones age in the group and then divide with the number of people in the group.

It is very easy for our brains to understand imperative thinking because we have been schooled that way.

Pascal used a more functional way to solve the problem and managed to do so before Ada even though he had a four times larger group of people.

The four concepts of functional programming are Functional types, expressivity, immutable values and declarative programming. I will look into what these concepts are, and how Pascal can use them to complete the task.

A functional type is a type that works well with functional programming paradigms. The most common is the linked list.

The linked list has two parts, a head and a tail. The tail is in itself a linked list. This makes the type recursive.

How would a linked list definition look in code? Something like this where the type has a head, and a tail. You have a property to tell if the list is empty or not. It's all you need for this recursive type.

Pascal used the linked list functional type to structure his group.

Another common functional type is the binary tree. You use that for search and sorting algorithms.

In a functional language each function has a type. This makes it easier to use functions as values.

The key to expressivity is how you express the problem. Ada tackles the problem as the entire group where as Pascal tries to solve the problem for the indiviual person.

We define the following

3. What happens when there's only one person in the group? Return that persons age with group size 1
11. For a group we express that the total age is first persons age + rest of the groups calculated age

We calculate the number of persons in the group at the same time as we calculate the age. Since we need to return two values form the calculation we uses another functional construct called Tuple. It is simply two values as one.

Instead of counting from start to finish Pascal divided his problem into 8 subproblems

He told the first person in each column to calculate the ages and return the result to him.

You should beware of recursing in non functional languages, because they do not optimize for recursion. When you write a recursion like this it will compile into function calls where as a functional language might optimize it into a while loop. This is called tail recursion optimization because extensive functional calls is expensive.

Make sure that you know that the depth has a limit before you start recursing in C#.

It's mutable values that makes parallelization so hard. If we we're to parallelize Ada's solution it would be necessary to share the mutable state "total" between different threads. This is the source of deadlocks and race conditions.

We have immutable types in the .NET framework. String is immutable. If we add another string to a string, it will create a new string - not modify the existing.

String instance methods that manipulates the string always returns a new string instance.

Immutable leads to function chaining. No operation on datetime can ever return null

Creating immutable types will help you code more functionally so you should make your types immutable where you can. In an immutable type you can't modify values without getting a new instance of the type.

In above example you will get a new Person instance when you want to increase the age of the Person.

Ada's problem solution focus on how to calculate the result. A declarative problem solution will focus on what we want instead of how to get it.

In declarative programming we declare what, instead of how.

averageAge of group is -> call average with result from totalAgeAndCount of group

average is -> totalAge divided by groupSize

totalAgeAndCount is -> 0, 0 when group is empty first persons age + rest of the groups age and rest of the group size + 1

Like this we have declared what we want instead of how to get it. This method is declarative and very expressive.

Windows forms programming is an exellent example of UI programming that is not declarative. All the way you tell the computer how it should produce the desired UI.

In HTML you tell the browser what it should display, and not how to do it. With the previous example of WinForms programming, it is interesting that XAML is declarative. Microsoft took windows programming from being imperative to declarative with the transformation from WinForms to WPF.

Declarative programming should be independent on what order you declare things. A good example of this is XSLT style sheets where you define templates for rendering and it does not matter in what order you do things.

It eliminates side effects since you don't have any mutable state.

The trick is to define what instead of how.

Using immutable values instead of mutating states causes less side effects that is a known source for bugs

Expressive code is easier to read as it states what is being done instead of how

If we want to make parallelization embarrassing, we should use functional programming

Things that didn't make it.