TDC POA 2015 - Seven Languages in Seven Weeks

TDC POA 2015 - Seven Languages in Seven Weeks

4569aec00cb223b3fbf484f9e7ba1256?s=128

Renan Ranelli

September 24, 2015
Tweet

Transcript

  1. SEVEN LANGUAGES IN SEVEN WEEKS Renan Ranelli

  2. Renan Ranelli (Milhouse)

  3. Software Engineer @ Renan Ranelli (Milhouse)

  4. None
  5. None
  6. AGENDA • Why should I care about learning new languages?

    • A little bit about the languages in the book and how they compare with Ruby • What I learned during the last few years
  7. WHO IS THIS TALK FOR • You, who is an

    Object oriented programmer and has heard about functional programming • You, who have no clear understanding on why learning many languages will help you be better at your language of choice
  8. 1 - WHY SHOULD I CARE?

  9. WHY SHOULD I CARE ? • First of all... •

    I Think you should learn programming languages • But my opinion probably will not matter to you. So, listen to these guys:
  10. http://blog.golang.org/concurrency-is-not-parallelism

  11. http://blog.golang.org/concurrency-is-not-parallelism

  12. http://blog.golang.org/concurrency-is-not-parallelism

  13. None
  14. DISCLAIMER: ALL THE LANGUAGES HERE ARE TURING COMPLETE

  15. WE WILL A LITTLE ABOUT • Ruby • Io •

    Prolog • Scala • Erlang • Clojure • Haskell
  16. WHAT I AIM TO ACHIEVE • I will try to

    explain what is important when learning a new programming language • I expect to show you that characterizations such as “it is a functional language” or “it is object oriented” is insufficient and most of the times innapropriate • I *Do Not* intend to teach you any of the languages
  17. WE WILL A LITTLE ABOUT • Ruby • Io •

    Scala • Erlang • Clojure • Haskell Support for OOP Support for FP
  18. 2 – SELECTED POINTS ABOUT EACH LANGUAGE

  19. RUBY • Object oriented, class based, dynamic and strongly typed

    • *Extremely* meta-programmable • OPEN CLASSES !!!!!! • Complex syntax, complex evaluation rules • Reads like a novel • We all know and love it
  20. IO • Object oriented, prototype based, strongly typed • Extremely

    simple and consistent syntax • Heavy emphasis on message passing, not method call. (method is a message that returns an object that can receive the message call) • Easy to create DSLs • Excellent concurrency primitives (futures, corroutines, actors) • CRAZY amount of reflective power
  21. IO

  22. IO Message

  23. IO Message

  24. IO Message

  25. IO Message

  26. IO

  27. IO

  28. SCALA • OOP, FP, statically typed, strongly typed • Has

    a powerful type system (not as much as Haskell's) • Offers advanced FP concepts such as monads and type classes • Easy(-ish) to create DSLs • You can emulate non-strict evaluation with “call by name” vs “call by value” parameter passing strategies • Suffers from the Java legacy to a certain extent (nulls)
  29. SCALA

  30. SCALA

  31. SCALA

  32. SCALA

  33. SCALA

  34. ERLANG • Designed by Ericsson to build telecom software •

    Alien syntax, derived from Prolog • Functional, enforces extreme isolation of processes. Truly share-nothing. • Amazing support for faul-tolerant, near-real-time distributed application development • Quite opinionated .. • ALIEN SYNTAX
  35. CLOJURE • Is a LISP (!!1!!11) • FP, supports OOP,

    strongly typed and dynamically • Strong focus on good concurrency primitives and immutable & persistent data structures • Being a LISP, has macros • Being a LISP, code is data and data is code • Not so Lispy. No custom reader macros and no automatic tail call optimizations (schemers be mad)
  36. CLOJURE • Although Clojure is a strict language, you can

    simulate non-strictness using macros • Its possible to define the language on-the-fly, i.e., the language is internally reprogramable (heavy influce in both Ruby and Smalltalk) • Offers the CLOS-like long forgotten multiple-dispatch !
  37. HASKELL • Non-strict (lazy) pure functional language • No exceptions

    and no mutable state (!) • Unparalleled type system (at least in production-ready languages) with parametric types, type classes, algebraic data types and type inference • Offers the full pack of FP crazyness: Monads, Monoids, Functors, applicatives, Foldables and Semigroups are common ground among Haskell programmers • Much more close to Math, simplyfing the way we represent abstract, symbolic and self-recursive constructs
  38. HASKELL • Makes it impossible to mutate state • But

    allow you to simulate its effects with Monads
  39. HASKELL

  40. HASKELL

  41. HASKELL

  42. 3 – WHAT I LEARNED AFTER READING THIS BOOK

  43. WHAT DOES IT TAKE TO LEARN A NEW LANGUAGE ?

    • Syntax • The programming languages primitives • The type system (strong or weak? Static or dynamic?) • Evaluation rules (precedence, strictness, etc) • Idioms • Libraries • Tools, IDEs, yadda yadda
  44. WHAT DOES IT TAKE TO USE A LANGUAGE IN PRODUCTION

    • Meta-programming and extensibility models • Concurrency model • Library distribution • Debugging, IDEs, Tools, Refactoring tools ... • *Community* • Concurrency model (again!)
  45. YOU CAN'T SEPARATE THE LANGUAGE AND ITS ECOSYSTEM

  46. IS IT THAT RUBY IS PRODUCTIVE IN ITSELF, OR ARE

    RUBY LIBRARIES, LIKE RAILS, PRODUCTIVE??
  47. LEARN FROM OTHERS

  48. UNDERSTAND HOW THEY SOLVE PROBLEMS YOU HAVE, OR PROBLEMS YOU

    DON'T EVEN KNOW YOU HAVE
  49. GET TO KNOW WHAT YOU CAN IMITATE ! SEE CONCURRENT-RUBY

    AND CELLULOID !
  50. THERE IS *A LOT* OF COOL STUFF OUT THERE. LOOK

    OUTSIDE YOUR COMMUNITY
  51. HAVE FUN

  52. HAVE FUN

  53. OBRIGADO !

  54. @renanranelli /rranelli Renan Ranelli (Milhouse) milhouseonsofware.com