01 - Aprendendo Elixir v2 - Introdução — Transcript
Full transcript
- 0:00Olá,
- 0:02você desenvolvedor, seja muito bem-vindo
- 0:04a essa nova playlist. Chamamos aqui de
- 0:08Aprendendo Elixir V2, né? Nessa playlist
- 0:12a gente vai abordar e expandir um pouco
- 0:15mais os assuntos que falamos três anos
- 0:19atrás naquela playlist Aprendendo Elixe.
- 0:22Lá abordamos sintaxe básica e fomos
- 0:25avançando um pouco pelos módulos, né,
- 0:28pela pelos módulos segundo o Elixir
- 0:31School, né, que aí fomos falando de OTP,
- 0:34de supervisor, de Ger, de Worker, etc.
- 0:38Mas aqui vamos ter um foco um pouco mais
- 0:44eh reflexivo,
- 0:46além de também utilizar eh essas
- 0:49construções, né, a sintaxe, a gente vai
- 0:52voltar a aprender ou rever, rememorar
- 0:55essa sintaxe que a gente aprendeu no
- 0:57anterior. E vamos refletir sobre
- 1:00performance, sobre como é a construção
- 1:05de aplicações realmente resilientes e
- 1:08escaláveis usando o elixeir ou usando
- 1:11todo o seu ecossistema. Então essa é
- 1:14uma, vamos dizer que é uma evolução, mas
- 1:19fundamentalmente
- 1:21conceitual,
- 1:23que nos vai fazer pensar sobre a
- 1:26linguagem, sobre a tecnologia, sobre
- 1:30linguagens funcionais, sobre o nosso
- 1:33contexto atual, contexto de inteligência
- 1:35artificial e o que precisamos aprender
- 1:38para que a gente possa eh trabalhar de
- 1:41uma maneira eh que seja seja produtiva,
- 1:44utilizando também muito dessas novas
- 1:47tecnologias que ajudam o desenvolvedor a
- 1:51desenvolver. Então, e esse é um vídeo
- 1:55introdutório em que eu vou apresentar um
- 1:56pouco mais dessa ideia, disso que
- 1:59estamos preparando aí e que virá na
- 2:02sequência, nos próximos vídeos. Nós já
- 2:04temos isso todo esquadrinhado, bem
- 2:07desenhado, pra gente poder trazer aqui
- 2:09para vocês, tá?
- 2:13Então, eh, um pouco disso que eu falei,
- 2:16né? É uma evolução. A gente vai tentar
- 2:20ser muito mais reflexivos, né, sobre o
- 2:24que estamos construindo, porque se a
- 2:27gente for parar para analisar, a IA ou a
- 2:30inteligência artificial tem construído
- 2:32softwares, tem construído sistemas, mas
- 2:34elas não pensam sobre o que estão
- 2:36construindo, não pensam na qualidade
- 2:38daquilo e nem em arquitetura
- 2:41sobre o que elas estão fazendo. apenas
- 2:43são são bando de papagaio que repetem,
- 2:46né, e introduzem as mesmas coisas que já
- 2:49estão aí. Então, precisamos eh
- 2:53não pensar somente em sintaxe, mas
- 2:55entender realmente o fundamento por trás
- 2:57da sintaxe, porque
- 3:01é isso que devemos fazer como seres
- 3:03humanos, pensar sobre, né? Ou seja, a
- 3:06arte de refletir e de criar soluções que
- 3:09realmente eh prevejam determinadas
- 3:12falhas, né? E o Elixe e seu ecossistema,
- 3:17né? Ele traz isso dentro de si, né,
- 3:20quando criaram lá atrás o Erlang, a BIM,
- 3:24é para prever determinados determinadas
- 3:27situações que acontecem
- 3:30eh
- 3:32no mundo real, onde as aplicações rodam
- 3:35no mundo real, né? Então vamos passar
- 3:39por isso, né?
- 3:41pela sintaxe, pelos OTPs, pelo OTP na
- 3:45realidade, pelos processos supervisors,
- 3:47gen, server. Então, todo esse esse esse
- 3:52esse ferramental disponível dentro da
- 3:55BIM, dentro do Elix, vamos entender ou
- 3:58construir, né, eh, sistemas modernos com
- 4:02Phoenix, né, pensando em cada etapa, né,
- 4:04refletindo sobre cada etapa, além de
- 4:06levar isso pra produção, o que que a
- 4:08gente precisa fazer para garantir que a
- 4:10nossa aplicação está saudável realmente,
- 4:12né? Que tipo de análise posterior? Que
- 4:16tipo de observabilidade? O que que a
- 4:17gente faz aqui que pode refletir no
- 4:23projeto, no na aplicação em produção? O
- 4:26que que pode acontecer? Como que a gente
- 4:28observa isso? como que a gente prevê
- 4:30determinadas falhas, né, que podem
- 4:33acontecer no mundo concorrente, no mundo
- 4:37onde as coisas acontecem em paralelo.
- 4:39Então, vamos ter essa abordagem
- 4:42também aqui dentro dessa trilha, tá bom?
- 4:45Desse dessa playlist, dessa sequência de
- 4:47vídeos. Eh,
- 4:52então [roncando] nossa jornada, né, vai
- 4:54passar por
- 4:56fundamentos, né, fundamentos funcionais.
- 5:00a gente vai rever sintaxe do elixir, a
- 5:03gente vai rever como funciona os os
- 5:07building blocks, os pedaços ou as eh as
- 5:13construções de código mais impactantes
- 5:16numa aplicação. Por exemplo, a gente
- 5:18utiliza o if, a gente utiliza case, a
- 5:20gente utiliza if. A gente, como é que a
- 5:23gente trata os erros? Então a gente vai
- 5:25ver toda essa questão de sintaxe e
- 5:28sintaxe numa aplicação que realmente ela
- 5:32vai pra produção, né? Não somente, ah,
- 5:35precisamos aprender como é que funciona
- 5:36essa sintaxe,
- 5:38mas aprender ela porque ela é útil num
- 5:41contexto real, né? E e no elixe o o
- 5:45interessante é que a grande maioria das
- 5:48coisas que são disponíveis na sintaxe,
- 5:51na na biblioteca padrão, no kern, você
- 5:55consegue utilizar e você precisa
- 5:56utilizar para ter uma aplicação robusta.
- 5:58Obviamente também utilizamos coisas um
- 6:01pouco mais nativas do do Airlang, né,
- 6:05dentro da nossa aplicação real. Então
- 6:06assim, entender um pouco desse
- 6:08fundamento funcional e direcionado
- 6:11também dentro do ecossistema Elixer,
- 6:14porque se a gente for analisar uma
- 6:17linguagem puramente funcional como
- 6:19Haykale e comparar ela com elix, você
- 6:22vai ter diferenças, né, fundamentais,
- 6:26né, principalmente na forma de tratar os
- 6:28efeitos colaterais, né? Então a gente
- 6:30vai falar um pouco sobre isso também,
- 6:32né? a gente vai pensar sobre essa
- 6:34mentalidade funcional de mutabilidade e
- 6:37transformação de dados. Ou seja, eh, os
- 6:41dados eles são transformados, eles
- 6:45chegam a um determinado, entram com
- 6:47determinado estado e eles saem através
- 6:51de uma sequência de pipes para um
- 6:54determinado estado. Vamos pensar em
- 6:56arquitetura distribuída e aplicações
- 6:59resilientes. Isso tudo a gente vai
- 7:00abordar nessa sequência de vídeos, nessa
- 7:04também chamada trilha de aprendizagem,
- 7:07tá bom? pilares. Isso aqui é
- 7:09fundamental, né? São coisas que são
- 7:13nativas,
- 7:15né, dentro da BIM e também no
- 7:18ecossistema, né, que fazem muito efeito,
- 7:21muito, são muito significativos hoje em
- 7:24dia, se a gente for olhar, tá? Então, a
- 7:26gente temos dentro da BIM ali,
- 7:29resiliência e concorrência e dentro do
- 7:32da comunidade a gente tem o Phoenix, que
- 7:34é o Phoenix Live View, que nos dá o
- 7:36tempo real. as aplicações feitas em
- 7:39tempo real. Isso aqui otimiza bastante o
- 7:42processo de desenvolver aplicações, de
- 7:44garantir que essas aplicações estão lá,
- 7:47né? Claro que não é só isso, a gente
- 7:48precisa pensar em observabilidade, mas
- 7:51vamos abordar Ling Crash, né? Deixa
- 7:53quebrar como é que funciona isso, porque
- 7:55eles desenvolveram essa eh
- 7:59qual é o fundamento, na real dessa
- 8:02filosofia, né? E a gente utiliza isso do
- 8:05elixe de fato, a gente prevê cada
- 8:08minúsculo erro ou a gente deixa quebrar
- 8:11e vamos tratar isso depois, né? Como é
- 8:14que isso funciona na prática, né? um
- 8:16sistema que eh
- 8:19pode ser levado à produção, como é que
- 8:21funciona a concorrência, que é o grande
- 8:24boom ou exigência, podemos dizer assim,
- 8:28boom de exigência, né, do mercado hoje,
- 8:31do das aplicações hoje. Elas precisam
- 8:35ser concorrentes, elas precisam rodar
- 8:38paralelamente, você precisa escalar caso
- 8:42a sua aplicação ela não seja o
- 8:44suficiente pra sua demanda. Então isso,
- 8:47essas coisas elas precisam ser pensadas
- 8:50ou no caso do Elix, as pessoas acabam
- 8:51não pensando porque ele faz isso meio
- 8:53que nativamente, mas você precisa pensar
- 8:56porque apesar de fazer isso nativamente
- 8:59a nível de de software, vamos dizer
- 9:03assim, de construção nativa, você
- 9:05precisa pensar como você deve lidar com
- 9:08cada situação de concorrência. Por
- 9:11exemplo, se você tem uma aplicação
- 9:12financeira, como é que você não debita o
- 9:15saldo duas vezes caso chegue no mesmo
- 9:18momento, no mesmo instante, duas
- 9:19requisições? Como é que isso funciona
- 9:22dentro do elixir? Como é que a gente
- 9:23consegue prever isso? Que ferramentas
- 9:25ele propõe ou ele fornece pra gente
- 9:29lidar com esse tipo de situação?
- 9:33E a ideia é,
- 9:36se você vem de uma linguagem orientada a
- 9:39objetos, onde
- 9:41eh os objetos eles são as construções
- 9:46principais nesse sentido de informação e
- 9:50o estado consequentemente ele é mutável,
- 9:53você vai eh ver uma diferença ou você
- 9:57vai entender que isso muda quando a
- 9:59gente fala de linguagem funcional ou
- 10:01isso muda quando a gente fala de elixe
- 10:03de irlândia, de bin, tá? Eh, nossa
- 10:07tendência dentro de uma linguagem
- 10:09funcional é simplificar e transformar,
- 10:13né? Então, a gente não vai, não devemos,
- 10:16isso pode acontecer, mas não deveríamos
- 10:19deixar a nossa aplicação mais complexa
- 10:21do que ela precisaria ser. Deveria
- 10:23simplificar, né? Transformar as coisas
- 10:27em módulos, né? criar funções em que
- 10:31transformam os objetos e deixar os
- 10:34efeitos colaterais dessas informações
- 10:37bem eh consolidadas, bem eh mapeadas,
- 10:42porque o que faz a diferença na hora de
- 10:46você garantir uma aplicação os efeitos
- 10:47colaterais, porque se você hoje roda
- 10:50testes num cenário simulado,
- 10:53eh, você tem uma certa garantia. As
- 10:56funções puras você tem garantia quase
- 10:57que total, mas as funções que dependem
- 11:00de contexto externo, que tem são
- 11:02chamados de side effects, efeitos
- 11:04colaterais, você tem uma garantia muito
- 11:06menor. Então é, são side effects que
- 11:10podem causar problemas na sua aplicação.
- 11:13Então, eh,
- 11:16e esse é o ponto de aplica, por isso
- 11:18que, e esse é o ponto, né? Por isso que
- 11:20precisamos simplificar mais ainda para
- 11:22que esses efeitos colaterais sejam muito
- 11:24bem observáveis e a gente consiga medir
- 11:27isso, prever erros e então subir ajustes
- 11:31caso necessário. Então vamos acabar
- 11:34desaprendendo. quem vem, né, de
- 11:36linguagens imperativas, né, e orientado
- 11:38a objetos, vai acabar desaprendendo um
- 11:42pouco, né, para poder simplificar e
- 11:45começar a desenvolver aplicações, né,
- 11:47simples, porém que trazem dentro de si
- 11:51tudo que hoje é necessário, né, de
- 11:54concorrência, de resiliência, de
- 11:56escalabilidade.
- 12:00Por isso,
- 12:02vamos quebrar o paradigma ali, né,
- 12:05durante esse processo, não agora, mas a
- 12:07gente vai acabar quebrando o paradigma,
- 12:09não porque a gente vai comparar, mas
- 12:11porque a gente vai mostrar o caminho que
- 12:14a gente vai seguir, né? Acho que esse
- 12:16vai ser um dos poucos pontos que a gente
- 12:18vai comparar, né? O que que faz um, que
- 12:20faz outro. Gente, não faz sentido isso,
- 12:23né? De comparação, porque cada
- 12:25linguagem, cada paradigma atende uma
- 12:28necessidade específica.
- 12:30Mas falando desse nicho, desse
- 12:33ecossistema de aplicações que a gente
- 12:36pode construir, né, aplicações pro mundo
- 12:40real, que a gente pode construir com
- 12:42elixir, então faz sentido você ver os
- 12:45dados como algo que se transforma,
- 12:49né? Então você transforma os dados, por
- 12:52isso você tem um um uma imutabilidade
- 12:54muito maior. O dado que chega, você não
- 12:56consegue mudar, você consegue
- 12:58transformar. Aí no final você tem um
- 12:59dado eh transformado, que esse dado pode
- 13:03então ele ser eh eh salvo, ser enviado
- 13:08para algum ente externo, alguma coisa
- 13:10assim. Então você você tem um um pipe
- 13:13muito puro, pode ter, tá? Então a
- 13:15possibilidade de você ter um pipe muito
- 13:17puro é muito maior, então não tem
- 13:20efeitos, tantos efeitos colaterais. Por
- 13:23que que eu falo? Pode ter, pode ser
- 13:25assim, porque é uma linguagem aberto ao
- 13:29que você quer fazer, né? Você pode pegar
- 13:32todo o seu paradigma imperativo e
- 13:34orientado objetos e colocar isso dentro
- 13:37do elixir. Você pode fazer isso, você
- 13:39precisa não. Você não precisa fazer
- 13:41isso. Você pode pensar funcional, você
- 13:43pode ter um forma de pensar diferente e
- 13:46aí criar aplicações diferentes, tá? Você
- 13:49não precisa trazer a sua carga de
- 13:52entendimento ou nem de entendimento, mas
- 13:55de eh eh os os dogmas que você aprendeu
- 13:59num paradigma trazer para um outro, né?
- 14:02A ideia é vamos refletir um pouco sobre
- 14:04o que significa desenvolver aplicações
- 14:07com paradigma funcional e então seguir
- 14:10assim, né? E ver o impacto disso, né? Eu
- 14:13garanto que a gente vai acabar focando
- 14:15em coisas mais importantes depois que a
- 14:18gente para de se preocupar em como a
- 14:21nossa aplicação ela tá sendo
- 14:23desenvolvida, ela tá realmente
- 14:25manutenível e tudo, porque se a gente
- 14:26segue um pattern, né, que a gente pode
- 14:29construir dentro de cada aplicação, ela
- 14:31tem um pattern, mas se a gente segue e
- 14:34confirma que tá, esse pattern tá
- 14:36valendo, tá tá válido pra nossa
- 14:38aplicação, então a gente se preocupa
- 14:40muito mais em, tá? Vamos observar e
- 14:42garantir que isso não quebre, né? O
- 14:44grande segredo, o grande, a grande
- 14:47vontade é ter uma aplicação que você não
- 14:48precise dar muita manutenção e quando
- 14:50der, você sabe o que fazer, porque ela
- 14:53tá clara o suficiente, tá manutenível o
- 14:56suficiente.
- 14:59Então você acaba se libertando um pouco
- 15:02quando você tem dados imutáveis, tá?
- 15:04Você e e isso é o fundamento ou
- 15:07fundamenta o letting crash, né? O deixe
- 15:10quebrar. né, quando os dados eles são
- 15:12imutáveis, porque a a grande grande
- 15:14problema eh ou a grande grande situação
- 15:20é ou eu trato todos os erros que eu
- 15:23posso prever ou eu deixo quebrar e tudo
- 15:28bem, minha aplicação ela não vai morrer
- 15:30por conta disso, né? Que o grande o
- 15:31grande E aí reforçando, por que que isso
- 15:33é um grande problema? Porque se tem uma
- 15:35aplicação que se eu não trato o erro e
- 15:37ela tem uma memória compartilhada, um
- 15:40uma memória que tem estado que que
- 15:43aquela informação que entrou ela tá
- 15:44mudando a o estado na memória. Então se
- 15:47você não trata o erro corretamente, de
- 15:49maneira certa, então aquele dado ele vai
- 15:51sujando a memória. Então ela vai eh
- 15:54mantendo-se constantemente
- 15:57e dentro da aplicação, ou seja, você não
- 15:59tem, você não consegue reverter, você
- 16:00não consegue limpar. Então o o lading
- 16:03crash o deixe quebrar, ele é muito nesse
- 16:05princípio de bom, se os dados são
- 16:06imutáveis, não preciso tratar todo o
- 16:10erro, deixa quebrar, o usuário vai ter o
- 16:12seu erro 500 ou erro 200, 200 não, né? O
- 16:15erro 400. Eh, mas eh deixe isso quebrar
- 16:21porque isso não impede a minha
- 16:23aplicação, isso não vai sujar a minha
- 16:25memória, né? Eu tenho visto aplicações a
- 16:28título de exemplo, tá? não de
- 16:30comparação, mas uma aplicação em Elix,
- 16:33né, e uma aplicação em Node, né, depois
- 16:35de um tempo, essa aplicação em Node, ela
- 16:37precisou ser restartada porque ela tava
- 16:40ela tava eh trabalhando de uma maneira
- 16:42errada. Então você fazia um post e o
- 16:45post não se comportava da maneira certa,
- 16:46dava um erro, porque provavelmente eh
- 16:49esse estado, essa memória, ela se sujou,
- 16:52então acabava sendo compartilhado isso e
- 16:55ela entrava em degradação.
- 16:57Então isso eu não enxerguei, né? pode
- 17:00ser limitação minha, mas pelo todo por
- 17:03todo esse princípio de deixe quebrar, de
- 17:06imutabilidade, a gente não consegue
- 17:08enxergar essa degradação
- 17:10eh a nível de tempo. Por isso que você
- 17:13tem uma uma aplicação, você tem
- 17:15histórias de aplicações que elas estão
- 17:17rodando há muito tempo sem precisar ser
- 17:20reiniciada, sem precisar restartar, né?
- 17:25Então o imutável ele elimina race
- 17:28conditions, ele eh elimina essa
- 17:31necessidade de locks, certo? Em termos
- 17:35gerais, né? E mantém estados
- 17:37consistentes. Isso aqui a gente tá
- 17:38falando nível de de de cerne de núcleo,
- 17:42de core da da linguagem ou de core da
- 17:46BIM, tá? A B é a máquina virtual onde
- 17:50roda todas as aplicações desenvolvidas
- 17:52em Elixe de maneira simples. Então, a
- 17:55nível de core você tem essas garantias,
- 17:58mas a nível de sua aplicação, você
- 18:00precisa pensar em race conditions,
- 18:03porque se você tem uma eh se você tem um
- 18:06sistema financeiro, se você tem um
- 18:08sistema em que que pode acontecer race
- 18:11conditions, aliás, todo sistema pode ter
- 18:14race condition. Se você tá no mundo, se
- 18:16você jogou o seu sistema em produção,
- 18:18você pode ter milhões de acessos. Isso
- 18:20gera race condition em algum momento.
- 18:22Então, se você tem race cit, você
- 18:24precisa pensar sobre ele, né? Porque
- 18:28nativamente a gente tem um sistema que
- 18:31elimina race conditions, que você não
- 18:33vai ter race conditions na sua
- 18:34aplicação, tá? Então, precisamos pensar
- 18:38sobre race conditions, sim, mas a nível
- 18:41de aplicação, a nível de, perdão, a
- 18:45nível de de sistema, né, de sistema
- 18:49rodando, de sistema implantado, você não
- 18:51vai ter problemas de race condition,
- 18:54questão de memória um pouco mais
- 18:55profundamente. Você não vai ter isso,
- 18:57tá? você não vai ter esses problemas e
- 18:59esses estados inconsistentes por conta
- 19:01de todo de tudo o que a BIM fornece, de
- 19:05tudo o que foi desenvolvido dentro dessa
- 19:07BIM.
- 19:10E aí, só para exemplificar, né, a gente
- 19:13trabalha muito com data transformation
- 19:15dentro do elix, né, quase um elixing on
- 19:19rails, né, você tem uma linha de ação em
- 19:22que as coisas podem acontecer, você pode
- 19:24e deve tratar os erros de input de
- 19:27usuário para ele não ter um um estouro
- 19:29de erro 500, porém você tem uma acho que
- 19:32é o o grande um grande diferencial, né,
- 19:36assim, do Erlang, que é a linguagem que
- 19:38podemos dizer pi do elixe é o pipe.
- 19:41Então esse pipe ele faz com que você
- 19:43tenha uma uma leitura muito mais clara
- 19:45da função ou do fluxo de funções, do
- 19:48fluxo de operações que tá acontecendo
- 19:50sobre aquela informação, sobre aquele
- 19:52dado. Então isso é legal, né? Isso
- 19:55simplifica a nossa vida como
- 19:57desenvolvedor, porque a gente consegue
- 19:58ler aquilo que tá feito e entender de
- 20:01maneira clara. E pronto, vamos nos
- 20:03preocupar agora com outras coisas, né?
- 20:05Não precisamos se preocupar com com o
- 20:07estado, com só precisa se preocupar com
- 20:10a como aquela função ela tá se
- 20:12comportando com aquela informação que
- 20:14entra e como que eu vou devolver essa
- 20:15informação para continuar rodando no
- 20:17pipe de informações ou de
- 20:21transformações, melhor dizendo.
- 20:24Como eu falei, né, a gente tem essa essa
- 20:29eh essa filosofia de deixe quebrar, né,
- 20:33acaba sendo
- 20:35essa ideia de resiliência nativa.
- 20:39Por que que por que isso é uma filosofia
- 20:42e não um comportamento? Isso é um
- 20:45pensamento, né? Esse é um conceito, esse
- 20:47é um é uma forma de pensar na
- 20:50arquitetura do nosso sistema e não uma
- 20:53funcionalidade, uma ferramenta. Não é
- 20:56uma ferramenta que eu tenho que usar, é
- 20:58como as coisas acontecem, né? pelo
- 21:01estado ser imutável, não vai ter aquele
- 21:04problema de ficar sujando a memória toda
- 21:06vez que tiver um erro não tratado, um
- 21:09raise, alguma coisa assim nesse sentido.
- 21:11Então, por isso que a filosofia é: "Tá,
- 21:14deixa quebrar. Eu não tratei, tudo bem.
- 21:16Não, não preciso tratar todos os erros
- 21:18possíveis. Eu não preciso botar um try
- 21:20catch em tudo, porque eh o grande
- 21:23problema de eu não tratar erros qualquer
- 21:26linguagem que não tem muito essa
- 21:29imutabilidade é que sim, vai sujar a
- 21:32memória em algum momento. Não
- 21:34necessariamente vai sujar agora, mas
- 21:37em algum momento vai ter algum problema.
- 21:39Então, como isso é impossível, porque ah
- 21:44o nosso estado é imutável, então não tem
- 21:46problema, você não precisa tratar tudo.
- 21:48Você precisa tratar sim, porque o
- 21:49usuário vai receber o erro 500, mas não
- 21:52precisa tratar tudo porque não não a sua
- 21:55a sua aplicação não vai morrer se você
- 21:57eventualmente deixar de tratar alguma
- 21:59informação, tá? Então, por isso que vai
- 22:01existir. E aí isso sim são ferramentas,
- 22:06né, que é o supervisors e o workers, que
- 22:08são estratégias e e código, né, e
- 22:12sintaxe de como você vai construir as
- 22:14coisas para funcionar de uma maneira que
- 22:16ele se restaure, que é o self healing
- 22:18ali de você, de ele se recuperar de uma
- 22:20falha. Quebrou, tá? Vamos recuperar de
- 22:23uma falha, né? E por que que a gente tem
- 22:25isso? Porque dentro da nativamente aqui
- 22:28do elixir da do elixe da BIM da do
- 22:31erlang, né? São as linguagens. A BIM é a
- 22:33máquina virtual, você trabalha com
- 22:35processos, então tudo é processo. Então,
- 22:38por ser processo, eh, eles podem ser um
- 22:41processo que fique lá nativo ou fique lá
- 22:44em background de rodando. Então, se
- 22:45aquele processo morre e é um processo
- 22:47importante, né? Então você precisa
- 22:50restaurar ele paraa sua aplicação
- 22:51continuar eh trabalhando sem precisar
- 22:55restartar toda a aplicação para
- 22:56reiniciar todos os processos. Então você
- 22:59tem supervisor e o workers. O workers
- 23:01como um processo que faz alguma coisa, o
- 23:03supervisor como um processo que observa
- 23:06esses caras, esses workers, e se eles
- 23:08morrerem eu preciso reiniciar eles.
- 23:11Então é essa essa ferramenta, né, essa
- 23:14sintaxe, ela vai te dar essa
- 23:16possibilidade ali, né? Então, uma
- 23:18frasezinha interessante ali, falhas são
- 23:21inevitáveis em sistemas distribuídos.
- 23:24Eh, tentar prevenir, tentar preveni-las
- 23:28é fútil, gerenciá-las é o diferencial. E
- 23:31acredito que tudo
- 23:33é gerenciável, né? Assim, todo o
- 23:36fundamento deve ser como eu vou
- 23:38gerenciar isso, né? como que eu vou
- 23:40lidar com esses com essas situações,
- 23:42qual é o tradeof disso e o que que eu
- 23:44preciso decidir. Acho que esse é o ponto
- 23:47central aqui,
- 23:49só para eh pictórico aqui, só para
- 23:54descrever um pouco mais ou deixar essa
- 23:56imagem na cabeça, né, essa imagem mental
- 23:59aí, né? Então, processos, como eu falei
- 24:01antes, tudo é processo e um processo
- 24:03dentro da BIM, ele é muito econômico,
- 24:05né? é realmente uma eh um processo muito
- 24:09muito pequeno de consumo de memória.
- 24:12Você tem todos os elementos básicos de
- 24:16um processo simulado, de um processo que
- 24:18é uma trad de processo que roda em uma
- 24:20thread para um processo que roda é
- 24:23dentro da BIM. Então tem basicamente as
- 24:25mesmas coisas ali, então são são bem
- 24:28similares, porém uma você lida
- 24:30diretamente com a máquina, né, com o
- 24:33hardware do sistema e outro você lida
- 24:36com a BIM, que é uma simulação disso.
- 24:40Portanto, isso é muito mais leve de você
- 24:42iniciar, de você remover, né, deletar.
- 24:45Isso faz muita diferença, tá? Porque daí
- 24:47a gente começa a pensar
- 24:50eh
- 24:52em processos, né? Ah, podemos eh simular
- 24:56um mundo real dentro de um uma aplicação
- 25:00nossa. Por exemplo, tem um caso, né? Eu
- 25:03posso deixar o vídeo aqui na descrição
- 25:06desse exemplo de que cada processo ele é
- 25:12o Waltergate é um é um projeto, né,
- 25:14feito pr pra saúde na área de saúde, tá?
- 25:17Então tem um vídeo que eu vou deixar
- 25:18aqui e cada processo era um paciente,
- 25:22né? ou é um paciente. Então você tem
- 25:25milhões de pacientes, você tem milhões
- 25:28de processos, um para cada paciente, e
- 25:30você tem ali um processo, ele fica vivo
- 25:32na máquina. Obviamente tem estratégias,
- 25:34né, de manter processos vivos,
- 25:36dependendo do paciente tá disponível ou
- 25:39não, de disponibilidade do paciente, de
- 25:41tempo, né? Mas assim, você tem um para
- 25:43cada, né? Você tem um pareamento de um
- 25:45para um, o que que é, o que é legal,
- 25:47porque você pega um um cenário, um um
- 25:51mundo real e você consegue trazer ele
- 25:53para dentro da BIM, para dentro da sua
- 25:56aplicação e você consegue lidar com
- 25:58isso, isso de uma maneira muito mais
- 25:59assertiva. Então você não lida com
- 26:01linhas de uma tabela, você lida com
- 26:04processos. Ou seja, o usuário, né, nesse
- 26:07caso, o paciente, ele não é uma linha no
- 26:10postgis, no my, não é uma linha de uma
- 26:13de uma tabela, ele é realmente um
- 26:15processo, ele é vivo, você consegue
- 26:17falar com aquele processo, né? Você
- 26:19consegue mandar mensagens e receber
- 26:21mensagens, né? Minha conotação para
- 26:23falar, tá? Então você tem essa, você
- 26:27pode criar aplicações segundo esse
- 26:30princípio, segundo esse fundamento,
- 26:33porque eh a BIM te fornece isso, o
- 26:37Elixir te fornece isso. E eh tem um um
- 26:41livro do Joe Armstrong, né, que é o
- 26:45programa em Herlang versão 2, os
- 26:47primeiros capítulos ali que ele
- 26:50descreve. Aí ele disse: "Ah, vou parar
- 26:53um pouco de pensar sobre sobre
- 26:56programação, sobre
- 26:58sistemas e vamos só refletir aqui. Ele
- 27:02disse: "Ah, tô olhando pela minha janela
- 27:03e tô vendo lá uma pessoa levando o
- 27:05cachorro para passear, né, a o carro
- 27:09passando, o avião." Não. Então ele ele
- 27:12olha pro mundo e vê o mundo e tenta
- 27:17entender que isso as essas coisas
- 27:19acontecem concorrentemente,
- 27:20paralelamente, então eu consigo fazer
- 27:23uma simulação desse mundo real dentro de
- 27:25uma aplicação, né? Então a nossa
- 27:27aplicação ela consegue lidar, conseguirá
- 27:30lidar dessa maneira, tá? Porque temos
- 27:32ferramentas para isso dentro da BIM.
- 27:39E, né, a gente vai abordar ali sobre o
- 27:41Live View, porque o Live Viw é um um
- 27:44Live View tá dentro do Phoenix e o
- 27:45Phoenix é o framework, né, que
- 27:47incorporou essa biblioteca Live View. E
- 27:50você consegue criar aplicações
- 27:53robustas, complexas e ao mesmo tempo
- 27:56usando a simplicidade,
- 27:58né? Se você entende o conceito, né, de
- 28:01de gen server, de worker, de supervisor,
- 28:05essa simplicidade de criar aplicações
- 28:08ali dentro do do Elix, dentro do do
- 28:12Phoenix. Então, a gente vai ver isso. A
- 28:16gente vai criar aplicações para o mundo
- 28:17real, a gente vai usar Live View, a
- 28:19gente vai usar Phoenix, a gente vai
- 28:22criar aplicações que a gente consiga ter
- 28:25métricas sobre isso, a gente consiga
- 28:27prever falhas, porque falhas acontecem,
- 28:29é inevitável, e pensar, tá, tradeof,
- 28:32como que a gente lida com isso? pode ter
- 28:34uma forma boa de lidar, que tem
- 28:37problemas, e pode ter uma forma tão boa
- 28:40de lidar, eh, mas que tem vantagem sobre
- 28:44determinado problema. Então, assim, são
- 28:46tradeoffs, tudo é uma escolha, né? Tem
- 28:50uma máxima que diz assim: "Se você não
- 28:53escolhe, alguém escolhe por você, né?
- 28:55Então, se a gente não escolhe uma
- 28:57solução,
- 28:59provavelmente vai quebrar." E a e essa
- 29:01foi a escolha. a escolher deixar
- 29:03quebrar, que isso pode ser ruim,
- 29:05dependendo do nosso nível de aplicação,
- 29:06né? Se a nossa aplicação for muito
- 29:08crítica, deixar nossa aplicação quebrar
- 29:10em produção, mesmo que seja por 10
- 29:13minutos, por 5 minutos, pode fazer com
- 29:15que um parceiro, um cliente, um um
- 29:19customer, alguém, né, que esteja
- 29:22envolvido diretamente, que faz com que
- 29:26eh nossa aplicação
- 29:28ela seja válida no mercado, ou seja, a
- 29:30gente tá ganhando dinheiro em cima disso
- 29:32ou a gente tá promovendo, tá entregando
- 29:34valor em cima disso, ele vai deixar de
- 29:36de confiar nessa aplicação. Ah, mas ela
- 29:39falhou. Todas falham. OK, todas falham.
- 29:43Mas precisamos pensar sobre quais falhas
- 29:46podem ser muito críticas pra gente a
- 29:48ponto de deixar isso subir em produção e
- 29:52deixar o cliente testar, né?
- 29:55Eh, é uma coisa que depende muito do da
- 29:58área, do nicho da sua aplicação, né?
- 30:01Assim, é financial. Financial, de
- 30:03preferência era melhor não falhar nunca,
- 30:05né? sabe que pode falhar, mas quais são
- 30:08o tipo de falhas que a gente consegue
- 30:09lidar muito bem, né? E falhas que a
- 30:13gente não deveria deixar permitir de
- 30:15jeito nenhum. E quais estratégias que a
- 30:17gente pode utilizar para mitigar ou para
- 30:19resolver ou para prever falhas nessa
- 30:23ótica?
- 30:26E aí, só apresentando aqui os nossos as
- 30:28três fases ou três pilares que a gente
- 30:30vai abordar, fundamentos que a gente vai
- 30:32refletir muito sobre sintaxe, tipos
- 30:35imutabilidade, pattern mating, o
- 30:37operador pipe, o o benefício dele, tá
- 30:41assim de criar umas uns eh criar as
- 30:45nossas funções, eu ia chamar de building
- 30:47blocks da nossa aplicação, que são os
- 30:49nossos pedaços, né, conceituais e código
- 30:54que entregam o valor para nossa
- 30:56aplicação, né? O
- 30:59eh o poder da OTP dentro disso, né? Como
- 31:02que a gente pode elevar o nível e sair
- 31:04de uma uma
- 31:07sair de algo muito mais ã sintático de
- 31:11síntaxe para tá? A gente precisa muito
- 31:15integrar supervisor aqui por conta de X,
- 31:19Y ou Z, né? Então, ou seja, refletir
- 31:21sobre onde que a gente pode sair do
- 31:24feijão com arroz e colocar mais
- 31:27qualidade, porque a gente precisa
- 31:29garantir mais, porque a gente precisa
- 31:30prever mais, porque a gente precisa
- 31:32também economizar mais, né? Será que a
- 31:36gente precisa de fila para fazer
- 31:38determinada coisa? Será que a gente
- 31:40precisa, sei lá, integrar eh eh
- 31:44cubernetes e cáfica e não sei o quê?
- 31:47Será que a gente precisa disso? Então, é
- 31:50até que ponto eu realmente vou precisar,
- 31:54porque hoje eu posso dizer assim: "Ah,
- 31:56eu preciso, mas talvez eu esteja dizendo
- 31:59que eu preciso porque eu conheço mais
- 32:01uma tecnologia do que a outra". Então, é
- 32:05entender muito mais o poder da OTP e ter
- 32:09realmente poder de eh poder de decisão,
- 32:13ou seja, refletir e decidir de uma
- 32:15maneira consciente, né? Eu tenho um
- 32:17poder porque eu tenho consciência
- 32:18daquilo. Não é o poder porque eu tô no
- 32:21nível de tomar decisões, mas eu eu posso
- 32:24eu posso tomar essa decisão. Eu posso
- 32:26ser um crítico disso porque eu conheço.
- 32:29Então conhecer para criticar, né? Então
- 32:32essa é importante. E três, né? Quais são
- 32:36as ferramentas e ferramentais
- 32:38disponíveis na comunidade e o que que a
- 32:41gente pode construir também para que a
- 32:43gente tenha nosso deploy em produção com
- 32:46garantias,
- 32:47com escalabilidade, com métricas, com
- 32:52dashboard que nos informa: "Olha, isso
- 32:54aqui vai quebrar amanhã porque tá
- 32:57aumentando a quantidade de informação
- 33:00dentro de um processo, porque o processo
- 33:02tá vivo há muito tempo, né, por falha.
- 33:05de desenvolvimento, obviamente, né? Mas
- 33:07assim, você consegue ver antes de
- 33:10quebrar, você consegue prever que num
- 33:13dia, após uma sequência de de
- 33:19dias de acumulando informação dentro de
- 33:22um processo, você consegue prever que,
- 33:23opa, daqui a um dia isso vai não vai
- 33:26mais suportar, porque a quantidade de
- 33:28memória usada por esse processo é muito
- 33:30alta e vai quebrar. Obviamente a
- 33:32aplicação vai se vai se recuperar disso
- 33:34porque nativamente ela se recupera a
- 33:36aplicação em geral, mas assim você vai
- 33:39ter estourado um erro, você não vai ter
- 33:41conseguido processar aquilo e você vai
- 33:43ter perdido, provavelmente aquela
- 33:45quantidade de informação que estava
- 33:47acumulada. Qual é a melhor forma de
- 33:48fazer isso, né? Qual é a forma que vai
- 33:51garantir essa pressão, né, essa pressão
- 33:55profunda que ela sofreu nesse tempo? A
- 33:58gente consegue fazer isso com elixe?
- 34:01A gente tem um poder do OTP ali que pode
- 34:03fazer isso. Ah, vou dividir para
- 34:05conquistar, vou separar em outros
- 34:06processos para processar essa
- 34:08informação, para não acumular muito
- 34:10dentro de um único processo, né? Então,
- 34:14existem formas. Pode ser que o que eu tô
- 34:16falando aqui vocês não estejam
- 34:18conseguindo visualizar, é porque
- 34:24não é só desenvolver usando sintaxe, é
- 34:28pensar sobre, né? E o elixe abimlang,
- 34:32tudo isso que compila para bim, você tem
- 34:34glin também que compila para bim, tudo
- 34:36isso vai beber da mesma fonte de não é
- 34:39só uma uma sintaxe, é entender como que
- 34:42funciona por trás, é entender como que
- 34:44as coisas realmente estão sendo
- 34:46processadas ali, né? O que é um
- 34:48processo? Qual é o qual é o impacto
- 34:51disso? Se eu estrangular muito um
- 34:53processo, se eu tiver fizer um worker,
- 34:56um worker só para tudo, eu vou est
- 34:58fazendo, eh, eu vou est não utilizando o
- 35:01poder da máquina virtual da BIM e vou
- 35:05estar quebrando a minha aplicação depois
- 35:06de um tempo. Vai ser como rodar eh uma
- 35:10máquina dentro do cubernetes, né? Então,
- 35:12ela vai morrer, eu vou restartar a
- 35:13máquina, OK? Mas eu perdi o que tava
- 35:17sendo processado ali, né? Então é é
- 35:19muito mais o pensar, né? Trazendo de
- 35:22novo aquilo que eu falei no início, isso
- 35:23é muito mais reflexivo
- 35:26e entender também os pedaços de código,
- 35:29os elementos, os tools, as ferramentas e
- 35:32a gente conseguir sair do outro lado com
- 35:34observação, observabilidade, né? Com
- 35:38produto muito bem manutenível. qualquer
- 35:41pessoa que entrar no seu eh no seu time
- 35:44vai conseguir entender muito bem, não
- 35:47porque tá documentado. Ah, eu enfiei
- 35:50milhões de linhas de documentação e
- 35:51agora eu entendo porque eu tenho que ler
- 35:53aquela documentação. Não somente por
- 35:55isso, mas porque o código ele está muito
- 35:56legível, ele tá simples, né?
- 36:02E aí, nos próximos vídeos ou no próximo
- 36:04vídeo a gente vai falar um pouco mais
- 36:06dessa máquina virtual que é o fundamento
- 36:09de tudo, porque em cima do que a gente
- 36:11entender da máquina virtual da BIM, a
- 36:15gente vai conseguir entender porque que
- 36:16a gente fez, por que a gente utilizou um
- 36:20supervisor, porque a gente utiliza um
- 36:22worker, por que a gente tá fazendo um
- 36:24código que é reto e a gente joga num
- 36:27Phoenix, né, no Framework Phoenix e
- 36:29acontece a mágica e funciona tudo bem,
- 36:32né? Quando quebra um processo, ninguém
- 36:34morre, né? Quem tá muito dentro do do
- 36:38elix, né? Que trabalha muito com feijão,
- 36:41com arroz, desenvolvendo aplicações
- 36:42Phoenix, acaba não sentindo os
- 36:45benefícios, assim, entendendo realmente
- 36:47como é que funciona a coisa e acaba
- 36:48sendo recebendo só os benefícios sem
- 36:51senti-los, sem percebê-los, né? Só quem
- 36:55eh consegue trabalhar com duas
- 36:57linguagens, vamos dizer, uma imperativa
- 37:00que ela um node, por exemplo, um PHP que
- 37:04roda de uma maneira um pouco mais eh
- 37:07single thread ali, obviamente tem eh
- 37:10especificidades para você potencializar
- 37:12isso, mas então a título de exemplo,
- 37:14macro, né, uma linguagem que trabalha em
- 37:17cima de uma thread só, de uma monread,
- 37:19um single thread e um processo e você
- 37:23tem uma linguagem que ela
- 37:25você não, ela trabalha
- 37:28vários cores, né? Ela usa tudo que a
- 37:31máquina tem, um é um ponto, né? Mas
- 37:33assim, ela trabalha de uma maneira já
- 37:35distribuída, você acaba não tendo o que
- 37:37pensar em várias coisas que outras
- 37:39tecnologias você tem que pensar muito
- 37:40mais, não a nível de aplicação, não a
- 37:43nível de sua aplicação, a nível de, tá,
- 37:45isso aqui vai quebrar a minha máquina,
- 37:48né? Isso vai quebrar a minha aplicação
- 37:50assim, vai quebrar mesmo que eu vou ter
- 37:52que fazer o restart. O o sistema
- 37:54operacional tem que fazer restart nela.
- 37:56Então isso dentro do elixe não deveria,
- 38:00dependendo de como você desenvolve, não
- 38:02deveria acontecer. O sistema prional não
- 38:04deveria restartar a sua aplicação. Ela
- 38:07deveria se autorecuperar e restartar
- 38:09tudo que falhou, tudo que precisa ser
- 38:11restartado. Então quem dá isso pra gente
- 38:15é a BIM, tá? a máquina virtual do
- 38:18Erlang, máquina virtual do Elix, máquina
- 38:21virtual desenvolvida
- 38:23para segurar isso tudo, né? Pra gente, a
- 38:26gente compila nossas aplicações para
- 38:28essa máquina virtual rodar. É, a bem é
- 38:30como se fosse uma JVM, né? Uma Java
- 38:33virtual machine, só para a título de
- 38:36comparação de máquina virtual. são muito
- 38:40diferentes a título de de de
- 38:43implementação de desenvolvimento, mas só
- 38:46a título de ah, existe a máquina virtual
- 38:48do Java e existe a máquina virtual do
- 38:50Airlang, né, do Elix, por assim dizer.
- 38:54Então vou deixar aqui nos comentários
- 38:55desse vídeo, né, os links para
- 38:57documentação oficial do Elix, do
- 38:59Phoenix, também vou deixar do Erlang,
- 39:01mas pode focar no no Elix do Erlang,
- 39:04porque você vai ter ali umas funções e
- 39:06fundamentais que vai estar disponível
- 39:09dentro do elixe por conta da
- 39:10interoperabilidade. Vou também deixar os
- 39:12links da comunidade, né, das comunidades
- 39:16eh que eu participo, né, no Telegram,
- 39:19né, mas de algumas outras comunidades
- 39:20também de Elix e o repositório do curso,
- 39:24onde eu vou eh disponibilizar esses
- 39:26slides, tá? Eh, para vocês poderem ter
- 39:30como referência novamente e também
- 39:32qualquer código que vai acontecer em
- 39:34cada em cada vídeo, né? Então, no
- 39:36próximo vídeo, a gente vai falar um
- 39:37pouco mais sobre a BIM, entender um
- 39:39pouco mais profundamente, mergulhar
- 39:40dentro disso, né, para que a gente possa
- 39:43voltar paraa sintaxe e aí entender
- 39:45realmente e e visualizar como que essa
- 39:49sintaxe conversa, né, com a construção
- 39:53da BIM, né, como que isso funciona, né?
- 39:58Eh, e acredito que isso vai ser
- 39:59importante pros próximos passos que a
- 40:02gente vai tomar aí. Então, se você tiver
- 40:04gostado desse vídeo, eh, curta o vídeo,
- 40:08eh, para poder chegar mais pessoas, né,
- 40:11interessadas nesse mundo e
- 40:13desenvolvimento de aplicações robustas,
- 40:16escaláveis, resilientes e mais, né? E se
- 40:22inscreva no canal, caso você não seja
- 40:23inscrito. A gente vai manter essa
- 40:27sequência de vídeos aí até a gente
- 40:29conseguir fechar com chave de ouro ali
- 40:31no deploy, né? Passando por tudo isso
- 40:34que a gente comentou e chegando no
- 40:35deploy, tá bom? E na no deploy pós que é
- 40:39a observação daquilo que a gente
- 40:41implantou ali em produção. Obviamente a
- 40:43gente vai ter vídeos um pouco mais
- 40:44práticos e outros um pouco mais
- 40:46conceituais.
- 40:47Então, até o próximo vídeo, eu espero
- 40:50você. E se tiver alguma dúvida, comente
- 40:54aí nos comentários. Vou tentar responder
- 40:57o mais breve possível.
- 41:00Até mais. M.
About this transcript
This page contains the full transcript of 01 - Aprendendo Elixir v2 - Introdução by Você, desenvolvedor!, generated from the public captions YouTube serves with the video. The transcript has 5,923 words across 914 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.
What you can do with it
Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.
Free YouTube transcript tool
YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.