Learning FPLev Walkin@levwalkin

Myself

Founder, Chief Editor of a peer-reviewed «Practice of Functional Programming» journal http://fprog.ru/

CTO Echo, a venture backed companyhttp://aboutecho.com/

Proficient in N languages, M of them FP

Echo

50,000+ HTTP requests per second

500,000+ simultaneous users on site

1,527,721,774 search queries last month

JavaScript, Clojure, Haskell, C, LAMP, RoR, OCaml, Python, Perl, Visual Basic, C++

What’s your reason to learn FP?

1.You already suspect that FP approach works best for your domain

2.You want to learn FP to expand your tool set

Mature options

Haskell (OCaml, F#)

Scala

Clojure (CL, Scheme)

Erlang

Statically typed

Haskell, OCaml, F# — part of ML family

Utilize Hindley—Milner type inference

You might not even SEE any types

Types provide useful documentation

Statically typed

Scala

Very sophisticated type system

Type inference fails often (you have to annotate with types)

Lots of syntax sugar, lots of ways to do things

Type inference

-- Haskell program

main = print “Hello, world!”

(* OCaml program *)

let main = print_string “Hello, world!”

Explicit types

-- Haskell programmain :: IO ()main = print “Hello, world!”

(* OCaml program *)val main : unitlet main = print_string “Hello, world!”

Dynamically typed

LISP (type annotations are NOT static types)

Erlang (Dialyzer helps a bit)

Pure FP training

. . .requires pure language.

Haskell is the only viable option.

Purity in Haskell

Function have no side effects

All state changes are only through specially constructed monads (IO, ST)

Static types force isolation

Lazyness thrown in for a deeper fun

HaskellMedium-size syntax, relatively easy to learn, but...

Simple & interesting things are EASY

Yet, there are LOTS of abstractions and approaches to learn: Type classes, Monads, Arrows, parsing, pretty-printing.

This is why we chose Haskell, right?

“One”

“example.”“silly”

http://fprog.ru/2009/issue2/roman-dushkin-algebraic-data-types/

Haskell, OCaml, F#

data Tree a =! Leaf a! | Node (Tree a) (Tree a)

type ‘a tree =! | Leaf of ‘a! | Node of ‘a tree * ‘a tree

type Tree<'a> = | Leaf of ‘a | Branch of ‘a Tree * ‘a Tree

“One”

“example.”“silly”

3

85

Haskelldata Tree String =! Leaf String! | Node (Tree String) (Tree String)

strToLenTree :: Tree String ! Tree Int

strToLenTree (Leaf s) = Leaf (length s)strToLenTree (Node left right) =! ! ! Node (strToLenTree left)! ! ! ! ! (strToLenTree right)

Haskelldata Tree a =! Leaf a! | Node (Tree a) (Tree a)

mapTree :: (a ! b) ! Tree a ! Tree b

mapTree f (Leaf x) = Leaf (f x)mapTree f (Node left right) =! ! ! ! Node (mapTree f left)! ! ! ! ! ! (mapTree f right)

strToLenTree :: Tree String ! Tree IntstrToLenTree = mapTree length

Prototyping[~]> ghci tree.hs GHCi, version 7.0.4 :? for help[1 of 1] Compiling Main ( tree.hs, interpreted )Ok, modules loaded: Main.*Main> let tree = Node (Leaf "An") (Leaf "example")*Main> mapTree (\s -> length s) treeNode (Leaf 2) (Leaf 7)*Main> mapTree (\s -> filter Data.Char.isUpper s) treeNode (Leaf "A") (Leaf "")*Main> mapTree (filter Data.Char.isLower) treeNode (Leaf "n") (Leaf "example")

*Main> :t mapTreemapTree :: (a -> b) -> Tree a -> Tree b*Main> :t mapTree lengthmapTree length :: Tree [a] -> Tree Int

LISPClojure: immutability, persistent data structures, JVM

Scheme: very small language, suitable for teaching/learning

Common Lisp: it is a fat multiparadigm language and has everything (though parts may be rotten a bit)

Erlang

Simple language

Telecom systems, 24/7, системы массового обслуживания (web?)

Hot code reload, deep introspection, embedded facilities for easier clustering

Erlang

% Reverse a stringreverse(String) -> reverse2(String, []).

% Reverse with an accumulatorreverse2([ ], Acc) -> Acc;reverse2([Head | Tail], Acc) ->! reverse2(Tail, [Head | Acc]).

Erlang

% Sends request to the [remote] system% and waits for the response backsend_and_wait(Pid, Message, Timeout) ->! Pid ! Message,! receive! ! Response -> {ok, Response}! after! ! Timeout -> {error, timeout}! end.

http://tonsky.livejournal.com/tag/clojure

Clojure vs LISP*NEW language, with sound idioms

Immutable data structures are idiomatic

Fast pace of development

JVM may be a big bon for some

Learn it if you want sound, practical language

Scheme vs LISP*

Small, simple language (R5RS)

A basis for SICP — Structure and Interpretation of Computer Programs

Learn SICP if you want to study Programming

CL vs LISP*

Many complex ideas mixed in

No enforcement of a good style — you have to do it on your own

Learn it if you want unrestricted power

http://www.ozon.ru/context/detail/id/8696277/

Haskell vs ML*

More sound type system

LOTS of language research happen on Haskell

Learn it if you want to learn FP

Learn it if it fits your domain well

http://mirror.ocamlcore.org/ocaml-tutorial.org/the_basics.html

OCaml

Several mostly compatible syntaxes

You can always create a mutable variable or class field, though not idiomatic

Clearer semantics and computation model (straightforward translation to assembly)

http://www.slideshare.net/michielovereem/beyond-functional-programming-in-haskell-an-introduction-to-ocaml

OCaml vs ML*

OCaml is to Haskell as C is to C++

Poor library support

FAST (on 1-core systems)

Learn it if you want a practical tool and not satisfied with Haskell or F#

http://www.ozon.ru/context/detail/id/6151130/

F# vs ML*

Works under Microsoft .Net

F# on Mono is somewhat usable

Learn it if you want to tinker with FP on MS platform

Erlang vs *SMALL language, somewhat bigger OTP

Great support for concurrency (Actors), and parallelism

Hot code reload & run time introspection

OOP on the outside; FP on the inside

Learn it if you build 24/7 production system

Scala vs *

Big language, a functional C++ of sorts

JVM

Learn it if you want a great tool, not satisfied with Java, yet have no appreciation for true elegance (Clojure)

Learning FP

Haskell provides models and abstractions (read papers) — pure FP

Scheme teaches you Programming (read SICP)

Everything else is too practical

Practicing FP.Net → F#

JVM → Clojure (elegance and simplicity), Scala (less restrictions)

!{.Net|JVM} → OCaml (if you do not need libraries), Clojure, Haskell (if you have balls)

24/7 → Erlang

For individuals

You want flexible system which allows you to cut corners

Common Lisp

Scala

F#

For teamsYou want to think about lifecycle, support, maintenance, group dynamics

OCaml (static typing provides some guarantees)

Erlang (simple and straightforward, designed to withstand errors, good for novices)

http://ru.xored.com/2012/12/02/scala/

For teams

Scala gets increasingly popular because people do not appreciate elegance and sound restrictions

People will throw up in a few years working with accumulated Scala code

...like C++

http://www.rsdn.ru/article/haskell/haskell_part1.xml

Haskell resources

Мягкое введение в Haskell

Изучай Haskell во имя добра!

http://tonsky.livejournal.com/tag/clojure

Clojure resources

1.Learn spoken English

2.Журнал Никиты Прокопова (tonsky@LJ) содержит ссылки и рекомендации

http://www.ozon.ru/context/detail/id/3645143/

Erlang resources

1.Programming Erlang: Software for a Concurrent World

2.http://learnyousomeerlang.com

Shameless plug

Журнал «Практика функционального программирования»

fprog.ru

@fprogru

Thank you!

Questions?@levwalkin