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
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
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
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
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
