O documento introduz os conceitos e princípios da programação funcional, incluindo: (1) funções de primeira classe, dados imutáveis e funções puras como características centrais; (2) os princípios SOLID aplicados à programação funcional; (3) a migração de OO para FP enfatizando composição ao invés de herança e uso de dados imutáveis.

1. Introdução
Myself
------
Luiz Stangarlin
Trabalho
--------
principal: 'Full-Stack' Developer
secundario: Networking, Infosec, Sysadmin (private & public cloud)
Estudo
------
Computação Grafica, VR/AR.
Programming Languages & Compilers (Here be dragons!)
Hobby
-----
Musica - electric guitar
Eletrônica
Games

2. Motivo
Dar um panorama da área de programação e introduzir o paradigma e como ele
se encaixa no cenário da computação.
É mais fácil aprender quando se ter um motivo.
Comparar como um mesmo conceito pode ser implementado sobre o paradigma
funcional e OO ao mesmo tempo.

3. Computação
Antiga busca matematica por uma forma de resolver teoremas automaticamente.
Foi provado que nem todos teoremas podem ser automaticamente provados.
Porem alguns podem, usando processamento de simbolos, o que funda a
Computação.

4. Computação
Alonzo Church Turing
------------- ------
Matematica Tecnologia/Ferramentas
O que fazer Como fazer
Top-down Bottom-up
Matematico Hacker
Teoria Prática
Imperativo/OO Funcional
Church-Turing thesis, prova que ambos as duas formas são equivalentes.
A computação é a junção das duas formas de pensar.

5. Programação funcional
Circa ~1970, todos os principais paradigmas (Imperativo, OO, FP)
Porque agora?
. O hardware era limitado no começo.
. O hardware teve um incrível desenvolvimento, possibilitou
grande sucesso do paradigma imperativo, e ocultou problemas.
. Crescimento vertical
O que ocorreu?
. Hardware agora é menos limitado
. Dark-Silicon, Von Neumann Bottleneck
. Crescimento horizontal
. Mais nucleos, processamento paralelo, GPU
Complexidade
. Velho inimigo (crise do software I)

6. Linguagens, Paradigmas e conceitos

7. Linguagens, Paradigmas e conceitos

8. Linguagens, Paradigmas e conceitos
Uma forma de mapear e entender a grande quantidade de ferramentas
e linguagens.
Uma forma de categorizar as linguagens, e comparar suas características.
Mais importante do que saber tudo o que existe, é aprender a navegar na
"bagunça".
(Meu objetivo silly era aprender todas, então um método era necessário)

9. O que é FP?
O paradigma descreve o que e não como é feito, sendo assim declarativo.
. First class functions (math: high-order function).
Função são dados, lambdas.
. Pure functions.
Funções cuja saída é apenas resultado de seus parâmetros.
. Immutable data.
Sem variáveis, retornar novos dados no retorno das funções.
(pesquisa: estruturas de dados imutáveis eficientes
para evitar cópias excessivas)
. Composição,
Input de uma função gera a saída da próxima,
função usa outras funções e retorna uma nova função.
. Closures.
Quando uma variáveis usadas na função são vinculadas ao escopo

10. O que é FP?
. First class functions
. Immutable data
. Pure functions
. Composição

11. O que é FP?
. Closures

12. Conceito: SOLID
S - Single responsibility principle
O - Open/closed principle
L - Liskov substitution principle
I - Interface segregation principle
D - Dependency inversion principle
Barbara Liskov (et al.)

13. Princípio da responsabilidade única
A classe/função/módulo deve ter apenas uma responsabilidade.
Uma função pura é algo com uma responsabilidade, transformar
sua entrada na saída. O que poderia ser mais simples?

14. Princípio Aberto/Fechado
Entidades de software devem ser abertas (ter a possibilidade)
para extensão e fechadas para modificação.
Em FP ao se usar funções de primeira ordem já se respeita este
princípio, tu não precisa modificar a função se tu pode criar
uma nova função que usa a outra e estende o comportamento dela.

15. Princípio de substituição de Liskov
Objeto em um programa devem ser substituíveis por instâncias
de seus subtipos sem que o comportamento correto do software
se altere.
Em FP, o mesmo princípio se aplica ao se passar lambdas.

16. Princípio de substituição de Liskov
Simulando polimorfismo em FP.

17. Interface segregation principle
Muitas interfaces específicas são melhores que uma única
interface de proposito geral.
Este é o principio de FP ao se levar ao limite a ideia,
cada função é uma interface específica por sí só.

18. Princípio de inversão de dependência
Se deve depender na abstração e não na implementação concreta.
Aqui é onde o paradigma brilha, Funções de primeira classe
são exatamente o princípio de inversão em ação, é tão natural
expressar isto em FP, que quase não se percebe.

19. Migrando para FP
Ao mover de OO para FP:
. Composição ao invés de herança.
(na verdade mesmo em OO, tu deve considerar este ponto)
. Pense sobre dados imutáveis.
Os dados fluem entre as functions, ao invés de usar "=" atribuição.
. Funções fazem um único trabalho, ao invés de ter classes.
. Use o princípio de substituição de Liskov.

20. Finalizando
Princípios e conceitos sobre desenvolvimento de software se
aplicam a vários paradigmas.
Se você programa em OO e conhece estes princípios da boa
construção de software, você já tem o que é preciso para
aprender e usar FP.

21. Sources
Referencias:
http://blog.ploeh.dk/2014/03/10/solid-the-next-step-is-functional/
https://fsharpforfunandprofit.com/fppatterns/
https://pt.slideshare.net/velvetflair/functional-programming-fundamentals
https://medium.com/javascript-scene/the-two-pillars-of-javascript-pt-2-funct
ional-programming-a63aa53a41a4
https://gist.github.com/Byte-666/f66c689e8a2fcd5cf1a0450d23f09b7e
https://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf
https://www.youtube.com/watch?v=ibRar7sWulM (Barbara Liskov: Programming the
Turing Machine)
Extra:
https://www.youtube.com/watch?v=IOiZatlZtGU (Philip Wadler: Propositions as
Types)
https://www.youtube.com/watch?v=VpzhH9CXOy0 (Paulo Torrens: Lógica de
Programação não existe)
https://github.com/papers-we-love/papers-we-love/blob/master/design/out-of-t
he-tar-pit.pdf