Apresentação sobre a estrutura base de tudo em Elixir. Feita na Meetup de Elixir em Curitiba no dia 21 de Setembro de 2017 por mim.
Vale lembrar que a talk foi praticamente um plágio de uma parte do keynote do José Valim na Elixir Conf EU de 2017.
Aqui está o keynote: https://www.youtube.com/watch?v=IZvpKhA6t8A
E pra quem é mais apressado, direto ao ponto onde a parte da talk que fiz começa: https://youtu.be/IZvpKhA6t8A?t=1248
3. What is Elixir? For devs!
● Sabemos que Elixir é bem
diferente do que a gente
está acostumado
● Mas o que
especificamente?
● Vamos começar pelo
começo!
4. Os 3 pilares
● Estado
○ Data!!
● Comportamento
○ Code!!!
● Tempo
○ WTF?!!!!!!
5. Os 3 pilares em Elixir
● Esses conceitos estão
totalmente separados
um do outro
○ Data imutável
○ Modules sem dados
intrínsicos
○ Processes é o que junta
tudo
7. Processos!!!
● Processos carregam os dados
● Rodam o comportamento
sequencialmente
● E introduzem a noção
concorrência
● E o tempo?
○ A noção de tempo é adicionada a
partir do momento em que os
processos precisam se comunicar
8. Para quê usar processos?
● Para gerenciar estado mutável
● Para execução concorrente
● Para tratar e isolar falhas
● Para comunicação distribuída
9. E daí?
● Agora você sabe as principais diferenças de Elixir e
outras linguagens
● Agora você sabe quando usar e quando não usar
processos
● Todas essas coisas exigem você mudar o seu
pensamento e o seu código
10. E daí?
● É por isso que existem features como:
○ Pattern matching
○ Guard clauses
○ Multiple function clauses
○ Pipe operator
○ Protocols
○ Macros
● E filosofias como:
○ Less assignments
11. Concluindo!
● Elixir não é feita só pra resolver problemas como paralelismo, resiliência e
zero-downtime deploy.
● Podemos e devemos usar Elixir para coisas do dia-a-dia!
● Porque?
○ Tem uma sintaxe boa
○ É full featured
○ Tem um ferramental completo e unificado
○ É simples e organizada desde o princípio
14. Curitiba | São Paulo | San Francisco, US
ateliware.com.br
+55 (41) 3010-2275
Notes de l'éditeur
Antes:
A galera da meetup passada, contribuiu na comunidade?
Vai ter pouco código, mas pode ser que ocorram algumas hemorragias nasais aí
Antes
Essa talk na verdade é um plágio puro de um terço do keynote do Valim na ElixirConf EU desse ano
Quem viu?
Mesmo se viu, acho que é interessante pra gente discutir sobre essas coisas
3 partes
Elixir é bem diferente
Funcional e tal
Mas o que especificamente?
Entender isso vai ajudar bastante para aprender de uma forma mais rápida
Vamos começar pelo começo.
Que não é o getting started!!!
E sim como a linguagem funciona!
Estado
Dados
Comportamento
Código, funções e métodos
Tempo
Esse é mais difícil de separar isso mentalmente
Principalmente para quem está acostumado com o código ao lado
O motivo de chamar de “Tempo”, é que se olharmos de uma perspectiva externa, algo aconteceu em algum lugar no tempo que mudou aquele estado
Em OO, cada objeto carrega sua própria noção de tempo, ou seja, cada um pode mudar a qualquer momento, e alterar a execução de todo o resto
Depois
Entenderam?
Conseguem perceber como todos esses conceitos estão embutidos em cada objeto que você instancia em OO?
Agora vamos abrir o capô do elixir
No elixir, os conceitos estão cada uma na sua caixinha
Analogia da piada da cabeça do homem e da cabeça da mulher
Dados são imutáveis
Representam o estado
Não tem a noção de tempo embutida neles
Modules sem dados intrínsicos
Tudo o que uma function precisa para executar é dado a ela como input
O objetivo das functions é “transformar” o input delas no output desejado
Processes é o que junta tudo
É nele que é adicionada a noção de tempo
Eu vou me aprofundar mais nisso mais pra frente
Depois
Essas são as 3 primitivas que existem no Elixir, tudo que é feito funciona a partir disso aqui
Perceberam que a nomenclatura das coisas em Elixir fica mais clara
Em OO quem gerencia tudo é o objeto, em Elixir, cada um tem seu papel
Fica claro o que é comportamento e o que é estado
Assim como o dado, o próprio comportamento não muda
Se a mesma função for chamada passando os mesmos argumentos o resultado sempre será o mesmo
Existem exceções, claro, como o método Date.today() mas o princípio é esse
Mas onde entra o processo nessa história?
Na verdade o processo é quem está executando esse código
Sua aplicação já é um processo
Indo mais a fundo
Spawn
Damos o módulo
A função
E os dados
É aí que começamos a juntar as coisas
Sequentially - confusão bem comum
Mas esse código sendo executado sequencialmente não é uma propriedade de linguagens imperativas?
Não, nas linguagens imperativas você executa operações sequencialmente, e progride através da mutação do estado
Em FP não tem isso, é só várias linhas de código executando uma após a outra, sem mutações, sem tempo.
E o tempo?
Enquanto processos são totalmente independentes, o tempo pode até existir, mas não é uma questão importante
Historinha da árvore caindo, pode até fazer barulho, mas se não houver ninguém escutando, o fato de cair é irrelevante.
Só quando múltiplos processos começam a conversar é que o tempo ganha sua importância.
Início
Processos em Elixir não são ferramentas para controlar o seu design
Não é feito apenas para você organizar o seu código ou para separar domínios da sua app (como são os objetos em OO)
São feitos para controlar o runtime da sua aplicação, não cada domínio em específico
Para gerenciar estado mutável
Cada processo tem seu próprio estado, e nesse caso, esse estado carregado pelo objeto, pode mudar
Para execução concorrente
Pode ser até mesmo execução que você nem precise saber do resultado, nem se importe com o estado dela
Para tratar e isolar falhar
Esse é um dos casos mais interessantes
Exceções matam o processo
O processo avisa os processos que estão linkados
O gerenciamento de falhas é claro e simples
Para comunicação distribuída
Aí então usando meio que todas as propriedades dos processo ao mesmo tempo
Principais diferenças
Kernel da linguagem, como ela funciona
Isso é muito importante, pois é a primeira coisa que tem que mudar na sua cabeça
Não usar processos
É difícil se controlar no começo talvez
Mas é recompensador você abrir mão de usar processo para o que não precisa
É igual a você abrir mão de criar objetos para o que não precisa em OO
Mudar o pensamento
Principalmente no começo, isso é muito difícil
E mudar o código às vezes é mais difícil ainda, dependendo do nível de “programação no automático” que vc está
Features
Pattern matching = extraindo dados de dentro de outros dados
Guard clauses = determinando comportamento de acordo com o estado
Multiple function clauses = misturam guards com pattern matching - no fundo, é um case
Pipe operator = facilita no encadeamento de funções - transformar um dado em outro gradualmente fica fácil
Protocols = que permitem polimorfismo de comportamento dependendo do tipo de dado
Macros = que permitem metaprogramação sem a perda absurda de performance
Filosofias
Less assignments = filosofia que nasce do com o uso de pipe operators
Let it fail = não dá pra prever tudo - exceções são melhores do que dados errados
You probably don’t need a database = que na verdade também se alinha ao fato de Elixir ser resiliente
Documentação = organização é levada a sério em Elixir, deu pra ver pelo exemplo de como ele funciona
Ler tópicos
Depois
Então usem Elixir pra tudo!
Não queremos tirar você de onde você está, se você estiver feliz