Node.JS: O estado da arte – Hipsters Ponto Tech #491
Resumo
O episódio #491 do Hipsters Ponto Tech reúne André Davi, Vini Neves, Mônica Caveiro e Ju Amoazey para uma discussão abrangente sobre o estado atual do Node.js. Os participantes exploram as principais novidades e tendências do runtime, com foco em melhorias recentes que impactam o desenvolvimento back-end.
Uma das atualizações mais celebradas é o suporte nativo ao TypeScript, que permite a execução direta de arquivos .ts sem compilação prévia, embora ainda não realize type checking. Os participantes destacam como essa funcionalidade atende a uma demanda antiga da comunidade e facilita a adoção de tipagem em projetos Node, especialmente para desenvolvedores que vêm de outras linguagens como Java. A conversa também aborda a relação de “amor e ódio” com o TypeScript e sua importância crescente no desenvolvimento back-end.
Outras novidades técnicas discutidas incluem a atualização do motor V8 (que traz melhorias de performance e novas features do JavaScript), suporte nativo a WebSocket (eliminando a dependência de bibliotecas externas como socket.io), e a introdução de um modelo de permissões experimental que permite controle granular sobre acesso a disco, rede e processos. Os participantes também comentam sobre a equalização progressiva entre APIs do front-end e back-end, como a Fetch API nativa e o sistema de módulos ESM, que reduzem a diferença cognitiva para desenvolvedores que trabalham em ambas as frentes.
A discussão se expande para temas como estratégias de atualização de versão (com foco em segurança e suporte LTS), os desafios das dependências de bibliotecas externas (ilustrado pelo caso do Axios), e o impacto das LLMs (Large Language Models) na geração de código Node. Os participantes compartilham experiências pessoais com projetos marcantes e oferecem dicas valiosas para quem quer se aprofundar no Node, incluindo a importância de entender o event loop, I/O não bloqueante e a arquitetura por trás do runtime.
Indicações
Conceitos
- Event Loop e I/O não bloqueante — Ju Amoazey e Vini Neves enfatizam a importância de entender o event loop e a arquitetura de I/O não bloqueante do Node, especialmente à medida que a complexidade dos projetos aumenta, pois isso evita bugs e problemas de performance.
- Sistema de módulos (CommonJS vs ESM) — Vini Neves lista o entendimento do sistema de módulos (require vs import/export) como uma das quatro dicas essenciais para dominar o Node, já que essa foi uma fonte histórica de problemas e agora suporta ambos os padrões.
Cursos
- Carreira de Backend Node.js (Alura) — Mônica Caveiro e Vini Neves recomendam a carreira da Alura como um caminho estruturado para aprender Node, com conteúdos organizados por níveis (iniciante, intermediário e avançado) e uma curva de aprendizado bem planejada.
- Curso de Serverless com Node (em desenvolvimento na Alura) — Vini Neves revela que está trabalhando em um novo curso sobre serverless com Node, mencionando que seria um bom tema para um futuro episódio do podcast.
Ferramentas
- Cursor (com regras/configurações) — Mônica Caveiro e Vini Neves mencionam usar o Cursor com regras (rules) específicas definidas para o projeto, o que melhora significativamente a precisão das sugestões de código e reduz erros relacionados a versões e dependências.
Linha do Tempo
- 00:02:07 — Introdução às novidades do Node.js — André Davi abre a discussão perguntando sobre o que há de novo e interessante no mundo do Node. Vini Neves responde destacando o suporte nativo ao TypeScript como uma das features mais aguardadas, explicando que ainda é rudimentar (não faz type checking) mas já permite executar arquivos .ts diretamente. Os participantes comentam sobre a relação de amor e ódio com TypeScript e sua importância para o desenvolvimento back-end.
- 00:05:46 — Atualização da V8 e WebSocket nativo — Vini Neves explica a importância da atualização do motor V8, que traz para o Node todas as melhorias e novas features implementadas no Chrome. André Davi pergunta sobre vantagens concretas, e Vini cita melhorias em WebAssembly, Regex e performance de arrays. Em seguida, discutem o suporte nativo a WebSocket, que elimina a dependência de bibliotecas externas como socket.io, possivelmente impulsionado pela demanda de aplicações de IA que usam conexões persistentes.
- 00:10:24 — Test runner interno e redução de dependências — Mônica Caveiro menciona o test runner interno do Node, com melhorias como suporte a subtestes, facilitando testes unitários e de integração. A conversa evolui para a estratégia geral do Node de reduzir dependências externas, exemplificada pela Fetch API nativa (disponível desde a versão 22) que substitui bibliotecas como Axios. Ju Amoazey compartilha sua “cruzada pessoal” contra o uso desnecessário do Axios quando soluções nativas estão disponíveis.
- 00:13:01 — Estratégias de atualização e segurança — André Davi pergunta sobre a cultura de atualização no ecossistema Node, comparando com sua experiência em Java. Ju Amoazey enfatiza a importância de atualizações por questões de segurança, explicando que o JavaScript é tolerante a breaking changes, mas problemas geralmente surgem de dependências aninhadas. Vini Neves detalha o ciclo de suporte LTS (Long Term Support), onde apenas as três versões pares mais recentes recebem atualizações de segurança.
- 00:20:51 — Modelo de permissões e segurança — Vini Neves apresenta o modelo de permissões experimental do Node (disponível desde a versão 22), que permite controle granular sobre o que um script pode acessar: disco, rede, WebAssembly, processos filhos, etc. Ele explica como isso ajuda a prevenir ataques, como ransomware, ao restringir permissões de escrita. Mônica Caveiro complementa com a flag —allow-net para controle de quais endpoints externos o back-end pode acessar, aumentando a segurança contra exfiltração de dados.
- 00:31:43 — Equalização entre front-end e back-end — A conversa retorna ao tema da redução das diferenças entre desenvolvimento front-end e back-end no Node. Ju Amoazey destaca a equiparação do sistema de módulos (ESM vs CommonJS) como um avanço crucial que resolveu muitos problemas de compatibilidade. Vini Neves menciona outras features como hot reload nativo (flag —watch) e URL pattern, mostrando como o Node está se tornando mais consistente com as APIs do navegador.
- 00:36:10 — Node.js e LLMs: cuidados e boas práticas — André Davi levanta a questão do uso de LLMs (como Copilot e Cursor) para gerar código Node. Ju Amoazey alerta sobre os riscos de typo squatting (bibliotecas maliciosas com nomes similares aos legítimos) e breaking changes em versões de dependências sugeridas erroneamente. Mônica Caveiro e Vini Neves compartilham experiências positivas com configurações de contexto (rules) no Cursor que melhoram a precisão, mas reforçam a necessidade de revisão manual de comandos e instalações sugeridas.
- 00:43:01 — Dicas finais e recursos de aprendizado — Os participantes compartilham dicas para quem quer se aprofundar em Node. Mônica Caveiro menciona a carreira de Backend Node.js da Alura. Ju Amoazey recomenda estudar o event loop e a arquitetura orientada a eventos após o básico. Vini Neves destaca quatro pilares: sintaxe JavaScript/TypeScript, compreensão do event loop, I/O não bloqueante e sistema de módulos (CommonJS vs ESM), além de mencionar um curso em desenvolvimento sobre serverless com Node.
Dados do Episódio
- Podcast: Hipsters Ponto Tech
- Autor: Alura - Hipsters Network
- Categoria: Technology Science Education
- Publicado: 2025-11-25T03:17:23Z
- Duração: 00:49:19
Referências
- URL PocketCasts: https://pocketcasts.com/podcast/8c92b8c0-2f51-0134-eba6-0d50f522381b/episode/37e4f6c3-16b4-4e25-a406-b78adcd563d7/
- UUID Episódio: 37e4f6c3-16b4-4e25-a406-b78adcd563d7
Dados do Podcast
- Nome: Hipsters Ponto Tech
- Site: https://www.hipsters.tech/
- UUID: 8c92b8c0-2f51-0134-eba6-0d50f522381b
Transcrição
[00:00:00] RIPSTERS.TEC, o podcast de tecnologia e outras modinhas.
[00:00:13] Salve, ouvintes do RIPSTERS.TEC, está no ar mais um episódio do seu podcast favorito.
[00:00:18] Eu sou o André Davi, sou seu host nesse episódio e vamos falar de tecnologia e de tecnologia que parece que está por todas as partes.
[00:00:27] Recentemente a gente gravou um episódio sobre N8N e quem está lá por trás? O Node.
[00:00:33] E a gente olha para o Node Red e quem está lá atrás? O Node.
[00:00:38] E parece que isso se espalha cada vez mais.
[00:00:42] Seja você um fã ou seja você um hater, é muito importante a gente se atualizar do que está acontecendo nesse mundo.
[00:00:48] Por isso, vamos ver quem é a galera que está aqui para bater esse papo.
[00:00:57] Quem está aqui comigo hoje é ele, Vini Neves. Tudo bem com você, Vini?
[00:01:02] Tudo bem, André. E uma vez eu dei uma palestra cujo título era PHP versus Node.
[00:01:09] O PHP ganhou, imagino. Não, não vão entrar nesse mérito.
[00:01:14] Porque quem está aqui com a gente também é ela, Mônica Caveiro. Tudo bem, Mônica?
[00:01:19] Olá, pessoal. Obrigadaço mais uma vez por estar aqui no RIPSTERS.
[00:01:23] E eu sou suspeita para falar do PHP e Node, então…
[00:01:26] Vamos ver.
[00:01:27] Vamos ver até onde essa conversa vai, porque a nossa quarta componente hoje é ela, Ju Amoazey.
[00:01:33] Tudo bem com você, Ju?
[00:01:34] Tudo bem, André. Eu não posso falar muito do Node, porque eu sou muito grata a ele,
[00:01:39] porque o Node me salvou de ter que ser front-end para sempre.
[00:01:43] Então, eu comecei como front-end, né?
[00:01:45] Quando eu descobri que eu podia sair da frente…
[00:01:48] Eu podia me livrar da vida de alinhar quadradinhos e bolinhas.
[00:01:52] Eu fui muito mais feliz graças ao Node.
[00:01:54] Eu não posso criticar uma coisa dessa.
[00:01:57] E posso contar a curiosidade?
[00:01:59] Manda aí.
[00:02:00] Eu aprendi Node com a Ju.
[00:02:01] Olha aí, que beleza, que legal.
[00:02:04] Pô, então, peraí. Vamos começar entendendo esse negócio?
[00:02:07] Que o Node é sucesso, acho que está bem claro, né?
[00:02:09] Eu sempre gosto de brincar, fazer essas graças aí.
[00:02:12] Tal linguagem é melhor que tal linguagem.
[00:02:14] Mas a gente sabe que é pura bobeira, que é pura brincadeira.
[00:02:17] Porque, no fim das contas, você precisa resolver um problema.
[00:02:19] O que eu realmente estou interessado em saber nesse episódio de hoje é
[00:02:22] o que tem de legal no Node agora?
[00:02:25] O que tem de fresquinho?
[00:02:27] As atualizações?
[00:02:28] Para onde ele foi?
[00:02:29] É um universo que eu não estou muito imerso.
[00:02:31] Não é a linguagem que eu piloto todo dia.
[00:02:33] Então, Vini, já que você deu a ideia, eu vou jogar essa bomba no teu colo, cara.
[00:02:37] O que tem de legal acontecendo no mundo do Node?
[00:02:39] Olha, eu vou começar falando que eu estou tendo um sonho sendo realizado,
[00:02:43] que é o suporte a TypeScript, né?
[00:02:44] Ainda rudimentar, porque ele não está fazendo type checking para a gente,
[00:02:48] mas ele já consegue lidar com o arquivo .ts.
[00:02:52] Então, assim, eu acho isso muito legal,
[00:02:54] porque é a galera do Node ouvindo a comunidade, né?
[00:02:57] Porque, assim,
[00:02:57] abrindo um parênteses muito rápido sobre TypeScript,
[00:03:01] eu posso dizer que ele é uma relação de amor e ódio, né?
[00:03:03] Normalmente, a galera começa a aprender e odeia,
[00:03:06] e quer fazer N em qualquer lugar, porque está vendo do JavaScript.
[00:03:09] JavaScript não tem type, não tem type checking, não tem enforcement, não tem nada.
[00:03:13] E aí, a pessoa meio que fica brigando ali com TypeScript,
[00:03:16] porque a pessoa tende a querer escrever JavaScript no arquivo .ts,
[00:03:20] e aí vem ali um pouco de briga.
[00:03:22] Então, fechei o parênteses.
[00:03:23] Mas, na prática, isso ajuda muito a gente que está desenvolvendo,
[00:03:26] principalmente quando…
[00:03:27] Quando a gente chega em um projeto novo,
[00:03:29] ou um projeto que a gente não tem muito conhecimento.
[00:03:31] Então, ter essa tipagem aí ajuda demais.
[00:03:33] Então, eu acho que, de cara, eu vou jogar isso daí,
[00:03:35] suporte a TypeScript.
[00:03:37] Moni e Ju são fãs de TypeScript também?
[00:03:40] Gostaram dessa chegada?
[00:03:41] Como foi para vocês?
[00:03:42] Ou nem mudou o olhar e falaram,
[00:03:43] pô, não estou nem aí,
[00:03:44] eu vou no meu JavaScript mesmo, porque eu estou feliz.
[00:03:47] Não, não, só para o back-end.
[00:03:48] O back-end não sobrevive sem o TypeScript.
[00:03:51] E a minha relação de amor e ódio com o TypeScript é que
[00:03:54] ele é muito útil.
[00:03:56] Então, realmente,
[00:03:56] isso que o Vini falou acontece.
[00:03:58] Na hora que você começa, você fala,
[00:03:59] gente, eu não quero isso.
[00:04:01] Tudo aparece squig e vermelho embaixo das coisas.
[00:04:04] Eu não entendo o porquê que ele diz que
[00:04:07] esse método precisa receber não sei o que lá.
[00:04:10] Depois que você entende, fica ótimo.
[00:04:12] Especialmente para trabalhar com…
[00:04:14] Ah, você tem muita integração, muita API,
[00:04:16] seu código está muito modularizado,
[00:04:17] você não tem que ficar lembrando o que recebe de um lado para o outro.
[00:04:21] Ajuda muito.
[00:04:22] Porém, eu, pessoalmente,
[00:04:23] acho que era uma solução que precisava ter,
[00:04:26] no JavaScript,
[00:04:27] mais que o TypeScript,
[00:04:29] ele não é a melhor implementação,
[00:04:31] mas é o que temos.
[00:04:32] Então, fico feliz.
[00:04:34] O suporte nativo ao TypeScript
[00:04:36] era uma das coisas que
[00:04:38] a galera que defende
[00:04:40] alguns runtimes mais novos,
[00:04:42] especialmente o Node e o Ban,
[00:04:43] eles defendiam.
[00:04:44] Pô, o Node e o Ban,
[00:04:46] eles já têm TypeScript nativo,
[00:04:48] você não precisa compilar, é muito mais fácil.
[00:04:50] Mas o Node é o Node, né?
[00:04:52] Ele já está consolidado no mercado,
[00:04:54] ele já tem bibliotecas,
[00:04:55] todas as bibliotecas,
[00:04:56] e se você tem um sistema muito grande,
[00:04:58] você não vai trocar para, de repente,
[00:05:00] pegar um runtime que apareceu agora.
[00:05:02] Então, eu achei ótimo, achei tops.
[00:05:05] Cara, no meu caso,
[00:05:07] o que eu acho legal, assim,
[00:05:08] eu uso o TypeScript no dia a dia,
[00:05:10] tem jeito a pesar que também trabalho
[00:05:11] no PHPzinho aí da massa, no legadão,
[00:05:14] não posso deixar ele de lado,
[00:05:16] mas, cara, TypeScript é o que a Ju falou.
[00:05:19] Não tem como, a gente não tem como
[00:05:20] viver mais no backend sem isso.
[00:05:23] Cara, as novas versões trouxeram
[00:05:24] muitas coisas legais, cara,
[00:05:26] essa parte que o Vinícius citou foi incrível, assim,
[00:05:28] então, no meu dia a dia, assim,
[00:05:30] não tem muito mais que complementar,
[00:05:31] acho que ele já falou bastante coisa,
[00:05:33] mas essas coisas que vieram, assim,
[00:05:35] principalmente essa parte do TypeScript,
[00:05:37] eu acho que é uma das partes mais importantes.
[00:05:39] E falando ainda das novidades,
[00:05:40] tem mais coisas legais, né?
[00:05:41] Óbvio que eu trouxe uma listinha aqui
[00:05:43] que eu vim preparado, né?
[00:05:44] Então, assim, a primeira coisa que eu vou trazer aqui
[00:05:46] é o update da V8.
[00:05:48] Para quem não sabe e nunca pôs a mão no Node, né?
[00:05:51] O Node, basicamente, ele rola em cima da V8,
[00:05:55] que é o motor, né?
[00:05:55] que é o motor, né?
[00:05:56] que é o motor, né? que é o motor, né?
[00:05:56] do Chrome, para lidar com JavaScript.
[00:05:58] Então, o Node agora atualizou a V8,
[00:06:02] e aí a gente consegue ganhar tudo que foi implementado lá na V8,
[00:06:06] vindo para o Node.
[00:06:07] Viní, pausa um pouquinho,
[00:06:08] porque você falou de ele começar a aceitar a V8 e tudo mais,
[00:06:12] e que roda em cima dela.
[00:06:13] A minha pergunta é a seguinte,
[00:06:15] antes de essa implementação acontecer,
[00:06:18] se resolviam os problemas de uma forma X.
[00:06:21] O que que você ganhou?
[00:06:23] Porque você falou, a gente consegue usar as vantagens da V8.
[00:06:26] Que vantagens são essas?
[00:06:26] O que que trouxe de novo para o Node?
[00:06:29] Boa, assim, acho que o primeiro ponto é, sem V8 não tem Node, né?
[00:06:33] O Node roda em cima da V8, sempre foi assim.
[00:06:35] E o que que é a V8?
[00:06:36] É a engine de JavaScript do Chrome.
[00:06:40] Só que o Node não lança tantas versões quanto o Chrome lança updates, né?
[00:06:46] Então, assim, o Node, ele está um pouco,
[00:06:48] sempre um pouco para trás em relação ao que está rodando hoje.
[00:06:51] Então, quando o Node faz o upgrade,
[00:06:55] ele traz as features do JavaScript que foram implementadas lá.
[00:06:59] Então, por exemplo, tem coisa lá de WebAssembly, que Deus nos proteja.
[00:07:04] Tem umas melhorias lá de Regex,
[00:07:07] tem melhorias de performance com Array, de 16 bits, se eu não me engano.
[00:07:13] Então, assim, pensa que a gente está, óbvio, a gente está aqui escovando o bit,
[00:07:16] quando a gente começa a falar aqui de WebAssembly e 16 bits, né?
[00:07:19] Então, parece que a gente é muito inteligente.
[00:07:21] Mas a ideia aqui principal é, quando o Node faz o update,
[00:07:25] da V8, o que a gente precisa saber?
[00:07:27] Tudo que a V8 lá do Chrome trouxe em relação a JavaScript, a runtime,
[00:07:32] provavelmente vai vir para o Node também.
[00:07:34] E não para por aí, né?
[00:07:37] Uma outra parada também que veio agora para o Node,
[00:07:40] e é uma coisa até que eu acho que ainda demorou muito,
[00:07:43] que é o WebSocket nativo, né?
[00:07:45] A gente que trabalha no backend,
[00:07:46] a gente sempre dependia de alguma lib para fazer o WebSocket.
[00:07:50] Então, a gente fazia um npm install alguma coisa, socket.io, enfim, cada um tem sua preferida.
[00:07:55] E agora a gente tem o WebSocket nativo.
[00:07:57] Muito provavelmente, meio que, assim,
[00:08:00] aí aqui sou eu dando um palpite baseado em vozes na minha cabeça,
[00:08:03] mas muito provavelmente por conta dessa onda de IA,
[00:08:05] porque tem gente que prefere usar o WebSocket para abrir e deixar um canal aberto ali.
[00:08:10] Por exemplo, se você quer abrir um chat com uma LLN,
[00:08:12] tem gente que prefere o WebSocket para fazer isso, por N motivos.
[00:08:16] Então, eu acho que isso pode ter sido meio que um enforcing
[00:08:19] para não ficar para trás nessa direção aí.
[00:08:22] Pô, e vamos combinar que, acho que a Amônia,
[00:08:24] Pô, e vamos combinar que, acho que a Amônia,
[00:08:25] a Ju concordam, você parar de depender de outras bibliotecas,
[00:08:29] de outras ferramentas, por si só, já é uma baita vantagem, né?
[00:08:33] Porque a gente tem linguagens que são poderosas e conhecidas
[00:08:36] por terem um monte de biblioteca disponível, sim.
[00:08:39] Mas o nativo sempre vale mais a pena, né?
[00:08:41] Exato.
[00:08:42] Se a gente for pensar em depender de bibliotecas,
[00:08:46] eu acho que, não sei, foi esse ano, talvez,
[00:08:48] teve uma falha de segurança bizarra no Axios,
[00:08:53] que era uma das bibliotecas,
[00:08:54] de manager requisição, né, mais usada no JavaScript.
[00:08:59] E eu falava faz tempo, gente, não precisa mais usar o Axios,
[00:09:03] você já não precisa, porque o Node, ele não tinha,
[00:09:07] isso que o Vini falou de você ter uma biblioteca nativa,
[00:09:12] o Node passou muito tempo sem ter uma biblioteca nativa para fazer isso,
[00:09:16] quase todo mundo usava o Axios.
[00:09:18] Mas já faz bastante tempo que ele tem,
[00:09:20] eu sempre falo, quando eu via código novo usando o Axios,
[00:09:23] eu falava, gente, vamos tirar o Axios, né?
[00:09:24] Eu sempre falava, quando eu via código novo usando o Axios, eu falava, gente, vamos tirar o Axios,
[00:09:24] vamos tirar uma biblioteca que, ó, já tem do Node,
[00:09:27] a não ser que seja uma coisa muito específica,
[00:09:29] que, sei lá, nem lembro mais quais seriam os casos,
[00:09:31] usa o Fetch, usa o Fetch API do JavaScript mesmo, tá?
[00:09:35] E essa era a minha cruzada pessoal,
[00:09:37] quando eu via o Axios nos códigos das outras pessoas.
[00:09:39] E aí ele, enfim, não tem muito isso,
[00:09:42] ah, mas isso é muito usado,
[00:09:43] ah, mas a biblioteca é muito mantida,
[00:09:45] não tem muito isso, se você tá com uma biblioteca externa no seu projeto,
[00:09:49] você tem que ser responsável por ela.
[00:09:50] E aí, aí a coisa começa a pegar, não tem jeito.
[00:09:54] Eu vim buscar aqui, Ju, que você falou que faz um tempo,
[00:09:57] parece que foi na versão 22 que começou a ter esse suporte a Fetch API,
[00:10:02] e a partir disso a galera já pôde começar a deixar de lado.
[00:10:05] A gente tá o quê, na versão 25 agora, do Node?
[00:10:09] Então, assim, já tem um tempo, né, que tá andando.
[00:10:11] É, as versões estáveis, elas são sempre pares,
[00:10:14] então acho que a última estável é a 24,
[00:10:17] mas a última mesmo é a 25, né?
[00:10:20] Então, se você quiser long-term suporte, aí são as versões pares.
[00:10:23] Tem uma coisa que você…
[00:10:24] vocês não citaram, que eu acho que é bem legal,
[00:10:26] tipo, também já tem um tempo que a gente tem o teste runner interno, né?
[00:10:30] O de teste, né?
[00:10:32] E teve algumas coisas que teve de mudança neles também,
[00:10:35] a parte de subteste tá, se eu não me engano, tá aguardando dentro dele,
[00:10:40] então, tipo, isso vai mudar muito
[00:10:43] e melhorar essa parte de fazer os testes unitários, né, os testes de integração.
[00:10:48] Então, eu acho que isso é uma coisa que veio na 24 também, se eu não me engano.
[00:10:52] Caralho!
[00:10:53] Então, tem muita coisa legal, assim, principalmente com essa parte de teste.
[00:10:56] É o que a Ju tava falando.
[00:10:57] Cara, a gente vai tentando tirar a dependência de libs externas
[00:11:01] e colocando muita coisa interna.
[00:11:03] Então, isso tá melhorando bastante a linguagem
[00:11:05] e tá trazendo muita performance também, principalmente.
[00:11:19] A gente tá falando bastante diversão e, de novo, gente,
[00:11:23] sou do mundo Node, então talvez seja uma
[00:11:25] pergunta que os ouvintes falem, pô, André, que pergunta
[00:11:27] óbvia, por que você foi perguntar isso?
[00:11:29] Mas vocês que estão no mundo Node,
[00:11:31] tem essa corrida pela atualização
[00:11:33] da versão, ou tem aquela
[00:11:35] preocupação em não vai
[00:11:37] atualizar ainda, porque vai quebrar tudo?
[00:11:39] Dá pra perceber que eu vim do Java,
[00:11:41] que a gente tinha essa preocupação
[00:11:42] sempre, tem cara rodando no Java
[00:11:45] 6 até hoje.
[00:11:46] Eu sou uma pessoa que trabalha com Java hoje em dia
[00:11:49] e com, então, hoje eu tenho
[00:11:51] os BFFs, onde eu trabalho hoje tem os BFFs
[00:11:53] e tal, que é
[00:11:55] front-end TypeScript, mas os serviços
[00:11:57] são em Java, então sei bem
[00:11:59] como é. Eu não sei muito bem
[00:12:01] se é uma corrida, mas a gente
[00:12:03] especialmente nos últimos tempos
[00:12:05] eu tenho sempre ficado
[00:12:07] e pedido para as pessoas ficarem de olho nas
[00:12:09] atualizações, mas por causa de atualizações
[00:12:11] de segurança. Então,
[00:12:13] eu falo isso inclusive para as pessoas que não atualizam seus celulares.
[00:12:16] Atualizem seus celulares,
[00:12:17] por favor.
[00:12:19] Atualizações de segurança.
[00:12:21] E não tem muito jeito,
[00:12:23] tem que olhar sempre Breaking Changes.
[00:12:26] O JavaScript é muito
[00:12:27] tolerante à falha nesse sentido,
[00:12:30] por causa da natureza da linguagem.
[00:12:32] E que eu me lembre,
[00:12:33] o Node também segue isso.
[00:12:36] Se vocês tiverem algum
[00:12:37] caso de Breaking Change grave
[00:12:39] no Node, por exemplo,
[00:12:41] que aconteceu com o Python, aí vocês podem me lembrar.
[00:12:44] Mas não costuma,
[00:12:45] a não ser que você esteja usando
[00:12:47] dependências de dependências de dependências,
[00:12:50] aquele inferno que vai juntando uma
[00:12:51] coisa dentro da outra, e tenha problemas
[00:12:53] de atualização nas dependências, as dependências
[00:12:55] das dependências, se você estiver usando
[00:12:57] bibliotecas mais bem mantidas e tal,
[00:12:59] não costuma ter problema.
[00:13:01] Costuma ser realmente o que é mais
[00:13:03] atualizado,
[00:13:04] o que é mais indicado na medida do possível.
[00:13:08] Você não precisa sair correndo,
[00:13:09] porque você está na 24, mudou para 25,
[00:13:11] mas, sei lá, você também não pode ficar na 6.
[00:13:13] E vale a gente
[00:13:15] falar que o Node dá sempre
[00:13:17] suporte à versão N até a
[00:13:19] N-2. O que eu quero dizer com isso?
[00:13:21] Hoje, a LTS,
[00:13:23] a LTS, para quem não sabe,
[00:13:25] isso não é coisa do Node, é de versionamento no geral,
[00:13:28] a LTS é de Long Term
[00:13:29] Support. O que isso quer dizer?
[00:13:32] Que se alguém achar algum problema,
[00:13:34] vai lá ter algum time disponível
[00:13:35] para atualizar e corrigir.
[00:13:37] Então saiu uma possível falha de segurança,
[00:13:40] se você está rodando hoje o Node
[00:13:41] na data do lançamento,
[00:13:44] o último, o LTS
[00:13:45] mais antigo é o 20.
[00:13:47] Então, se você está rodando na versão 20,
[00:13:49] hoje, você vai ter suporte.
[00:13:51] Quando sair a 26,
[00:13:54] aí a 20 cai,
[00:13:55] fica 22, 24, 26.
[00:13:57] Quando sair a 28, 24, 26, 28.
[00:14:00] Então, tem sempre esse menos 2.
[00:14:02] E a estratégia
[00:14:03] de você se manter atualizado,
[00:14:06] eu acho que isso varia muito de empresa
[00:14:07] para empresa, de quão crítico é
[00:14:09] o projeto. Porque, por exemplo,
[00:14:11] eu já trabalhei em empresas
[00:14:13] que o padrão era
[00:14:15] a LTS menos 1.
[00:14:17] Por quê? Ela está mais tempo estável
[00:14:19] do que a versão mais recente,
[00:14:21] então ela já está mais conhecida, mais estável,
[00:14:23] já passou por um monte
[00:14:26] de bug fixes e tudo mais,
[00:14:28] e ainda mantém suporte.
[00:14:30] Quando você vem para a mais recente,
[00:14:33] pode ser que alguém descubra
[00:14:34] uma vulnerabilidade, ou ela sai com uma
[00:14:36] vulnerabilidade lá no dia zero,
[00:14:38] e aí você vai estar exposto. Então, tem estratégias
[00:14:40] e estratégias. Depende muito
[00:14:42] se o seu back-end está
[00:14:44] exposto para a internet,
[00:14:46] então, assim, óbvio, vou dar a cartada
[00:14:48] do depende aqui, acho que tem estratégia
[00:14:50] para todo tipo.
[00:14:51] Agora, quando a Ju falou,
[00:14:53] eu não me lembro de verdade
[00:14:56] qual foi a última breaking chain
[00:14:58] de violenta que teve no Node,
[00:14:59] eu não sei se foi porque eu não passei,
[00:15:01] o que eu já vi, eu já sofri
[00:15:03] muito com o Node, e é isso, tanto no back
[00:15:05] como no front, é o que a Ju falou.
[00:15:08] Dependência de dependência.
[00:15:09] Às vezes tem lá, você está usando
[00:15:11] uma biblioteca, a biblioteca até recebe
[00:15:13] algum update ali, mas a dependência
[00:15:16] da dependência não funciona
[00:15:17] nas versões mais recentes do Node.
[00:15:19] Você quer ver uma parada que acontece?
[00:15:21] Tem um projeto que você fez
[00:15:24] há quatro anos atrás, aí você estava
[00:15:26] usando o Node mais recente da época.
[00:15:28] Pode acontecer de você querer rodar ele
[00:15:30] hoje com o Node de hoje e não vai funcionar,
[00:15:32] porque as bibliotecas não suportam
[00:15:34] e tudo mais, aí você vai ter que fazer
[00:15:36] um downgrade e ver o que você vai querer fazer.
[00:15:38] Mas, assim, a nível de breaking chain
[00:15:40] do tipo de ser caótico
[00:15:42] para fazer o update,
[00:15:44] em questão de código,
[00:15:46] eu não me lembro de ter passado por nada que tenha sido
[00:15:48] muito complicado,
[00:15:49] já passei por perrengues,
[00:15:51] sim, com as dependências.
[00:15:53] Porque aí é aquela parada, a Ju trouxe aqui do Axios,
[00:15:56] mas cada escolha que você faz
[00:15:58] é uma renúncia. Quando você coloca uma dependência
[00:15:59] no seu projeto, ainda mais se
[00:16:01] aquilo não está bem encapsulado
[00:16:03] e tudo mais, para tirar
[00:16:05] depois, meu amigo,
[00:16:07] é sofrido. Uma coisa que eu lembrei,
[00:16:10] não sei se foi de break chain,
[00:16:12] mas eu lembro que teve um lance
[00:16:13] de uma atualização do OpenSSL
[00:16:15] que quebrou, que elevou
[00:16:17] algumas coisas de segurança e quebrou um monte de coisa,
[00:16:19] um monte de lugar, porque as chaves
[00:16:21] ficaram menores, aí quebrou
[00:16:23] alguma coisa, eu lembro que teve uma coisa dessa
[00:16:25] e também teve uma parte
[00:16:27] de binário, se não me engano foi do
[00:16:29] 22 para o 24, que
[00:16:31] também foi removido e também teve
[00:16:33] muita gente que teve problema com isso.
[00:16:35] Eu não estou lembrando detalhes agora, mas eu lembro
[00:16:37] que teve alguma coisa desse tipo.
[00:16:38] Mas você já serviu como cavaleira do caos,
[00:16:41] já trouxe para a gente.
[00:16:43] Eu vou confessar para vocês que eu tinha pesquisado
[00:16:45] aqui uma lista de mudanças e eu fiquei muito curioso
[00:16:47] com uma que está aqui, que é o
[00:16:49] Web Storage ser habilitado por
[00:16:51] padrão. O que que ele faz
[00:16:53] como era antes e por que que é bom
[00:16:55] isso? O que que é esse Web Storage
[00:16:57] dentro do Node? Por que que alguém
[00:16:59] deveria se interessar por essa novidade
[00:17:01] quando passou a existir dentro de uma função?
[00:17:03] O que você está falando é do
[00:17:05] Web Storage, é daquela
[00:17:07] parte louca do Session Storage, não é isso?
[00:17:09] Que ele mudou algumas partes
[00:17:11] que ele estava fazendo mais
[00:17:13] digamos assim, um ambiente mais
[00:17:15] browser-like, sabe?
[00:17:17] Então ele teve algumas mudanças nesse ponto.
[00:17:20] É, o Browser Storage
[00:17:21] é a ideia justamente, para quem vem do front
[00:17:23] e está aqui segurando a minha mão, a gente tem
[00:17:25] lá o Local Storage e o Session Storage no
[00:17:27] navegador. A grosso modo
[00:17:29] o Web Storage no Node é exatamente
[00:17:31] isso. Então imagina que
[00:17:33] se a gente precisa fazer uma
[00:17:35] persistência, fazer uma sessão, assim
[00:17:37] eu acho que tem casos de uso muito específico
[00:17:39] porque se a gente fala numa REST API
[00:17:41] por exemplo, e aí se a gente está seguindo
[00:17:43] todas as constraints dela,
[00:17:45] não existe sessão, né? Porque
[00:17:46] uma REST API é stateless.
[00:17:49] Então cada requisição deveria ser
[00:17:51] independente e eu não quero
[00:17:53] guardar alguma coisa da requisição anterior
[00:17:55] para a próxima, né? Então se eu estou
[00:17:56] seguindo uma REST API e eu quero dar
[00:17:59] o crachá de REST API
[00:18:00] para o meu backend, a gente não tem isso.
[00:18:03] Então isso às vezes é útil em
[00:18:05] outros cenários, mas a
[00:18:07] ideia do Node, não só com
[00:18:09] a Local Storage em si, né? Com o Storage
[00:18:10] em si, tem um padrão de URL
[00:18:12] que era diferente e agora está mais parecido com
[00:18:14] de front também. A ideia
[00:18:16] o que eles estão querendo fazer
[00:18:18] é deixar homogêneo
[00:18:21] o JavaScript que a gente escreve no frontend
[00:18:23] para o backend, para justamente as
[00:18:25] pessoas poderem aqui ficar
[00:18:27] migrando de um lado para o outro
[00:18:29] sem ser uma coisa tipo muito
[00:18:31] abrupta, né? Então
[00:18:33] é bem por aí.
[00:18:35] Esse movimento, o Node
[00:18:37] ele surgiu
[00:18:39] em 2009? Não me lembro, acho que é 2009
[00:18:41] a primeira versão. É, 2015 acho que é
[00:18:43] React, 2009 Node. Foram
[00:18:45] implementadas várias
[00:18:47] funcionalidades no Node que eram
[00:18:49] muito diferentes na época da forma que
[00:18:51] como funcionava no browser, inclusive
[00:18:53] a forma de se trabalhar a sync
[00:18:55] sync e a sync, né? E
[00:18:57] putz, isso foi um tiro
[00:18:59] no pé, eu acho, porque depois
[00:19:01] o Node teve que ficar implementando
[00:19:03] melhoria, implementando melhoria para ir tirando
[00:19:05] e deixando mais próximo, deixando mais
[00:19:07] próximo, deixando mais próximo, porque era
[00:19:09] fonte de muito bug, fonte de
[00:19:11] muita dor de cabeça
[00:19:13] você tem um padrão, que era o padrão que era usado
[00:19:15] no navegador, aí veio o Node, ah o Node faz
[00:19:17] diferente, putz. E aí você que vem
[00:19:19] do navegador, você quer usar o negócio, você não pode, você tem que
[00:19:21] aprender a usar do jeito do Node, porque o Node
[00:19:23] não tem isso, o navegador, algumas coisas
[00:19:25] realmente não faz sentido, então, por exemplo, eventos
[00:19:27] de janela e browser não faz sentido até no Node
[00:19:29] e o contrário também se aplica
[00:19:31] mas a forma como as coisas são
[00:19:33] usadas, acho que ainda
[00:19:35] o pessoal de manutenção do Node ainda tá
[00:19:37] arrumando muita coisa que
[00:19:39] era mais diferente, mas
[00:19:41] por motivos talvez meio óbvios
[00:19:43] e reclamação da comunidade, estão deixando
[00:19:45] cada vez mais iguais
[00:19:47] porque uma coisa que é interessante do JavaScript
[00:19:49] que o ECMA, né, que é
[00:19:51] a instituição lá que manda no JavaScript
[00:19:53] não manda no JavaScript porque é um consórcio, né
[00:19:55] só especifica o que tem que ter
[00:19:57] então tem que ter sorte
[00:19:59] tem que ter uma função, não sei o que lá, o array
[00:20:01] tem que ser desse jeito, mas não implementa nada
[00:20:03] quem implementa, então quando solta
[00:20:05] a versão, todos os vendors
[00:20:06] no caso, sei lá, que a gente chama de vendor, né
[00:20:08] Chrome é um vendor, Firefox
[00:20:10] etc, etc, todo mundo tem que atacar
[00:20:12] vácuo pra implementar do seu jeito, e o Node
[00:20:15] também, e o Ban também, e o
[00:20:17] Deno também, Dino, né, também
[00:20:18] então, essa é uma particularidade do
[00:20:21] JavaScript, é a forma como
[00:20:23] ele não tem uma autoridade central
[00:20:24] que diz de que forma as coisas estão
[00:20:26] implementadas, cada lugar implementa
[00:20:29] como quer, usando o motor
[00:20:30] o seu próprio motor, né, o seu próprio engine
[00:20:33] no caso do Chrome e do Node
[00:20:35] é a V8, né, que aí o Vini
[00:20:37] comentou mais cedo
[00:20:37] Uma outra parada que eu quero
[00:20:51] puxar aqui, que, assim
[00:20:53] a galera que fica, tem uma
[00:20:54] mística, né, e uma
[00:20:56] fama do Node, que a galera
[00:20:59] às vezes torce o nariz e tal
[00:21:01] fala, é o JavaScript no back-end
[00:21:03] e tal, mas tem uma feature muito legal
[00:21:04] que tá vindo, ela ainda tá
[00:21:06] como um experimental, mas ela já tá estável
[00:21:09] porque eu acho que é desde a 22
[00:21:10] que tem, que é o modelo de permissões
[00:21:13] porque, por exemplo, tinha uma parada que era difícil
[00:21:15] você cuidar das permissões
[00:21:17] e quando eu digo permissão, não é permissão de acesso
[00:21:19] do usuário, tipo, será que esse usuário
[00:21:21] pode fazer essa ação? Não é disso que eu tô falando
[00:21:22] mas eu tô falando de, esse script
[00:21:25] que eu tô executando, pode ter
[00:21:27] acesso ao disco?
[00:21:28] Ele pode ter acesso à WebAssembly?
[00:21:31] Ele pode ter acesso aos
[00:21:32] processos da
[00:21:34] Filhos, né, o Charlie lá? Então, assim
[00:21:37] esse permissionamento ainda tem
[00:21:39] uma flagzinha de experimental
[00:21:40] mas é muito interessante porque agora
[00:21:42] pensa lá no package.json e no NodeScript
[00:21:45] você coloca, você consegue dizer
[00:21:47] umas flags lá e dizer que
[00:21:48] aquele processo, aquele script, quando
[00:21:50] executar, ele não vai ter, por exemplo
[00:21:52] permissão de escrever no disco. Ele pode
[00:21:54] ler, mas ele não pode escrever, né
[00:21:56] e aí, óbvio que tem muitas
[00:21:58] isso desdobra muito
[00:22:00] mas é uma parada muito legal, porque
[00:22:02] eu acho que mais
[00:22:04] e mais, né, as pessoas estão ficando conscientes
[00:22:06] da importância de se escrever software seguro
[00:22:09] né, no sentido de
[00:22:10] tomar cuidado pra não deixar uma parada
[00:22:12] aberta e aí vem um ransomware
[00:22:15] ou uma parada da vida aí, né
[00:22:16] enfim, então
[00:22:18] esse tipo de coisa ajuda
[00:22:20] a gente a se prevenir disso
[00:22:22] do tipo, beleza, esse script aqui
[00:22:24] ele não vai ter acesso de escrita no disco
[00:22:26] e se por algum motivo
[00:22:28] ele for infectado
[00:22:31] ou alguma coisa maliciosa, ele vai tentar
[00:22:32] escrever no disco lá, vai tomar uma exceção
[00:22:34] porque ele não tem permissão
[00:22:36] então a gente começa a ter um ajuste fino
[00:22:38] muito mais interessante, né
[00:22:40] porque assim, o paradigma do Node já é
[00:22:42] diferente, porque a gente tá falando de
[00:22:43] back-end orientado ao evento, né, porque é 20 loop
[00:22:46] que, enfim, né, a galera tá
[00:22:48] a galera de back-end às vezes tá pensando em
[00:22:50] edge e tudo mais, e aí
[00:22:52] o Node ele funciona um bocadinho diferente
[00:22:54] mas ele tá pegando as coisas, né
[00:22:56] de outras linguagens, acho que isso é muito
[00:22:58] comum, e trazendo pra ele, então
[00:23:00] vale também falar do
[00:23:02] Permission Model do Node
[00:23:04] Além desse Permission também tem aquele do
[00:23:06] AllowNet, né, que pra controlar
[00:23:09] pra ter controle de rede, né
[00:23:10] tem também essa permissão
[00:23:12] que veio também, que é muito legal
[00:23:13] Aí no AllowNet é pra você dizer
[00:23:16] quais são os outros back-ends que você pode
[00:23:18] fazer requisição, então por exemplo
[00:23:20] as vezes a gente tem o nosso back-end
[00:23:22] e a gente tem um gateway de pagamento
[00:23:24] então a gente quer dizer que, olha, pra esse gateway
[00:23:26] de pagamento aqui, você pode
[00:23:28] permitir acesso, e aí você consegue
[00:23:30] brincar com isso, do tipo, permitir
[00:23:32] acesso inteiro, pode fazer
[00:23:34] qualquer requisição pra qualquer lugar na internet
[00:23:37] ou você fazer por
[00:23:38] domínio, você consegue fazer por IP
[00:23:40] enfim, tem várias
[00:23:42] restrições que você consegue colocar
[00:23:44] mas no sentido de o que
[00:23:46] com qual outro back-end o seu
[00:23:48] back-end pode falar, e aí se entrar
[00:23:50] alguma coisa ali maliciosa
[00:23:53] alguma coisa ali, então do tipo
[00:23:54] imagina que vai entrar ali um
[00:23:56] software malicioso que tá só genifando
[00:23:58] pegando token e mandando pra um outro
[00:24:00] lugar, por exemplo, e aí você consegue controlar
[00:24:02] você tem ali literalmente
[00:24:04] a lista de com quem
[00:24:06] o seu back-end pode falar
[00:24:08] Pô, mas vocês estão trazendo várias mudanças
[00:24:10] bem granulares assim
[00:24:12] de segurança mesmo, né, de deixar
[00:24:14] essa responsabilidade do software
[00:24:17] ser seguro na mão da pessoa
[00:24:18] que tá ali desenvolvendo e não só
[00:24:20] na mão da infra e tudo mais
[00:24:22] pelo menos o que vocês trouxeram parece ser uma constante
[00:24:24] isso. É, segurança
[00:24:26] bom, sempre foi crítico
[00:24:28] mas com o avanço
[00:24:31] eu não vou falar avanço
[00:24:32] nas tecnologias de ar, primeiro porque isso é muito
[00:24:34] difuso e
[00:24:36] às vezes o termo perde um pouco de sentido
[00:24:38] mas avanço na capacidade de processamento
[00:24:41] deu uma empurrada
[00:24:42] na, digamos assim
[00:24:44] na capacidade
[00:24:46] de invasão
[00:24:48] de quebrar
[00:24:50] a segurança de computadores
[00:24:51] então segurança sempre foi crítico mas agora tá
[00:24:54] bizarramente importante
[00:24:56] e as coisas que a comunidade
[00:24:58] pede muitas vezes
[00:25:00] são relacionadas à segurança
[00:25:03] no caso do Node
[00:25:04] muita coisa aconteceu no Javascript
[00:25:06] inclusive acho que a chegada do TypeScript também
[00:25:08] por, na minha opinião
[00:25:10] gente que veio pro TypeScript
[00:25:12] vindo de outras linguagens
[00:25:14] vindo de outros paradigmas
[00:25:17] e que preferiu
[00:25:19] levantar
[00:25:20] a plaquinha do que se acostumar
[00:25:22] aos paradigmas do próprio Javascript
[00:25:24] que eles são um pouco diferentes
[00:25:26] especialmente aí a galera do Java, né
[00:25:28] que aí transformou o TypeScript numa espécie de
[00:25:30] Java misturado com Javascript
[00:25:32] onde nada é muito definido
[00:25:34] tudo funciona pela metade, pronto falei
[00:25:36] mas é o que a gente tem
[00:25:37] mas, enfim
[00:25:40] segurança, não tem jeito
[00:25:41] Cybersec é uma das coisas
[00:25:44] hoje, há um tempinho já
[00:25:46] e daqui pra frente eu acho que vai ser uma das coisas
[00:25:48] mais críticas em qualquer
[00:25:50] qualquer
[00:25:50] lugar, qualquer produto que você tenha
[00:25:52] qualquer lugar que você trabalhe
[00:25:54] então, se você tem um runtime
[00:25:56] que roda, cara, praticamente
[00:25:58] tudo que é Javascript
[00:26:00] no back-end
[00:26:02] e que também controla as bibliotecas
[00:26:04] que a gente usa no front, né
[00:26:06] então, por exemplo, você precisa dele
[00:26:08] pra você rodar React, compilar os seus
[00:26:10] React pra eles se transformarem em Javascript
[00:26:12] blá blá blá blá, você
[00:26:13] assim, isso fica mais crítico ainda
[00:26:16] porque o lance do Axis
[00:26:18] ah, o Axis é uma biblioteca externa, mas isso não garante
[00:26:20] também que uma falha interna do Node não possa dar
[00:26:22] um problema lá pra frente
[00:26:24] não, com certeza
[00:26:26] e essa responsabilidade que a gente
[00:26:28] sempre traz, compartilhada, é importante
[00:26:30] você adquirir esses conhecimentos
[00:26:32] não só daquilo que você está fazendo
[00:26:34] não só como deve, mas também
[00:26:36] das outras áreas que tem a ver
[00:26:38] que estão em volta ali, pra você saber exatamente
[00:26:40] o que que vão explorar, o que que é uma
[00:26:42] vulnerabilidade, o que que estão olhando
[00:26:44] agora eu queria brevemente um momento
[00:26:46] meio lúdico, porque eu estava conversando
[00:26:48] com um aluno que eu encontrei
[00:26:50] no Next, recentemente
[00:26:52] e eu falei, pô cara, eu estou mal feliz
[00:26:54] estou criativo, estou usando muita
[00:26:56] coisa de N8n
[00:26:58] e tal, estou felizão
[00:26:59] aquela paixão, o que que vocês já
[00:27:02] fizeram com o Node, não precisa ser dessas
[00:27:04] últimas versões, que dá aquele orgulhinho
[00:27:06] assim, sabe aquele orgulho dev
[00:27:08] aquele orgulho nerd, aquele orgulho que você olha e fala
[00:27:10] caraca, ficou legal
[00:27:12] isso aqui, que bacana, esse projeto
[00:27:14] ficou bonitinho, porque no final
[00:27:16] das contas, a gente trabalha resolvendo
[00:27:18] o problema de alguém, a pessoa vai ficar feliz
[00:27:20] que o problema dela foi resolvido
[00:27:22] mas tem códigos ou tem estratégias
[00:27:24] que a gente segue, que deixam a gente
[00:27:26] orgulhoso, Vini, você tem alguma aí
[00:27:28] que te deixa, que deixou seu coração mais
[00:27:30] mais em festa?
[00:27:32] Olha, além de ter instalado uma biblioteca
[00:27:34] que valida se um número é par ou
[00:27:36] ímpar
[00:27:37] e se você está dentro
[00:27:39] tem bastante download dela, muito
[00:27:41] isso que eu ia falar, se você está achando
[00:27:44] que eu estou zoando, existe um
[00:27:46] é par, is even, e tem um is
[00:27:48] odd também, então assim
[00:27:50] existe biblioteca que faz isso, por incrível que pareça
[00:27:52] mas assim, tem uma parada que aí
[00:27:54] quando eu puxo de memória, eu trabalhei num projeto
[00:27:56] que ele
[00:27:57] era de gestão
[00:27:59] educacional, e ele tinha uma parada
[00:28:02] que era do professor
[00:28:04] montando
[00:28:05] a grade, tu pensa no começo do ano
[00:28:08] que está montando a grade, qual aula
[00:28:10] vai ser quando, então cada professor
[00:28:12] vai se organizando lá
[00:28:13] ele está numa turma, ela está
[00:28:16] numa turma de manhã, a outra
[00:28:17] não fica uma aula marcada em cima da outra
[00:28:20] e tal, e aí a gente fez uma parada
[00:28:22] usando o socket.io, porque
[00:28:24] na época não tinha suporte a websocket
[00:28:26] que é uma parada tipo que a gente tem hoje
[00:28:28] tipo no Trello, no Miro, que você consegue
[00:28:30] ver o que outras pessoas estão fazendo ali
[00:28:32] e aí conforme alguém começava a arrastar
[00:28:34] um quadradinho, você via o que
[00:28:36] você estava fazendo, você via das outras pessoas
[00:28:38] fazendo e tal, então foi uma parada
[00:28:40] muito legal. Oi, isso aí dá uma alegria
[00:28:42] foi isso, assim, eu acho
[00:28:44] que esse é um dos que eu me lembro bastante
[00:28:46] e teve uma outra também
[00:28:48] que aí tinha
[00:28:50] a ver com aguentar
[00:28:52] a pancada, do tipo assim, a gente teve que
[00:28:54] fazer um back-end que
[00:28:56] sem entrar muito detalhe
[00:28:58] imagina que a gente mandava um post notification
[00:29:00] e eram muitos usuários
[00:29:01] e aí quando esse post notification era enviado, todo mundo
[00:29:04] clicava nele e batia alguma coisa no back-end
[00:29:06] então a gente tinha que responder, dar conta
[00:29:08] de responder esse tanto de
[00:29:09] tinha que escalar, e era sazonal
[00:29:12] sazonal no sentido assim
[00:29:15] em determinados momentos tinha esse pico
[00:29:18] de consumo, mas isso não tinha
[00:29:20] padrão nenhum, podia ser de manhã, podia ser
[00:29:22] de tarde, porque era orientado ali
[00:29:23] a pessoa lá mandar a notificação
[00:29:26] e aí era todo mundo correndo pro aplicativo pra ver
[00:29:28] e aí a gente teve que trabalhar
[00:29:29] com camada de cache e tal
[00:29:31] e como que escalava, entender
[00:29:33] aí eu me lembro que nesse projeto
[00:29:36] que eu fui a fundo mesmo entender
[00:29:38] o ciclo de vida do Node pra eu conseguir
[00:29:40] ver o que que dava pra fazer, porque a gente tá falando
[00:29:42] que é um processo só, a gente tem
[00:29:44] o event loop, as coisas ali
[00:29:46] por debaixo dos fones funcionam de uma forma
[00:29:48] ali muito peculiar
[00:29:50] foi lá entender, ver onde que dava pra fazer cache
[00:29:52] o que dava pra fazer e tal, também foi bem legal
[00:29:54] só uma curiosidade, eu procurei aqui
[00:29:56] a biblioteca, a Easyven
[00:29:58] tem 179 mil downloads
[00:30:00] só essa semana, e a Iso
[00:30:02] de 530 mil
[00:30:03] gente, eu tô com reflexo
[00:30:05] mas voltando a pergunta
[00:30:08] eu tive que procurar
[00:30:09] não, é um dado maravilhoso
[00:30:12] eu tô maluco com isso
[00:30:14] mas por que que uma tem mais download
[00:30:16] que a outra, né?
[00:30:17] tem que ver qual que é a par e qual que é a ímpar
[00:30:20] porque aí o pessoal só nega, né?
[00:30:22] aí, então, tipo, baixa uma e nega pra saber se é o outro
[00:30:25] vai ver que é isso, né?
[00:30:28] Ju, você tem algum que marcou
[00:30:29] o coração aí, que ficou pra história
[00:30:31] ou não?
[00:30:32] tem um que eu fiz há muito tempo atrás
[00:30:34] quando eu tentei aprender
[00:30:36] shell script e
[00:30:38] fiquei batendo cabeça com shell script
[00:30:40] porque eu tinha 60 repositórios
[00:30:43] do GitHub
[00:30:44] que eu precisava baixar, instalar
[00:30:47] rodar os testes
[00:30:48] e ver os resultados dos testes
[00:30:50] e aí eu pensei, vou fazer um script pra fazer isso pra mim
[00:30:52] bate lá no GitHub
[00:30:53] aquela velha história de demorar mais
[00:30:56] fazendo o programa do fazendo na mão
[00:30:58] exato
[00:30:59] aí eu falei, não, vou fazer em shell script
[00:31:02] aproveitar pra aprender shell script aqui
[00:31:04] que é o mais indicado
[00:31:05] só que aí eu fiquei lá batendo cabeça
[00:31:08] com shell script e pensei
[00:31:10] quer saber, eu vou fazer isso aqui em javascript mesmo
[00:31:12] que é o que eu sei fazer
[00:31:13] e aí botei lá o meu projetinho pra funcionar
[00:31:16] fiz em Node lá, ele já batia na pasta
[00:31:19] já instalava os projetos
[00:31:20] batia nos repositórios, instalava, rodava os testes
[00:31:22] tudo via comando
[00:31:24] um scriptzinho que fazia, e eu fiz sozinha
[00:31:26] na época, eu fiz aqui assim, nossa
[00:31:27] cara, que da hora, e eu era front
[00:31:30] era front na época
[00:31:31] nunca tinha feito nenhum script na minha vida
[00:31:34] foi o primeiro que eu fiz
[00:31:35] vamos até pegar esse ponto, Ju
[00:31:43] porque é legal, você comentou na sua apresentação
[00:31:45] que o Node te deu a oportunidade de sair de front
[00:31:48] e ir pra back-end, e vocês estão dizendo
[00:31:50] pra mim no papo todo, que o Node
[00:31:52] nas últimas atualizações ele tem caminhado
[00:31:54] pra ficar menos esquisito
[00:31:56] pra pessoa encontrar uma coisa
[00:31:57] menos diferente de um lado
[00:32:00] pro outro, hoje em dia
[00:32:02] analisando aqui como tá agora o estado
[00:32:04] da arte, ainda é
[00:32:05] muito diferente o que a pessoa
[00:32:07] vai ver em termos de estruturas
[00:32:10] em termos de como fazer no front
[00:32:12] e no back, ou já deu uma equalizada
[00:32:14] legal? Eu acho que já
[00:32:16] resolveu muita coisa quando
[00:32:17] equiparou o sistema
[00:32:19] de módulos, e de import
[00:32:21] e export de módulos, que no Node
[00:32:23] era de um jeito, eu falei
[00:32:25] assim, que não era assim que eu queria dizer
[00:32:27] importação e exportação de módulos
[00:32:29] que no Node era diferente
[00:32:31] de como trabalhar no navegador
[00:32:33] então você vai lá, aprende, import e export
[00:32:35] funcionava super bem, aí no Node
[00:32:37] era diferente, e
[00:32:39] não é só diferença do jeito de escrever
[00:32:41] isso difere na forma
[00:32:43] como o Node usa os arquivos
[00:32:45] então, o lugar onde ele
[00:32:47] guarda essas referências de importação e exportação
[00:32:49] e também na forma como ele
[00:32:51] acessa os módulos do Node era diferente
[00:32:54] não era só a sintaxe, e isso dava
[00:32:56] muito, muito, muito
[00:32:58] problema, quando
[00:32:59] o Node resolveu equiparar
[00:33:01] manteve o antigo, mas resolveu começar a aceitar
[00:33:04] o que era
[00:33:05] nativo do
[00:33:07] navegador, que teoricamente é o
[00:33:09] primeiro, é o certo, entre muitas aspas
[00:33:12] continuou dando problema
[00:33:13] porque as bibliotecas precisavam
[00:33:15] atualizar tudo também, tem biblioteca dando
[00:33:17] problema até hoje
[00:33:19] inclusive uma bem famosa
[00:33:22] mas, pra mim, depois que
[00:33:24] mudou isso aí, já melhorou 500%
[00:33:26] isso, implementando
[00:33:28] o FET, nossa, já deu
[00:33:30] uma bela melhorada, mas deve ter outros casos
[00:33:32] aí que o pessoal lembra
[00:33:33] eu acho que o Node, no geral, ele tá tentando pegar
[00:33:36] a pessoa desenvolvedora aí
[00:33:38] pela mão, né, a Ju já falou ali
[00:33:40] do ASM, né
[00:33:41] que é o, fazer o import e export
[00:33:43] e o Require, que é o comum de AS
[00:33:46] eu acho que se agora
[00:33:47] o negócio tá tão
[00:33:49] sendo mãezona
[00:33:51] que você consegue hoje misturar os dois
[00:33:53] no projeto, assim, né, você consegue
[00:33:55] trabalhar com híbrido e fazer uma migração
[00:33:58] gradual
[00:33:59] mas é o tipo de coisa também que você consegue colocar lá no
[00:34:01] lente e rodar um comando e ele
[00:34:03] troca pra você tudo de Require pra
[00:34:05] ASM ou vice-versa
[00:34:08] ali. Tem uma outra parada também que tá
[00:34:10] agora, que tem suporte nativo
[00:34:12] é o
[00:34:13] a flag de watch, né, pra assistir
[00:34:15] tipo, pra você fazer o hot reload do que você
[00:34:17] tá codando. Antes, de novo,
[00:34:19] você dependia de ter uma lib, tinha gente que usava
[00:34:21] NodeMont, tinha gente que usava não sei o que
[00:34:23] pra você ficar fazendo esse hot reload
[00:34:25] do tipo, alterei a controller ali
[00:34:27] agora ela vai da cambalhota pra trás ou meio pra frente
[00:34:30] e aí eu não quero ficar
[00:34:31] restartando o processo toda vez que isso acontece
[00:34:33] então antes você dependia de uma
[00:34:35] lib pra isso, agora também tem suporte
[00:34:37] lá nativo. Então eu acho que assim, no geral
[00:34:40] tem o URL pattern também, eu já falei
[00:34:42] que era como que você traduzia
[00:34:44] o esquema de URL, também tá
[00:34:46] igual. Então eu acho que assim, acho que
[00:34:47] tá muito…
[00:34:49] tá bem estável. E eu acho que o Node
[00:34:51] tá querendo ficar tão parecido com
[00:34:54] com front-end que agora
[00:34:56] o que tá na moda agora é fazer
[00:34:57] framework de back-end, né. Porque antes
[00:35:00] era Express. Aí virou Express
[00:35:02] e Nest
[00:35:03] aí veio Fastify
[00:35:06] e aí veio
[00:35:07] Coa e aí veio não sei o que. Então eu acho que agora
[00:35:10] tô querendo criar uma pluralidade
[00:35:12] aí de framework no back-end pra poder falar
[00:35:14] que tá igual front mesmo de verdade
[00:35:15] É, a velha história do JavaScript
[00:35:18] é que sai um framework a cada semana
[00:35:20] mas por incrível que pareça, eu na minha vida
[00:35:22] só usei três.
[00:35:23] Não é porque eles saem muito que eles são bons, né.
[00:35:27] Eu ia falar isso
[00:35:28] eu ia falar isso, mas assim, tem muita coisa aí
[00:35:30] que não é muito legal, mas tipo, sai muito
[00:35:32] isso aí é bastante. E é nessa
[00:35:34] popularidade que acho que as linguagens elas ganham
[00:35:36] muita gente, mas onde a gente
[00:35:37] precisa ficar mais atento com qualidade
[00:35:39] daquilo que tá sendo escolhido. E aí pra gente
[00:35:42] entrar nesse último ponto
[00:35:43] o momento de código hoje é um momento
[00:35:46] muito interessante porque a gente tem cada vez
[00:35:48] mais código desenvolvido com auxílio de LLM
[00:35:50] não importa se é copiloto, não importa
[00:35:52] se você tá pedindo pra gerar. O Node
[00:35:54] talvez sofra com que outras
[00:35:56] linguagens sofrem, que é, se você for só
[00:35:58] e pedir pra uma LLM me gerar o código
[00:36:00] essas pequenas diferenças
[00:36:02] de versão, elas acabam
[00:36:04] aparecendo, porque a LLM foi treinada
[00:36:06] numa outra versão, e aí você
[00:36:08] não consegue. Como hoje
[00:36:10] isso está? As LLMs estão cuspindo
[00:36:12] mais código bagunçado
[00:36:13] e que trabalhão ter que dar manutenção
[00:36:16] nisso, era melhor ter feito na mão?
[00:36:17] É melhor usar só como piloto?
[00:36:20] Como que vocês estão sentindo
[00:36:21] Node ao lado dos códigos
[00:36:24] gerados aí por LLM?
[00:36:26] Eu tenho usado bastante o cursor, mas
[00:36:28] no momento, porque eu tô
[00:36:30] mexendo em muito projeto Java, e ele me
[00:36:31] ajuda a entender o que acontece.
[00:36:34] Eu vou falar uma coisa que
[00:36:36] aconteceu
[00:36:37] não comigo, mas num pair que eu estava
[00:36:39] ajudando uma outra pessoa e
[00:36:41] eu impedi a pessoa de fazer
[00:36:43] uma bobagem, que é, a LLM
[00:36:46] por causa da, justamente
[00:36:47] de, às vezes, ser
[00:36:49] treinada em uma outra versão, e a LLM
[00:36:52] não sabe o que ela tá falando,
[00:36:53] ela vai juntando as coisas.
[00:36:55] E um problema é que a gente tem nos repositórios
[00:36:58] de bibliotecas
[00:36:59] e pacotes que o Node usa,
[00:37:02] o principal é o NPM. E o que acontece
[00:37:04] no NPM? Você tem uma biblioteca
[00:37:05] muito boa que você usa, e ela chama
[00:37:08] Banana. Aí alguém coloca
[00:37:10] no NPM uma biblioteca chamada
[00:37:12] Banana
[00:37:13] com dois N’s. E essa biblioteca
[00:37:16] tá lá, só que ela não é a biblioteca que
[00:37:17] você quer. Pô, mas você só sabe o nome.
[00:37:19] Então, o que aconteceu nesse
[00:37:21] pair que eu tava acompanhando? A pessoa tava lá pedindo
[00:37:24] pro Tailwind, não, pro WindSurf
[00:37:26] e o WindSurf tava lá ajudando e eu lendo
[00:37:28] Ah, tá, beleza. E teve uma hora
[00:37:30] que o WindSurf falou assim, ó, pega esse
[00:37:31] comando aqui e joga no seu terminal e
[00:37:33] executa pra ele instalar essa biblioteca.
[00:37:36] E a pessoa foi copiar e quando eu
[00:37:37] falei, para, não faz isso.
[00:37:40] Vai lá no NPM
[00:37:41] na página deles, confere
[00:37:44] se a biblioteca que você quer é essa
[00:37:46] mesma, e não era. Era uma outra,
[00:37:47] outra com o nome igual. Ou, às vezes
[00:37:49] uma tem hífen, outra não tem hífen.
[00:37:51] E, cara, era uma biblioteca que não
[00:37:53] fazia nada, era uma bobagem. Mas, nessa
[00:37:55] você instala um negócio aleatório
[00:37:57] no seu
[00:37:58] programa. Porque você foi
[00:38:01] copiando e colando e não dá pra fazer
[00:38:03] isso. Você tem que olhar todos os comandos
[00:38:05] que ela te passa. Então, mesmo quando
[00:38:07] eu tô no cursor, eu não deixo ele fazer nada
[00:38:10] automático. Eu olho todos
[00:38:11] os comandos, eu rodo todos os comandos
[00:38:13] na mão. E, no caso, quando
[00:38:15] a ULLM te fala
[00:38:17] pra você, ó, instala essa biblioteca aqui,
[00:38:20] não instala de cara. Vai
[00:38:22] no NPM, confere se é
[00:38:23] realmente o que você quer. Porque
[00:38:25] acontece mesmo. E já aconteceu muito também
[00:38:27] do código
[00:38:29] sugerir, por exemplo,
[00:38:31] Breaking Change. Então, você tava usando a versão
[00:38:33] mais nova de uma biblioteca, uma versão, sei lá,
[00:38:36] 2.lalala de uma biblioteca
[00:38:38] e ele te sugere de uma anterior
[00:38:40] que o método já não é aquele.
[00:38:41] E você vai lá, coloca no seu código,
[00:38:44] parece certo, mas não roda.
[00:38:46] Porque a versão tá errada.
[00:38:47] E esse tipo de detalhe, você acaba tendo
[00:38:49] que ficar olhando, olhando, olhando toda hora.
[00:38:52] Faz parte, ajuda a escrever
[00:38:53] bastante. Mas, gente,
[00:38:56] por favor, tomem cuidado com o que
[00:38:57] vocês vão instalar, com o que
[00:38:59] os seus assistentes
[00:39:01] virtuais, pra usar uma gíria
[00:39:03] dos anos 90, eles estão te passando.
[00:39:06] Caraca, Ju, mas é muito importante isso que você
[00:39:07] falou, antes de deixar a Moni e o Vini
[00:39:09] compartilharem aí como tem sido a experiência
[00:39:11] deles com o Node e com
[00:39:13] LLMs, em termos de qualidade de código.
[00:39:16] É muito importante você ter,
[00:39:17] tocado nesse ponto, porque
[00:39:19] é uma nova realidade
[00:39:22] com a qual todas vamos
[00:39:23] conviver. E aí a gente tá fazendo um programa
[00:39:26] sobre Node.js, falando
[00:39:27] de novidades, atualização. Por quê?
[00:39:30] Justamente pra você,
[00:39:31] ouvinte, ter esse hábito de se acostumar
[00:39:34] a acompanhar a tecnologia que você tá
[00:39:35] usando, de uma versão pra outra,
[00:39:37] ler change log, entender o que mudou,
[00:39:40] saber onde tá a documentação.
[00:39:41] É isso que vai diferenciar a pessoa
[00:39:43] que tá indo lá na LLM, pedindo um código
[00:39:45] inteiro pronto e não sabe o que tá funcionando.
[00:39:47] De você, que às vezes vai ser
[00:39:49] justamente quem vai revisar, vai ser o líder de um
[00:39:51] projeto que vai falar, gente, segura
[00:39:53] a onda, que aqui a gente perdeu a mão.
[00:39:55] Mas, tô aqui contaminando os outros
[00:39:57] com as minhas opiniões também, né?
[00:39:59] Moni, como tem sido a sua experiência?
[00:40:01] Tem recebido código de qualidade das LLMs
[00:40:03] aí quando o assunto é Node? Ou
[00:40:05] também sempre com esse pé atrás?
[00:40:07] Uma coisa que ajude o setor do cursor, eu também uso
[00:40:09] o cursor, e aqui a gente fez
[00:40:11] algumas configurações nele pra dizer
[00:40:13] o que a gente usa, como a gente usa, dando
[00:40:15] algum contexto. Então,
[00:40:17] cara, tá muito bom, tá difícil
[00:40:19] ele errar, dar alguma diferença,
[00:40:21] assim como a Ju falou, por conta
[00:40:23] desse contexto que a gente colocou.
[00:40:25] Então, basicamente, você…
[00:40:28] A gente colocou essa configuração,
[00:40:29] baixou o projeto, já baixa essa configuração
[00:40:31] junto, e aí tá ajudando
[00:40:33] bastante, pelo menos aqui, o pessoal
[00:40:35] do trabalho. É engraçado a Ju falar
[00:40:37] lá do nome errado de biblioteca,
[00:40:40] que eu fiz uma live pra turma
[00:40:41] de front-end da
[00:40:43] Olho Jabá e Espontâneo.
[00:40:45] Pra galera que tá fazendo apostec
[00:40:47] de front-end, né? E aí,
[00:40:49] essa parada tem um nome, que chama
[00:40:51] TypoSquatting, que é
[00:40:53] literalmente você criar uma biblioteca
[00:40:55] com Typo. Então, você imagina React,
[00:40:58] que é R-E-A-C,
[00:40:59] né? E aí, a pessoa vai lá e troca
[00:41:01] o C pelo T, ou A pelo Q,
[00:41:03] e aí, se você der um
[00:41:06] Typo desse daí, já
[00:41:07] era, né? Pro seu lado.
[00:41:09] Mas, assim, eu acho que… Eu vou fazer um pouco
[00:41:11] do combo do que as duas falaram,
[00:41:13] porque aqui eu também tô usando o cursor hoje,
[00:41:16] e o que salva,
[00:41:17] são as rules, as regras que você consegue
[00:41:19] definir, e aí você consegue fazer
[00:41:21] rules pro projeto, tem boas práticas,
[00:41:24] tem um diretório do próprio cursor
[00:41:26] que você tem… A galera
[00:41:27] faz as rules e
[00:41:29] compartilha e tal, isso é muito legal.
[00:41:32] Agora, um cuidado que tem que ter…
[00:41:33] Ah, eu acho que não é específico de Node, é qualquer coisa
[00:41:35] que você instala, dependência,
[00:41:38] que é… Qual que é o padrão
[00:41:40] que, às vezes, ele usa? Você fala assim,
[00:41:41] olha, você pede direitinho o que você
[00:41:44] quer. Ah, eu quero uma API,
[00:41:46] REST,
[00:41:47] com CRUD de produtos, usando
[00:41:49] Express, por exemplo.
[00:41:52] E aí, às vezes,
[00:41:53] se você não tem isso definido, ao invés
[00:41:56] de fazer o que a gente faria, que é
[00:41:57] npm install express, e aí ele vai
[00:42:00] pegar por padrão a última, ele vai
[00:42:02] lá no package.json, mete uma versão do
[00:42:03] Express específica lá, e depois
[00:42:06] faz o npm install, né? Aí você tem
[00:42:08] que ficar… Então, se você tá
[00:42:09] usando essas rules, e aí isso vai variar
[00:42:12] da ferramenta que você tá usando,
[00:42:14] todas têm esse conceito.
[00:42:16] Tô falando do cursor que é o
[00:42:17] mais uso, mas todas têm esse
[00:42:19] mesmo conceito. Que, basicamente, é você definir um
[00:42:21] prompt universal, que vai estar sempre lá
[00:42:24] gastando dinheiro, né? Porque é isso
[00:42:25] que o prompt faz, né? Gastar dinheiro. Mas ele
[00:42:27] ajuda você a errar menos.
[00:42:29] Então, vale a pena definir tudo lá direitinho.
[00:42:32] E, no final das contas,
[00:42:33] vou usar a carta do depend, porque depend
[00:42:35] diz como que você pede. Se você pedir
[00:42:37] direitinho, ele tende a
[00:42:39] fazer direitinho.
[00:42:41] Isso não muda o medo que vocês colocaram, que fez todo mundo
[00:42:43] que tá na frente do computador agora, ir lá no
[00:42:45] terminal, começar a apertar a setinha pra
[00:42:47] cima, pra ver as últimas instalações
[00:42:49] que fez, pra ver se não andou
[00:42:51] instalando algum pacote maluco.
[00:42:53] Galera, eu queria agradecer
[00:42:55] demais vocês por esse papo,
[00:42:57] e pra gente fazer só a rodada final, que acho que
[00:42:59] vale a pena. Cês têm dicas,
[00:43:01] se não tiverem, tudo bem, mas cês têm dicas de
[00:43:03] materiais, comunidades,
[00:43:05] coisas legais de Node, pra galera que tá
[00:43:07] ouvindo, quem sabe, ficar mais perto
[00:43:09] dessa linguagem, ou começar a codar
[00:43:11] nela, já que é uma linguagem que é
[00:43:13] tão poderosa, assim, justamente
[00:43:15] pela quantidade de pessoas que usa,
[00:43:17] o que que cês indicariam, se tivesse que dar
[00:43:19] uma única dica pros nossos ouvintes?
[00:43:21] Fazer aquele jabá involuntário?
[00:43:23] Tem o Carreira de Backend Node.js, tá a lura, ó!
[00:43:27] É, tem, hein? Tem, bom, enfim.
[00:43:30] Já que a Moni já
[00:43:31] colocou o jabá, a documentação
[00:43:33] do Node, ela é um pouco
[00:43:35] esquisita, de começo,
[00:43:37] eu acho, assim, na minha opinião
[00:43:39] ela é meio estranha, ela não é a mais,
[00:43:41] uma das mais amigáveis, mas
[00:43:43] eu acho que
[00:43:45] depois que você aprende a fazer o crew de base,
[00:43:47] já começa um TypeScript, se você
[00:43:49] puder, porque vai fazer muita diferença, você não vai ter
[00:43:51] as duas… Ah, aprender JavaScript e depois
[00:43:53] colocar o TypeScript em cima. É, depois que você
[00:43:55] faz o crew de básico, é legal você dar um passo pra trás
[00:43:57] pra entender isso que o Vini falou lá atrás,
[00:43:59] que é o paradigma que o…
[00:44:01] meio um paradigma, né? É a escolha de
[00:44:03] arquitetura que a V8 usa,
[00:44:05] que é voltada a eventos,
[00:44:08] que é um pouco específica,
[00:44:09] um pouco diferente, e aí entender como
[00:44:11] o loop de eventos funciona, porque
[00:44:13] à medida que você aumenta a complexidade
[00:44:15] dos projetos, que você trabalha com
[00:44:17] o Node, a entender
[00:44:19] como o loop de eventos funciona,
[00:44:21] e como a sincronicidade funciona
[00:44:23] no Node, faz bastante diferença.
[00:44:25] Então, eu iria por aí. Pega lá
[00:44:27] os projetinhos mais básicos, depois volta
[00:44:29] pra estudar um pouquinho
[00:44:31] sobre o loop de eventos
[00:44:33] e a arquitetura do Node
[00:44:35] por trás, por baixo dos panos,
[00:44:37] baixo dos panos? Fiquei confusa agora qual
[00:44:39] que é o certo, mas acho que vale a pena fazer isso.
[00:44:41] Pô, duas dicas valiosíssimas,
[00:44:43] ficou ruim pra você agora, hein, Vini?
[00:44:45] A Moni já mandou nosso momento jabá
[00:44:47] absurdo, maravilhoso, assina embaixo.
[00:44:50] A Ju já deu uma dica
[00:44:51] fantástica de dar um passo pra trás.
[00:44:53] Meu filho, agora a bomba
[00:44:55] tá com você. Rapaz, agora eu vou ativar
[00:44:57] minha carta que estava em modo de defesa
[00:44:59] aqui, né, minha carta armadilha,
[00:45:01] tal como o Yu-Gi-Oh! faria.
[00:45:03] Então, eu tenho quatro coisas aqui
[00:45:05] pra trazer de dicas.
[00:45:07] São três muito tech. Então,
[00:45:09] é o seguinte, a gente já falou do nosso
[00:45:11] bingo do Event Loop. Então, assim,
[00:45:13] se você quer aprender como o Node funciona,
[00:45:15] você precisa entender qual
[00:45:17] é óbvio, a sintaxe é o pré-requisito.
[00:45:19] Então, tem que saber JavaScript, TypeScript,
[00:45:21] não tem pra onde correr, mas
[00:45:23] o paradigma dele é diferente. A ideia
[00:45:25] do Event Loop, né, pra quem
[00:45:27] não, assim,
[00:45:29] sem entrar muito aqui na escovação de bit,
[00:45:31] é uma única thread rodando
[00:45:33] o processo do Node
[00:45:35] e os processos não são blocantes,
[00:45:37] certo? Ele não bloqueia
[00:45:39] o processo, dependendo do que está acontecendo.
[00:45:42] Então, por isso que é uma coisa orientada
[00:45:43] a eventos, então tem que entender isso.
[00:45:45] Né, e aí isso já
[00:45:47] já linka uma, já linka
[00:45:49] um na outra, é justamente a ideia do
[00:45:51] non-blocking. O que que eu quero dizer?
[00:45:52] O I.O.A. entrar, o input, output, ele não
[00:45:55] fica travado, dependendo do que está
[00:45:57] acontecendo. Isso pode
[00:45:59] fazer que coisas aconteçam
[00:46:01] de uma forma que você não estava esperando,
[00:46:04] por você não saber que é
[00:46:05] assim que funciona. Então, já comba
[00:46:07] lá um com dois, que é o Event Loop
[00:46:09] e o non-blocking I.O.A. Tem que entender
[00:46:11] como que isso funciona.
[00:46:12] Ainda mais quando a coisa escala, a gente vai fazendo
[00:46:14] backends mais complexos, a gente pode
[00:46:16] gerar um bug sem querer. A última
[00:46:18] coisa também, pra fechar o nosso bingo, a gente já
[00:46:20] falou, que é como que funciona o sistema de
[00:46:22] módulo do Node. Então, tem que saber
[00:46:24] como que funciona o CommonJS,
[00:46:27] que é o Require, e o ESM, que é
[00:46:28] o de módulos, né?
[00:46:30] Então, ESModules. Então, tem
[00:46:32] que saber como é que isso daí funciona.
[00:46:35] E a minha última dica, eu vou fazer
[00:46:37] eco do que a Mônica trouxe pra gente, que é
[00:46:38] obviamente a carreira de Node
[00:46:40] da Alura, né? Como eu tenho uma carreira
[00:46:43] fusta aqui há muito tempo, vou dar um
[00:46:44] mega spoiler aqui em primeira mão. Eu estou
[00:46:46] trabalhando num curso agora, por exemplo,
[00:46:48] de serverless com Node, né?
[00:46:51] Que é, inclusive, fica aí,
[00:46:52] a gente tem que fazer um episódio só de serverless, André.
[00:46:54] Fica aí na pauta. Já saiu
[00:46:57] mais um já. É.
[00:46:58] Porque, assim, a ideia é como é que a gente
[00:47:00] faz, como é que a gente usa Node
[00:47:02] no mundo de serverless, né? Que não
[00:47:04] é um mundo sem servidor, bem que poderia ir.
[00:47:07] Mas aí, isso tá lá
[00:47:08] na carreira Node. Então, é
[00:47:10] uma carreira que tá muito legal, que ela foi pensada
[00:47:13] pra te guiar pelo caminho,
[00:47:15] né? Então, ela tem os níveis de acordo
[00:47:16] com o seu momento iniciante,
[00:47:19] intermediário e mais avançado.
[00:47:21] Então, tem muito conteúdo
[00:47:23] legal lá e com uma curva de aprendizado
[00:47:25] muito bacana também. Então,
[00:47:27] acho que isso aí fecha as minhas
[00:47:29] quatro dicas que eu tinha pra te dar.
[00:47:31] Dicas muito boas, além de todo o papo
[00:47:33] que foi muito bom, por isso que eu queria agradecer demais
[00:47:35] o Vini, a Moni,
[00:47:37] a Ju, por terem estado aqui e trocado
[00:47:39] essa ideia com a gente e me ajudado,
[00:47:41] te ajudado a entender um pouquinho mais sobre o Node.
[00:47:43] Faz o seguinte, tem alguma
[00:47:45] dúvida, assim, uma
[00:47:46] dúvida que você tem sobre o Node.js
[00:47:48] e não consegue tirar de jeito nenhum? Deixa aqui
[00:47:50] nos comentários. Vamos fazer esse teste.
[00:47:53] Vamos ver se a gente consegue pegar a sua dúvida
[00:47:54] e trazer na edição do próximo episódio
[00:47:57] o Marcos coloca a nossa
[00:47:59] resposta. Além disso, vem cá
[00:48:01] e avalia o Hipsters no Spotify
[00:48:02] e também, é claro, recomenda
[00:48:04] pra um amigo ou uma amiga que possam se interessar.
[00:48:07] A gente se vê na próxima
[00:48:09] semana. Até mais.
[00:48:13] Pessoal, chegou aquela época
[00:48:15] do ano que muitas
[00:48:16] gente espera, que é a época
[00:48:18] da promoção de Black November
[00:48:20] da Alura, que tá dando até
[00:48:22] 50%
[00:48:24] de desconto pra você tirar de vez
[00:48:27] do papel ainda nesse ano
[00:48:29] o plano de mergulhar,
[00:48:32] se aprofundar na sua
[00:48:33] carreira. Então passa aqui na descrição
[00:48:35] do episódio, não perca
[00:48:36] a maior black de todas, tão grande
[00:48:38] que quase não cabe na tela. Quem entrar no site
[00:48:40] galura.com.br vai
[00:48:42] entender do que eu tô falando. Se matricula
[00:48:45] hoje mesmo.
[00:48:46] Não perde, não deixa pra depois
[00:48:48] a Black November da Alura
[00:48:50] com até 50% de desconto.
[00:48:53] A gente espera por você.
[00:49:16] Um abraço e até a próxima semana.