Por que functional programming é mais rápido?

Por que functional programming é mais rápido?

Vou te mostrar que functional programming não é algo novo: não foi criado nem nesse milênio e tu provavelmente já sabe muito mais do que acha. Tenho 15 minutos pra te mostrar o porquê do paradigma ter se tornado popular nas últimas décadas.

Apresentado no TDC Porto Alegre 2015 - Trilha Big Data.

8c01de31d4ea71756e85a0aca3852e2e?s=128

Irio Musskopf

September 25, 2015
Tweet

Transcript

  1. Por que Por que functional programming functional programming é mais

    rápido? é mais rápido?
  2. Irio Musskopf Um-dia-quem-sabe-formado Matemático Trabalhando pra Neighborly(.com)

  3. (Re)vendo conceitos (Re)vendo conceitos

  4. None
  5. 100 103,5

  6. (10, 42) 105

  7. None
  8. ∠A + ∠B + ∠C = 180˚, ∀ ΔABC

  9. Moses Schönfinkel 1889 - 1942 Haskell Curry 1900 - 1982

    Alonzo Church 1903 - 1995 Cálculo Cálculo λ λ
  10. > let grossAmount price = price * 1.03 > grossAmount

    100 103.0 > grossAmount 100 103.0 -- $ ghci
  11. rand (http://goo.gl/0BaCQp) IO Exceções Exceções

  12. Immutability -> memoization

  13. > let investments = [1000, 500] > let investmentsCount =

    length(investments) > let amount = sum(investments) > let average = amount / investmentsCount > print average 750.0 -- $ ghci
  14. Immutability -> memoization Lazy evaluation

  15. > insert(a_collection, 42) > remove(a_collection, 42) -- $ ghci

  16. > insert(a_collection, 42) >>= remove(a_collection, 42) -- $ ghci

  17. Immutability -> memoization Lazy evaluation Monads

  18. > let multiplyAndSum x y = (x + x +

    x + x) + (y + y + y + y) -- $ ghci
  19. > let multiplyAndSum x y = (x + x +

    x + x) + (y + y + y + y) > let multiplyAndSum x y = 4 * x + 4 * y -- $ ghci
  20. > let multiplyAndSum x y = (x + x +

    x + x) + (y + y + y + y) > let multiplyAndSum x y = 4 * x + 4 * y > let multiplyAndSum x y = 4 * (x + y) -- $ ghci
  21. Immutability -> memoization Lazy evaluation Monads Compile-time optimizations

  22. scala> Stream.from(1). filter(_ < 100). map(_ + 1). take(2). toList

    // $ sbt console > take 2 $ map (+1) $ filter (<100) [1..] -- $ ghci tudoaomesmotempoagora tudoaomesmotempoagora
  23. Não será mais rápido que procedural às vezes será

  24. MapReduce

  25. Obrigado! Obrigado! @irio iirineu@gmail.com