Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Qualé dessa Programação Funcional?

83aaddfb8a64b3fcdda06d8562013b7c?s=47 Andrew Rosa
September 19, 2015

Qualé dessa Programação Funcional?

O atual cenário de programação está mais uma vez mudando. Vemos a ascenção de diversas (não tão) novas linguagens, muitas seguindo este tão falando paradigma funcional. Mas o que afinal seria uma linguagem funcional? No que ela difere do que temos atualmente? E mais importante, o que nós Rubistas ganhamos com isso?
Aqui pretendo fazer uma breve exposição sobre o quais seriam estas diferenças entre FP e OOP, suas vantagens e cuidados. E também como podemos trazer algumas de suas idéias e práticas para melhorar nosso próprio código Ruby, hoje.

83aaddfb8a64b3fcdda06d8562013b7c?s=128

Andrew Rosa

September 19, 2015
Tweet

Transcript

  1. Qualé dessa programação Funcional?

  2. None
  3. Mônadas

  4. Mônadas são apenas monoids na categoria dos endofuctores

  5. F(idx ) = idF(x) F(g∘ f) = F(g) ∘  F(f), ∀

    f : x → y e g : y → z
  6. ( ͡° ͜ ʖ ͡°)

  7. order = Order.new(total: 100) # => <Order#123 @total=100>

  8. coupon.discount(order) # => 10

  9. address.shipping_cost(order) # => 30

  10. order.total # => 120

  11. address.shipping_cost(order) # => 30

  12. order.total # => 150

  13. (╯°□°)╯︵ ┻━┻)

  14. OBJETOS

  15. Estado + Comportamento

  16. Estado e Comportamento são características independentes

  17. CADASTRO

  18. CADASTRO BÁSICO PRO

  19. BÁSICO INDIVIDUAL STARTUP PRO HOSTED ON-PREMISE CADASTRO

  20. CADASTRO

  21. TERMOS

  22. PESSOAL TERMOS

  23. TERMOS ENDEREÇO PESSOAL

  24. PESSOAL PAGAMENTO ENDEREÇO ACESSO

  25. Fluxo de Informação

  26. ESTADO

  27. Dados são apenas dados

  28. Números, Strings, Símbolos

  29. Listas, Mapas, Conjuntos

  30. [{name: "Rubyconf", year: 2014}, {name: "Rubyconf", year: 2015}]

  31. {name: "Rubyconf", year: 2015}

  32. "Olá Rubyconf 2015!"

  33. [:h1, {class: "greetings"}, "Olá Rubyconf 2015!"]

  34. <h1 class="greetings"> Olá Rubyconf 2015! </h1>

  35. Dados são manipuláveis

  36. Dados livres contribuem com a simplicidade

  37. COMPORTAMENTO

  38. Trabalhamos realizando transformações sobre dados

  39. tech-events -> filter (by-year 2015) -> map make—greeting -> map

    wrap-with-markup -> render-html
  40. Usamos funções como unidade básica de abstração

  41. def make—greeting (event) let name = get event :name year

    = get event :year str "Olá " name " " year "!"
  42. Funções dizem “o que fazer” e não o “como fazer”

  43. result = [] for event in tech_events do result <<

    make_greeting(event) end result
  44. tech-events -> map make—greeting

  45. map make-greeting tech-events

  46. Composição é feita via Funções de Alta Ordem

  47. Funções podem ser parâmetros de outras funções

  48. map make—greeting tech-events

  49. map f collection

  50. map f collection filter f collection reduce f collection

  51. Funções podem ser produzir novas funções

  52. filter (by-year 2015) tech-events

  53. def by-year (year) function (event) year == (get event :year)

  54. Dá pra eliminar metade do Design Patterns ;-)

  55. Factory, Strategy, Observer, Visitor, Command…

  56. Objetos pequenos e de propósito único

  57. Funções contribuem com a elegância

  58. IMUTABILIDADE

  59. Mutabilidade causa dependências implícitas

  60. order = Order.new(total: 100) # => <Order#123 @total=100>

  61. coupon.discount(order) address.shipping_cost(order) order.total # => 120

  62. address.shipping_cost(order) coupon.discount(order) order.total # => 117

  63. address.shipping_cost(order) # $30 coupon.discount(order) # 10% order.total # => 117

  64. address.shipping_cost(order) coupon.discount(order) order.total # => 117

  65. …além de um escopo praticamente ilimitado

  66. order.place!

  67. Mutabilidade deve ser isolada

  68. Funções puras

  69. def make—greeting (event) let name = get event :name year

    = get event :year str "Olá" name " " year "!"
  70. let event = {name: “RC”, year: 2000} greet = make-greeting

    event assert-eq greet, ”Olá RC 2000!”
  71. Valores vs Entidades

  72. inc 1 # => 2

  73. coupon.discount(order) # => <Order#123 @total=80> order # => <Order#123 @total=80>

  74. coupon.discount(order) # => <Order#456 @total=80> order # => <Order#123 @total=100>

  75. Estruturas Persistentes

  76. a = [1, 2] # => [1, 2] b =

    push a 3 # => [1, 2, 3] a # => [1, 2]
  77. API com semântica mutável porém produz cópias imutáveis

  78. Ruby Hamster, Immutable.js

  79. Imutabilidade contribui com a compreensão

  80. THERE AND BACK AGAIN…

  81. OOP não trata sobre objetos e hierarquias

  82. –Alan Kay “I thought of objects being like biological cells

    and/or individual computers on a network, only able to communicate with messages (so messaging came at the very beginning -- it took a while to see how to do messaging in a programming language efficiently enough to be useful).”
  83. DB CLIENT APP

  84. Lógica de negócio Funcional Organização feita em Objetos

  85. DB VIEW MAILER

  86. API DOM API

  87. Arquitetura Hexagonal

  88. Ambiente externo isolado

  89. Aplicação 100% testável

  90. Hot-swap

  91. DB CLIENT APP V1

  92. DB CLIENT APP V2

  93. DB VIEW MAILER

  94. DB VIEW MAILER V3

  95. React, Elm, Erlang…

  96. MELHORE SEU RUBY

  97. Foco em operações pequenas…

  98. transformando valores imutáveis…

  99. o que facilita a compreensão…

  100. e maximiza a testabilidade.

  101. Quer emular Haskell? Use Haskell oras :-)

  102. Divirta-se

  103. seja usando Ruby ou quem sabe…

  104. usando Clojure ;-)

  105. Andrew Rosa @_andrewhr

  106. Obrigado! @_andrewhr