My slides from Try {harder} 2012

1. Didn’t code in ages.
HaXe got in the way.
LISP

2. or how I learned to stop worrying and
love parentheses

3. ; Clojure - a new dialect of LISP
(defn hello [name]
(println "Hello," name, "!"))
(hello "TryHarder")

4. but we’re going to talk about more
than just LISP

5. what is functional programming?

6. the history of functional programming

7. why did functional programming
become so popular (again)?

8. or commonly used OO
the differences between FP and
imperative programming

9. analyze the current usage of
object-oriented languages

10. accidental complexity

11. let’s have a look at object-oriented
programming languages and their
programming model

12. there are lots and lots of object-oriented
languages out there

13. JAVA
C#
AS3
HaXe
Python
Ruby
PHP
...

14. but actually they aren’t really that
different

15. similar features:
Still we have religious
fights about them!
Classes
Inheritance
Polymorphism
Closures
imperative
...

16. Still we have religious
fights about them!
slightly different styles:
Indentation
Semicolons
Syntactic sugar
...

17. is this the holy grail of programming?
are we done?

18. accidental complexity
“Accidental complexity is complexity that arises in
computer programs or their development process which
is non-essential to the problem to be solved. While
essential complexity is inherent and unavoidable,
accidental complexity is caused by the approach chosen
to solve the problem.”

19. Causes side effects
Factories or Dependency
variables vs. values
Injection are a sign of
Accidental Complexity
class Rhino
{
private var _position:Point;
public function Rhino(position:Point)
{
_position = position;
or
_position = position.clone();
}
}

20. Side effects
Everyone needs to
observe everyone. observers / dispatching events
The environment stops
when observing it.
var rhino:Rhino = new Rhino();
var water:Water = new Water();
rhino.addEventlistender(Event.RHINO_JUMP, water.splash);

21. mutability and state
Mutability and state are accidental complexity.

22. We are to familiar with
OO to see the problems.
Most programmers see syntax and and expressivity as the key features
in a programming language.
Whereas we really run into problems understanding larger applications
and also the effect that changes will take are very hard to predict.

23. A builder doesn’t need to
building blocks
know what happens
inside a brick.
Pointers in C
Object-oriented programming/design is meant to simplify our
lives by using object-oriented modules/libraries as our building
blocks for our program.
But without knowing the internals this is almost impossible.
(Pure) Functions are a far better fit for this purpose.

24. “Civilization advances by extending the
number of important operations which
we can perform without thinking.”
Alfred North Whitehead

25. now imagine you don’t know
anything about
object-oriented programming

26. the history of functional-programming

27. Math theory:
Definition of functions
Their application
Functional languages
were developed to have a
clearer approach to
mathematics
lambda calculus
by Alonzo Church in 1930

28. functional-programming languages
1959
Lisp
1975
ML, FP, Scheme
1986
Standard ML
1990
Haskell, Erlang
2000
OCaml
2003
Scala
2005
F#
2007
Clojure

29. what is functional-programming?

30. They talk about
algorithms, ds, recursion,
scope ... on page 216
they introduce
ASSIGNEMENT
Available for free online.

31. In a restricted sense: functional programming means
programming without mutable variables, assignments, loops
or imperative control structures.

32. In a wider sense: functional programming means to focus on functions.

33. In particular: functions can be values that are produced,
can be consumed and composed.

34. what is essential in a language
for functional programming?

35. higher-order function
It has to be possible to use functions as in input or return values in other
functions

36. function curryMe(input:Function):Function
{
return curry(input, 2);
}

37. first-class functions
It has to be possible to declare functions anywhere, even inside other functions

38. function outerFunction():int
{
function innerFunction():int
{
return 0;
}
return innerFunction();
}

39. recursion
It has to be possible to call functions recursively

40. function sum(xs:Array):int
{
if(xs.length == 0) return 0;
return xs.shift() + sum(xs);
}

41. pure functions
Take and/or return values
Local scope: no side effects
Same arguments: same result
Easy to understand, change & test

42. function pure(x:int, y:int):int
{
return x + y;
}
var _y:int = 1000;
function notPure(x:int):int
{
return x + _y;
}

43. No classes, what types
data-structures
do we have??
Just use basic types
(Lists) and operate on
them.
Basically the same as we
already.
Code == Data
"It is better to have 100 functions operate on one data
structure than to have 10 functions operate on 10 data
structures." - Alan J. Perlis

44. why did functional-programming did
become so popular (again) recently?

45. Clojure
F#
Scala
new functional-programming languages
are popping up left and right

46. Clojure
F#
Scala
Moores law

47. Single-Threaded clock
speed has stalled.
Number of cores
increases.
In a couple of years we
will have laptops with
32 or 64 cores.

48. examples

49. //AS3
a + b;
a * b;
;Clojure
(+ a b)
(* a b)

50. //AS3
Math.max(a, b);
;Clojure
(max a b)

51. //AS3
function add(x:int,y:int):int
{
return x + y;
}
;Clojure
(defn add [x, y]
(+ x y))

52. //AS3
function fibonacci( a:int ):int
{
if( a == 0 || a == 1 )
return a;
else
return fib( a - 1 ) + fib( a - 2 );
}

53. ;Clojure
(defn fib [n]
(if (= n 0) 0
(if (= n 1) 1
(+ (fib (- n 1)) (fib (- n 2))))))

54. ;Clojure - whole fibonacci sequence
(defn lazy-seq-fibo
([]
(concat [0 1] (lazy-seq-fibo 0 1)))
([a b]
(let [n (+ a b)]
(lazy-seq
(cons n (lazy-seq-fibo b n))))))

55. (defn neighbours [[x y]]
(for [dx [-1 0 1] dy (if (zero? dx) [-1 1] [-1 0 1])]
[(+ dx x) (+ dy y)]))
(defn step [cells]
(set (for [[loc n] (frequencies (mapcat neighbours cells))
:when (or (= n 3) (and (= n 2) (cells loc)))]
loc)))

56. Runs on the JVM
Interoperability with
Java libraries
why clojure?