O documento discute a importância do aprendizado de linguagens funcionais, destacando sua evolução e o ressurgimento recente em contextos como a programação em paralelo. Exemplos de linguagens funcionais como Erlang, F#, Clojure e Scala são apresentados, juntamente com conceitos chave como imutabilidade, recursão e monadas. A necessidade de adotar esses paradigmas é enfatizada para a construção de software eficiente e moderno.

1. Por que você precisa (re)aprender linguagens funcionais? Luiz Borba Maio-2010

2. Alonzo Church – anos 30 cálculo lâmbda λ x.x + 1 ( λ x.x + 1) 3 = 4

3. LISP – 1958 (defun quicksort (lis) (if (null lis) nil (let* ((x (car lis)) (r (cdr lis)) (fn (lambda (a) (< a x)))) (append (quicksort (remove-if-not fn r)) (list x) (quicksort (remove-if fn r))))))

4. Haskell – 1990 qsort [] = [] qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

5. Mainstream Desde os anos 60 Imperativa Procedural (Cobol, Fortran, C) e depois... Imperativa Orientada a Objetos (Smalltalk, C++, Java)

6. E como ficou o paradigma funcional? Basicamente na academia Desde de meados dos anos 90 Completamente esquecido

7. Mas, de repente...

8. Sinais

9. Erlang – Ericsson Language Criada em 1986 1998 AXD301 – confiabilidade de 99.9999999% Banida e disponibilizada como open source 2004 Reintroduzida na Ericsson

10. Microsoft F# Criada em 2002 Incluída no Visual Studio 2008 como um add-on Será parte integrante do Visual Studio 2010

11. Clojure Criada em 2007 Dialeto moderno de LISP Roda na JVM

12. Scala Criada em 2003 Funcional + Orientada a Objetos Linguagem “pós-funcional“ Backend do Twitter def qsort: List[Int] => List[Int] = { case Nil => Nil case pivot :: tail => val (smaller, rest) = tail.partition(_ < pivot) qsort(smaller) ::: pivot :: qsort(rest) }

13. Bancos NOSQL Google - Paper em 2007 sobre BigTable Map/Reduce Explosão de soluções CouchDB, MongoDB, Neo4j, Redis, Memcachedb, Dynamo, Cassandra, Voldermort, HBase, Hypertable, FluidDB, Riak, RavenDB, Dynomite, ...

14. Que diabos tá acontecendo?

15. Evolução das CPUs

16. “ Software is getting slower faster than hardware becomes faster” (Nicklaus Wirth)

17. código existente será obsoleto

18. temos que escrever código paralelo

19. QUEM SABE FAZER?

20. usando conceitos funcionais é mais fácil

21. Funções de Alta Ordem def apply(f:Int => String, v:Int) = f(v)

22. Imutabilidade let price = 10

23. Sem efeitos colaterais

24. Pattern Matching let peek s = match s with | Cons(hd, tl) -> hd | Nil -> failwith &quot;Empty stack&quot;

25. Actors Model class Ping(count: int, pong: Actor) extends Actor { def act() { var pingsLeft = count – 1 pong ! Ping while (true) { receive { case Pong => if (pingsLeft % 1000 == 0) println(&quot;Ping: pong&quot;) if (pingsLeft > 0) { pong ! Ping pingsLeft -= 1 } else { println(&quot;Ping: stop&quot;) pong ! Stop exit() } } } } }

26. Outros conceitos chaves Recursion Currying Lazy Evaluation Continuations Closures Functional Composition Referential Transparency Monads

27. Então vou fazer todos os meus novos sistemas usando linguagens funcionais?

28. NÃO

29. Vamos usar linguagens que tenham um mix de paradigmas

30. Funcional, Imperativa e Orientada a Objetos

31. Scala, C#, F# e Java (?)

32. Precisamos aprender linguagens funcionais para escrever o software do futuro.

33. Perguntas? [email_address]