O que o Rubyista tem para aprender com Io, Prolog, Clojure, Scala, Haskell e Erlang? Essa talk vai mostrar.

1. SEVEN LANGUAGES
IN SEVEN WEEKS
Renan Ranelli

2. Renan Ranelli (Milhouse)

3. Software Engineer @
Renan Ranelli (Milhouse)

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

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