The document discusses the threat of functional programming becoming more widely adopted. It begins by introducing the author and their background in functional programming. It then contrasts imperative programming which focuses on sequencing instructions and memory management, with declarative programming which describes what is wanted without specifying how to do it. The document advocates for the benefits of functional programming such as its focus on minimizing side effects and moving parts to make code more understandable. It discusses concepts in functional programming including higher order functions, immutable data structures, and avoiding object encapsulation. Finally, it provides a checklist for exploring functional programming further.

1. The Imminent Threat
of Functional Programming

2. Dimitry Solovyov
‣ Haskell enthusiast and FP proponent
‣ Heavy user of Underscore (FP library for JavaScript)
‣ Former assistant teacher of FP course at TTI
‣ Developer at Amber Games and Livesheets

3. dresdencodak.com

4. FUNCTIONAL
PROGRAMMING

5. In programming land,
there are two kinds of problems

6. In programming land,
there are two kinds of problems
memory
management

7. In programming land,
there are two kinds of problems
sequencing memory
(aka do it in what order?) management

8. In programming land,
there are two kinds of problems
sequencing memory
E D
LV
management
(aka do it in what order?)
SO

9. In programming land,
there are two kinds of problems
memory D *
sequencing VE
(aka do it in what order?)
O L
management
S
* Except for null pointer exceptions ;-)

10. In programming land,
there are two kinds of problems
?
memory D *
sequencing VE
(aka do it in what order?)
O L
management
S
* Except for null pointer exceptions ;-)

11. Sequencing in Java
while cond stmt
do stmt while cond
for init cond step stmt
for x : xs stmt

12. Sequencing in Ruby
loop stmt
while cond stmt
until cond stmt
stmt while cond
stmt until cond
for x in xs stmt
xs each stmt
n times stmt
n upto m stmt
n downto m stmt
...

13. Sequencing in Ruby
loop stmt
while cond stmt
How elegant! until cond stmt
stmt while cond
stmt until cond
for x in xs stmt
xs each stmt
n times stmt
n upto m stmt
n downto m stmt
...

14. Imperative programming in a nutshell
10 BEGIN
20 DO SOMETHING
30
40
DO THAT OTHER THING
GOTO 20 ✔
INSTRUCTIONS RESULT

15. Declarative programming in a nutshell
Dear computer,
I want a pony.
MAGIC ✔
DESCRIPTION RESULT

16. INSTANT
SUCCESS

17. “ OO makes code understandable by
encapsulating moving parts.
FP makes code understandable by
minimizing moving parts.
”
-- Michael Feathers
“Functional Programming in C++”
http://goo.gl/aVSXX

18. Abstraction and reusability in FP
Absolutely abstract
Category theory *
ly reu sable
High
Exciting
ly comp
osable
Mathematically proven
Ex tremely fun to be composable
* Check out Scalaz for CT in Scala
Guava for other FP patterns in Java

19. +
Some GoF pattern analogs
provided at semantic level
“Design Patterns in Haskell”
http://goo.gl/T0Evt

20. You can get away without
encapsulating in objects
Data types
fo
rm
r
fo
ed
d
ne
in
to
ig
s
de
operate on Immutable
Combinators
data structures

21. You can get away without
encapsulating in objects
Data types
fo
rm
r
fo
ed
d
ne
in
to
ig
s
de
operate on Immutable
Combinators
data structures

22. You can get away without
encapsulating in objects
Data types
Ready for the
age of multicore
fo
rm
r
fo
ed
d
ne
in
to
ig
s
de
operate on Immutable
Combinators
data structures

23. Traits instead of inheritance
Thesis: Inheriting state creates brittle software.
Inheriting implementation tends to
become useless over time.
“Life without Objects”
http://goo.gl/wlOyq

24. Traits instead of inheritance
Thesis: Inheriting state creates brittle software.
Inheriting implementation tends to
become useless over time.
A
B Data type
“Life without Objects”
C Expected to behave
like A, B, and C
http://goo.gl/wlOyq

25. “ In the exclusive sense, functional
means no side-effects.
In the inclusive sense it means a
programming style which composes
functions in interesting ways.
”
-- Martin Odersky
“In Defense of Pattern Matching”
http://goo.gl/HaKQD

26. Origin of the “functional style”
LISP ML
Common Lisp Standard ML
Scheme OCaml
Dylan F#
Racket Haskell
Closure JVM Frege JVM
Scala * JVM
* (cough) Close enough.

27. LISP ML
Dynamic Strong types
Code = data Type inference
Metaproggin' ADTs
First-class functions
Higher-order functions
Pattern matching

28. LISP ML
Dynamic Strong types
Code = data Type inference
Metaproggin' ADTs
First-class functions
Higher-order functions
Pattern matching

29. Linus says:
“Words are cheap,
show me the code.”

30. Fake first-class functions in Java
interface Func<A, B> {
B apply(A x);
}
static <A, B, C> Func<A, C> compose(final Func<A, B> f,
final Func<B, C> g) {
return new Func<A, C>() {
public C apply(A x) {
return g.apply(f.apply(x));
}
};
}

31. Fake higher-order functions in Java
static <A, B> List<B> map(final Iterable<A> xs,
final Func<A, B> f) {
List<B> ys = new ArrayList<B>();
for (A x : xs) {
B y = f.apply(x);
ys.add(y);
}
return ys;
}
map

32. Fake higher-order functions in Java
static <A, B> B fold(final Iterable<A> xs,
final B init,
final Func2<A, B, B> f) {
B acc = init;
for (A x : xs) {
acc = f.apply(x, acc);
}
return acc;
}
fold

33. REFERENTIAL
TRANSPARENCY

34. How logic works
x=1
y=2
x+y=3

35. in languages
How logic works with side-effects
x=1
y=2
x + y = 3*
* But only if the moon is still young!
Otherwise the answer is 5.

36. Functional programming on the JVM
en l
fe d
tio ss
ar ia
ef le
ch n
c o cy
s
nc cla
sp nt
es
at er
e- rol
ct
ns
g
an re
in
ur
m att
fu st-
sid nt
tr efe
os
p
fir
cl
r
Clojure ✔ ✔ ✔ ✘ ✘
Fantom ✔ ✔ ✔ ✘ ✘
Frege ✔ ✔ ✔ ✔ ✔
Java ✔ ✘ ✘ ✘ ✘
JRuby ✔ ✘ ✘ ✘ ✘
Kotlin ✔ ✔ ✔ ✘ ✔
Scala ✔ ✔ ✔ ✘ ✔

37. FP exploration checklist
❏ Start learning a functional language:
Scala, Clojure, or even Haskell
❏ Get together @ Latvian FP Group:
look for it on LinkedIn http://goo.gl/YhlJl
❏ Talk to me! dimituri@gmail.com