Successfully reported this slideshow.
Your SlideShare is downloading. ×

Diving into Functional Programming

Upcoming SlideShare
Os Keysholistic
Os Keysholistic
Loading in …3

Check these out next

1 of 42 Ad

More Related Content

Slideshows for you (20)

Similar to Diving into Functional Programming (20)


Recently uploaded (20)

Diving into Functional Programming

  1. 1. Learning FP Lev Walkin @levwalkin
  2. 2. Myself Founder, Chief Editor of a peer-reviewed «Practice of Functional Programming» journal CTO Echo, a venture backed company Proficient in N languages, M of them FP
  3. 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. 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. 5. Mature options Haskell (OCaml, F#) Scala Clojure (CL, Scheme) Erlang
  6. 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. 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. 8. Type inference -- Haskell program main = print “Hello, world!” (* OCaml program *) let main = print_string “Hello, world!”
  9. 9. Explicit types -- Haskell program main :: IO () main = print “Hello, world!” (* OCaml program *) val main : unit let main = print_string “Hello, world!”
  10. 10. Dynamically typed LISP (type annotations are NOT static types) Erlang (Dialyzer helps a bit)
  11. 11. Pure FP training ...requires pure language. Haskell is the only viable option.
  12. 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. 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. 14. “One” “silly” “example.”
  15. 15. 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
  16. 16. “One” 3 “silly” “example.” 5 8
  17. 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. 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. 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. 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. 21. Erlang Simple language Telecom systems, 24/7, системы массового обслуживания (web?) Hot code reload, deep introspection, embedded facilities for easier clustering
  22. 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. 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. 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
  25. 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. 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. 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 fits your domain well
  28. 28. 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)
  29. 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 satisfied with Haskell or F# programming-in-haskell-an-introduction-to-ocaml
  30. 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
  31. 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. 32. 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)
  33. 33. Learning FP Haskell provides models and abstractions (read papers) — pure FP Scheme teaches you Programming (read SICP) Everything else is too practical
  34. 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. 35. For individuals You want flexible system which allows you to cut corners Common Lisp Scala F#
  36. 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. 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 C++
  38. 38. Haskell resources Мягкое введение в Haskell Изучай Haskell во имя добра!
  39. 39. Clojure resources 1. Learn spoken English 2. Журнал Никиты Прокопова (tonsky@LJ) содержит ссылки и рекомендации
  40. 40. Erlang resources 1. Programming Erlang: Software for a Concurrent World 2.
  41. 41. Shameless plug Журнал «Практика функционального программирования» @fprogru
  42. 42. Thank you! Questions? (мы пишем на Руби!)