Intro to Functional Programming Workshop (code4lib)

Editor's Notes

• #4: Treats programming as the evaluation of mathematical processes Based on what's call the lambda calculus.  Mention this is turing complete way of representing a programing language with only anonymous function
• #5: But what does this mean? Every function returns a value, that's what functions do they map one value to another. given an input a function always returns the same value in general it's more about stating what your problem is.
• #6: The big this this all entails is there are no 'Side Effects' in functional programming. When you call a function nothing about the world changes, can you say this is true about OOP?  This is much more meaningful that it may seem at first. If a variable is declared (and the usually aren't) it can never change it's value. This is even true for something like 'i' in a 'for loop' or the value a while loop checks... so that mean there are not classic iterators: no for loops, and no while loops.
• #7: So why do all this? Number one reason by far for me is the really amazing abstractions you can come up with. For programming side effect free is an awesome guarantee There a lot of potential research that we can get some great and easy parallization from all this There are already functional features in languages like C#, python, ruby, LINQ. If you understand FP you can pick these things up a lot faster Big ideas are starting to come from the fp community.  When google release mapreduce, anyone with a background in lisp for functional programming would have instantly be able to guess roughly how the process worked.
• #8: So I'm going to talk about 2 languages tonight side by side. Haskell is an amazing language, but it has a reputation for being very difficult to learn.  As much as I would like to pretend that this is not the case, it really can be.  Tonight I'm sticking to just a small subset of haskells expressiveness to go over the essentials of functional programming.  Get started with haskell isn't really so bad once you know the basics and understand fp a little better.
• #9: Now JavaScript has the opposite problem. Most people view it as simply a mediocre clientside language. But it's actually an amazingly powerful language, and also probably the most functional of all mainstream languages. I want to show you that functional programming isn't really that hard, it's just different.  I'm willing to bet that most anyone in the room has already used some really powerful functional features of javascript without even knowing it.
• #11: Before we begin I want to just mentions lists a bit.  Functional programmin, with no standard loops, is very heavily based on recursion, and so it also relies heavily on lists. Here are some basic operations on a list that you'll need to be familiar with.  They go by many other names.
• #24: The first essential feature of functional programming, is what is refered to as a 'first class function' This is one of the easiest concepts to grasp, it seemly means that functions can be treated just like any other object, and most importantly that they can be passed just like arguments.
• #25: so first we're going to put together a simple function this one adds '2' to a  number and this one addes '3' this are both in haskell and should be very simple to understand.  any questions
• #26: Now we're going to make the opposite function, that is a function that takes a function and applies it to a predetermined argument. So arg is '2' takes whatever function you pass it and gives it the argument '2' <walk them through the output>
• #27: How many of you have ever written any javascript at all? Everyone that just raised there hands has used a lambda function. All a lambda function is is an unnamed or anonymous function.  I'll show you in a bit how common these are in javascript Lambda functions are the core of funtional programming, although the can be all but removed from some languages. Initially what they offer may seem of limited use, but as we go on you should see how the become pretty essential. If you're insane you can literarly usual solely lambda functions to do all of your computation, you can even implment addition and subtraction without numbers.  Hell you can even implment recursion in using only unnamed functions.
• #28: Now these examples are stupidly simple, but you'll see lambda popping up all over this presentaiton in various forms. so here we're defining a function, add4, as a lambda <walk through notation? Now also notice how we can pass this function as a first class function directly to our previous argIsX function
• #29: Here some everyday javascript, these snippets are just pulled straight from standard javascript tutorials.  You've probably written code like this if you've ever done any javascript.
• #36: Closures sound more complicated then they are.  Closures let us capture some variable in the scope of a function we return... Examples will do you much better than me describing it.
• #37: So here's add5 for reference. Now this pattern of addX is pretty obvious, there must be a way to abstract this away right? so we can make this functioncalled makeAdder that takes a values. here is the same code 2 different ways, in put cases we're returning a function that has this value we based enclosed in it. Now we can make adders more easily. So you can see in the about put the function we returned remembers what value we passed to it. This also demonstrates another important property of lambda functions.
• #43: okay so proper first class functions, lambdas and closure are the core of functional programming.  coupled with recursion you're pretty much done. However these are really just the primative of functional programming.  Next we're going to answer what's probably the biggest question you have.  Since we throw out all the iterators I know of, how the hell do I get any actual work done? That brings us to higher order functions, by definiton these are just functions that take functions as an argument, but there are some that form the basis of how you should think about problems in fp.
• #44: Map is the most obvious, it solve the problem of the vast majority of iteration that you do.   map takes a function and a list and returns a new list with that function applied to every item in it. From here on out I'm going to show you how higher order functions work in haskell, and how there implemented in javascript
• #45: this is actually a pretty easy concept. so in the first example double all takes a list, and the applys times 2 to each item, so it doubles every item in the list. square all does the same thing but squares them square and add just shows off how we can use our lambda again and upperCase takes a string an applies toUpper to each letter in that string, a string is afterall just a list of characters.
• #46: just a note on haskell here, you can actually leave out the arguments on both sides if we're missing an arguement we essentially create a closure waiting for that argument. We'll talk more about this later.
• #51: filter does what the name sounds like, it takes a function which performs a test and only returns values that pass.
• #52: so this first case selects every item that is even the next selects every one that is evenly divisible by 17  And this last is a little different.  This is a neat trick called function composition.  what we do is apply the rightmost function and then send it's value to the left most.  this makes it very easy to define complicated functions by composing them. explain output
• #57: Folds are very poweful, but also the most likely to give you a headache until you undertand them.  There are actually several types of folds, we're going to focus on what's call a left fold, foldl or often reduce (in ruby it's called inject). fold takes a function, and initial value, and a list of values and 'folds' all the values of that list into a single value.
• #58: The simpliest and most obious use of fold it to some values ina list, see here our function is 'add' and our intial value is 0. This reverse is actually a bit more tricky, I'll actually walk you through this. finally I'll show you some more function composition. we can define sumOfSquare 2 ways, the first more verbose maps square to a list, and the folds it just like sum, The second composes our sum and squareAll functions.
• #59: here I'll walk you through the recursion for the fold revers.
• #64: Many of you may know of Joel Spolsky, he's one of the people behind stack over flow A few years ago he wrote about the functional properties of javascript and gave this as his implementation of map. But we can see here that this implementation itself is not functional.  In some cases this is meaningless, but notice what happens to the array we're passing?   In a purely functional work the original array will ALWAYS be untouched, in this case the original array is deleted.
• #65: Once again Spolsky also implemented this, but once again it's not functional. However this time it is less damaging and probably more effiience.  Some languages let you choose when you want to be functional, choose wisely.
• #78: Finally we'll discuss function currying. what happens in any language you know when you call a function that takes 3 arguements with only 2 arguement? Error right?  Well not in haskell, in haskell you get a new function waiting for the 3rd arguement. let's look at some examples
• #79: here I'll defiine a new version of add that takes 2 arguments If I call it with only one then I get a function waiting for the next argument, you can see this is even easier than our earlier example that build closures
• #80: what's crazy is that you can actually implement this functionality in javascript