A Sceptical Guide to Functional Programming

Feel free to tweet

#devbash

A Sceptical Guide to
Functional Programming

Garth Gilmour (garth.gilmour@instil.co)

In the Belfast IT Forum BASH the audience are
entertained by two separate and unequal types of
presenter. World class experts who understand the
topic they are presenting on and uninformed dilettantes
who mither on about stuff they barely understand.

This is the latter 

This is a Sceptical Roadmap
  Personally I really like FP
  Not so sure about FP programmers
  Some things I’m going to say will really annoy
any FP purists out there...

Don't program
in Java!!

Why not?

Its restrictive – everything
has to be an object!!

What should
I use?

Program in
Lisp!!

Why?

Its brilliant – everything
has to be a list!!!!

Erm.....

Or better yet
Haskell!!

Why?

Its brilliant – you cant do
anything except pure math!!!!

Right...bye....

Pure Languages Vs. Hybrids

JavaScript Ruby Scala F# Clojure Haskell
ClojureScript
CoffeeScript
Dart
Groovy
Powershell

The 1990’s

Perl
Delphi

C++ C Python

VB
Lua

The 2010’s (Part 1)

Scala Groovy

JRuby Java Clojure

Jython
Kotlin


C# PowerShell

F# CLR VB

IronRuby IronPython


Dart CoffeeScript

GWT JavaScript

ClojureScript Many more ...

Does the Language Matter?

In the Soviet army it
takes more courage to
retreat than advance.

Joseph Stalin

Miyamoto Musashi

I Like Scala...
package demos.scala.classes.basic

class Employee(val name : String,
val age : Int,
val salary : Double)

$ javap -private demos.scala.classes.basic.Employee
Compiled from "Employee.scala"
public class demos.scala.classes.basic.Employee
extends java.lang.Object
implements scala.ScalaObject{
private final java.lang.String name;
private final int age;
private final double salary;
public java.lang.String name();
public int age();
public double salary();
public demos.scala.classes.basic.Employee(java.lang.String, int, double);
}

A Quick Word On Clojure
  A LISP with more syntax than ((( )))
  Dynamically typed and mostly functional
  Integrates fully with the JVM/CLR
  Extensive support for concurrency
  Via efficient but immutable collections

(defn printRow [rowNum height]
(dotimes [n (- height rowNum)] (print " "))
(dotimes [n (- (* rowNum 2) 1)] (print "#"))
(println))

(defn printPyramid [height]
(dotimes [n height] (printRow (+ n 1) height)))

(println "Enter the height of the pyramid...")
(printPyramid (Integer/parseInt (read-line)))

@FooBar
public class MyClass {
}

What Makes this Functional?

  Functional Composition
  Immutable State
  First Class Functions
  Internal Iteration
  Declarative Feel
  Use of a DSL

You Are Doing FP Already (Kinda)
  If you program in:
  XSLT (my favourite language)
  JavaScript (esp. if you use JQuery, Dojo etc…)
  C# from VS2008 onwards (esp. LINQ)
  Java (believe it or not…)
  If you use libraries like Guava / Google Collections
  If you follow certain coding conventions / best practises

  Ruby or Python
  Then you are already using FP techniques
  Even if you don’t already know it

Is XSLT a Functional Language?

<xsl:template match="title">
<header>
<h1><xsl:value-of select="text()"/></h1>
</header>
</xsl:template>

<title>Introduction to Java</title> <header>
<h1>Introduction to Java</h1>
</header>

Is XSLT a Functional Language?

Stylesheet

? Output Tree

Input Tree
XSLT Engine
?
?

LINQ is a Functional Technology

Query

Expression Tree

LINQ to SQL
C# Compiler
Plug-In

?

No Fear
(Well Just A Little)

Pure Bowel
Knotting Terror

def main(args : Array[String]) {
println("---Demo 1---")
val limit = 6
(1 to limit).foreach(num => printf("%d ", num))
println
(1 to limit).foreach(printf("%d ", _))

println("nn---Demo 2 ---")
val data = List(10,11,12,13,14,15)
val result1 = data.foldLeft(1000)((a,b) => a + b)
val result2 = data.foldLeft(2000)(_ + _)
println(result1)
println(result2)

println("n---Demo 3 ---")
val text = "abc123def456ghi789"
val newText = "[a-z]{3}".r.replaceAllIn(text, _.group(0).toUpperCase())
println(newText)
}

(defn times2 [x] (* x 2))
(defn greaterThan15 [x] (> x 15))

(def myvector [10 12 14 16 18 20 22 24])

(def result1 (map times2 myvector))
(def result2 (map (fn [x] (* x 2)) myvector))
(def result3 (map #(* %1 2) myvector))

(def result4 (filter greaterThan15 myvector))
(def result5 (filter (fn [x] (> x 15)) myvector))
(def result6 (filter #(> %1 15) myvector))

(def result7 (map #(* %1 2) (filter #(> %1 15) myvector)))

The Road Not Taken...
The newest version of the Microsoft Visual J++ development environment supports a language
construct called delegates or bound method references…

It is unlikely that the Java programming language will ever include this construct. Sun already
carefully considered adopting it in 1996, to the extent of building and discarding working
prototypes. Our conclusion was that bound method references are unnecessary and detrimental
to the language…

We believe bound method references are unnecessary because another design alternative, inner
classes, provides equal or superior functionality. In particular, inner classes fully support the
requirements of user-interface event handling, and have been used to implement a user-interface
API at least as comprehensive as the Windows Foundation Classes.

We believe bound method references are harmful because they detract from the simplicity of the
Java programming language and the pervasively object-oriented character of the APIs….

Extracts From: About Microsoft’s “Delegates"
Whitepaper by the Java language team at JavaSoft

private void demoTemplatesAndCallbacks(HibernateTemplate template) {
String query = "select delivery.course.title from Delivery delivery";
List titles = template.executeFind(new QueryCallback(query));
System.out.println("Courses being delivered are:");
for(Object title : titles) {
System.out.printf("t%sn",title);
}
}

public class QueryCallback implements HibernateCallback {
public QueryCallback(String query) {
this.queryStr = query;
}
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(queryStr);
return query.list();
}
public String queryStr;
}

private void demoTemplatesAndCallbacks(HibernateTemplate template) {
String query = "select delivery.course.title from Delivery delivery";
List titles = template.executeFind((s) => s.createQuery(query).list());
System.out.println("Courses being delivered are:");
titles.forEach((t) => System.out.printf("t%sn",title));
}

SwingUtilities.invokeLater(new Runnable() {
public void run() {
textField.setText(theResult);
}
});

SwingUtilities.invokeLater(() => textField.setText(theResult));

val originalData = List("ab", "cd", "ef", "gh", "ij", "kl")

val newData1 =
originalData.map((str) => new Result(str + "yy", Thread.currentThread.getId))

val newData2 =
originalData.par.map((str) => new Result(str + "zz", Thread.currentThread.getId)

Programmer

a=a+1
Mathematician

class Person {
public String toString() {
StringBuilder sb = new StringBuilder(); Person earning
sb.append(“Person earning ”); 5000.0 with tax of
sb.append(salary.calcMonthlyBasic()); 763 and pension
sb.append(“ with tax of ”);
payment of 469.0
sb.append(salary.monthlyTax());
sb.append(“ and pension payment of ”);
sb.append(salary.monthlyPension());
return sb.toString();
} class Person {
private Salary salary; public String toString() {
} StringBuilder sb = new StringBuilder();
sb.append(“Person earning ”);
sb.append(5000.0);
Person earning sb.append(“ with tax of ”);
5000.0 with tax of sb.append(salary.monthlyTax());
sb.append(“ and pension payment of ”);
0 and pension
sb.append(salary.monthlyPension());
payment of 0 return sb.toString();
}
private Salary salary;
}

What's The Use?
  Code is easier to reason about.
  Compilers & VM’s can partition code automatically
into sections and run them in parallel.
  Lazy Evaluation

if(foo() && bar()) { func(foo(), bar());
zed(); -------------------------------
} void func(a, b) {
if(zed()) {
if(foo() || bar()) { c = a + 1; //foo not called till here
zed(); }
} }

Another reason that you might be interesting in purity is that it
gives you a better handle on parallelism. It doesn't make
parallelism easy, but it kinda makes it feel a bit more within
reach.

...
I dont think its parallelism without tears, but it kinda gives you
a chance in a way that the imperative by default with shared
mutable state makes things very difficult.

Simon Peyton Jones
(On SE Radio Ep 108)

But all a purely functional program
can do is heat up the CPU - and
that's still a side effect!!!

Higher-Order Functions
(inc. Currying & Partial Invoke)

def joinUp(separator : Char)(data : Array[String]) = {
val sb = new StringBuilder
for(str <- data) {
sb.append(str)
sb.append(separator)
}
sb.substring(0,sb.length - 1)
}

def joinUpWithHashes = joinUp('#') _
def joinUpWithHyphens = joinUp('-') _

def main(args : Array[String]) {
val testData = Array("abc","def","ghi","jkl","mno")
println(joinUp(',')(testData))
println(joinUpWithHashes(testData))
println(joinUpWithHyphens(testData))
}

Type Inference
& Parametric Polymorphism

int foo(int a) { int foo(int a) {
int b = zed(); int b = zed();
if(b > a) { if(b > a) {
return a + foo(b); return foo(a + b);
} else { } else {
return b; return 1;
} }
} }

a
b

a
b
a
a
b
b
a
b

def processItem(item : StockItem) {
item match {
case Book(_,"Crime") => println("Found a crime novel")
case Movie(_,MovieType.DVD) => println("Found a DVD movie")
case CD(_,_,12) => println("Found a CD with 12 tracks")
case CD(_,"Soundgarden",_) => println("Found a CD by Soundgarden")
case Book(_,_) => println("Found some kind of book")
case _ => println("Found something...")
}
}

Monads By Metaphor
int pthread_create(pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine) (void *),
void *arg);

Monads By Quotation

Monads turn control flow into data
flow, where it can be constrained
by the type system.

Oleg Kiselyov

Monads By Example
  Monads remove the boilerplate involved when
extracting / inserting values from “Amplified Types”
  Whilst enabling the compiler to perform extra checks
  Kind of like AOP but without the runtime overhead

List<T>
Map<T,U>
Option<T> (aka Maybe<T>)
EntityManager<T>
Repository<T>
ThreadSafe<T>
IO<T>

void printPostcode(Person person) {
String code = person.findAddress().findPostcode().findValue();
System.out.println(code);
}

void printPostcode(Person person) {
Address address = person.findAddress();
if(address != null) {
Postcode postcode = address.findPostcode()
if(postcode != null) {
String code = postcode.findValue();
System.out.println(code);
}
}
}

class Person(val name : String, val address : Address) {
def findAddress() : Option[Address] = {
if(address == null) {
None
} else {
Some(address)
}
}
}

def printPostcodeIfExists(person : Person) {
println("Working with " + person.name)
for (
place <- person findAddress;
code <- place findPostcode;
result <- code findValue
) println(result)
}

I Trust That's All Clear Now 

One Final Thought...

OO makes code understandable by
encapsulating moving parts. FP makes
code understandable by minimizing
moving parts.

Michael Feathers

To Summarize...
  You can start doing this today
  Get familiar with the FP parts of your language
  Prefer internal iteration to explicit loops
  Play with making sections of code side-effect free
  Experiment with building functional machines
  Use the emerging support for ‘hands-free’ concurrency
  Review, measure, assess, adjust
  Make this years new language an FP one
  Try Scala to extend what you already know into FP
  Try Clojure, F# or Haskell to get a new perspective

21st March 2012

Kevlin Henney
A Question of
Craftsmanship

April/May

??
We are speaking to a
few exciting people!

September 2012

Jim Webber
Mr NOSQL

A Sceptical Guide to Functional Programming

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to A Sceptical Guide to Functional Programming (20)

More from Garth Gilmour (20)

Recently uploaded (20)

A Sceptical Guide to Functional Programming