Diving into Functional Programming

1. Learning FP Lev Walkin @levwalkin

2. Myself Founder, Chief Editor of a peer-reviewed «Practice of Functional Programming» journal http://fprog.ru/ CTO Echo, a venture backed company http://aboutecho.com/ Proﬁcient in N languages, M of them FP

3. 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++

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

5. Mature options Haskell (OCaml, F#) Scala Clojure (CL, Scheme) Erlang

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

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

8. Type inference -- Haskell program main = print “Hello, world!” (* OCaml program *) let main = print_string “Hello, world!”

9. Explicit types -- Haskell program main :: IO () main = print “Hello, world!” (* OCaml program *) val main : unit let main = print_string “Hello, world!”

10. Dynamically typed LISP (type annotations are NOT static types) Erlang (Dialyzer helps a bit)

11. Pure FP training ...requires pure language. Haskell is the only viable option.

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

13. Haskell Medium-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?

14. “One” “silly” “example.”

16. “One” 3 “silly” “example.” 5 8

17. Haskell data 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)

18. Haskell data 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 Int strToLenTree = mapTree length

19. 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) tree Node (Leaf 2) (Leaf 7) *Main> mapTree (s -> filter Data.Char.isUpper s) tree Node (Leaf "A") (Leaf "") *Main> mapTree (filter Data.Char.isLower) tree Node (Leaf "n") (Leaf "example") *Main> :t mapTree mapTree :: (a -> b) -> Tree a -> Tree b *Main> :t mapTree length mapTree length :: Tree [a] -> Tree Int

20. LISP Clojure: 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)

21. Erlang Simple language Telecom systems, 24/7, системы массового обслуживания (web?) Hot code reload, deep introspection, embedded facilities for easier clustering

22. Erlang % Reverse a string reverse(String) -> reverse2(String, []). % Reverse with an accumulator reverse2([ ], Acc) -> Acc; reverse2([Head | Tail], Acc) -> ! reverse2(Tail, [Head | Acc]).

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

24. 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 http://tonsky.livejournal.com/tag/clojure

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

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

27. 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 ﬁts your domain well http://www.ozon.ru/context/detail/id/8696277/

28. OCaml Several mostly compatible syntaxes You can always create a mutable variable or class ﬁeld, though not idiomatic Clearer semantics and computation model (straightforward translation to assembly) http://mirror.ocamlcore.org/ocaml-tutorial.org/the_basics.html

29. 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 satisﬁed with Haskell or F# http://www.slideshare.net/michielovereem/beyond-functional- programming-in-haskell-an-introduction-to-ocaml

30. 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 http://www.ozon.ru/context/detail/id/6151130/

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

32. Scala vs * Big language, a functional C++ of sorts JVM Learn it if you want a great tool, not satisﬁed with Java, yet have no appreciation for true elegance (Clojure)

33. Learning FP Haskell provides models and abstractions (read papers) — pure FP Scheme teaches you Programming (read SICP) Everything else is too practical

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

35. For individuals You want ﬂexible system which allows you to cut corners Common Lisp Scala F#

36. For teams You 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)

37. 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://ru.xored.com/2012/12/02/scala/

38. Haskell resources Мягкое введение в Haskell Изучай Haskell во имя добра! http://www.rsdn.ru/article/haskell/haskell_part1.xml

39. Clojure resources 1. Learn spoken English 2. Журнал Никиты Прокопова (tonsky@LJ) содержит ссылки и рекомендации http://tonsky.livejournal.com/tag/clojure

40. Erlang resources 1. Programming Erlang: Software for a Concurrent World 2. http://learnyousomeerlang.com http://www.ozon.ru/context/detail/id/3645143/

41. Shameless plug Журнал «Практика функционального программирования» fprog.ru @fprogru

42. Thank you! Questions? jobs@aboutecho.com (мы пишем на Руби!)

Diving into Functional Programming

You are reading a preview.

Check these out next

Diving into Functional Programming

More Related Content

Slideshows for you (20)

Similar to Diving into Functional Programming (20)

Recently uploaded (20)

Diving into Functional Programming