<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Ricardo Mello</title><description>Ricardo Mello, engenheiro full-stack sênior em Cabo Frio, RJ. Escrevo sobre web, JavaScript, cloud e AI.</description><link>https://ricmello.com/</link><language>pt-BR</language><item><title>Você não precisa de superpoderes. Precisa de contexto.</title><link>https://ricmello.com/posts/voce-nao-precisa-de-superpoderes/</link><guid isPermaLink="true">https://ricmello.com/posts/voce-nao-precisa-de-superpoderes/</guid><description>Plugins de agentes prometem um processo mágico. Nos meus números, o que funciona é o setup montado em cima do jeito que eu já trabalho.</description><pubDate>Sun, 15 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Toda tecnologia nova traz junto um pacote de metodologias prontas prometendo te ensinar a usá-la do jeito certo. Não seria diferente com os agentes de IA.&lt;/p&gt;
&lt;p&gt;Basta abrir o LinkedIn pra ver alguém instalando um plugin aleatório que promete transformar o Claude Code num time inteiro de engenheiros. Brainstorm, SDD, TDD, subagente revisando subagente. E aí a pessoa muda a forma que trabalha há vinte anos pra caber dentro do fluxo do plugin.&lt;/p&gt;
&lt;p&gt;Isso funciona com muitas pessoas? Sim, mas se você é um dev experiente, você já acumulou uma bagagem absurda que pode e deve ser amplificada com os agentes ao invés de recomeçar do zero.&lt;/p&gt;
&lt;p&gt;E só um disclaimer aqui: eu sou contra a síndrome de gabriela, por favor não me entenda mal. O ponto é que na nossa área surgem tantas coisas novas todos os dias, que é importante saber diferenciar hype de tendência, e isso tem se tornado mais difícil a cada dia.&lt;/p&gt;
&lt;p&gt;Eu também instalei. Usei o &lt;a href=&quot;https://github.com/obra/superpowers&quot;&gt;superpowers&lt;/a&gt; por meses, testei as &lt;a href=&quot;https://github.com/mattpocock/skills&quot;&gt;skills do Matt Pocock&lt;/a&gt;, e continuo com os dois instalados. Mas percebi uma coisa olhando os meus próprios logs: eles quase não são usados. E não foi porque eu desativei.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;“é importante saber diferenciar hype de tendência, e isso tem se tornado mais difícil a cada dia.”&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&quot;o-que-esses-plugins-fazem&quot;&gt;O que esses plugins fazem&lt;/h2&gt;
&lt;p&gt;Sendo justo: os plugins são muito bons. O superpowers é bem pensado, e várias das skills dele são exatamente o que um dev sênior faz no automático: entender o problema antes de sair codando, escrever um plano, rodar os testes antes de dizer que terminou, não aceitar code review sem questionar, e por aí vai.&lt;/p&gt;
&lt;p&gt;Esse é justamente o ponto. &lt;strong&gt;É processo.&lt;/strong&gt; E processo genérico, que serve pra qualquer projeto, em qualquer stack, pra qualquer pessoa. É o feijão com arroz.&lt;/p&gt;
&lt;h2 id=&quot;o-que-o-meu-setup-faz&quot;&gt;O que o meu setup faz&lt;/h2&gt;
&lt;p&gt;O meu setup é menos glamouroso. Em cada projeto eu tenho um repositório que eu chamo de &lt;code&gt;bridge&lt;/code&gt;, que fica do lado dos repositórios do projeto.&lt;/p&gt;
&lt;p&gt;O nome bridge vem da ponte de comando do navio, onde o capitão e a equipe comandam a navegação. Pra um setup com múltiplos projetos (front-end, backend, infra, mobile, data…), é muito importante conseguir navegar entre eles e criar features de ponta a ponta. Podem me chamar de narcisista, mas eu sou o capitão e gerencio o meu projeto da minha ponte de comando.&lt;/p&gt;
&lt;p&gt;Ela carrega:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;um &lt;code&gt;CLAUDE.md&lt;/code&gt; com o que só aquele workspace sabe: o que é cada repo e qual agente cuida dele, qual a branch padrão dos PRs em cada um, a ordem quando uma feature cruza repos (a API vem primeiro), onde ficam as anotações de cada ticket;&lt;/li&gt;
&lt;li&gt;um agente por stack (Angular, Flutter, Laravel, Spring Boot…), cada um conhecendo as convenções e as armadilhas daquele projeto;&lt;/li&gt;
&lt;li&gt;skills pro meu fluxo de trabalho: pegar ticket do Jira, abrir ou revisar PR no GitHub/Bitbucket, consultar o banco de dev, ler logs, iniciar a stack inteira, ou escrever descrição de PR de um jeito que o time leia;&lt;/li&gt;
&lt;li&gt;hooks pra garantir os padrões e a segurança, como bloquear qualquer comando que tente ler o &lt;code&gt;.env&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Nada disso é genial. São coisas que eu já fazia na mão e cansei de explicar pro agente toda sessão.&lt;/p&gt;
&lt;p&gt;E tem uma regra master que segura tudo isso de pé: &lt;strong&gt;defer, don’t duplicate&lt;/strong&gt;. Cada repositório já tem o próprio &lt;code&gt;CLAUDE.md&lt;/code&gt; com a stack, as convenções, os comandos de lint e teste. A bridge não copia nada disso. Ela sabe pra onde mandar cada tarefa, e o agente daquele repo lê as regras específicas dele antes de mexer em qualquer coisa. Importante: o Claude Code não carrega sozinho o &lt;code&gt;CLAUDE.md&lt;/code&gt; de um repositório vizinho, então essa leitura precisa estar explícita no agente.&lt;/p&gt;
&lt;p&gt;Segue uma lista de exemplos do mundo real:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Investigar um bug no backend, debugar a API, entender que ele era um problema no ETL, e abrir um PR pro repositório de data;&lt;/li&gt;
&lt;li&gt;Implementar uma nova tela no front-end (Angular) e no app (Flutter), além de identificar um bug no endpoint que havia sido desenvolvido por outro time, subindo um PR pra correção;&lt;/li&gt;
&lt;li&gt;Planejar, desenvolver, e testar um CRUD com front-end (React) e back-end (Java) com direito a gravação de evidência.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A ideia é sempre usar agentes específicos pra cada repo, e deixar eles trabalharem enquanto você direciona o navio.&lt;/p&gt;
&lt;h2 id=&quot;os-números&quot;&gt;Os números&lt;/h2&gt;
&lt;p&gt;Fui contar nos transcripts do Claude Code de um projeto de cliente, que somam umas 270 sessões nas últimas semanas.&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Skills invocadas&lt;/th&gt;
&lt;th&gt;Vezes&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;As minhas (PR no Bitbucket, Jira, descrição de PR, consulta no banco, subir o backend local, review…)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;226&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;As do superpowers (brainstorming, writing-plans, subagent-driven-development…)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;19&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;Com os subagentes foi a mesma coisa: o agente de Spring Boot foi chamado 78 vezes, o de code review 41 e o de frontend 40.&lt;/p&gt;
&lt;p&gt;E sim, esse número é enviesado. O superpowers dispara pouco porque os meus agentes e skills ganham na hora em que o modelo escolhe o que usar. Não é prova de que o plugin é ruim. É sinal de que, quando existe uma opção específica, o modelo prefere ela. Eu também.&lt;/p&gt;
&lt;h2 id=&quot;processo-vs-contexto&quot;&gt;Processo vs. contexto&lt;/h2&gt;
&lt;p&gt;O que uma skill agrega é proporcional ao que ela ensina de novo pro modelo.&lt;/p&gt;
&lt;p&gt;O Claude sabe fazer TDD. Sabe escrever um plano e sabe fazer brainstorm. Ele leu mais livro de engenharia de software do que eu e você juntos. Uma skill que ensina isso pra ele tá ensinando o que ele já sabe.&lt;/p&gt;
&lt;p&gt;Agora, o Claude não sabe que o PR da API vai pra &lt;code&gt;dev&lt;/code&gt; e não pra &lt;code&gt;main&lt;/code&gt;. Ele não sabe que o Karma do projeto Angular tá quebrado e que só o build de produção pega erro de template. Também não sabe que a homologação tem um banco por cliente, nem que o time não lê descrição de PR com mais de 20 linhas.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Processo é commodity. Contexto não é.&lt;/strong&gt; É a mesma ideia do &lt;a href=&quot;https://ricmello.com/posts/o-codigo-nao-se-tornou-commodity-apos-a-ai/&quot;&gt;meu último post&lt;/a&gt;: o que tem valor nunca foi a parte genérica.&lt;/p&gt;
&lt;h2 id=&quot;o-custo-que-ninguém-mostra&quot;&gt;O custo que ninguém mostra&lt;/h2&gt;
&lt;p&gt;Plugin de processo não é de graça. A minha bridge também carrega contexto em toda sessão, mas é contexto do meu projeto. O superpowers injeta no início de &lt;strong&gt;toda&lt;/strong&gt; sessão um bloco com essa pérola:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Tudo em caixa alta, competindo com as regras do meu &lt;code&gt;CLAUDE.md&lt;/code&gt;. Quando eu perguntei pro Claude se valia escrever esse artigo, a regra do plugin mandava ele abrir uma sessão de brainstorming antes de responder. Era só uma pergunta.&lt;/p&gt;
&lt;p&gt;E o custo não é só desse plugin. Quando fui medir, das 40 skills que eu adicionei às minhas sessões, 23 não foram usadas nenhuma vez em cinco semanas, e 21 delas vinham de plugins. Mesmo assim, todas vão junto no catálogo de toda requisição.&lt;/p&gt;
&lt;p&gt;E tem o lixo que fica pra trás. O fluxo de subagentes do superpowers grava briefs e relatórios numa pasta &lt;code&gt;.superpowers/&lt;/code&gt; que o git ignora e ninguém limpa. Numa feature nova, essa pasta ainda tinha os relatórios de uma feature já entregue. O meu agente de Spring Boot achou aquilo, percebeu que não batia com o histórico do git, e gravou sozinho uma memória dizendo pra si mesmo, em resumo: &lt;em&gt;“não confie nesse diretório, confie no git”&lt;/em&gt;.&lt;/p&gt;
&lt;p&gt;Ou seja, o plugin criou um estado que o meu agente precisou aprender a ignorar.&lt;/p&gt;
&lt;h2 id=&quot;então-eu-não-devo-usar-depende&quot;&gt;Então eu não devo usar? Depende.&lt;/h2&gt;
&lt;p&gt;Já falei aqui antes que dev é pago pra dizer “depende”. Então:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Se você tá começando com agentes&lt;/strong&gt;, um plugin de processo te dá um ponto de partida decente. Muito melhor que nada.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Se você quer ideias&lt;/strong&gt;, leia skills. O &lt;code&gt;verification-before-completion&lt;/code&gt; do superpowers é basicamente a regra que eu tenho no meu &lt;code&gt;CLAUDE.md&lt;/code&gt; de não dizer que os testes passaram sem mostrar o output. Copie a ideia e adapte pro seu contexto.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Se a skill só roda quando você chama&lt;/strong&gt;, ótimo. O &lt;code&gt;grilling&lt;/code&gt; do Matt Pocock, que te enche de perguntas até o plano fazer sentido, é ótimo quando eu peço. Ferramenta é isso.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;O problema começa quando o plugin decide sozinho quando entrar em ação e quer ditar o seu fluxo. Aí ele deixou de ser ferramenta e virou teu chefe.&lt;/p&gt;
&lt;h2 id=&quot;como-montar-o-seu&quot;&gt;Como montar o seu&lt;/h2&gt;
&lt;p&gt;Eu não segui nenhum framework. O setup foi crescendo a partir da fricção:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Digitei o mesmo comando duas vezes?&lt;/strong&gt; Vira script. E vale pro agente também: o meu &lt;code&gt;CLAUDE.md&lt;/code&gt; diz que, se ele digitar o mesmo comando duas vezes numa sessão, é hora de virar script.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Expliquei a mesma coisa pro agente duas vezes?&lt;/strong&gt; Vira regra no &lt;code&gt;CLAUDE.md&lt;/code&gt; do repo.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Corrigi o agente?&lt;/strong&gt; Vira memória, com o &lt;em&gt;porquê&lt;/em&gt; junto.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Um fluxo tem mais de três passos e se repete toda semana?&lt;/strong&gt; Vira skill ou comando.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;O repo tem convenções densas?&lt;/strong&gt; Ganha um agente próprio, que lê as regras daquele repo antes de mexer.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Comece pequeno: um &lt;code&gt;CLAUDE.md&lt;/code&gt; que diga o que é cada repo e pra qual branch vai o PR de cada um, e um hook bloqueando o &lt;code&gt;.env&lt;/code&gt;. O que é regra de cada repo fica no &lt;code&gt;CLAUDE.md&lt;/code&gt; daquele repo. O resto aparece sozinho.&lt;/p&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Não vou te prometer que isso deixa você 100x mais produtivo. Deixo essa pros vendedores de curso. O que eu posso dizer é que o setup que funciona pra mim é o meu jeito de trabalhar transformado em código, e não um jeito novo de trabalhar que alguém empacotou num plugin.&lt;/p&gt;
&lt;p&gt;Ferramenta boa se adapta a você. Quando é você que tá se adaptando à ferramenta, vale parar e se perguntar quem tá trabalhando pra quem.&lt;/p&gt;
&lt;p&gt;Você não precisa de superpoderes. Precisa de contexto, e isso você já tem: são os seus anos de projeto. O navio é seu. Não entregue o leme de bandeja. Até mais!&lt;/p&gt;</content:encoded><category>ai</category><category>ferramentas</category></item><item><title>O código não se tornou commodity após a AI. Ele sempre foi</title><link>https://ricmello.com/posts/o-codigo-nao-se-tornou-commodity-apos-a-ai/</link><guid isPermaLink="true">https://ricmello.com/posts/o-codigo-nao-se-tornou-commodity-apos-a-ai/</guid><description>Código sempre foi commodity. De Delphi ao low-code, toda ferramenta prometeu substituir um time inteiro. O que a AI barateou e o que continua valendo ouro.</description><pubDate>Tue, 24 Feb 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Recentemente eu li algumas notícias apocalípticas sobre a profissão de desenvolvimento após o advento da AI, como &lt;a href=&quot;https://medium.com/chris-messina/code-as-commodity-b9b7492dc4eb&quot;&gt;esse post&lt;/a&gt; do Chris Messina dizendo que código se tornou uma commodity, ou o CEO da Microsoft AI dizendo &lt;a href=&quot;https://fortune.com/2026/02/13/when-will-ai-kill-white-collar-office-jobs-18-months-microsoft-mustafa-suleyman&quot;&gt;nesse artigo da Fortune&lt;/a&gt; que dá 18 meses pra automatizar todas as profissões de colarinho branco, incluindo a nossa.&lt;/p&gt;
&lt;p&gt;Não adianta, basta surgir uma tecnologia disruptiva que os profetas do apocalipse e a galera do hype surgem em pé de guerra. Na prática, toda ferramenta que reduz fricção na criação de software gera um certo pânico no mercado, mas depois vira uma infraestrutura invisível.&lt;/p&gt;
&lt;p&gt;O mercado de tecnologia é feito de ciclos, e quem tá nessa há mais tempo sabe bem do que eu estou falando. Delphi, Visual Basic, Dreamweaver, WordPress, low-code, no-code… Todos eles prometeram a mesma coisa: &lt;strong&gt;permitir que um único desenvolvedor faça o trabalho de um time inteiro&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;E aqui estamos, 20 anos depois, ouvindo a mesma história de novo.&lt;/p&gt;
&lt;h2 id=&quot;a-commodity-código&quot;&gt;A commodity código&lt;/h2&gt;
&lt;p&gt;Um dos exemplos mais conhecidos sobre comoditização é o sal, que era considerado um artigo precioso, causou guerras e ergueu impérios, mas hoje é baratinho no mercado e qualquer um pode comprar.&lt;/p&gt;
&lt;p&gt;O sal se tornou barato, mas cozinhar não se tornou uma commodity. A skill de saber o que fazer com os ingredientes é o que realmente importa.&lt;/p&gt;
&lt;p&gt;O código sempre foi algo básico. Qualquer aluno de primeiro período de faculdade ou de curso técnico consegue criar instruções básicas, rodar um algoritmo e criar um software pequeno. Eu programava desde os treze anos de idade, enquanto meu irmão mais novo o faz desde os oito.&lt;/p&gt;
&lt;p&gt;Engenheiros, por exemplo, já usam o tal “disposable software” há muito tempo, criando algoritmos pra resolver cálculos quando o matlab não consegue. Pessoas criavam sistemas inteiros na década de 90 usando MS Access, Delphi, VB e similares.&lt;/p&gt;
&lt;p&gt;O que mudou de lá pra cá foi que software se tornou algo muito complexo, e na maioria das vezes um complexo totalmente desnecessário.&lt;/p&gt;
&lt;p&gt;O que a IA realmente reduziu foi o custo da produção de código sintático, como boilerplates. O custo de decisão arquitetural continua o mesmo, senão maior.&lt;/p&gt;
&lt;h2 id=&quot;os-vendedores-de-complexidade&quot;&gt;Os vendedores de complexidade&lt;/h2&gt;
&lt;p&gt;Eu nunca escrevi aplicações em Ruby, mas tive que ver &lt;a href=&quot;https://www.youtube.com/watch?v=gcwzWzC7gUA&quot;&gt;esse keynote&lt;/a&gt; do DHH na RubyConf onde ele mencionou um termo que eu achei sensacional: “merchants of complexity”.&lt;/p&gt;
&lt;p&gt;Desenvolver código se tornou algo muito complicado e a culpa também é nossa. Muitas empresas acham que precisam separar frontend e backend porque todo mundo tá fazendo e elas não querem ficar pra trás. Isso faz algumas empresas precisarem de um arquiteto, 2 devs backend, 1 dev frontend, DevOps, dois ciclos de QA, PM, entre outros, pra subir uma tela de login básica em 3 meses pra um volume ridículo de usuários.&lt;/p&gt;
&lt;p&gt;Se os LLMs vão mudar isso? Com certeza vão, mas não é o fim do mundo.&lt;/p&gt;
&lt;p&gt;As mesmas empresas que criaram essa complexidade desnecessária agora estão vendendo a solução. Enquanto o Suleyman disse que vai automatizar tudo em um ano e meio, o mesmo artigo da Fortune traz um estudo da METR que diz que a AI está causando o efeito contrário e deixando os devs 20% mais lentos. Na prática são executivos vendendo um produto. A Borland fez isso com o Delphi, enquanto a Microsoft fez a mesma coisa com o VB.&lt;/p&gt;
&lt;h2 id=&quot;o-que-não-é-commodity&quot;&gt;O que não é commodity&lt;/h2&gt;
&lt;p&gt;Se código sempre foi commodity, o que não é commodity de fato?&lt;/p&gt;
&lt;p&gt;Saber &lt;strong&gt;o que fazer&lt;/strong&gt;, &lt;strong&gt;por que fazer&lt;/strong&gt;, e como fazer isso &lt;strong&gt;sobreviver em produção no longo prazo&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;A AI pode criar o melhor código pra uma situação, quando na verdade a decisão deveria ter sido remover aquele código, ou em outro cenário ela pode criar uma implementação redundante que vai causar gargalos de desempenho em produção.&lt;/p&gt;
&lt;p&gt;Mesmo um dev sênior usando AI precisa de julgamento técnico pra tomar as decisões certas. Ela não conhece todas as suas regras de negócio, seus SLAs, ou por que aquele “refactoring bobo” vai quebrar três outros serviços. Nunca foi sobre code vs no-code, mas ser um dev ou um mero digitador.&lt;/p&gt;
&lt;h2 id=&quot;um-novo-ciclo&quot;&gt;Um novo ciclo&lt;/h2&gt;
&lt;p&gt;Devs generalistas vão ascender e ter novamente a possibilidade de criar software em escala para problemas reais, enquanto devs backend que não fazem a mínima ideia de como funciona a aplicação pra qual eles criam APIs, ou devs frontend que não sabem o básico de como o backend funciona vão perder espaço. Um dev fullstack usando Claude Code ou Cursor consegue prototipar em dias (ou horas) o que antes precisava de um squad inteiro durante semanas.&lt;/p&gt;
&lt;p&gt;Eu enxergo essas mudanças como o início de um novo ciclo, onde saber fazer código não é o suficiente. Mas pra mim e pra vários desenvolvedores do mercado, nunca foi. A nossa profissão sempre foi mais intelectual do que braçal e isso meus amigos, não é commodity.&lt;/p&gt;
&lt;p&gt;Eu uso LLMs diariamente e realmente enxergo a AI como uma ferramenta poderosa para potencializar o desenvolvimento de aplicações por parte de desenvolvedores que levam o mercado a sério. Porém, eu enxergo esta mesma AI como uma bomba nas mãos de quem não entende os conceitos básicos de desenvolvimento de software. Simplesmente porque quando a gente atinge o limite de até onde ela consegue ir, é o primeiro grupo que vai saber o que fazer, enquanto o segundo vai precisar abrir um ticket de suporte no Lovable.&lt;/p&gt;
&lt;p&gt;Então basicamente o que está acontecendo não é uma desvalorização acentuada do código ou da profissão de desenvolvedor, mas um novo ciclo que está começando seguindo os mesmos princípios que já vivemos antes. Essa ferramenta é mais poderosa do que todas as outras, mas todas as outras também foram as mais poderosas de suas épocas.&lt;/p&gt;
&lt;p&gt;Se você sobreviveu ao Delphi, ao jQuery, ao Angular 1 vs 2 (ou ao React), ao hype do blockchain, você vai sobreviver a esse também.&lt;/p&gt;</content:encoded><category>ai</category><category>carreira</category></item><item><title>AI Agents, Comandos de Voz e uma nova forma de criar software</title><link>https://ricmello.com/posts/ai-agents-comandos-de-voz-e-uma-nova-forma-de-criar-software/</link><guid isPermaLink="true">https://ricmello.com/posts/ai-agents-comandos-de-voz-e-uma-nova-forma-de-criar-software/</guid><description>Dois hábitos que mudaram meu jeito de trabalhar: AI Agents na IDE, com regras pro código sair do seu jeito, e ditado por voz pra pedir código falando.</description><pubDate>Thu, 19 Jun 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;A forma que a gente trabalha há muito tempo não me parece a ideal. Eu posso até não ter achado a forma ideal ainda, mas eu continuo nessa procura. Eu realmente acho que depois de a tecnologia evoluir tanto, a gente não precisa mais trabalhar como datilógrafos do século passado.&lt;/p&gt;
&lt;p&gt;Se você parar pra observar o quanto o nosso modelo de trabalho evoluiu nos últimos anos comparado às tecnologias que a gente desenvolve, você vai notar um gap muito grande. A gente desenvolveu aplicações distribuídas, blockchain, inteligência artificial, visão computacional, e muitas outras coisas absurdamente incríveis, ao mesmo tempo que nós continuamos fazendo isso sentados (alguns de pé) escrevendo em uma tela branca – pode me zoar, eu não uso dark mode.&lt;/p&gt;
&lt;p&gt;Os softwares de reconhecimento de voz eram horríveis sim, mas o Ditado do Mac não é mais aquela coisa primitiva que rodava em um Symbian. E se você não conhece o Symbian, me avisa pra eu parar de usar exemplos velhos.&lt;/p&gt;
&lt;p&gt;Eu imagino que essas ferramentas só vão melhorar ao longo do tempo, e sinceramente eu não quero ficar parado no tempo fazendo coisas como eu fazia lá em 2010. Te convido a fazer o mesmo.&lt;/p&gt;
&lt;p&gt;Tenho testado algumas formas diferentes de trabalhar nesses últimos anos. Isso inclui inteligência artificial, comandos de voz, e até o amado/odiado vibe coding. Quero compartilhar dois pontos que estão mudando a minha forma de trabalhar, e talvez mude a sua também.&lt;/p&gt;
&lt;h2 id=&quot;1-ai-agents&quot;&gt;1. AI Agents&lt;/h2&gt;
&lt;p&gt;A menos que você esteja vivendo em uma caverna, você já deve ter ouvido falar de AI Agents. Resumindo de uma forma bem rasa, um AI agent é um ChatGPT turbinado que executa tarefas de forma autônoma direto na sua IDE. Ele cria features, altera arquivos e roda comandos com um único prompt, o que te permite realizar mudanças significativas em segundos.&lt;/p&gt;
&lt;p&gt;AI Agents são o presente, e eu recomendo fortemente que façam parte do seu workflow. Dependendo da linguagem você pode querer usar uma IDE com o AI Agent e outra que você se sentir mais confortável pra programar, mas vale muito a pena. O ganho de produtividade é absurdo, e do momento que você cria o seu próprio framework com o &lt;a href=&quot;https://docs.cursor.com/context/rules&quot;&gt;Cursor Rules&lt;/a&gt; ou similar, o Agent começa a gerar um código bem parecido com o que você escreveria.&lt;/p&gt;
&lt;p&gt;Pensando em time, você também consegue adicionar essas regras ao repositório, e outras pessoas do time usando AI Agents terão resultados parecidos. Você também pode pedir uma revisão de código pro seu Agent baseado nas regras antes de submeter pra revisão do time.&lt;/p&gt;
&lt;p&gt;A lista de prós é extensa, e vale o teste. Minha lista de AI Agents favoritos tem: &lt;a href=&quot;https://www.cursor.com&quot;&gt;Cursor&lt;/a&gt;, &lt;a href=&quot;https://github.com/features/copilot&quot;&gt;GitHub Copilot&lt;/a&gt; e &lt;a href=&quot;https://windsurf.com&quot;&gt;WindSurf&lt;/a&gt;. O &lt;a href=&quot;https://docs.anthropic.com/en/docs/claude-code/overview&quot;&gt;Claude Code&lt;/a&gt; é muito bom, mas ele roda no terminal e não na IDE.&lt;/p&gt;
&lt;p&gt;P.S.: Se alguém usa a &lt;a href=&quot;https://www.jetbrains.com/ai/&quot;&gt;AI da JetBrains&lt;/a&gt;, defende ela aqui porque eu não curti muito.&lt;/p&gt;
&lt;h2 id=&quot;2-ditado-e-comandos-de-voz&quot;&gt;2. Ditado e comandos de voz&lt;/h2&gt;
&lt;p&gt;Algo relativamente antigo, genérico e que funciona em várias aplicações diferentes é o Ditado. A proposta é bem simples: você consegue escrever falando. Isso serve pra mandar mensagens, pedir pra inteligência artificial criar alguma coisa, ou pedir pra Siri tocar uma música. Isso vai te fazer pensar duas vezes antes de mandar aquele áudio que poderia ser uma mensagem.&lt;/p&gt;
&lt;p&gt;Eu não sou um heavy user da Siri, tenho conhecimento muito básico de assistentes, e mantenho o “Hey Siri” desativado porque eu ainda sou meio bolado com um celular ou computador me ouvindo o tempo todo, mas tenho mudado minha cabeça quanto isso porque eu acho algo inevitável.&lt;/p&gt;
&lt;p&gt;“Ah mas o ChatGPT tem modo voz”. Concordo totalmente, mas o modo de voz do ChatGPT não vai abrir o seu WhatsApp e mandar uma mensagem (ainda), ou escrever algo dentro da sua IDE. Se você aliar o ditado do mac ou do Windows a uma IDE com AI Agent, você vai simplesmente abrir uma classe de entity, e dizer em voz alta “create a repository for this entity”. Voilà. O AI Agent vai começar criar.&lt;/p&gt;
&lt;p&gt;Eu não sei dizer a qualidade dos prompts em português, mas no teste que eu fiz funcionou perfeitamente. Até porque os modelos usados são o Claude, GPT, Gemini, e outros grandes que a gente já usa no dia a dia.&lt;/p&gt;
&lt;p&gt;Aqui vão os links sobre como habilitar o modo de ditado: &lt;a href=&quot;https://support.apple.com/pt-br/guide/mac-help/mh40584/mac&quot;&gt;macOS&lt;/a&gt; e &lt;a href=&quot;https://support.microsoft.com/pt-br/windows/usar-a-digita%C3%A7%C3%A3o-por-voz-para-falar-em-vez-de-digitar-no-seu-computador-fec94565-c4bd-329d-e59a-af033fa5689f&quot;&gt;Windows&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Falar com uma AI, ver ela programando e só revisar o resultado me faz sentir o Homem de Ferro falando com o Jarvis. Eu acho algo incrível e que só tem a melhorar no futuro.&lt;/p&gt;
&lt;p&gt;A maioria dessas ferramentas possuem um período de testes gratuito, então vale muito a pena fazer um teste. Te garanto que você vai curtir um bocado. Dica: O Claude é meu modelo favorito mesmo no GitHub Copilot, mas embora eu tenha usado o Copilot desde os betas, hoje eu tô no time do Cursor.&lt;/p&gt;
&lt;p&gt;Ainda me vejo escrevendo prompts muito mais pelo costume do que pela facilidade. Mudar a forma de trabalhar depois de mais de uma década é complicado. E se você tem LER, que são aquelas lesões por esforço repetitivo, isso vai te ajudar um bocado a digitar menos e aliviar elas também – mas não esqueça da fisioterapia.&lt;/p&gt;</content:encoded><category>ai</category><category>ferramentas</category><category>carreira</category></item><item><title>Web Components com Preact</title><link>https://ricmello.com/posts/web-components-com-preact/</link><guid isPermaLink="true">https://ricmello.com/posts/web-components-com-preact/</guid><description>Como transformar componentes Preact em web components com o preact-custom-element: registro da tag, atributos observados, Shadow DOM e callbacks.</description><pubDate>Fri, 26 Apr 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;O Preact se intitula como “Fast 3kB alternative to React with the same modern API”. E na minha opinião, ele tá se subestimando. Não é minha intenção entrar em uma comparação de React vs Preact, mas a performance dele a possibilidade de criar web components são duas grandes vantagens. É esse segundo ponto que vamos abordar hoje.&lt;/p&gt;
&lt;p&gt;Eu escolhi o Preact ao invés de outras libs como Lit ou Stencil porque além de ele ser muito leve e possuir uma ótima performance, os componentes são iguais aos do React, o que significa uma curva de aprendizado muito pequena caso o seu time já conheça React. Você consegue criar uma lib agnóstica sem abrir mão do TSX/JSX, hooks, e tudo aquilo que faz o React ser o que ele é, o que na minha opinião faz o Preact ser o melhor dos dois mundos no desenvolvimento de bibliotecas.&lt;/p&gt;
&lt;p&gt;Por último, mas não menos importante, o Preact já oferece suporte nativo aos Signals, que te permite criar um gerenciamento de estado atômico e, mais uma vez, muito performático.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id=&quot;o-projeto&quot;&gt;O projeto&lt;/h2&gt;
&lt;p&gt;O nosso objetivo vai ser bem simples, que é transformar um componente de counter em um web component. Sabe aquele counter que aparece quando você gera uma aplicação com o vite? Ele mesmo. Vamos usar uma técnica simples pra transformar esse cara em um web component que pode ser utilizado em qualquer lugar, inclusive em um HTML comum.&lt;/p&gt;
&lt;h2 id=&quot;mão-na-massa&quot;&gt;Mão na massa&lt;/h2&gt;
&lt;p&gt;Pra esse exemplo eu criei um projeto Preact no &lt;a href=&quot;https://stackblitz.com&quot;&gt;Stackblitz&lt;/a&gt; e vou alterá-lo para exportar e renderizar os web components. Se preferir, você também pode criar um projeto local usando o &lt;a href=&quot;https://preactjs.com/guide/v10/getting-started&quot;&gt;getting started&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Eu deletei o app.tsx e o app.css. Também removi o &lt;code&gt;render()&lt;/code&gt; do &lt;code&gt;main.tsx&lt;/code&gt;. Como nós vamos exportar o web component pra ser usado diretamente no HTML, não faz sentido renderizar o preact como aplicação.&lt;/p&gt;
&lt;p&gt;Pra começar, crie um componente &lt;code&gt;counter.tsx&lt;/code&gt; com o seguinte conteúdo:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import { FunctionalComponent } from &apos;preact&apos;;
import { useCallback, useState } from &apos;preact/hooks&apos;;

export const Counter: FunctionalComponent = () =&amp;gt; {
  const [count, setCount] = useState(0);

  const increment = useCallback(() =&amp;gt; {
    setCount(count + 1);
  }, [count]);

  return &amp;lt;button onClick={increment}&amp;gt;count is {count}&amp;lt;/button&amp;gt;;
};&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&quot;o-pulo-do-gato&quot;&gt;O pulo do gato&lt;/h3&gt;
&lt;p&gt;Qualquer componente preact pode ser registrado como web component usando o mini wrapper &lt;a href=&quot;https://github.com/preactjs/preact-custom-element&quot;&gt;preact-custom-element&lt;/a&gt;. Esse cara transforma o componente em Web Component seguindo a V1 da especificação Custom Elements.&lt;/p&gt;
&lt;p&gt;Pra instalar o wrapper, rode o seguinte comando:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;npm install preact-custom-element&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E se você está usando typescript, instale os types também:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;npm i @types/preact-custom-element --save-dev&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora, é só usar o wrapper no componente e o código do seu counter deve ficar assim:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import { FunctionalComponent } from &apos;preact&apos;;
import { useCallback, useState } from &apos;preact/hooks&apos;;
import register from &apos;preact-custom-element&apos;;

export const Counter: FunctionalComponent = () =&amp;gt; {...};

register(Counter, &apos;ric-counter&apos;);&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Por último, exporte o componente no &lt;code&gt;main.tsx&lt;/code&gt;. Como removemos a maior parte desse arquivo, ele deve ficar assim:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import &apos;./index.css&apos;;

export * from &apos;./counter&apos;;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A partir daí você já consegue utilizar o seu web component no index.html:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;!DOCTYPE html&amp;gt;
&amp;lt;html lang=&quot;en&quot;&amp;gt;
  &amp;lt;head&amp;gt;
    &amp;lt;meta charset=&quot;UTF-8&quot; /&amp;gt;
    &amp;lt;link rel=&quot;icon&quot; type=&quot;image/svg+xml&quot; href=&quot;/vite.svg&quot; /&amp;gt;
    &amp;lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot; /&amp;gt;
    &amp;lt;title&amp;gt;Vite + Preact + TS + Web Components&amp;lt;/title&amp;gt;
  &amp;lt;/head&amp;gt;
  &amp;lt;body&amp;gt;
    &amp;lt;ric-counter&amp;gt;&amp;lt;/ric-counter&amp;gt;
    &amp;lt;script type=&quot;module&quot; src=&quot;/src/main.tsx&quot;&amp;gt;&amp;lt;/script&amp;gt;
  &amp;lt;/body&amp;gt;
&amp;lt;/html&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Com isso, o web component será renderizado normalmente:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Botão counter sendo renderizado como web component&quot; width=&quot;1400&quot; height=&quot;525&quot; src=&quot;https://ricmello.com/_astro/image-01.CLaZ0W8__ZUG7nt.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Você deve ter notado que eu declarei a tag &lt;code&gt;&amp;lt;ric-counter&amp;gt;&amp;lt;/ric-counter&amp;gt;&lt;/code&gt; antes do import do &lt;code&gt;main.tsx&lt;/code&gt;. Isso é pra mostrar que ele consegue detectar tags que já foram declaradas antes de ele ser inicializado, o que significa que você não precisa se preocupar em carregar o js antes das tags.&lt;/p&gt;
&lt;h2 id=&quot;atributos&quot;&gt;Atributos&lt;/h2&gt;
&lt;p&gt;Os atributos são essenciais pra permitir que a aplicação possa controlar o comportamento dos componentes, ao mesmo tempo que nós como desenvolvedores de componentes definimos o que pode ser controlado.&lt;/p&gt;
&lt;p&gt;Os web components recebem os atributos como string por padrão, então é importante ter em mente que os seus dados podem precisar ser convertidos antes da utilização. Eu considero uma boa prática fazer isso já nas primeiras linhas do componente, e trabalhar internamente com a variável no tipo que eu quiser pra sempre converter tudo em um lugar único:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import { useCallback, useState } from &apos;preact/hooks&apos;;
import register from &apos;preact-custom-element&apos;;
import { FunctionalComponent } from &apos;preact&apos;;

interface CounterProps {
  label?: string;
  steps?: string;
}

export const Counter: FunctionalComponent&amp;lt;CounterProps&amp;gt; = ({
  label = &apos;Count is&apos;,
  steps: rawSteps = &apos;1&apos;,
}) =&amp;gt; {
  // Converto o atributo steps (rawSteps) pra number e uso como steps internamente
  const steps = Number(rawSteps);
  const [count, setCount] = useState(0);

  const increment = useCallback(() =&amp;gt; {
    setCount(count + steps);
  }, [count, steps]);

  return (
    &amp;lt;button onClick={increment}&amp;gt;
      {label} {count}
    &amp;lt;/button&amp;gt;
  );
};

register(Counter, &apos;ric-counter&apos;, [&apos;label&apos;, &apos;steps&apos;], { shadow: false });
//          ^            ^           ^                       ^
//          |         tag HTML       |                   shadow-dom
//     Componente           Atributos observados&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Sempre que um atributo observado for alterado, o componente vai ser atualizado. Os atributos que não estiverem nessa lista só serão detectados caso sejam passados na inicialização.&lt;/p&gt;
&lt;p&gt;Já o shadow, é um booleano que indica se o seu componente deve usar ou não o &lt;a href=&quot;https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_shadow_DOM&quot;&gt;Shadow DOM&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;O HTML com os atributos:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;!DOCTYPE html&amp;gt;
&amp;lt;html lang=&quot;en&quot;&amp;gt;
  &amp;lt;head&amp;gt;
    &amp;lt;meta charset=&quot;UTF-8&quot; /&amp;gt;
    &amp;lt;link rel=&quot;icon&quot; type=&quot;image/svg+xml&quot; href=&quot;/vite.svg&quot; /&amp;gt;
    &amp;lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot; /&amp;gt;
    &amp;lt;title&amp;gt;Vite + Preact + TS + Web Components&amp;lt;/title&amp;gt;
  &amp;lt;/head&amp;gt;
  &amp;lt;body&amp;gt;
    &amp;lt;ric-counter label=&quot;Custom count:&quot; steps=&quot;2&quot;&amp;gt;&amp;lt;/ric-counter&amp;gt;
    &amp;lt;script type=&quot;module&quot; src=&quot;/src/main.tsx&quot;&amp;gt;&amp;lt;/script&amp;gt;
  &amp;lt;/body&amp;gt;
&amp;lt;/html&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora é só testar e ver um novo label e incrementando de dois em dois:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Botão counter customizado&quot; width=&quot;1400&quot; height=&quot;525&quot; src=&quot;https://ricmello.com/_astro/image-02.KMb3ZWdW_1TNHlw.webp&quot;&gt;&lt;/p&gt;
&lt;h3 id=&quot;callbacks&quot;&gt;Callbacks&lt;/h3&gt;
&lt;p&gt;Os callbacks são um tipo importante de atributo, afinal as pessoas que vão utilizar o nosso componente precisam saber se um botão foi clicado e/ou se o estado do componente mudou.&lt;/p&gt;
&lt;p&gt;Como os atributos de um web component são passados como strings, é preciso passar as funções de callback de uma forma diferente: via JavaScript.&lt;/p&gt;
&lt;p&gt;E pra tornar isso possível vamos adicionar uma nova propriedade ao nosso componente chamada &lt;code&gt;onChange&lt;/code&gt; e executar esse callback dentro a função de increment:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import { useCallback, useState } from &apos;preact/hooks&apos;;
import register from &apos;preact-custom-element&apos;;
import { FunctionalComponent } from &apos;preact&apos;;

interface CounterProps {
  label?: string;
  steps?: string;
  onChange?: (count: number) =&amp;gt; void;
}

export const Counter: FunctionalComponent&amp;lt;CounterProps&amp;gt; = ({
  label = &apos;Count is&apos;,
  steps: rawSteps = &apos;1&apos;,
  onChange,
}) =&amp;gt; {
  const steps = Number(rawSteps);
  const [count, setCount] = useState(0);

  const increment = useCallback(() =&amp;gt; {
    setCount(count + steps);
    onChange &amp;amp;&amp;amp; onChange(count + steps);
  }, [count, steps, onChange]);

  return (
    &amp;lt;button onClick={increment}&amp;gt;
      {label} {count}
    &amp;lt;/button&amp;gt;
  );
};

register(Counter, &apos;ric-counter&apos;, [&apos;label&apos;, &apos;steps&apos;, &apos;onChange&apos;]);&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E agora no HTML, basta usar o &lt;code&gt;querySelector&lt;/code&gt; e atribuir a propriedade com a nossa função de callback:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;body&amp;gt;
  &amp;lt;ric-counter label=&quot;Custom count:&quot; steps=&quot;2&quot;&amp;gt;&amp;lt;/ric-counter&amp;gt;
  &amp;lt;script type=&quot;module&quot; src=&quot;/src/main.tsx&quot;&amp;gt;&amp;lt;/script&amp;gt;
  &amp;lt;script type=&quot;module&quot;&amp;gt;
    const counter = document.querySelector(&apos;ric-counter&apos;);
    counter.onChange = () =&amp;gt; {
      console.log(&apos;counter changed&apos;);
    };
  &amp;lt;/script&amp;gt;
&amp;lt;/body&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora é só testar e ver um console.log sendo executado cada vez que clicar no botão. Você também pode ver o resultado final no meu &lt;a href=&quot;https://stackblitz.com/edit/vitejs-vite-nuvqqa&quot;&gt;Stackblitz&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Poder utilizar um web component direto no HTML abre portas pra muitos casos reais de uso. Você pode exportar os seus componentes pra serem incluídos em sites wordpress, ou até mesmo criar wrappers pra outros frameworks e reutilizar o seu código em diferentes interfaces.&lt;/p&gt;
&lt;p&gt;Como eu disse antes &lt;a href=&quot;https://ricmello.com/posts/web-components-e-o-futuro-das-libs-front-end/&quot;&gt;nesse post&lt;/a&gt;, eu não acho que valha a pena desenvolver aplicações inteiras usando web components podendo usar direto o preact ou outro framework, mas se o seu contexto é libs, widgets, ou qualquer tipo de componente que é incorporado em outro website (por exemplo um chat), essa abordagem vai fazer muito sentido.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;Se você curte o assunto e gostaria de ver mais posts desses por aqui, me avisa porque é algo que eu tenho gostado bastante de estudar, e acho que realmente vale a pena o investimento.&lt;/p&gt;</content:encoded><category>web-components</category><category>frontend</category><category>react</category><category>typescript</category></item><item><title>Web Components e a minha opinião sobre o futuro das libs front-end</title><link>https://ricmello.com/posts/web-components-e-o-futuro-das-libs-front-end/</link><guid isPermaLink="true">https://ricmello.com/posts/web-components-e-o-futuro-das-libs-front-end/</guid><description>O que são web components, onde eles brilham (libs agnósticas, design systems, micro frontends), com o que criar e por que eu acho que são o futuro.</description><pubDate>Thu, 04 Apr 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Eu tô ficando velho. E como todo velho, eu ganho licença poética pra prever eventos futuros baseados em eventos passados. Tem dia que eu sei que vai chover, tem dia que eu sei que vai ser bom, e tem dia que eu consigo escrever.&lt;/p&gt;
&lt;p&gt;Eu tenho trabalhado bastante com web components nos últimos anos, e tô realmente impressionado com o quanto eu consegui escalar o desenvolvimento das minhas libs depois que eu passei a utilizá-los, então esse post é pra compartilhar minha experiência e explicar por que eu acredito que o futuro das libs é por esse caminho.&lt;/p&gt;
&lt;h2 id=&quot;tá-mas-o-que-são-web-components&quot;&gt;Tá, mas o que são web components?&lt;/h2&gt;
&lt;p&gt;Eu copiei essa definição do &lt;a href=&quot;https://developer.mozilla.org/pt-BR/docs/Web/API/Web_components&quot;&gt;site da Mozilla&lt;/a&gt; (MDN): Web Components é uma suíte de diferentes tecnologias que permite a criação de elementos customizados reutilizáveis — com a funcionalidade separada do resto do seu código — e que podem ser utilizados em suas aplicações web.&lt;/p&gt;
&lt;p&gt;E a minha explicação de dev simplão é: Web Components são componentes similares aos do react, angular, etc, mas que rodam em qualquer lugar e são nativos do browser. Você cria um componente &lt;code&gt;&amp;lt;ric-header&amp;gt;&amp;lt;/ric-header&amp;gt;&lt;/code&gt; e pode usar em qualquer lugar que vai funcionar, assim como o nosso bom e velho javascript.&lt;/p&gt;
&lt;h2 id=&quot;em-qualquer-lugar&quot;&gt;Em qualquer lugar?&lt;/h2&gt;
&lt;p&gt;Sim. Na &lt;del&gt;p$#%@&lt;/del&gt; coisa toda. Você pode usar o mesmo componente em um site wordpress, em um site HTML igual aos que eu fazia em 2010, ou em uma SPA react/angular/seuframeworkaqui.&lt;/p&gt;
&lt;p&gt;Os Web Components são nativos do browser, e por isso você não precisa de nenhuma mágica para renderizar. Desde que um browser moderno seja utilizado, você realmente pode utilizar o web component em uma página HTML básica ou integrar ao seu site em React.&lt;/p&gt;
&lt;p&gt;E sobre browsers modernos, &lt;a href=&quot;https://caniuse.com/custom-elementsv1&quot;&gt;aqui está a especificação do caniuse&lt;/a&gt;. Todos os browsers atuais são compatíveis, com exceção do nosso já conhecido Opera Mini e &lt;a href=&quot;https://bugs.webkit.org/show_bug.cgi?id=182671&quot;&gt;desse “bug”&lt;/a&gt; no Safari.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Tabela de suporte dos navegadores aos web components: all green&quot; width=&quot;1400&quot; height=&quot;677&quot; src=&quot;https://ricmello.com/_astro/image-01.cEthR12M_CBlFG.webp&quot;&gt;&lt;/p&gt;
&lt;h3 id=&quot;bug-no-safari&quot;&gt;Bug no Safari?&lt;/h3&gt;
&lt;p&gt;Na verdade é a falta de suporte ao atributo &lt;code&gt;is=&quot;&quot;&lt;/code&gt;, e que está categorizada como WONTFIX no bugzilla. Nessa especificação, nós poderíamos customizar as tags nativas do HTML com esse atributo. Porém, não vai impactar em muita coisa porque podemos alcançar o mesmo resultado de outra forma.&lt;/p&gt;
&lt;p&gt;Em resumo, você poderia registrar usar um componente de parágrafo customizado assim:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;customElements.define(&quot;word-count&quot;, WordCount, { extends: &quot;p&quot; });&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E utilizar o componente com esse código:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;p is=&quot;word-count&quot;&amp;gt;&amp;lt;/p&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Porém, o mesmo comportamento pode ser alcançado registrando um novo componente assim:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;customElements.define(&quot;word-count&quot;, WordCount);&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E usando o componente:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;word-count&amp;gt;&amp;lt;/word-count&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Eu sei que a gente perde um pouco da flexibilidade por precisar de uma tag nova, mas não tem muito o que fazer a não ser reclamar na issue pra ver se a galera do safari implementa.&lt;/p&gt;
&lt;h2 id=&quot;casos-de-uso&quot;&gt;Casos de uso&lt;/h2&gt;
&lt;p&gt;E se você está se perguntando pra que criar uma tag customizada nativa do browser se o seu React/Angular já faz isso dentro do framework, vamos entender onde esses componentes podem te ajudar um bocado:&lt;/p&gt;
&lt;h3 id=&quot;bibliotecas-agnósticas&quot;&gt;Bibliotecas agnósticas&lt;/h3&gt;
&lt;p&gt;Se você também trabalha desenvolvendo libs que precisam rodar em diferentes tecnologias, vale a pena olhar com carinho pra uma abordagem baseada em web components.&lt;/p&gt;
&lt;p&gt;Muitas libs do mercado já estão indo por esse caminho como o &lt;a href=&quot;https://ionicframework.com/docs/components&quot;&gt;Ionic&lt;/a&gt;, o &lt;a href=&quot;https://swiperjs.com&quot;&gt;Swiper&lt;/a&gt;, o &lt;a href=&quot;https://material-web.dev&quot;&gt;Material&lt;/a&gt;, entre outros. A ideia aqui é criar a sua lib usando web components e criar wrappers pros frameworks que você quiser manter, enquanto suporta todos os outros. No caso do Swiper eles estão abandonando os wrappers também e indo pra uma abordagem full web component.&lt;/p&gt;
&lt;h3 id=&quot;design-systems&quot;&gt;Design Systems&lt;/h3&gt;
&lt;p&gt;Uma das coisas mais difíceis no desenvolvimento de design systems é conseguir manter uma base agnóstica que sobreviva ao longo do tempo sem sofrer com clones e adaptações.&lt;/p&gt;
&lt;p&gt;Os devs da sua empresa usam Angular e a sua empresa compra uma outra empresa onde os devs usam React. Unificar as identidades visuais provavelmente vai girar em torno de clonar o Design System pra React, ou em casos mais doidos reescrever tudo pra Angular.&lt;/p&gt;
&lt;p&gt;Já com web components seria basicamente criar wrappers pro react e ir substituindo os componentes mantendo a regra de negócio (quase) intacta.&lt;/p&gt;
&lt;h3 id=&quot;micro-frontends&quot;&gt;Micro Frontends&lt;/h3&gt;
&lt;p&gt;Eu continuo sendo do time contra Micro Frontends (fique à vontade pra me chamar pra bater um papo e me mostrar um case maneiro), mas respeito quem usa. Exemplo similar ao de Design Systems, MFEs geralmente envolvem a utilização de mais de um framework ao mesmo tempo.&lt;/p&gt;
&lt;p&gt;E aqui, de novo, unificar os estilos entre diferentes times com diferentes frameworks é muuuito complicado. Às vezes eu navego em 3 telas do mesmo app e vejo 3 layouts diferentes, e é por conta dessa dificuldade de manter um padrão entre diferentes times com diferentes stacks de tecnologia em empresas gigantes.&lt;/p&gt;
&lt;p&gt;Os Web Components se aplicariam muito bem nesse mesmo cenário tendo uma lib de componentes única entre os times.&lt;/p&gt;
&lt;h2 id=&quot;e-como-eu-faço-pra-usar-esse-treco&quot;&gt;E como eu faço pra usar esse treco?&lt;/h2&gt;
&lt;p&gt;Bom, tem várias ferramentas por aí que vão te dar o mesmo resultado. Vale testar a que for melhor pro seu cenário, mas eu vou te dar algumas ideias:&lt;/p&gt;
&lt;p&gt;Se o seu forte é Angular, o &lt;a href=&quot;https://angular.dev/guide/elements&quot;&gt;Angular Elements&lt;/a&gt; é a ferramenta oficial pra isso. Porém, eu te recomendo testar o &lt;a href=&quot;https://lit.dev&quot;&gt;Lit&lt;/a&gt; que tem uma sintaxe parecida mas é focado em Web Components. Outra opção é o &lt;a href=&quot;https://stenciljs.com/docs/getting-started&quot;&gt;Stencil&lt;/a&gt;, que é feito pela galera do Ionic.&lt;/p&gt;
&lt;p&gt;Agora, se o seu forte é React, o suporte nativo só vai vir na v19 (&lt;a href=&quot;https://github.com/facebook/react/issues/11347&quot;&gt;acompanhe essa thread aqui&lt;/a&gt;), mas existem alguns wrappers pela comunidade que prometem o mesmo resultado. Outra opção, que eu recomendo fortemente, é o &lt;a href=&quot;https://preactjs.com/guide/v10/web-components/&quot;&gt;preact&lt;/a&gt; que é super leve, possui a mesma sintaxe e já tem suporte nativo.&lt;/p&gt;
&lt;p&gt;E se você não está familiarizado com nenhum desses dois, vale fazer uns testes e ver qual você se adapta melhor.&lt;/p&gt;
&lt;h2 id=&quot;opinião-sobre-o-futuro-do-desenvolvimento-front-end&quot;&gt;Opinião sobre o futuro do desenvolvimento front-end&lt;/h2&gt;
&lt;p&gt;Eu acredito fortemente que as bibliotecas que usamos serão mais focadas em web components e menos em frameworks. O Swiper e o Ionic são bons exemplo disso e têm evoluído bastante.&lt;/p&gt;
&lt;p&gt;Isso permitiria à galera do Angular, por exemplo, usar vários componentes que hoje são exclusivos do React e vice-versa. Outro ganho é que as pessoas que hoje mantém libs para os dois frameworks poderiam concentrar os esforços em uma lib universal, usando o tempo livre pra tomar uma cerveja ou criar novas libs.&lt;/p&gt;
&lt;p&gt;Eu não acho que valha a pena desenvolver uma aplicação comum com web components, porque os frameworks realmente aceleram o desenvolvimento e colocar mais uma camada no meio pode não ser muito inteligente.&lt;/p&gt;
&lt;p&gt;Porém, se você trabalha com libs, times cross, e/ou precisa ter uma base sólida de componentes, esse é o caminho. Eu tenho usado o preact onde vários sites de clientes usam os mesmos componentes e o resultado tem sido muito bom.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;Se você curte o assunto e gostaria de ver mais posts desses por aqui, me avisa porque é algo que eu tenho gostado bastante de estudar, e acho que realmente vale a pena o investimento.&lt;/p&gt;</content:encoded><category>web-components</category><category>frontend</category><category>react</category><category>angular</category></item><item><title>Adicionando domínio customizado a uma Lambda com o API Gateway</title><link>https://ricmello.com/posts/dominio-customizado-para-lambda-com-api-gateway/</link><guid isPermaLink="true">https://ricmello.com/posts/dominio-customizado-para-lambda-com-api-gateway/</guid><description>Troque a URL feia da sua Lambda por um domínio próprio com API Gateway: criação da API, stage, certificado no ACM, registro no DNS e mapeamento.</description><pubDate>Wed, 27 Mar 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Já tem tempos que eu não escrevo então me desculpa porque perdi um pouco o jeito, mas hoje eu vou compartilhar algo super simples que eu nunca tinha feito: adicionar um domínio customizado pra uma AWS Lambda.&lt;/p&gt;
&lt;p&gt;Se você nunca criou uma lambda, te recomendo &lt;a href=&quot;https://ricmello.com/posts/backend-pro-seu-frontend-com-aws-lambda/&quot;&gt;esse post aqui&lt;/a&gt; que eu acabei de criar.&lt;/p&gt;
&lt;p&gt;Agora, nós vamos adicionar um domínio customizado pra ela.&lt;/p&gt;
&lt;h2 id=&quot;mas-por-que-usar-um-domínio-customizado&quot;&gt;Mas por que usar um domínio customizado?&lt;/h2&gt;
&lt;p&gt;E por que não usar? Parece que um gato sobe no teclado sempre que a gente gera um link de uma lambda. Links como  &lt;a href=&quot;https://dz4y7rvv2az4iopdqzvgneefhy0jdfii.lambda-url.us-east-1.on.aws&quot;&gt;https://dz4y7rvv2az4iopdqzvgneefhy0jdfii.lambda-url.us-east-1.on.aws&lt;/a&gt; ou &lt;a href=&quot;https://lh4j4sdpmljdcrcr34gqc6ddni0qvugg.lambda-url.us-east-1.on.aws&quot;&gt;https://lh4j4sdpmljdcrcr34gqc6ddni0qvugg.lambda-url.us-east-1.on.aws&lt;/a&gt; são gerados e ficam beeem feios quando usados no frontend.&lt;/p&gt;
&lt;p&gt;Plus, se você precisar apontar o seu link pra qualquer outro lugar (outra lambda, uma API, outra cloud…) será muito mais tranquilo e você não vai ter que atualizar a url da lambda em milhares de lugares onde ela pode estar sendo utilizada.&lt;/p&gt;
&lt;h2 id=&quot;api-gateway&quot;&gt;API Gateway&lt;/h2&gt;
&lt;p&gt;Pra atingir o nosso objetivo, vamos usar o API Gateway. Esse cara consegue organizar todas as nossas lambdas e criar mapeamentos pra elas definindo paths específicos. Isso te permite usar a lambda &lt;code&gt;nomesuperultragigante.lambda-url.us-east-1.on.aws&lt;/code&gt; como um endpoint comum &lt;code&gt;api.meuwebsite.com/v1/lambda&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&quot;criando-a-api-no-api-gateway&quot;&gt;Criando a API no API Gateway&lt;/h2&gt;
&lt;p&gt;Pra começar, vamos criar a API que vai mapear a lambda em um endpoint no api gateway. Para isso, ainda na tela do API Gateway, vá em &lt;strong&gt;APIs &amp;gt; Create API &amp;gt; REST API&lt;/strong&gt;. Eu vou usar o nome &lt;code&gt;faker-api&lt;/code&gt; pra esse tutorial:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da tela de criação de API&quot; width=&quot;1400&quot; height=&quot;1197&quot; src=&quot;https://ricmello.com/_astro/image-01.D4g_Gw54_ZDf43g.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Com a API criada, você deve ver essa tela:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da tela de edição/configuração da API&quot; width=&quot;1400&quot; height=&quot;571&quot; src=&quot;https://ricmello.com/_astro/image-02.Ji3m4KCU_23X57.webp&quot;&gt;&lt;/p&gt;
&lt;h3 id=&quot;resources&quot;&gt;Resources&lt;/h3&gt;
&lt;p&gt;No API Gateway você pode realmente brincar de criação de API. Em create resources você pode ir definindo os paths por exemplo &lt;code&gt;/v1&lt;/code&gt;, depois &lt;code&gt;/v1/domain&lt;/code&gt; até chegar em &lt;code&gt;/v1/domain/endpoint&lt;/code&gt;. É uma ferramenta muito poderosa que te permite mapear todas as rotas e integrar com lambdas, apis, ou qualquer outro serviço.&lt;/p&gt;
&lt;p&gt;No nosso caso, eu vou tentar manter mais simples e criar um único resource chamado &lt;code&gt;persons&lt;/code&gt;. Para isso, vá em &lt;strong&gt;Create Resource&lt;/strong&gt;, dê o nome &lt;code&gt;persons&lt;/code&gt; pra ele, selecione a opção de CORS e clique em &lt;strong&gt;Create Resource&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da criação de Resource&quot; width=&quot;1400&quot; height=&quot;827&quot; src=&quot;https://ricmello.com/_astro/image-03.B8eqsJ4k_HyX4A.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Com o endpoint persons selecionado, vá em &lt;strong&gt;Create method&lt;/strong&gt; e preencha as seguintes infos:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Method type: GET&lt;/li&gt;
&lt;li&gt;Integration type: Lambda function&lt;/li&gt;
&lt;li&gt;Em lambda function: Selecione a nossa lambda de teste&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da criação de api pra lambda&quot; width=&quot;1400&quot; height=&quot;1577&quot; src=&quot;https://ricmello.com/_astro/image-04.DuFUt6wj_Z1NmQK1.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Depois de clicar em Create method, o resultado deve ser esse aqui:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da página com o método de persons criado&quot; width=&quot;1400&quot; height=&quot;874&quot; src=&quot;https://ricmello.com/_astro/image-05.DdSZVKry_23Kl4r.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Clique em &lt;strong&gt;Deploy API&lt;/strong&gt; e crie um stage chamado &lt;code&gt;development&lt;/code&gt;:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da tela de criação de stage&quot; width=&quot;1274&quot; height=&quot;1240&quot; src=&quot;https://ricmello.com/_astro/image-06.CVaRvKZi_Z28hHDj.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Você deve ser redirecionado pra essa tela com o stage criado, e mais uma URL gigante:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da página de stage development&quot; width=&quot;1400&quot; height=&quot;770&quot; src=&quot;https://ricmello.com/_astro/image-07.DvK1gZyq_sE7Ry.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;criando-o-domínio&quot;&gt;Criando o domínio&lt;/h2&gt;
&lt;p&gt;Pra criar o nosso domínio, vamos no painel do &lt;strong&gt;API Gateway -&amp;gt;  Custom domain names -&amp;gt; Create&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Create custom domain&quot; width=&quot;1142&quot; height=&quot;470&quot; src=&quot;https://ricmello.com/_astro/image-08.BFN1aS-2_ZmQpCN.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Antes de começar, na configuração do endpoint, você vai precisar adicionar um certificado pro domínio que você deseja criar. Clique em &lt;strong&gt;Create a new ACM certificate&lt;/strong&gt; e uma nova aba se abrirá.&lt;/p&gt;
&lt;p&gt;Na tela do Certificate Manager, clique em &lt;strong&gt;Request a certificate -&amp;gt; Request a public certificate&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Na tela que vai se abrir, insira o domínio que você vai usar pra solicitar o certificado. No meu caso é o &lt;code&gt;faker-api.ricmello.com&lt;/code&gt;, mas você pode adicionar mais de um domínio ou um wildcard como &lt;code&gt;*.ricmello.com&lt;/code&gt; pra não precisar criar um certificado pra cada subdomínio.&lt;/p&gt;
&lt;p&gt;O método de validação recomendado pela própria AWS é o de DNS.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da tela de requisição de certificado&quot; width=&quot;1400&quot; height=&quot;1112&quot; src=&quot;https://ricmello.com/_astro/image-09.D9dYh9J0_Z20ndh5.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Clique em &lt;strong&gt;request&lt;/strong&gt; e depois &lt;strong&gt;view certificate&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Caso você já use o Route53, basta clicar em &lt;strong&gt;Create records in Route 53&lt;/strong&gt; e os registros serão criados automaticamente pra validação do domínio. Ou caso você use outro serviço é só criar um novo registro do tipo CNAME e colar os valores que vão aparecer pra você como no print abaixo.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da página com o CNAME a ser criado&quot; width=&quot;1400&quot; height=&quot;459&quot; src=&quot;https://ricmello.com/_astro/image-10.DCE52Sj__Zf123.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Depois de configurar o DNS, o seu certificado vai estar disponível, mas isso pode demorar um pouco. Você pode usar a ferramenta &lt;a href=&quot;https://www.whatsmydns.net&quot;&gt;whatsmydns&lt;/a&gt; pra ver se a sua configuração tá certa e aguardar até o certificado ser emitido como esse aqui:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da tela de certificado com o status emitido&quot; width=&quot;1400&quot; height=&quot;647&quot; src=&quot;https://ricmello.com/_astro/image-11.Bh_nFk8Y_LBBd1.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Agora podemos voltar na criação do domínio no API Gateway e selecionar o certificado criado. No nome do domínio eu preenchi o mesmo &lt;code&gt;faker-api.ricmello.com&lt;/code&gt; que eu usei pro certificado:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da tela de criação do API Gateway com o certificado selecionado&quot; width=&quot;1400&quot; height=&quot;1413&quot; src=&quot;https://ricmello.com/_astro/image-12.Cc4lzbD9_OrMMw.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Clique em &lt;strong&gt;Create domain name&lt;/strong&gt; para salvar e volte pra tela de configuração de domínio. Você deve criar um CNAME apontando o seu domínio pro API Gateway domain name, que no meu exemplo é o &lt;code&gt;d-4ip5ycuy62.execute-api.us-east-1.amazonaws.com&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da configuração do nome de domínio customizado&quot; width=&quot;1400&quot; height=&quot;778&quot; src=&quot;https://ricmello.com/_astro/image-13.COsc_ANU_ZGedlx.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;associando-o-domínio&quot;&gt;Associando o domínio&lt;/h2&gt;
&lt;p&gt;Na tela de Custom domain names, vá em &lt;strong&gt;API mappings &amp;gt; Configure API mappings &amp;gt; Add new mapping&lt;/strong&gt;, e configure um mapeamento selecionando a sua API e o stage criado.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da tela de configuração de API com a lambda e o stage development selecionados&quot; width=&quot;1400&quot; height=&quot;647&quot; src=&quot;https://ricmello.com/_astro/image-14.D0rEWyZT_Z2vx5Pe.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Feito! O seu domínio vai apontar pro api gateway e você vai conseguir utilizar a lambda pelo mapeamento como na imagem abaixo.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Imagem da resposta da lambda utilizando o domínio criado&quot; width=&quot;1400&quot; height=&quot;206&quot; src=&quot;https://ricmello.com/_astro/image-15.BI9RLOAD_WrAIH.webp&quot;&gt;&lt;/p&gt;</content:encoded><category>aws</category><category>serverless</category><category>devops</category></item><item><title>Como criar um backend pro seu frontend com AWS Lambdas</title><link>https://ricmello.com/posts/backend-pro-seu-frontend-com-aws-lambda/</link><guid isPermaLink="true">https://ricmello.com/posts/backend-pro-seu-frontend-com-aws-lambda/</guid><description>Como criar uma AWS Lambda pelo console, publicar com Function URL e consumir no frontend, mais casos reais onde ela ajuda: proxy de API, BFF e mock.</description><pubDate>Mon, 25 Mar 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Embora eu não seja o cara do backend, eu sempre tive muito contato com o desenvolvimento de APIs mesmo enquanto front, mas Lambdas foram algo que eu sempre ignorei.&lt;/p&gt;
&lt;p&gt;Primeiro eu achava complicado, depois desnecessário porque eu achava mais fácil subir uma aplicação, até o dia que eu resolvi dar uma chance pro negócio e cara, vale a pena.&lt;/p&gt;
&lt;p&gt;No youtube tem vídeo antigo falando sobre isso, mas se você é velho que nem eu e gosta de ler, vamo lá!&lt;/p&gt;
&lt;p&gt;Ah, e pra esse exemplo eu vou criar uma lambda que busca os dados da Faker Api. É um exemplo básico, mas mais pra frente eu vou explicar alguns casos de uso reais onde ele pode ser útil.&lt;/p&gt;
&lt;h2 id=&quot;criando-a-lambda&quot;&gt;Criando a lambda&lt;/h2&gt;
&lt;p&gt;A real é que você não precisa ser o bichão do backend pra trabalhar com lambdas. Criar uma é bem simples e pode ser criada direto do painel da AWS. Pra começar, acesse o &lt;a href=&quot;https://console.aws.amazon.com/lambda/home&quot;&gt;painel das lambdas&lt;/a&gt; e clique em &lt;strong&gt;Create Function&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Ao criar, você pode usar um blueprint que já contém alguns exemplos como conectar ao DynamoDB ou ao S3, mas pro nosso caso nós vamos de &lt;strong&gt;Author from Scratch&lt;/strong&gt; mesmo.&lt;/p&gt;
&lt;p&gt;Dê um nome pra function, que eu vou chamar de &lt;code&gt;faker-api&lt;/code&gt;, e altere o campo architecture pra arm64 que tem um custo menor do que a x86. Você pode conferir o meu setup aqui:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;screenshot da tela de create function&quot; width=&quot;1400&quot; height=&quot;903&quot; src=&quot;https://ricmello.com/_astro/image-01.C8TBFl1x_PPI0z.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;implementando-a-faker-api&quot;&gt;Implementando a Faker Api&lt;/h2&gt;
&lt;p&gt;Function criada, agora vamos implementar o nosso código pra buscar os dados da faker api. Você deve substituir o código padrão do index.mjs por esse aqui:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import * as https from &apos;https&apos;;

function getData() {
  const apiUrl = `https://fakerapi.it/api/v1/persons?_quantity=1&amp;amp;_gender=male&amp;amp;_birthday_start=2005-01-01`;

  return new Promise((resolve, reject) =&amp;gt; {
    const req = https.get(apiUrl, {}, res =&amp;gt; {
      let rawData = &apos;&apos;;

      res.on(&apos;data&apos;, chunk =&amp;gt; {
        rawData += chunk;
      });

      res.on(&apos;end&apos;, () =&amp;gt; {
        try {
          resolve(JSON.parse(rawData));
        } catch (err) {
          reject(new Error(err));
        }
      });
    });

    req.on(&apos;error&apos;, err =&amp;gt; {
      reject(new Error(err));
    });
  });
}

export const handler = async (body) =&amp;gt; {
  const res = await getData();
  
  const response = {
    statusCode: 200,
    body: res,
  };
  return response;
};&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Explicando o código acima:&lt;/p&gt;
&lt;p&gt;Nós temos a arrow function &lt;code&gt;handler&lt;/code&gt;, que é responsável por executar a lambda. Dentro dela, eu tô chamando a função &lt;code&gt;getData&lt;/code&gt; que por sua vez faz uma requisição pra Faker Api utilizando a api &lt;code&gt;https&lt;/code&gt; do Node. Em seguida, faz o parser da response e retorna os dados.&lt;/p&gt;
&lt;p&gt;A essa altura a sua lambda deve estar assim:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Código-fonte da lambda faker-api&quot; width=&quot;1400&quot; height=&quot;926&quot; src=&quot;https://ricmello.com/_astro/image-02.Dee92ulI_3LRg4.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Clique em &lt;strong&gt;deploy&lt;/strong&gt; para publicar 🙂&lt;/p&gt;
&lt;h2 id=&quot;criando-uma-url-pública&quot;&gt;Criando uma URL pública&lt;/h2&gt;
&lt;p&gt;Por último, vá na aba &lt;strong&gt;Configuration&lt;/strong&gt;, clique em &lt;strong&gt;Function url&lt;/strong&gt; e &lt;strong&gt;Create function url&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da página Create function url&quot; width=&quot;1400&quot; height=&quot;364&quot; src=&quot;https://ricmello.com/_astro/image-03.CsPbaAzl_1VkbCy.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Vamos deixar o &lt;strong&gt;Auth Type&lt;/strong&gt; como &lt;code&gt;NONE&lt;/code&gt; e em Additional Settings, marque a caixa &lt;strong&gt;Configure cross-origin resource sharing (CORS)&lt;/strong&gt;. Depois, é só clicar em &lt;strong&gt;Save&lt;/strong&gt;. Você vai ver uma URL criada similar a essa aqui:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Screenshot da lambda com URL criada&quot; width=&quot;1400&quot; height=&quot;591&quot; src=&quot;https://ricmello.com/_astro/image-04.p_CJ5TRD_Z2uYFpI.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Basta abrir o link no seu navegador que você vai conseguir ver os resultados. E com isso você tem um endpoint seu publicado pra utilizar no frontend. É só consumir com a função &lt;code&gt;fetch&lt;/code&gt;.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const getData = async () =&amp;gt; {
    fetch(&apos;https://dz4y7rvv2az4iopdqzvgneefhy0jdfif.lambda-url.us-east-1.on.aws&apos;)
      .then((response) =&amp;gt; response.json())
      .then((data) =&amp;gt; {
        console.log(&apos;success: &apos;, data)
      })
      .catch((error) =&amp;gt; {
        console.error(&apos;error: &apos;, error);
      });
  };&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h2 id=&quot;tá-agora-vamos-aos-esclarecimentos&quot;&gt;Tá, agora vamos aos esclarecimentos&lt;/h2&gt;
&lt;p&gt;Você deve estar se perguntando: pra que diabos eu preciso de uma lambda pra chamar outra API pública se eu posso chamar ela diretamente? E a realidade é que você não precisa. Porém, existem alguns casos onde esse tipo básico de lambda vai te ajudar bastante:&lt;/p&gt;
&lt;h3 id=&quot;proxy-de-api&quot;&gt;Proxy de API&lt;/h3&gt;
&lt;p&gt;Nem sempre você vai querer que o frontend se conecte no seu endpoint ou possa manipular os resultados da pesquisa. No nosso exemplo, a lambda está filtrando os resultados da Faker Api pra sempre mostrar uma pessoa do gênero masculino nascida a partir de 01/01/2005, e o frontend (ou um usuário mal intencionado) não consegue mudar os filtros aplicados.&lt;/p&gt;
&lt;p&gt;Em um caso de uso real, eu subi um servidor do Strapi e usei a lambda pra expor algumas collections sem expor a API inteira. Nesse caso, a minha lambda tinha a apiKey pra consultar o Strapi e só retornava o que era estritamente necessário pro frontend funcionar. Praticamente um BFF.&lt;/p&gt;
&lt;h3 id=&quot;mock&quot;&gt;Mock&lt;/h3&gt;
&lt;p&gt;Se você precisar subir um serviço pra simular uma API que ainda não está construída, você pode usar essa mesma lambda retornando dados estáticos respeitando o contrato da API que ainda será feita. Em minutos você vai ter um endpoint pra trabalhar que vai estar acessível de qualquer lugar.&lt;/p&gt;</content:encoded><category>aws</category><category>serverless</category><category>frontend</category></item><item><title>Por que você não deveria usar funções de debounce o tempo todo</title><link>https://ricmello.com/posts/por-que-voce-nao-deveria-usar-debounce-o-tempo-todo/</link><guid isPermaLink="true">https://ricmello.com/posts/por-que-voce-nao-deveria-usar-debounce-o-tempo-todo/</guid><description>Debounce é gambiarra: por que esconder uma API lenta atrás de 300ms piora a experiência do usuário, e quando ainda faz sentido usar (sem se acostumar).</description><pubDate>Tue, 24 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;E porque essa técnica muito legal é gambiarra.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;Hoje eu vi outro post ensinando a criar uma função de debounce pra diminuir a quantidade de requisições desnecessárias.&lt;/p&gt;
&lt;p&gt;Se você não viu, tem &lt;a href=&quot;https://www.freecodecamp.org/portuguese/news/debounce-como-atrasar-a-execucao-de-uma-funcao-em-javascript-exemplo-com-js-es6/&quot;&gt;esse ótimo post do FreeCodeCamp&lt;/a&gt; ensinando.&lt;/p&gt;
&lt;p&gt;O debounce é &lt;del&gt;uma gambiarra&lt;/del&gt; um recurso super útil e que pode te ajudar bastante a controlar a quantidade de requisições feitas ao servidor, principalmente quando os recursos são limitados. Geralmente usado em campos de autocomplete, você espera até o usuário parar de digitar por determinado tempo (300 ou 500ms) pra fazer a requisição, assim você não faz uma requisição pra cada letra e diminui a quantidade de requests “desnecessários”.&lt;/p&gt;
&lt;h2 id=&quot;isso-faz-sentido&quot;&gt;Isso faz sentido?&lt;/h2&gt;
&lt;p&gt;Hoje podemos escalar aplicações como nunca em horários de pico, e poupar grana enquanto elas não estão sendo utilizadas. A obsessão por performance do lado do backend é frequente. Será que a API não consegue resolver isso sozinha?&lt;/p&gt;
&lt;p&gt;A resposta é: &lt;strong&gt;sim, deveria&lt;/strong&gt;. Estratégias de cache, bancos em memória, indexação, e um mundo de ferramentas criadas para fornecer uma resposta super rápida sem onerar o banco principal. APIs respondendo em 50ms enquanto a gente vai lá e mete um debounce de 300ms 🤡&lt;/p&gt;
&lt;h2 id=&quot;a-experiência-do-usuário&quot;&gt;A experiência do usuário&lt;/h2&gt;
&lt;p&gt;Todo mundo, principalmente quem é heavy user, já passou por apps ou sistemas onde você precisa esperar um tiquinho depois de digitar pra ver os resultados. É pouco tempo, mas é irritante quando você compara com ferramentas como a busca da Amazon, Google Maps, ou outras do tipo.&lt;/p&gt;
&lt;p&gt;Se você já colocou o delay e a API demora um pouco a mais pra responder, soma os tempos e você vai ver o usuário triste.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;“Aí, travou essa *****”
– Usuário triste&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Depois, abre o seu inspector e faz uma pesquisa no Google Maps pra você ver quantas requisições ele faz.&lt;/p&gt;
&lt;h2 id=&quot;ah-mas-ddos&quot;&gt;Ah, mas DDoS…&lt;/h2&gt;
&lt;p&gt;Se você confia no seu frontend pra te poupar de um DDoS, meu amigo… você tá em uma situação complicada. Acho que só outro post mesmo pra caber, mas me avisa aqui que eu faço.&lt;/p&gt;
&lt;h2 id=&quot;então-eu-não-devo-usar-debounce&quot;&gt;Então eu não devo usar debounce?&lt;/h2&gt;
&lt;p&gt;Calma… depois de virar dev sênior, você aprende que é pago pra dizer “depende” pra tudo. E mais uma vez aqui: DEPENDE.&lt;/p&gt;
&lt;p&gt;Se você trabalha em um frontend que consome uma API nova, e o backend não consegue dar conta de muitas requests, remove o debounce e pede pra ele consertar esse treco aí. Manda o print do inspector do site da Amazon e avisa quantas pessoas usam diariamente.&lt;/p&gt;
&lt;p&gt;Agora, se você trabalha em um sistema legado onde a API não dá conta da quantidade de requests, ou se o chefe não deixar o backend consertar o bug, ou se vc quiser salvar dinheiro pq a API do Google Places tá comendo seu orçamento, aí sim vc usa o debounce, mas não acostuma com ele. Debounce é gambiarra, não deixa te convencerem do contrário.&lt;/p&gt;</content:encoded><category>frontend</category><category>javascript</category><category>performance</category></item><item><title>O guia definitivo para hospedar uma SPA Angular/React com S3, Route 53 e CloudFront</title><link>https://ricmello.com/posts/hospedar-spa-angular-react-com-s3-route-53-e-cloudfront/</link><guid isPermaLink="true">https://ricmello.com/posts/hospedar-spa-angular-react-com-s3-route-53-e-cloudfront/</guid><description>Como hospedar uma SPA Angular ou React com bucket S3 privado, CloudFront com OAC, domínio no Route 53, certificado do ACM e o F5 que dá erro 403.</description><pubDate>Wed, 22 Mar 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;O combo S3 + CloudFront é uma ótima opção para hospedagem de aplicações Angular e React. Como dito antes &lt;a href=&quot;https://ricmello.com/posts/deploy-de-angular-react-para-o-s3-via-github-actions/&quot;&gt;nesse post&lt;/a&gt;, uma SPA é simplesmente um monte de arquivos HTML, CSS e JS que rodam no browser, então qualquer servidor de arquivos cumpre a responsa de hospedar esse tipo de aplicação.&lt;/p&gt;
&lt;p&gt;O S3 (Simple Storage Service) é um serviço de armazenamento de objetos que pode ser usado para armazenar e recuperar qualquer quantidade de dados de qualquer lugar na web.&lt;/p&gt;
&lt;p&gt;O CloudFront, por sua vez, é uma rede de entrega de conteúdo (CDN) que entrega dados, vídeos, aplicativos e APIs com segurança, baixa latência e alta velocidade de transferência. Ao usar o CloudFront com o S3, você pode melhorar o desempenho e a confiabilidade do seu site ou aplicativo distribuindo seu conteúdo globalmente para reduzir a latência, melhorar o tempo de carregamento das páginas e a quantidade de acessos ao bucket.&lt;/p&gt;
&lt;h2 id=&quot;pré-requisitos&quot;&gt;Pré-requisitos&lt;/h2&gt;
&lt;p&gt;Antes de começar, precisamos seguir o passo a passo para a  &lt;a href=&quot;https://ricmello.com/posts/publicar-aplicacao-angular-no-amazon-s3/&quot;&gt;criação do bucket no S3&lt;/a&gt;, e  caso você queira ter deploys automatizados, &lt;a href=&quot;https://ricmello.com/posts/deploy-de-angular-react-para-o-s3-via-github-actions/&quot;&gt;configurar o GitHub Actions&lt;/a&gt; pra atualizar o bucket automaticamente, Por último, vamos configurar o CloudFront e o Route 53.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Importante:&lt;/strong&gt; embora uma infinidade de artigos e tutoriais (incluindo o meu anterior) ensine, não é uma boa prática deixar o bucket público em produção. Logo, o CloudFront se torna super necessário, principalmente em ambientes corporativos.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&quot;reconfigurando-o-bucket&quot;&gt;Reconfigurando o bucket&lt;/h2&gt;
&lt;p&gt;Depois de seguir o passo a passo do tutorial anterior, vamos tornar o bucket privado novamente. Vá na aba permissions do seu bucket, remova a policy do tutorial anterior e marque a opção &lt;strong&gt;Block all public access&lt;/strong&gt;. O resultado deve ser esse:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Bucket privado e com policy removida&quot; width=&quot;1400&quot; height=&quot;1276&quot; src=&quot;https://ricmello.com/_astro/image-01.DnhTNlHw_1fEtTj.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;criando-a-distribuição&quot;&gt;Criando a distribuição&lt;/h2&gt;
&lt;p&gt;Vá para o &lt;a href=&quot;https://console.aws.amazon.com/cloudfront/v3/home&quot;&gt;painel do CloudFront&lt;/a&gt; na AWS e clique em &lt;strong&gt;Create Distribution&lt;/strong&gt;. Na criação de distribuição, iremos preencher alguns campos:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Origin domain:&lt;/strong&gt; selecione o bucket com a sua aplicação&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Origin access:&lt;/strong&gt; selecione a opção &lt;strong&gt;Origin access control settings (recommended)&lt;/strong&gt;, que irá deixar o bucket acessível somente para o CloudFront.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Ainda em Origin Access:&lt;/strong&gt; clique em &lt;strong&gt;Create Control Setting&lt;/strong&gt;, e em seguida em &lt;strong&gt;create&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Default root object&lt;/strong&gt;: preencha &lt;code&gt;index.html&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Clique em &lt;strong&gt;Create Distribution&lt;/strong&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Após a criação você verá um aviso dizendo que a policy do bucket precisa ser atualizada. O processo é bem simples: clique em &lt;strong&gt;Copy Policy&lt;/strong&gt; no próprio aviso, que irá deixar a policy na sua área de transferência, depois em &lt;strong&gt;Go to S3 bucket&lt;/strong&gt;, e cole o conteúdo em Bucket Policy.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Aviso de que a Bucket Policy precisa ser alterada&quot; width=&quot;1278&quot; height=&quot;330&quot; src=&quot;https://ricmello.com/_astro/image-02.CMdhyDOt_16Ag61.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Voltando à sua distribuição do CloudFront, você verá o link onde ela foi publicada. A essa altura o seu app já estará rodando nesse link mesmo com bucket privado.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Minha distribuição do CloudFront&quot; width=&quot;1400&quot; height=&quot;787&quot; src=&quot;https://ricmello.com/_astro/image-03.DwFzB95M_1T8NnC.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;configuração-do-domínio&quot;&gt;Configuração do domínio&lt;/h2&gt;
&lt;p&gt;Também é possível configurar um domínio personalizado no Route 53. Caso você ainda não tenha uma zona configurada, você tem duas opções:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.aws.amazon.com/pt_br/Route53/latest/DeveloperGuide/dns-configuring-new-domain.html&quot;&gt;Configurar o roteamento de DNS para um novo domínio&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.aws.amazon.com/pt_br/Route53/latest/DeveloperGuide/MigratingDNS.html&quot;&gt;Configurar o Route 53 como serviço DNS para um domínio existente&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Com a hosted zone criada, basta navegar até ela e clicar em &lt;strong&gt;Create Record&lt;/strong&gt; para criar um novo registro, e setar como &lt;strong&gt;Alias to CloudFront Distribution&lt;/strong&gt; e apontar para a URL da sua distribuição como no print abaixo:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Exemplo de criação de domínio personalizado no Route 53&quot; width=&quot;1400&quot; height=&quot;1061&quot; src=&quot;https://ricmello.com/_astro/image-04.DI26M17l_Z1AglEm.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Depois, precisamos voltar no painel do CloudFront &amp;gt; sua distribution &amp;gt; settings e:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Adicione o seu domínio como &lt;strong&gt;alternate domain name&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;Crie um certificado
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Atenção:&lt;/strong&gt; pro CloudFront, o certificado do ACM tem que ser criado na região &lt;strong&gt;us-east-1 (N. Virginia)&lt;/strong&gt;, não importa onde estejam o bucket e o resto da sua infra. Se você criar em outra região, ele simplesmente não aparece na lista. Confere a região no canto superior do console antes de pedir&lt;/li&gt;
&lt;li&gt;Clique em &lt;strong&gt;Request certificate&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;Selecione &lt;strong&gt;Request a public certificate&lt;/strong&gt; na janela que vai abrir&lt;/li&gt;
&lt;li&gt;Insira o seu domínio em &lt;strong&gt;Fully qualified domain name&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;Clique em Request&lt;/li&gt;
&lt;li&gt;Na lista de certificados, clique no certificado recém-criado&lt;/li&gt;
&lt;li&gt;Em Domains, vá em &lt;strong&gt;Create records in Route 53&lt;/strong&gt; e confirme a operação&lt;/li&gt;
&lt;li&gt;Aguarde o certificado ficar com o status &lt;strong&gt;Issued&lt;/strong&gt; (pode levar alguns minutos)&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Selecione o certificado que você acabou de criar&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img alt=&quot;Configuração do CloudFront com o domínio novo&quot; width=&quot;1400&quot; height=&quot;1061&quot; src=&quot;https://ricmello.com/_astro/image-05.D9eEUsIh_Z5zaKv.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;o-pulo-do-gato&quot;&gt;O pulo do gato&lt;/h2&gt;
&lt;p&gt;Tanto o Angular quanto o React possuem o conceito de rota, o que significa que elas são tratadas no frontend. Se o usuário der um F5 ou tentar abrir uma rota diferente do seu app, o CloudFront vai tentar buscar essa rota no S3 e retornar um erro porque ele não vai encontrar nenhum objeto na rota solicitada.&lt;/p&gt;
&lt;p&gt;A solução é redirecionar as requests para o &lt;code&gt;index.html&lt;/code&gt;. Para isso, vá em &lt;strong&gt;Error Pages&lt;/strong&gt; &amp;gt; &lt;strong&gt;Create Custom Error Response&lt;/strong&gt; e crie a configuração abaixo:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Custom Error Response configurada como http error = 403, customize error = yes, response page path = /index.html, http response code = 200: OK&quot; width=&quot;1400&quot; height=&quot;1116&quot; src=&quot;https://ricmello.com/_astro/image-06.D7dk0BWc_oVKun.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Essa config redireciona todos os erros 403 para o &lt;code&gt;index.html&lt;/code&gt; e retorna Http 200 (OK) para o browser. Assim, independente da rota que o usuário acessar, o CloudFront vai retornar o frontend e o próprio frontend é quem vai gerenciar se aquela rota existe ou não, além de realizar os redirecionamentos caso necessário, que é o comportamento correto.&lt;/p&gt;
&lt;h2 id=&quot;gg&quot;&gt;GG&lt;/h2&gt;
&lt;p&gt;Agora temos a aplicação publicada, com o bucket seguro e em uma rede de alta disponibilidade que vai acelerar o carregamento independente da localização do usuário.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Print da página publicada&quot; width=&quot;1400&quot; height=&quot;1014&quot; src=&quot;https://ricmello.com/_astro/image-07.C__KWzDc_1yC7de.webp&quot;&gt;&lt;/p&gt;</content:encoded><category>aws</category><category>frontend</category><category>devops</category></item><item><title>Deploy de app Angular/React para o S3 via GitHub Actions</title><link>https://ricmello.com/posts/deploy-de-angular-react-para-o-s3-via-github-actions/</link><guid isPermaLink="true">https://ricmello.com/posts/deploy-de-angular-react-para-o-s3-via-github-actions/</guid><description>Deploy de SPA Angular ou React no S3 com GitHub Actions: um workflow que só roda no push pra main, com credenciais via OIDC em vez de access key.</description><pubDate>Fri, 17 Mar 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Há um tempo atrás eu escrevi &lt;a href=&quot;https://ricmello.com/posts/publicar-aplicacao-angular-no-amazon-s3/&quot;&gt;esse post&lt;/a&gt; sobre como criar e publicar uma aplicação Angular no S3. Como ambos os frameworks usam a pasta dist, basta seguir os mesmos passos no React.&lt;/p&gt;
&lt;p&gt;Agora, nós vamos usar o GitHub Actions pra automatizar o nosso deploy e atualizar o ambiente automaticamente a cada commit na branch principal.&lt;/p&gt;
&lt;p&gt;E se você chegou até aqui mas ainda não entendeu muito bem porque publicar uma SPA no S3 ao invés de um nginx ou apache da vida, a resposta é simples: &lt;strong&gt;é tudo HTML, CSS e JS&lt;/strong&gt;. Uma SPA tem um monte de JS incorporado, regras de interface, libs, etc. mas no fim disso tudo o código é executado no browser, então a gente só precisa de um servidor de arquivos pra fazer a mágica acontecer.&lt;/p&gt;
&lt;h2 id=&quot;repo&quot;&gt;Repo&lt;/h2&gt;
&lt;p&gt;Dessa vez vamos usar um &lt;a href=&quot;https://github.com/ricmello/react-s3-app&quot;&gt;app react&lt;/a&gt; como exemplo, e se você é do team Angular pode usar &lt;a href=&quot;https://github.com/ricmello/angular-s3-app&quot;&gt;esse repo&lt;/a&gt; como base.&lt;/p&gt;
&lt;h2 id=&quot;criando-a-action&quot;&gt;Criando a Action&lt;/h2&gt;
&lt;p&gt;No seu repositório, vá para a aba actions pra criar o seu primeiro workflow. Digite Node.js na caixa de pesquisa, procure por essa action aqui e clique em &lt;strong&gt;Configure&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Busca por node.js nos workflows do GitHub Actions, com uma seta apontando pro workflow Node.js&quot; width=&quot;1400&quot; height=&quot;649&quot; src=&quot;https://ricmello.com/_astro/image-01.DdciT-QH_Z2u3pJ.webp&quot;&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Importante: GitHub Actions é o nome da ferramenta. Dentro dela, nós configuramos os workflows. Um workflow é um conjunto de instruções pra fazer o que você quiser com o seu projeto: rodar testes, buildar a aplicação, fazer o deploy ou tudo isso junto, se você consegue fazer no terminal é possível fazer via GitHub Actions. Ainda tem uma série de comandos predefinidos pra te ajudar no &lt;a href=&quot;https://github.com/marketplace?type=actions&quot;&gt;marketplace&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Após clicar em Configure, o GitHub vai gerar um workflow padrão para uma aplicação node:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs

name: Node.js CI

on:
  push:
    branches: [ &quot;main&quot; ]
  pull_request:
    branches: [ &quot;main&quot; ]

jobs:
  build:

    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18.x, 20.x, 22.x]

    steps:
    - uses: actions/checkout@v7
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v7
      with:
        node-version: ${{ matrix.node-version }}
        cache: &apos;npm&apos;
    - run: npm ci
    - run: npm run build --if-present
    - run: npm test&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Explicando o arquivo acima, ele é executado tanto em pushes quanto PRs para a branch main. Roda no ubuntu e executa nas versões 18, 20 e 22 do node. Como a gente não precisa suportar várias versões, eu vou fixar numa só: a 24.x, que é LTS. Essa é a parte de configuração do workflow.&lt;/p&gt;
&lt;p&gt;E aqui vai um detalhe importante: pra CI, rodar em PR faz todo sentido, mas esse workflow vai fazer &lt;strong&gt;deploy&lt;/strong&gt;. Se ele continuar rodando em &lt;code&gt;pull_request&lt;/code&gt;, qualquer PR aberto pra main publica em produção um código que nem foi revisado ainda. Por isso eu vou deixar só o &lt;code&gt;push&lt;/code&gt; na main, que é quando o PR já foi mergeado.&lt;/p&gt;
&lt;p&gt;Nas steps, que são as etapas, o &lt;code&gt;actions/checkout&lt;/code&gt; baixa o repositório, enquanto o &lt;code&gt;setup-node&lt;/code&gt; instala o nodejs. Com o node instalado, rodamos o &lt;code&gt;npm ci&lt;/code&gt; pra &lt;a href=&quot;https://ricmello.com/posts/npm-install-vs-npm-ci/&quot;&gt;instalar as dependências&lt;/a&gt;, depois o build e os testes. Como a nossa aplicação não tem testes, eu vou remover essa última linha.&lt;/p&gt;
&lt;p&gt;A essa altura, o seu arquivo deve estar assim:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;name: Deploy React app to S3

on:
  push:
    branches: [ &quot;main&quot; ]

jobs:
  build-and-deploy:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v7
    - name: Use Node.js 24.x
      uses: actions/setup-node@v7
      with:
        node-version: 24.x
        cache: &apos;npm&apos;
    - run: npm ci
    - run: npm run build&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora que já temos o script de build, é hora de publicar no S3. Eu criei um bucket com o nome de &lt;code&gt;my-react-s3-app&lt;/code&gt; usando as configurações do &lt;a href=&quot;https://ricmello.com/posts/publicar-aplicacao-angular-no-amazon-s3/&quot;&gt;tutorial anterior&lt;/a&gt;. Com o bucket pronto, fica faltando configurar as credenciais da AWS e subir os arquivos.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Com isso, o meu arquivo final ficou assim:&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;name: Deploy React app to S3

on:
  push:
    branches: [ &quot;main&quot; ]

permissions:
  id-token: write # necessário pro OIDC
  contents: read

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v7
    - name: Use Node.js 24.x
      uses: actions/setup-node@v7
      with:
        node-version: 24.x
        cache: &apos;npm&apos;
    - run: npm ci
    - run: npm run build

    - name: Setup AWS credentials
      uses: aws-actions/configure-aws-credentials@v6
      with:
        role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
        aws-region: ${{ secrets.AWS_REGION }}

    - name: Deploy to S3
      run: aws s3 sync dist/ s3://my-react-s3-app&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A step &lt;strong&gt;Setup AWS credentials&lt;/strong&gt; faz o workflow assumir uma role da AWS com permissão no S3. Na primeira versão desse post eu usava a access key e a secret de um usuário IAM guardadas nas secrets, mas hoje o recomendado é usar OIDC: o GitHub troca um token temporário por credenciais que expiram sozinhas, e não fica nenhuma chave de longa duração dando sopa pra vazar ou pra você lembrar de rotacionar. É por isso que o workflow precisa da permissão &lt;code&gt;id-token: write&lt;/code&gt;. Tanto o ARN da role quanto a region do meu app estão em secrets, assim eu não deixo nenhuma informação sensível no repositório.&lt;/p&gt;
&lt;p&gt;Você pode ver como configurar o OIDC e a role na AWS &lt;a href=&quot;https://docs.github.com/en/actions/how-tos/secure-your-work/security-harden-deployments/oidc-in-aws&quot;&gt;nesse link&lt;/a&gt; e você pode encontrar mais informações sobre as secrets &lt;a href=&quot;https://docs.github.com/en/actions/security-guides/encrypted-secrets&quot;&gt;aqui&lt;/a&gt;. Para criar as secrets basta ir no seu &lt;strong&gt;repositório no GitHub &amp;gt; Settings &amp;gt; Secrets and Variables &amp;gt; Actions&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;E por último, mas não menos importante, a task &lt;strong&gt;Deploy to S3&lt;/strong&gt; sobe os arquivos pro nosso bucket. Após fazer o push para o repositório, a aplicação fica disponível automaticamente em &lt;a href=&quot;https://github.com/ricmello/react-s3-app/actions/runs/4443180406&quot;&gt;alguns segundos&lt;/a&gt;. Você pode acessar o meu app &lt;a href=&quot;https://my-react-s3-app.s3.us-west-2.amazonaws.com/index.html&quot;&gt;nesse link&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;App publicado no S3&quot; width=&quot;1400&quot; height=&quot;1050&quot; src=&quot;https://ricmello.com/_astro/image-02.0mDqPw60_Z2oNSQw.webp&quot;&gt;&lt;/p&gt;</content:encoded><category>aws</category><category>devops</category><category>react</category><category>angular</category></item><item><title>npm install vs npm ci: qual utilizar?</title><link>https://ricmello.com/posts/npm-install-vs-npm-ci/</link><guid isPermaLink="true">https://ricmello.com/posts/npm-install-vs-npm-ci/</guid><description>A diferença entre npm install e npm ci: quando o lock é reescrito, por que o ci apaga o node_modules e falha fora de sincronia, e qual usar no CI.</description><pubDate>Tue, 28 Feb 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Logo do npm&quot; width=&quot;1080&quot; height=&quot;420&quot; src=&quot;https://ricmello.com/_astro/image-01.DAjLj8RY_Z8Tu3d.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;O comando padrão pra instalar as dependências é o &lt;code&gt;npm install&lt;/code&gt;. Se você usa o npm há certo tempo, provavelmente já utiliza esse comando sempre que precisa instalar as dependências de um projeto.&lt;/p&gt;
&lt;p&gt;O que nem todo mundo sabe é que desde o npm 5.7 (lá em 2018), existe um comando similar ao &lt;code&gt;npm install&lt;/code&gt; chamado &lt;code&gt;npm ci&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Nesse artigo, vamos entender as principais diferenças entre eles e quando utilizar cada um.&lt;/p&gt;
&lt;h2 id=&quot;npm-install&quot;&gt;npm install&lt;/h2&gt;
&lt;p&gt;O &lt;code&gt;npm install&lt;/code&gt; instala os pacotes do package.json e suas dependências. Se não existe um package-lock.json, ele resolve as versões a partir do &lt;code&gt;^&lt;/code&gt; ou do &lt;code&gt;~&lt;/code&gt; e gera o lock. Se o lock já existe e atende ao que tá no package.json, ele respeita o lock e instala exatamente aquelas versões (isso desde o npm 5.4.2). O lock só é reescrito quando precisa: quando você adiciona ou remove um pacote, ou muda uma versão no package.json pra uma faixa que o lock não atende mais.&lt;/p&gt;
&lt;h2 id=&quot;npm-ci&quot;&gt;npm ci&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;npm ci&lt;/code&gt;, ou “clean install” é utilizado para instalar as dependências do zero. Diferente do &lt;code&gt;npm install&lt;/code&gt;, esse comando instala as dependências a partir do &lt;code&gt;package-lock.json&lt;/code&gt; ou do &lt;code&gt;npm-shrinkwrap.json&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Isso garante que você irá sempre instalar a mesma versão de cada pacote, não importa quantas vezes o comando for executado e nem se houver atualizações disponíveis. Ideal para ambientes de build automatizado ou integração contínua (CI).&lt;/p&gt;
&lt;p&gt;Mas tem dois detalhes importantes: ele apaga a pasta &lt;code&gt;node_modules&lt;/code&gt; antes de instalar, e se o package.json e o package-lock.json não estiverem em sincronia, ele não tenta resolver nada. Ele dá erro e para. É mais um motivo pra &lt;a href=&quot;https://ricmello.com/posts/commitar-ou-nao-commitar-o-package-lock-json/&quot;&gt;sempre commitar o package-lock.json&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Como ele pula certas etapas como atualizar o package-lock.json e resolver as dependências, esse comando também é muito mais rápido do que o &lt;code&gt;npm install&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&quot;qual-usar&quot;&gt;Qual usar?&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;No seu ambiente de desenvolvimento, ou sempre que você for adicionar, remover ou atualizar dependências (com &lt;code&gt;npm install &amp;lt;pacote&amp;gt;&lt;/code&gt; ou &lt;code&gt;npm update&lt;/code&gt;), vale continuar usando o &lt;code&gt;npm install&lt;/code&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Já no caso de instalar as dependências no seu servidor de integração contínua, ou até mesmo instalar local mas sem atualizar nada, vá de &lt;code&gt;npm ci&lt;/code&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Ambos os comandos são similares mas têm aplicações bem distintas. Eu uso o &lt;code&gt;npm install&lt;/code&gt; no dia a dia, mas recomendo fortemente a utilização do &lt;code&gt;npm ci&lt;/code&gt; no servidor de integração contínua. Além de ter builds mais confiáveis, que quebram quando o lock tá fora de sincronia em vez de instalar outra coisa, ele ainda vai ficar mais rápido.&lt;/p&gt;</content:encoded><category>npm</category><category>javascript</category><category>devops</category></item><item><title>Commitar ou não commitar o package-lock.json?</title><link>https://ricmello.com/posts/commitar-ou-nao-commitar-o-package-lock-json/</link><guid isPermaLink="true">https://ricmello.com/posts/commitar-ou-nao-commitar-o-package-lock-json/</guid><description>Sim, você deve commitar o package-lock.json. Entenda o que o ^ realmente permite, por que o build quebra do nada e como o lock trava a árvore inteira.</description><pubDate>Sat, 25 Feb 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Commitar ou não commitar?&quot; width=&quot;500&quot; height=&quot;756&quot; src=&quot;https://ricmello.com/_astro/image-01.TaQQ_-ax_Z1ojDxp.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;versão-resumida&quot;&gt;Versão resumida:&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;Sim, você deve commitar&lt;/li&gt;
&lt;li&gt;Sempre faça o commit do arquivo quando ele for alterado&lt;/li&gt;
&lt;li&gt;Nunca delete o package-lock.json e nem coloque ele no .gitignore&lt;/li&gt;
&lt;li&gt;O mesmo vale para o yarn.lock&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&quot;contexto&quot;&gt;Contexto&lt;/h2&gt;
&lt;p&gt;Ainda hoje eu vejo muita gente discutindo sobre porque não commitar o package-lock. Rola um misticismo danado em cima desse arquivo tão útil e hoje vamos entender se vale a pena ou usar.&lt;/p&gt;
&lt;h2 id=&quot;os-problemas&quot;&gt;Os problemas&lt;/h2&gt;
&lt;p&gt;Tem sido cada vez mais raro, mas ainda acontece: aquela dependência que você adicionou no package.json e colocou a versão com um circunflexo (Ex.: &lt;code&gt;&quot;typescript&quot;: &quot;^4.0.0&quot;&lt;/code&gt;) atualizou pra versão 4.9 e sua aplicação começou a quebrar.&lt;/p&gt;
&lt;p&gt;Isso acontece porque o circunflexo permite atualizar minor e patch (qualquer 4.x, mas nunca a 5.0), e minor é justamente onde entram as novas features. O problema é que um código que o desenvolvedor considera como feature, pode se tornar uma breaking change pra você.&lt;/p&gt;
&lt;p&gt;Daí você pode ser malandro e tirar o circunflexo pra travar a versão, mas você sabia que a dependência da sua dependência também pode ter o tal circunflexo?&lt;/p&gt;
&lt;p&gt;Outro caso acontece quando você desenvolve a sua feature, commita o seu código, e na hora do CI o build vai lá e quebra, mas local ele roda normalmente.&lt;/p&gt;
&lt;p&gt;Ou pior, a versão de produção começa a apresentar um bug estranho que só acontece em produção, e depois de horas investigando você descobre que é a versão da lib que tá diferente.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Na minha máquina funciona&quot; width=&quot;600&quot; height=&quot;411&quot; src=&quot;https://ricmello.com/_astro/image-02.BLRTkgb7_1Xpb38.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;a-solução-package-lockjson&quot;&gt;A solução: package-lock.json&lt;/h2&gt;
&lt;p&gt;Todos esses problemas poderiam ter sido evitados com o package-lock.json. O lock, como seu próprio nome diz, é uma espécie de trava que descreve toda a árvore de dependências geradas pelo &lt;code&gt;npm install&lt;/code&gt; e garante que todas as pessoas do projeto, incluindo o seu CI, vão instalar as mesmas dependências e suas respectivas versões.&lt;/p&gt;
&lt;p&gt;Como cada commit tem seu snapshot do package-lock, você consegue voltar pra uma versão anterior da aplicação e reinstalar toda a árvore de dependências que funcionava quando o snapshot foi criado.&lt;/p&gt;
&lt;p&gt;O package-lock.json também indica quando uma dependência foi atualizada, te dando uma ótima visibilidade da árvore de dependências do seu projeto.&lt;/p&gt;
&lt;p&gt;E no CI, use o &lt;code&gt;npm ci&lt;/code&gt;, que instala exatamente o que tá no lock. Eu expliquei a diferença pro &lt;code&gt;npm install&lt;/code&gt; &lt;a href=&quot;https://ricmello.com/posts/npm-install-vs-npm-ci/&quot;&gt;nesse post&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&quot;pra-galera-do-yarn-yarnlock&quot;&gt;Pra galera do yarn: yarn.lock&lt;/h2&gt;
&lt;p&gt;E se você usa o yarn, isso também vale pra você. O yarn.lock tem a mesma funcionalidade do package-lock.json e também deve ser versionado.&lt;/p&gt;</content:encoded><category>npm</category><category>javascript</category><category>devops</category></item><item><title>React para devs Angular</title><link>https://ricmello.com/posts/react-para-devs-angular/</link><guid isPermaLink="true">https://ricmello.com/posts/react-para-devs-angular/</guid><description>Guia pra dev Angular aprender React: lib vs framework, criação do projeto com Vite, componentes, hooks no lugar de services, JSX, props e state.</description><pubDate>Mon, 09 Jan 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Já dizia o narrador em Joseph Climber, a vida de dev é uma caixinha de surpresas. Um dia você é dev Angular, no outro você acha uma oportunidade em uma empresa que você sempre quis trabalhar e quando vê a stack: React 🤦&lt;/p&gt;
&lt;p&gt;Em outro você é contratado pra uma consultoria para trabalhar com Angular, o seu projeto é cancelado na primeira semana e os caras perguntam “rola react?” 🤦 de novo.&lt;/p&gt;
&lt;p&gt;Pois é, os dois cenários aconteceram comigo em menos de um ano. Se adaptar à mudanças é uma skill importante, e isso não significa que você é um profissional ornitorrinco não. Só começa a ficar preocupante se você tiver um conhecimento superficial da stack mas o mais importante, independentemente do framework, são os fundamentos. E é sobre isso que eu pretendo escrever hoje: Como aprender React sendo um dev Angular.&lt;/p&gt;
&lt;p&gt;Cada tópico possui links para a documentação oficial para que você possa se aprofundar nos conceitos, mas é super importante saber que a curva de aprendizado é bem menor do que parece.&lt;/p&gt;
&lt;h2 id=&quot;o-que-é-o-react&quot;&gt;O que é o React&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://reactjs.org&quot;&gt;React&lt;/a&gt; é uma &lt;strong&gt;biblioteca&lt;/strong&gt; JavaScript para a construção de interfaces. E aqui começa a primeira diferença: o &lt;a href=&quot;https://angular.io&quot;&gt;Angular&lt;/a&gt; é um &lt;strong&gt;framework&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Por ser uma biblioteca, o React fornece uma série de funções para a construção de interfaces, mas deixa a cargo do desenvolvedor como usá-las em sua aplicação.&lt;/p&gt;
&lt;p&gt;Parte do sucesso do React vem dessa flexibilidade de ser relativamente não opinativo. Isso resultou em um ecossistema gigante de ferramentas em torno da lib, porém, ao mesmo tempo, você pode precisar de um pouco mais de esforço pra desenvolver uma aplicação do zero, porque precisamos passar um pouco mais de tempo configurando a estrutura do projeto e definindo/escolhendo os padrões.&lt;/p&gt;
&lt;p&gt;Isso pode ser bem esquisito pra quem vem do Angular já que o framework te dá uma série de guidelines a serem seguidos, mas é algo que se acostuma. Você também vai perceber que dá pra utilizar alguns padrões do Angular em um app React como rxjs, nx, etc. e a comunidade tem uma série de padrões próprios do React também.&lt;/p&gt;
&lt;p&gt;Eu sempre lembro de quando eu estava procurando referências sobre como criar a estrutura do projeto e caí num post do Dan Abramov dizendo que essa é a estrutura ideal: &lt;a href=&quot;http://react-file-structure.surge.sh&quot;&gt;http://react-file-structure.surge.sh&lt;/a&gt;. Isso mostra o quão livre nós estamos para criar nossos próprios padrões. Só não se esqueça: com grandes poderes vêm grandes responsabilidades.&lt;/p&gt;
&lt;h2 id=&quot;criação-de-um-projeto&quot;&gt;Criação de um projeto&lt;/h2&gt;
&lt;p&gt;Diferente do Angular onde o &lt;code&gt;ng new&lt;/code&gt; é quase um mantra, nós temos uma série de possibilidades diferentes ao criar um projeto react. Uma delas, inclusive, se resume em &lt;a href=&quot;https://reactjs.org/docs/add-react-to-a-website.html&quot;&gt;adicionar duas tags &lt;code&gt;&amp;lt;script&amp;gt;&lt;/code&gt; em um arquivo HTML qualquer&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;A forma recomendada pela documentação mais próxima da nossa realidade é o &lt;a href=&quot;https://reactjs.org/docs/create-a-new-react-app.html#create-react-app&quot;&gt;create-react-app&lt;/a&gt;, que gera um projeto configurado com scripts para executar a aplicação, rodar o build, etc. Pra isso, basta rodar o seguinte comando:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;npx create-react-app my-app --template typescript&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;O comando acima gera o projeto React configurado, e o flag &lt;code&gt;--template typescript&lt;/code&gt; adiciona a nossa linguagem do coração. Sem ele, o create-react-app gera um projeto javascript.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Atualização (2026):&lt;/strong&gt; o create-react-app foi oficialmente descontinuado pelo time do React em &lt;a href=&quot;https://react.dev/blog/2025/02/14/sunsetting-create-react-app&quot;&gt;fevereiro de 2025&lt;/a&gt;. Pra projeto novo, vá direto de Vite, que eu mostro logo abaixo.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3 id=&quot;vite&quot;&gt;Vite&lt;/h3&gt;
&lt;p&gt;Uma opção ainda melhor do que o create-react-app e que a comunidade já considera um novo padrão é o &lt;a href=&quot;https://vitejs.dev&quot;&gt;Vite&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;A proposta dos dois é parecida, mas enquanto o create-react-app usa o webpack, o vite usa o esbuild que é significativamente mais rápido, e essa diferença de velocidade vai crescendo junto com a aplicação.&lt;/p&gt;
&lt;p&gt;Pra criar um projeto com o Vite, é só rodar o comando abaixo e seguir as instruções:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;npm create vite@latest&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;componentes&quot;&gt;Componentes&lt;/h2&gt;
&lt;p&gt;Provavelmente o conceito mais importante do desenvolvimento front-end, a boa notícia é que a estrutura básica de um componente não muda de um framework pro outro.&lt;/p&gt;
&lt;p&gt;O ciclo de vida e os nomes das propriedades são diferentes, então você provavelmente vai ficar com a documentação debaixo do braço por algum tempo, mas não vai demorar muito pra acostumar. Dá uma olhada nessa comparação de um componente básico:&lt;/p&gt;
&lt;h3 id=&quot;componente-react&quot;&gt;Componente React&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;import React from &apos;react&apos;;
import &apos;./App.module.scss&apos;;

function App() {
  return &amp;lt;div className=&apos;App&apos;&amp;gt;Hello World&amp;lt;/div&amp;gt;;
}

export default App;&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&quot;componente-angular&quot;&gt;Componente Angular&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;import { Component } from &apos;@angular/core&apos;;

@Component({
  selector: &apos;app-root&apos;,
  template: `&amp;lt;div class=&quot;app&quot;&amp;gt;Hello World&amp;lt;/div&amp;gt;`,
  styleUrls: [&apos;./app.component.scss&apos;]
})
export class AppComponent {}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Enquanto a sintaxe é bem diferente, você pode perceber elementos muito similares. Ambos importam um arquivo scss, ambos possuem seus templates e ambos exportam seus componentes. Sendo assim, é possível usar o conhecimento que você já tem sempre que for criar um componente novo.&lt;/p&gt;
&lt;h3 id=&quot;ciclo-de-vida&quot;&gt;Ciclo de Vida&lt;/h3&gt;
&lt;p&gt;As funções do &lt;a href=&quot;https://pt-br.reactjs.org/docs/state-and-lifecycle.html&quot;&gt;ciclo de vida&lt;/a&gt; eram amplamente utilizadas pelos componentes de classe, mas como os componentes de função ganharam o gosto da galera, os &lt;a href=&quot;https://reactjs.org/docs/hooks-intro.html&quot;&gt;Hooks&lt;/a&gt; tomaram a cena e você pode pular direto pra estudar a utilização deles, principalmente o &lt;a href=&quot;https://reactjs.org/docs/hooks-effect.html&quot;&gt;Effect Hook&lt;/a&gt;, que é o cara que substitui os métodos do ciclo de vida em componentes de função.&lt;/p&gt;
&lt;h2 id=&quot;services&quot;&gt;Services&lt;/h2&gt;
&lt;p&gt;Já sobre services, diretivas, pipes… eles não existem.
&lt;img alt=&quot;Bola de feno no deserto&quot; width=&quot;500&quot; height=&quot;230&quot; src=&quot;https://ricmello.com/_astro/image-01.CcRgX5et_Z18YFnJ.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Nesse caso nós voltamos ao bom e velho JavaScript e criamos funções que serão utilizadas.&lt;/p&gt;
&lt;p&gt;Existem os &lt;a href=&quot;https://reactjs.org/docs/hooks-intro.html&quot;&gt;React Hooks&lt;/a&gt;, que você pode usar pra centralizar grande parte da sua lógica que iria para os services, mas eles são bem diferentes. Enquanto os services são injetáveis e possuem um conceito completamente diferente dos componentes, os hooks são uma forma de adicionar funcionalidades aos componentes, e são executados pelos próprios componentes.&lt;/p&gt;
&lt;h2 id=&quot;jsx&quot;&gt;JSX&lt;/h2&gt;
&lt;p&gt;Embora seja possível usar React sem JSX via &lt;a href=&quot;https://pt-br.reactjs.org/docs/react-api.html#createelement&quot;&gt;React.createElement()&lt;/a&gt;, na minha opinião não faz o mínimo sentido porque o código fica muito mais verboso.&lt;/p&gt;
&lt;p&gt;&lt;a href=&quot;https://pt-br.reactjs.org/docs/introducing-jsx.html&quot;&gt;O JSX&lt;/a&gt; (JavaScript XML) é uma extensão do JavaScript que te permite usar uma sintaxe similar à do HTML dentro do código JavaScript. Quando o código JSX for convertido pra JavaScript, ele é transformado em chamadas da função &lt;code&gt;React.createElement()&lt;/code&gt;. Isso significa que esse código:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const element = &amp;lt;h1&amp;gt;Hello, world!&amp;lt;/h1&amp;gt;;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Será convertido pra esse código durante o build:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// o segundo argumento são as props (aqui não tem nenhuma, por isso o null)
const element = React.createElement(&apos;h1&apos;, null, &apos;Hello, world!&apos;);&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Desde o React 17, os builds modernos usam o &lt;code&gt;react/jsx-runtime&lt;/code&gt; no lugar do &lt;code&gt;React.createElement()&lt;/code&gt;, mas a ideia é a mesma: o JSX vira chamada de função.&lt;/p&gt;
&lt;p&gt;O JSX é o formato recomendado e torna muito mais fácil a escrita dos templates. Há algumas pequenas diferenças em relação ao HTML como a classe CSS, em que você usa a propriedade &lt;code&gt;className&lt;/code&gt; ao invés de &lt;code&gt;class&lt;/code&gt; que é uma palavra reservada do JS, mas o fato de poder utilizar funções JS enquanto monta o template ajuda muito. Na minha opinião um &lt;code&gt;list.map(item =&amp;gt;{})&lt;/code&gt; é bem mais fácil de se fazer e entender do que um &lt;code&gt;*ngFor=&quot;let item of list&lt;/code&gt;“.&lt;/p&gt;
&lt;h2 id=&quot;props-e-state&quot;&gt;Props e State&lt;/h2&gt;
&lt;p&gt;As &lt;a href=&quot;https://reactjs.org/docs/components-and-props.html&quot;&gt;props&lt;/a&gt; são equivalentes aos &lt;code&gt;@Input&lt;/code&gt; do Angular, onde nós passamos as propriedades do componente. Cada prop estará disponível como um atributo do objeto &lt;code&gt;props&lt;/code&gt; da função do componente.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// Passando a prop title para o componente hello world
&amp;lt;Header title=&quot;Hey!&quot; /&amp;gt;

// Utilizando a prop na função
const Header = ({ title }) =&amp;gt; &amp;lt;h1&amp;gt;{title}&amp;lt;/h1&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;O React não possui um equivalente ao &lt;code&gt;@Output&lt;/code&gt;, mas nós podemos passar uma função de callback que será utilizada:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// Passando o callback de click para o componente de call to action
&amp;lt;CtaButton label=&quot;Click me&quot; onClick={() =&amp;gt; alert(&apos;Hello World&apos;)} /&amp;gt;

// Utilizando o callback no evento de clique do botão
const CtaButton = ({ label, onClick }) =&amp;gt;
  &amp;lt;button onClick={onClick}&amp;gt;{label}&amp;lt;/button&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&quot;state&quot;&gt;State&lt;/h3&gt;
&lt;p&gt;Além das props, cada componente possui o seu estado interno. Uma vez que esse estado é alterado, o componente renderiza novamente e o estado é mantido. Nós precisamos do hook &lt;a href=&quot;https://reactjs.org/docs/hooks-state.html&quot;&gt;useState()&lt;/a&gt; para acessar o estado de um componente de função.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import { useState } from &apos;react&apos;;

function App() {
  // Declarando uma nova variável de estado, que chamaremos de &quot;count&quot; e definimos como 0
  const [count, setCount] = useState(0);

  return (
    &amp;lt;div&amp;gt;
      &amp;lt;p&amp;gt;You clicked {count} times&amp;lt;/p&amp;gt;
      {/* Ao clicar no botão, chamamos a função setCount com o novo valor */}
      &amp;lt;button onClick={() =&amp;gt; setCount(count + 1)}&amp;gt;
        Click me
      &amp;lt;/button&amp;gt;
    &amp;lt;/div&amp;gt;
  );
}&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Embora eu tenha lutado com todas as minhas forças nos últimos anos, o React me levou pro time e eu tenho gostado bastante de trabalhar com ele.&lt;/p&gt;
&lt;p&gt;O React é mais simples que o Angular, isso é fato e a prova é que o Angular vem se tornando mais simples a cada release pra competir. Ter o conhecimento de Angular vai te fazer estar um passo à frente no quesito estrutura de projeto e padrões então o exercício maior é se aprofundar nos conceitos da lib enquanto põe alguns conceitos do Angular na geladeira.&lt;/p&gt;
&lt;p&gt;Somando isso a uma comunidade hypada cheia de ferramentas pra agilizar o desenvolvimento, nós temos uma facilidade muito grande de desenvolver projetos rapidamente sem comprometer a qualidade.&lt;/p&gt;
&lt;p&gt;Eu espero de verdade que você goste do framework e desse artigo, e se você chegou até aqui, tenta deixar um comentário com o que você gostaria de ver nos próximos posts e o que você achou do texto. Com isso, você me ajuda a definir os próximos temas :)&lt;/p&gt;</content:encoded><category>react</category><category>angular</category><category>frontend</category><category>javascript</category></item><item><title>Configurando um mac para desenvolvimento em 2022</title><link>https://ricmello.com/posts/configurando-um-mac-para-desenvolvimento-em-2022/</link><guid isPermaLink="true">https://ricmello.com/posts/configurando-um-mac-para-desenvolvimento-em-2022/</guid><description>Meu checklist de 2022 pra configurar um Mac de dev: Homebrew, nvm, Hyper, Oh My Zsh, Rectangle e uns ajustes de sistema que ninguém te conta.</description><pubDate>Mon, 13 Dec 2021 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Esse guia é pra você comprou um mac recentemente e não sabe por onde começar, ou precisa refrescar a memória sobre as principais ferramentas utilizadas no dia a dia de um dev.&lt;/p&gt;
&lt;h2 id=&quot;homebrew&quot;&gt;Homebrew&lt;/h2&gt;
&lt;p&gt;Provavelmente a ferramenta mais importante, o &lt;a href=&quot;https://brew.sh&quot;&gt;Homebrew&lt;/a&gt; (ou simplesmente brew) é o primeiro item da nossa lista. Esse cara é um gerenciador de pacotes que permite a instalação de várias ferramentas, aplicações e etc. direto pelo terminal com uma única linha de comando.&lt;/p&gt;
&lt;h3 id=&quot;chave-ssh&quot;&gt;Chave SSH&lt;/h3&gt;
&lt;p&gt;Eu precisei gerar uma chave SSH pra instalar o brew por limitações do GitHub. Pra gerar a chave, rode o comando &lt;code&gt;ssh-keygen&lt;/code&gt; no terminal. Ele vai pedir pra criar uma senha, definir o caminho pra salvar o arquivo e etc. Mas sendo bem sincero eu sou preguiçoso e saio apertando enter pra usar os valores padrões.&lt;/p&gt;
&lt;h3 id=&quot;brew&quot;&gt;Brew&lt;/h3&gt;
&lt;p&gt;Agora, vamos ao brew. Pra instalar, rode o seguinte comando no terminal:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;/bin/bash -c &quot;$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)&quot;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Esse comando foi copiado do site oficial do Brew, mas você também pode pegar de lá: &lt;a href=&quot;https://brew.sh&quot;&gt;https://brew.sh&lt;/a&gt;&lt;/p&gt;
&lt;h2 id=&quot;nvm&quot;&gt;NVM&lt;/h2&gt;
&lt;p&gt;Mesmo que você não seja um dev JavaScript, é bem possível que você use o Node.js pra alguma tarefa do dia a dia. O nvm permite a instalação de mais de uma versão do node, além de te ajudar a fugir de alguns &lt;a href=&quot;https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally&quot;&gt;erros de permissão&lt;/a&gt;, os famosos EACCES.&lt;/p&gt;
&lt;p&gt;Com o brew instalado, rode o comando abaixo e ele faz a mágica:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;brew install nvm&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Após a instalação do nvm, você pode instalar a versão LTS do node com o seguinte comando:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;nvm install --lts&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;hyper&quot;&gt;Hyper&lt;/h2&gt;
&lt;p&gt;O &lt;a href=&quot;https://hyper.is&quot;&gt;Hyper&lt;/a&gt; é um terminal da Vercel feito com tecnologias web e que cresceu bastante na comunidade. Muita gente prefere o &lt;a href=&quot;https://iterm2.com&quot;&gt;iTerm2&lt;/a&gt; mas eu fico com o Hyper pela fluidez da interface e pela simplicidade, tanto da configuração (um arquivo JSON) quanto da utilização.&lt;/p&gt;
&lt;p&gt;Pra instalar, vamos usar o brew mais uma vez:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;brew install hyper&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Um comportamento que quem vem de outros terminais pode estranhar, é que o hyper sempre abre uma nova aba a partir da home, e não da pasta local. Pra resolver isso, instale a extensão hypercwd rodando o seguinte comando no Hyper:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hyper i hypercwd&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Aproveita e dá uma olhada nos &lt;a href=&quot;https://hyper.is/plugins&quot;&gt;plugins&lt;/a&gt; e na &lt;a href=&quot;https://hyper.is/themes&quot;&gt;loja de temas&lt;/a&gt; do Hyper e escolhe um pra você. Eu uso o Solarized Dark e se você quiser experimentar rode o comando abaixo:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hyper i hyper-solarized-dark&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;oh-my-zsh&quot;&gt;Oh My Zsh&lt;/h2&gt;
&lt;p&gt;Ainda turbinando o seu terminal, vamos ao Oh My Zsh, que é uma baita ferramenta com vários helpers, plugins e funcionalidades que acaba ficando complicado detalhar num post só, mas se você quiser mais sobre o projeto é só acessar a página oficial em &lt;a href=&quot;https://ohmyz.sh&quot;&gt;https://ohmyz.sh&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Pra instalar, rode o seguinte comando retirado do site oficial:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sh -c &quot;$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)&quot;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Pode ser necessário reabrir o Hyper depois de instalar o Zsh, mas você vai notar a diferença de cara.&lt;/p&gt;
&lt;h2 id=&quot;rectangle&quot;&gt;Rectangle&lt;/h2&gt;
&lt;p&gt;Um outro cara que deve ser mencionado é o &lt;a href=&quot;https://rectangleapp.com&quot;&gt;Rectangle&lt;/a&gt;, que permite mover e redimensionar janelas sem a utilização de um mouse. Se você é da antiga, provavelmente usava um cara chamado &lt;a href=&quot;https://www.spectacleapp.com&quot;&gt;Spectacle&lt;/a&gt;, só que depois que ele foi descontinuado a comunidade passou a recomendar o Rectangle como a melhor alternativa. Pra instalar, vamos de brew:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;brew install rectangle&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;configurações-do-sistema&quot;&gt;Configurações do sistema&lt;/h2&gt;
&lt;p&gt;Aqui vão algumas configurações do próprio sistema que podem te ajudar:&lt;/p&gt;
&lt;h3 id=&quot;mouse&quot;&gt;Mouse&lt;/h3&gt;
&lt;p&gt;Eu acho que o mouse fica bem lento quando eu coloco no mac, tanto o meu logitech quanto o da apple. Pelo terminal, é possível configurar velocidades maiores do que nas preferências do sistema. Pra ver a velocidade atual, o comando é:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;defaults read -g com.apple.mouse.scaling &lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Pra definir a velocidade:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;defaults write -g com.apple.mouse.scaling  5.0&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Você pode definir um número até 7.0, e precisa reiniciar o computador depois de setar a configuração. Pra efeito de comparação, a configuração máxima setada via preferências do sistema é de 3.0&lt;/p&gt;
&lt;h3 id=&quot;corretor-ortográfico&quot;&gt;Corretor ortográfico&lt;/h3&gt;
&lt;p&gt;O cara que acaba atrapalhando pode ser desabilitado. Se você também não é muito fã do corretor, siga os passos abaixo:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;No Mac, escolha menu Apple 🍎 &amp;gt; Preferências do Sistema &amp;gt; Teclado &amp;gt; Texto.&lt;/li&gt;
&lt;li&gt;Desabilite a opção “Corrigir ortografia automaticamente”.&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&quot;finish-him&quot;&gt;Finish Him&lt;/h2&gt;
&lt;p&gt;Essas são as principais configurações que eu faço quando configuro um mac novo. Em 2021 eu acabei fazendo isso umas 4x e foi bem cansativo ficar lembrando, então estou compartilhando aqui.&lt;/p&gt;
&lt;p&gt;Você com certeza vai precisar de ferramentas mais específicas pro seu campo de atuação, mas imagino que todos os itens acima sejam genéricos e vão ajudar independente da especialidade.&lt;/p&gt;
&lt;p&gt;Segue alguns links úteis:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.jetbrains.com/pt-br/webstorm/&quot;&gt;WebStorm&lt;/a&gt;: a minha IDE favorita&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://code.visualstudio.com&quot;&gt;VS Code&lt;/a&gt;: a IDE favorita da comunidade&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.android.com/studio&quot;&gt;Android Studio&lt;/a&gt;: a IDE pra desenvolvimento com Flutter/Android&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://apps.apple.com/br/app/xcode/id497799835&quot;&gt;Xcode&lt;/a&gt;: um must-have pra quem desenvolve pra Mac e iOS, inclusive com flutter.&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.google.com/chrome/&quot;&gt;Google Chrome&lt;/a&gt;: Dispensa explicações&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://discord.com&quot;&gt;Discord&lt;/a&gt;: A melhor ferramenta de comunicação que você vai achar&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.postman.com&quot;&gt;Postman&lt;/a&gt;: Um must-have quando se trata de trabalhar com APIs REST, seja desenvolvendo ou consumindo&lt;/li&gt;
&lt;/ul&gt;</content:encoded><category>ferramentas</category><category>carreira</category></item><item><title>Como criar e publicar uma aplicação Angular no Amazon S3</title><link>https://ricmello.com/posts/publicar-aplicacao-angular-no-amazon-s3/</link><guid isPermaLink="true">https://ricmello.com/posts/publicar-aplicacao-angular-no-amazon-s3/</guid><description>Tutorial de 2021 pra publicar um app Angular no S3 como site estático, do ng build à bucket policy. Pra produção hoje, use bucket privado com CloudFront.</description><pubDate>Mon, 04 Oct 2021 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Angular + AWS S3 Logos&quot; width=&quot;1280&quot; height=&quot;500&quot; src=&quot;https://ricmello.com/_astro/image-01.D7aKfdyZ_28M9F9.webp&quot;&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Atualização (2026):&lt;/strong&gt; deixar o bucket público, como eu faço nesse post, não é mais recomendado. Desde abril de 2023 a AWS cria todo bucket novo com o Block Public Access ligado, e o jeito certo é manter o bucket privado com o CloudFront na frente. Eu mostro como &lt;a href=&quot;https://ricmello.com/posts/hospedar-spa-angular-react-com-s3-route-53-e-cloudfront/&quot;&gt;nesse post aqui&lt;/a&gt;. E se você usa Angular 17 ou mais novo, o build vai pra &lt;code&gt;dist/&amp;lt;nome-do-app&amp;gt;/browser&lt;/code&gt;, então é o conteúdo dessa pasta que você sobe pro bucket.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Se você ainda hospeda as suas aplicações frontend em servidores web como apache ou nginx, sinto dizer mas você provavelmente está perdendo dinheiro.&lt;/p&gt;
&lt;p&gt;Quando se fala em serverless, sempre pensamos no Lambda da AWS, no Google Cloud Functions, App Engine, etc. Eu mesmo hospedei aplicações Angular usando contêineres por bastante tempo, até surgir a seguinte dúvida:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Se servimos arquivos estáticos, pra que diabos a gente precisa subir um servidor?&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;No começo, ferramentas como S3 e Google Cloud Storage não serviam pra muita coisa senão armazenar e servir arquivos, mas conforme a nuvem foi evoluindo, esses serviços se tornaram ferramentas bastante poderosas a ponto de podermos utilizá-las para hospedar uma Single Page Application, eliminando a necessidade de subirmos servidores pra isso.&lt;/p&gt;
&lt;p&gt;Mas chega de papo furado. Mão na massa!&lt;/p&gt;
&lt;h2 id=&quot;criando-a-aplicação&quot;&gt;Criando a aplicação&lt;/h2&gt;
&lt;p&gt;Nesse artigo, vamos usar o “hello world” do Angular como exemplo, que é o app gerado com o ng new. Antes de continuar, você precisa dos seguintes requisitos:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Possuir a &lt;a href=&quot;http://nodejs.org&quot;&gt;versão LTS do Node.js&lt;/a&gt; instalada&lt;/li&gt;
&lt;li&gt;Instalar o Angular CLI com o comando npm install -g @angular/cli&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Com o node e o CLI instalado, basta rodar o comando ng new my-s3-app para criar o seu app. Ele vai te perguntar duas coisas:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Would you like to add Angular routing? (y/N)&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Which stylesheet format would you like to use?&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Na prática não faz muita diferença o que escolhermos aqui, mas por força do hábito eu sempre escolho adicionar o routing (preencha y e aperte enter) e selecionar o SCSS (use as setas e pressione enter) para os estilos.&lt;/p&gt;
&lt;p&gt;Feito isso o Angular vai gerar a aplicação e instalar as dependências necessárias pro seu projeto ser executado. Abra a pasta do projeto no terminal e digite um ng serve para executar o servidor localmente e ver se está tudo certo. Acesse localhost:4200 no navegador, você deve ver a seguinte página:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Uma captura de tela da página que o Angular cria quando geramos uma aplicação com o Angular CLI.&quot; width=&quot;1400&quot; height=&quot;1185&quot; src=&quot;https://ricmello.com/_astro/image-02.B7D1wXCW_Z2oKHeY.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Rode o comando ng build no terminal. Ele deve gerar uma pasta &lt;strong&gt;dist&lt;/strong&gt; dentro do projeto com a versão de produção do seu app. Lembra dessa pasta porque são os arquivos dela que nós vamos subir pro S3. O meu gerou assim:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Captura de tela do console indicando os arquivos que foram gerados: main, polyfills, runtime e styles.&quot; width=&quot;1400&quot; height=&quot;480&quot; src=&quot;https://ricmello.com/_astro/image-03._ov4VbzR_i2ep9.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;publicando-no-amazon-s3&quot;&gt;Publicando no Amazon S3&lt;/h2&gt;
&lt;p&gt;Agora, vamos publicar a nossa aplicação no S3. Antes disso você vai precisar de uma conta AWS para continuar. Caso não tenha, você pode se cadastrar em &lt;a href=&quot;https://aws.amazon.com&quot;&gt;https://aws.amazon.com&lt;/a&gt;. No primeiro ano, você vai poder testar vários serviços sem pagar nada por causa da camada gratuita. É uma ótima oportunidade pra experimentar diferentes serviços e configurações.&lt;/p&gt;
&lt;h3 id=&quot;criando-o-bucket&quot;&gt;Criando o Bucket&lt;/h3&gt;
&lt;p&gt;Uma vez logado no console, selecione o menu &lt;strong&gt;Services&lt;/strong&gt; &amp;gt; &lt;strong&gt;Storage&lt;/strong&gt; &amp;gt; &lt;strong&gt;S3&lt;/strong&gt; para acessar o console do S3. No console, precisaremos criar um bucket, que é onde vamos armazenar a nossa aplicação. O nome do bucket é único entre todas as contas da AWS, e além disso ele fará parte do nome de domínio, então precisamos escolher um nome específico que ainda não tenha sido usado, mas ao mesmo tempo não usarmos um nome esquisito porque ele vai ficar exposto.&lt;/p&gt;
&lt;p&gt;Dependendo da região, o S3 pode usar dois formatos de URL:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;s3-website dash (-) Region&lt;/strong&gt; ‐ &lt;a href=&quot;http://bucket-name.s3-website-Region.amazonaws.com&quot;&gt;http://nomedobucket.s3-website-&lt;/a&gt;&lt;a href=&quot;http://bucket-name.s3-website-Region.amazonaws.com&quot;&gt;&lt;em&gt;Region&lt;/em&gt;&lt;/a&gt;&lt;a href=&quot;http://bucket-name.s3-website-Region.amazonaws.com&quot;&gt;.amazonaws.com&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;s3-website dot (.) Region&lt;/strong&gt; ‐ &lt;a href=&quot;http://bucket-name.s3-website.Region.amazonaws.com&quot;&gt;http://&lt;/a&gt;&lt;a href=&quot;http://bucket-name.s3-website.Region.amazonaws.com&quot;&gt;&lt;em&gt;nomedobucket&lt;/em&gt;&lt;/a&gt;&lt;a href=&quot;http://bucket-name.s3-website.Region.amazonaws.com&quot;&gt;.s3-website.&lt;/a&gt;&lt;a href=&quot;http://bucket-name.s3-website.Region.amazonaws.com&quot;&gt;&lt;em&gt;Region&lt;/em&gt;&lt;/a&gt;&lt;a href=&quot;http://bucket-name.s3-website.Region.amazonaws.com&quot;&gt;.amazonaws.com&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Segue abaixo a minha configuração. Essa página tem várias outras opções, mas você pode ignorar e clicar em &lt;strong&gt;Create Bucket&lt;/strong&gt; no rodapé.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Captura de tela da minha configuração de bucket do S3&quot; width=&quot;1400&quot; height=&quot;1067&quot; src=&quot;https://ricmello.com/_astro/image-04.Cpg5eUWo_gvCMR.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Eu criei um bucket com o nome &lt;strong&gt;my-angular-s3-app&lt;/strong&gt; na Region &lt;strong&gt;us-west-2&lt;/strong&gt;. Todas as outras opções podem permanecer com seus valores default.&lt;/p&gt;
&lt;p&gt;Ao clicar em &lt;strong&gt;Create Bucket&lt;/strong&gt; , ele deve ficar disponível pra você no console do S3:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Captura de tela do console do S3 listando o bucket recém criado.&quot; width=&quot;1400&quot; height=&quot;608&quot; src=&quot;https://ricmello.com/_astro/image-05.TJK6iQSJ_2vs3D4.webp&quot;&gt;&lt;/p&gt;
&lt;h3 id=&quot;subindo-os-arquivos&quot;&gt;Subindo os arquivos&lt;/h3&gt;
&lt;p&gt;Clique no bucket que acabamos de criar, depois clique em upload e depois em add files. Vá para a pasta &lt;strong&gt;dist&lt;/strong&gt; &amp;gt; &lt;strong&gt;my-s3-app&lt;/strong&gt; que o ng build acabou de gerar e selecione todos os arquivos usando o mouse, ctrl+a (windows) ou cmd+a (mac). Você deve ver esse resultado:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Captura da tela de upload com os arquivos selecionados, listando os arquivos: 3rdpartylicences.txt, favicon.icon, index.html, etc.&quot; width=&quot;1400&quot; height=&quot;1083&quot; src=&quot;https://ricmello.com/_astro/image-06.C6J8sAht_1m5xag.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Se tudo estiver certo, basta clicar em upload, esperar a confirmação e partir pra próxima.&lt;/p&gt;
&lt;h3 id=&quot;ativando-a-hospedagem&quot;&gt;Ativando a hospedagem&lt;/h3&gt;
&lt;p&gt;Agora, para ativarmos a hospedagem de sites estáticos, vá em &lt;strong&gt;Properties&lt;/strong&gt; &amp;gt; &lt;strong&gt;Static website hosting&lt;/strong&gt; &amp;gt;  &lt;strong&gt;Edit&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Na página de edição, selecione &lt;strong&gt;enable&lt;/strong&gt; para habilitar a hospedagem de sites estáticos. Preencha index.html nos campos Index e Error document e salve as alterações.&lt;/p&gt;
&lt;p&gt;Ao voltar na aba properties, uma URL terá sido criada:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Captura de tela da área Static website hosting com a url criada&quot; width=&quot;1400&quot; height=&quot;443&quot; src=&quot;https://ricmello.com/_astro/image-07.Debffyft_1y8LcJ.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Porém, ao tentar acessar, você verá a seguinte mensagem:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Erro ao tentar acessar o bucket porque ele ainda está sem permissões de visualização.&quot; width=&quot;1400&quot; height=&quot;454&quot; src=&quot;https://ricmello.com/_astro/image-08.B0JdHOiW_1qHutC.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Isso acontece porque todos os buckets são privados por padrão, tornando-os inacessíveis.&lt;/p&gt;
&lt;p&gt;Para alterar isso, ainda no Bucket, vamos precisar ir na aba &lt;strong&gt;Permissions&lt;/strong&gt; &amp;gt; &lt;strong&gt;Block public access&lt;/strong&gt; &amp;gt;  &lt;strong&gt;Edit&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Captura de tela das alterações feitas nas configurações de acesso do bucket. As alterações estão descritas logo abaixo.&quot; width=&quot;1400&quot; height=&quot;1047&quot; src=&quot;https://ricmello.com/_astro/image-09.DhDcuJGh_2bEYUC.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Nessa tela, desmarcamos a opção &lt;strong&gt;Block &lt;em&gt;all&lt;/em&gt; public access&lt;/strong&gt; e deixamos marcado somente as opções:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Block public access to buckets and objects granted through &lt;em&gt;new&lt;/em&gt; access control lists (ACLs)&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Block public access to buckets and objects granted through &lt;em&gt;any&lt;/em&gt; access control lists (ACLs)&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Além disso, vamos precisar criar uma policy para garantir acesso anônimo para que os usuários possam acessar o bucket. Ainda na aba &lt;strong&gt;Permissions&lt;/strong&gt; , vá em &lt;strong&gt;Bucket policy&lt;/strong&gt; &amp;gt; &lt;strong&gt;Edit&lt;/strong&gt;. Cole o conteúdo abaixo, substituindo a tag pelo nome do seu bucket:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;{
  &quot;Version&quot;: &quot;2012-10-17&quot;,
  &quot;Statement&quot;: [
    {
      &quot;Sid&quot;: &quot;AllowPublicAccess&quot;,
      &quot;Action&quot;: [
        &quot;s3:GetObject&quot;
      ],
      &quot;Effect&quot;: &quot;Allow&quot;,
      &quot;Resource&quot;: &quot;arn:aws:s3:::my-angular-s3-app/*&quot;,
      &quot;Principal&quot;: &quot;*&quot;
    }
  ]
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A minha ficou assim:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Captura de tela da minha policy feita seguindo as instruções&quot; width=&quot;1400&quot; height=&quot;628&quot; src=&quot;https://ricmello.com/_astro/image-10.DLc_xYrg_1H2DMn.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;É importante permitir somente o GetObject, assim os usuários poderão visualizar a aplicação mas não vão conseguir alterar nenhum conteúdo do nosso bucket.&lt;/p&gt;
&lt;h3 id=&quot;sucesso&quot;&gt;Sucesso!&lt;/h3&gt;
&lt;p&gt;Agora é correr pro abraço. Acesse o link fornecido em static web hosting novamente e você vai ver a página rodando:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Captura de tela do site rodando no link do S3.&quot; width=&quot;1400&quot; height=&quot;1054&quot; src=&quot;https://ricmello.com/_astro/image-11.Di9-7ctl_Z2tEq6c.webp&quot;&gt;&lt;/p&gt;</content:encoded><category>aws</category><category>angular</category><category>frontend</category><category>devops</category></item><item><title>Conheça o Locus</title><link>https://ricmello.com/posts/conheca-o-locus/</link><guid isPermaLink="true">https://ricmello.com/posts/conheca-o-locus/</guid><description>Conheça o Locus, app open-source que criamos na TOTVS pra fazer check-in em mesas e áreas comuns via QR Code e acompanhar a ocupação do escritório.</description><pubDate>Tue, 04 May 2021 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Ilustração isométrica de um escritório de software com pessoas trabalhando em mesas e conversando&quot; width=&quot;1400&quot; height=&quot;1050&quot; src=&quot;https://ricmello.com/_astro/image-01.BClz1T_O_Z2fWlzo.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Fonte: [Freepik](https://www.freepik.com/free-vector/programmers-software-development-company-during-work-office-isometric-horizontal_6869592.htm)&lt;/p&gt;
&lt;p&gt;Alguns meses após o início da pandemia, não sabíamos muito bem pra onde ir. Empresas falavam em reabertura de escritórios, outras falavam em nunca mais voltar, e devido a inexperiência com uma situação que ocorrera há 100 anos atrás era como se cada pessoa andasse com um monte de interrogações na cabeça.&lt;/p&gt;
&lt;p&gt;Como Engenheiro de Software, uma certeza eu tinha: não voltaria pro escritório tão cedo. Talvez nunca. O trabalho remoto não é perfeito, mas os ganhos superam as perdas e depois de mais de um ano trabalhando dessa forma, eu ainda não consigo me enxergar voltando pro escritório mesmo no pós-pandemia, inclusive escrevi sobre isso: &lt;a href=&quot;https://ricmello.com/posts/o-trabalho-remoto-veio-pra-ficar/&quot;&gt;O trabalho remoto veio pra ficar&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Porém, algumas funções e perfis dependem de ir ao escritório, mesmo que de forma intermitente, seja para socializar de uma forma mais humana ou pra cumprir tarefas que ainda não foram migradas pro mundo virtual.&lt;/p&gt;
&lt;p&gt;Pensando nisso, nós recebemos o desafio de construir um app que permitisse aos colaboradores fazerem check-in nas mesas e nas áreas comuns para sinalizar que estão lá. Um mapa seria criado e seria possível saber quantas e quais mesas estavam ocupadas, e a lotação das áreas comuns. Esse app seria utilizado por nada mais, nada menos que a TOTVS. Assim nasceu o Locus.&lt;/p&gt;
&lt;h2 id=&quot;o-que-é-olocus&quot;&gt;O que é o Locus&lt;/h2&gt;
&lt;p&gt;Um app simples que consiste em um único propósito: controlar espaços internos. Pode ser utilizado para gerenciar vagas de mesas, ocupação da copa, das salas de reunião, ou de qualquer outra coisa que você imaginar.&lt;/p&gt;
&lt;p&gt;O funcionamento é super simples, onde o colaborador faz o check-in em um determinado lugar, e nós registramos essa entrada em nossa base. Caso o colaborador se dirija a outro lugar e faça check-in novamente, o app faz check-out no local anterior automaticamente, sinalizando a saída.&lt;/p&gt;
&lt;p&gt;Tudo é feito por meio de QR Codes impressos, com isso temos um custo super baixo de implantação. O Locus também gera os arquivos para impressão.&lt;/p&gt;
&lt;p&gt;Utilizando ferramentas de relatórios como o Metabase, é possível trabalhar esses dados e montar dashboards com indicadores de ocupação e disponibilidade.&lt;/p&gt;
&lt;h2 id=&quot;o-projeto&quot;&gt;O Projeto&lt;/h2&gt;
&lt;p&gt;O Locus é open-source, e está disponível no &lt;a href=&quot;https://github.com/locus-manager/locus&quot;&gt;GitHub&lt;/a&gt;. Você pode utilizar na sua infra local ou fazer o deploy para algum serviço em nuvem sem qualquer custo. Colaborações são super bem-vindas.&lt;/p&gt;</content:encoded><category>trabalho-remoto</category><category>ferramentas</category></item><item><title>O trabalho remoto veio pra ficar</title><link>https://ricmello.com/posts/o-trabalho-remoto-veio-pra-ficar/</link><guid isPermaLink="true">https://ricmello.com/posts/o-trabalho-remoto-veio-pra-ficar/</guid><description>Por que o trabalho remoto vale a pena pra empresa e pro dev, o erro de trocar o tempo de deslocamento por hora extra e dicas pro seu escritório em casa.</description><pubDate>Mon, 29 Mar 2021 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Mulher trabalhando no notebook sentada na cama, com um golden retriever dormindo em primeiro plano&quot; width=&quot;1400&quot; height=&quot;933&quot; src=&quot;https://ricmello.com/_astro/image-01.C4LjMbDe_Z1q9WoR.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Foto por [BRUNO EMMANUELLE](https://unsplash.com/@brunocervera?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText) no [Unsplash](https://unsplash.com/?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText)&lt;/p&gt;
&lt;p&gt;O trabalho remoto no Brasil era algo que pouquíssimas empresas do mercado de TI praticavam. Algumas permitiam o trabalho remoto de forma pontual, e a maioria rejeitava achando que o desenvolvedor produziria menos do que no escritório.&lt;/p&gt;
&lt;p&gt;A pandemia chegou, o COVID está aí até agora e se tem uma certeza que aprendemos durante o ano de 2020 é que o trabalho remoto não será algo passageiro, e tende a aumentar cada vez mais.&lt;/p&gt;
&lt;h2 id=&quot;é-mais-vantajoso-pra-empresa&quot;&gt;É mais vantajoso pra empresa&lt;/h2&gt;
&lt;p&gt;Eu já vi empresas permitirem o trabalho remoto em troca de um salário menor. E isso não faz o mínimo sentido porque é vantajoso pra eles também.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;GIF dos Simpsons: funcionários bajulando o Sr. Burns com “Absolutely. Genius. Oh, yes, sir.”&quot; width=&quot;480&quot; height=&quot;366&quot; src=&quot;https://ricmello.com/_astro/image-02.CynmFl8-_XgFeI.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Energia, água, aluguel… por mais que algumas forneçam ajuda de custos, grande parte do dinheiro dessas contas passa a sair do bolso do trabalhador. Óbvio que a empresa não vai pagar o seu aluguel, mas ela precisa de um escritório muitas vezes de um ou vários andares pra conseguir acomodar um bom número de funcionários.&lt;/p&gt;
&lt;p&gt;Esses custos diminuem quando ela mantém os funcionários em casa e cria vagas rotativas em seus escritórios, que podem ter tamanhos bem menores. Em casa você gasta mais água, energia… coisas que antes você consumia da empresa passaram a sair do seu bolso. Isso permite à empresa ter budget pra contratar mais pessoas e, consequentemente, aumentar a produtividade.&lt;/p&gt;
&lt;p&gt;Há quem diga que não, mas na minha experiência a produtividade do time aumenta e bastante durante o trabalho remoto. As pessoas se tornam mais focadas sem as distrações do escritório e precisam ser mais objetivas durante as famosas calls. As pessoas também são pressionadas a se tornarem mais independentes devido à sensação de estar sozinho, e isso faz com que elas evoluam profissionalmente.&lt;/p&gt;
&lt;h2 id=&quot;é-mais-vantajoso-para-o-profissional-também&quot;&gt;É mais vantajoso para o profissional também&lt;/h2&gt;
&lt;p&gt;Duas horas ou mais de deslocamento. Se você trabalha em uma grande cidade, provavelmente vive ou conhece alguém que vive essa realidade.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;GIF de uma mulher exausta, chorando com a mão no rosto&quot; width=&quot;480&quot; height=&quot;296&quot; src=&quot;https://ricmello.com/_astro/image-03.Com9e-Hl_Z12s15U.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Com o trabalho remoto, é como se você ganhasse uma parte da sua vida de volta. Aqui no Rio, por exemplo, eu demorava 1 hora e 40 minutos de casa até o trabalho. Era surreal e eu ainda precisava pegar duas conduções, o que significa que mesmo dormindo no ônibus, você ainda ia precisar acordar pra pegar o outro e tentar dormir de novo (eu só conseguia dormir no segundo).&lt;/p&gt;
&lt;p&gt;Minha solução foi encarar os valores de imóveis do Rio e me mudar pra um bairro próximo à empresa. Minha qualidade de vida aumentou consideravelmente, mesmo morando em um apartamento pequeno, enquanto minha conta bancária ficou bastante chateada comigo.&lt;/p&gt;
&lt;p&gt;Trabalhar de forma remota me permitiu morar no interior do Rio de Janeiro e continuar trabalhando pra uma grande empresa. A qualidade de vida aumentou ainda mais, porque sabemos que a vida no interior é bem mais tranquila, e a minha conta começou até a dar uns sorrisos de vez em quando.&lt;/p&gt;
&lt;p&gt;Além disso, o equilíbrio entre a vida real e a vida profissional aumentam porque gastando menos tempo no trânsito, você tem mais tempo pra fazer o que quiser.&lt;/p&gt;
&lt;h2 id=&quot;por-que-você-pode-estar-fazendo-isso-errado&quot;&gt;Por que você pode estar fazendo isso errado&lt;/h2&gt;
&lt;p&gt;Graças ao trabalho remoto repentino combinado à pandemia do COVID, nem todo mundo soube investir esse tempo extra e eu demorei bastante pra perceber onde estava errando:&lt;/p&gt;
&lt;p&gt;As horas a mais são suas, não da empresa.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;GIF de um filhote de panda abraçando uma bola e se recusando a soltar quando alguém tenta pegar&quot; width=&quot;238&quot; height=&quot;198&quot; src=&quot;https://ricmello.com/_astro/image-04.DgENt7Vk_8ENvw.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Na carreira de TI, a gente costuma ter um histórico de trabalhar além do normal pra entregar projetos mal estimados ou com prazos impostos. Muitos de nós demoravam 2 horas pra chegar na empresa, trabalhavam e faziam hora extra pra levar mais 2 horas pra chegar em casa. Se você somar:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;deslocamento + 1º turno + almoço + 2º turno + deslocamento&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;2 + 4 + 1 + 4 + 2 = 13 horas. Considerando que você deveria dormir de 7 a 8 horas por dia, sobraria umas 3 horas pra viver. Menos de 15% do seu dia. Se somar as horas extras, a conta piora.&lt;/p&gt;
&lt;p&gt;Infelizmente essa é a realidade da maioria das pessoas, e com a pandemia e o isolamento social, tivemos um boom de pessoas trocando as horas ganhas com o deslocamento por &lt;strong&gt;hora extra&lt;/strong&gt;. Muitas das vezes de graça mesmo.&lt;/p&gt;
&lt;p&gt;Isso está completamente errado. Devemos alcançar o equilíbrio entre vida profissional e vida social, e empresas e funcionários devem conversar abertamente sobre isso.&lt;/p&gt;
&lt;p&gt;Muitas das vezes existe a pressão da empresa em entregar projetos em prazos que não fazem sentido, e que são inegociáveis porque o cliente A ou B quer o projeto pronto pra fechar negócio, e o funcionário vê nessa nova situação uma oportunidade de atingir suas metas.&lt;/p&gt;
&lt;p&gt;E em outras, depois de tanto trabalhar e se deslocar, a pessoa esquece como ela era antes de ter entrado nessa, esquecendo suas ambições e prazeres. O medo do tédio provocado por esse vácuo de tempo que a falta do deslocamento deixou, faz com que essas pessoas trabalhem sem parar para se sentirem completas, e isso é bem triste.&lt;/p&gt;
&lt;p&gt;Em ambos os casos, é preciso conversar. Seja com amigos para relembrar como você era e se divertir, ou com a empresa para que eles entendam que o modelo de trabalho do time não é saudável. E se mesmo assim a sua empresa não te ouvir, há várias outras por aí pra te acolher. Se capacite, mantenha-se atualizado e vá à procura.&lt;/p&gt;
&lt;h2 id=&quot;invista-no-seu-escritório-particular&quot;&gt;Invista no seu Escritório Particular&lt;/h2&gt;
&lt;p&gt;Meus pais sempre me diziam que não há nada como o aconchego do seu lar. Ao montar um escritório em casa, essa máxima tem que prevalecer. A menos que você tenha uma grana considerável pra investir de início, vá aos poucos, mas compre produtos de qualidade que não vão te dar dor de cabeça depois de um certo tempo de uso.&lt;/p&gt;
&lt;p&gt;Considere usar uma cadeira ergonômica ao invés das tradicionais cadeiras gamer, e uma mesa sit-to-stand pra que você não fique sentado por muito tempo. Tente separar uma área da casa específica pra isso e, se não for possível, converse com os membros da sua família para respeitarem o seu espaço o máximo possível, principalmente durante as calls.&lt;/p&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;O trabalho remoto é uma relação de ganha-ganha, e por isso é tão vantajoso. Se você não consegue enxergar as vantagens dessa modalidade, provavelmente precisa equilibrar um pouco mais a sua balança.&lt;/p&gt;
&lt;p&gt;Mas esteja preparado. As empresas gostaram bastante dessa modalidade de trabalho e a expectativa é que, com o fim da pandemia, várias abordem uma jornada híbrida ou continuem de forma remota no futuro.&lt;/p&gt;</content:encoded><category>trabalho-remoto</category><category>carreira</category></item><item><title>Angular: Criando um Componente de Ícones pro seu projeto</title><link>https://ricmello.com/posts/angular-componente-de-icones/</link><guid isPermaLink="true">https://ricmello.com/posts/angular-componente-de-icones/</guid><description>Passo a passo pra criar um componente de ícones SVG no Angular, com cache e estilo via CSS (cor e tamanho), sem tag img e sem instalar nenhuma lib.</description><pubDate>Thu, 18 Feb 2021 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Ilustração de engrenagens brancas em estilo blueprint sobre fundo azul quadriculado&quot; width=&quot;1400&quot; height=&quot;1027&quot; src=&quot;https://ricmello.com/_astro/image-01.DUyNIZMq_Z1z8YSk.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Imagem de [Pete Linforth](https://pixabay.com/pt/users/thedigitalartist-202249/?utm_source=link-attribution&amp;amp;utm_medium=referral&amp;amp;utm_campaign=image&amp;amp;utm_content=3804745) por [Pixabay](https://pixabay.com/pt/?utm_source=link-attribution&amp;amp;utm_medium=referral&amp;amp;utm_campaign=image&amp;amp;utm_content=3804745)&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Se quiser pular a explicação, &lt;a href=&quot;https://github.com/ricardo-mello/icon-component-sample/tree/result&quot;&gt;tá aqui o link&lt;/a&gt; do resultado final.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Dependendo do seu projeto trabalhar com SVG pode ser uma benção e uma maldição.&lt;/p&gt;
&lt;p&gt;O SVG é super flexível, porque ele se adapta aos diferentes tipos de tela sem perder a resolução e também pode ser estilizado via CSS. Porém, uma das formas mais comuns de utilização é por meio da tag img, e isso é um problema porque quando você trata o SVG como imagem, ele perde todas as possibilidades de estilização. Esse problema faz alguns desenvolvedores recorrerem a recursos como filter e transform.&lt;/p&gt;
&lt;p&gt;Outra opção seria escrever o código SVG diretamente no html, o que ficaria uma bagunça. Ou ainda ter os svgs dentro de arquivos Javascript e utilizá-los via innerHTML, que é mais complicado e nada legal de se usar.&lt;/p&gt;
&lt;p&gt;Porém, é possível criar um componente que carregue o SVG no html para que você possa, via CSS, alterar itens como fonte, cor, entre outros sem precisar de nenhum dos recursos alternativos citados anteriormente. E o melhor, você não precisa de nenhuma biblioteca pra isso.&lt;/p&gt;
&lt;p&gt;Neste artigo, eu vou te mostrar como criar este componente.&lt;/p&gt;
&lt;h2 id=&quot;first-thingsfirst&quot;&gt;First things first&lt;/h2&gt;
&lt;p&gt;Para começar, vamos clonar a minha aplicação de teste. Ela já tem os arquivos SVG dentro da pasta assets e atualmente está usando a tag &lt;code&gt;img&lt;/code&gt; para renderizá-los. Execute o seguinte comando no seu terminal ou cmd:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;git clone https://github.com/ricardo-mello/icon-component-sample.git&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Depois, na pasta do projeto, rode o &lt;code&gt;npm install&lt;/code&gt; e em seguida o &lt;code&gt;npm start&lt;/code&gt; e ao abrir &lt;code&gt;http://localhost:4200&lt;/code&gt; no seu navegador você verá a seguinte tela:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Player com os botões anterior, play e próximo em preto, ainda renderizados com a tag img&quot; width=&quot;1070&quot; height=&quot;666&quot; src=&quot;https://ricmello.com/_astro/image-02.DberWm5q_Z8kVzF.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;É com esse player que a gente vai trabalhar.&lt;/p&gt;
&lt;h2 id=&quot;criando-o-componente&quot;&gt;Criando o componente&lt;/h2&gt;
&lt;p&gt;Após baixar o projeto, vamos gerar um módulo para o nosso componente:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ng generate module icon&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Módulo criado, hora de gerar o componente:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ng generate component icon --inline-template&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;O nosso componente de ícones precisa realizar basicamente 3 coisas:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Baixar o arquivo SVG&lt;/li&gt;
&lt;li&gt;Renderizar o arquivo SVG&lt;/li&gt;
&lt;li&gt;Armazenar o arquivo em cache&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Para que as instâncias do nosso componente compartilhem um mesmo cache sem precisar recorrer ao storage, vamos criar um serviço que gerencie os arquivos baixados:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ng generate service icon/icon&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A essa altura a estrutura do seu projeto deve estar mais ou menos assim:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;.
└── src
    ├── app
    │   ├── app.component.html
    │   ├── app.component.scss
    │   ├── app.component.spec.ts
    │   ├── app.component.ts
    │   ├── app.module.ts
    │   └── icon
    │       ├── icon.component.html
    │       ├── icon.component.scss
    │       ├── icon.component.spec.ts
    │       ├── icon.component.ts
    │       ├── icon.module.ts
    │       ├── icon.service.spec.ts
    │       └── icon.service.ts
    └── assets
        └── icons
            ├── next.svg
            ├── pause.svg
            ├── play.svg
            └── previous.svg&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora que já temos a estrutura concluída, vamos partir pra implementação. Para isso, vamos utilizar a api &lt;code&gt;fetch&lt;/code&gt; do próprio browser. Caso você pretenda dar suporte a algum navegador antigo que não dê suporte a essa api, pode usar o &lt;code&gt;httpClient&lt;/code&gt;. Minha ideia de não usá-lo é porque a API do fetch não passa por interceptors, nem por nenhum outro intermediário. Você pode conferir os navegadores suportados no &lt;a href=&quot;https://caniuse.com/?search=fetch&quot;&gt;caniuse&lt;/a&gt;.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Obs.: Os códigos estão comentados para explicar ao máximo o que foi feito. Caso você ainda esteja aprendendo, evite copiar e colar e foque em entender como o código funciona. Você vai me agradecer no futuro ❤&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr&gt;
&lt;p&gt;Vamos começar com o nosso service. O seu &lt;code&gt;icon.service.ts&lt;/code&gt; deve ficar com o conteúdo abaixo:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// src/app/icon/icon.service.ts&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;import { Injectable } from &apos;@angular/core&apos;;
import { Observable } from &apos;rxjs&apos;;
import { fromPromise } from &apos;rxjs/internal-compatibility&apos;;

@Injectable()
export class IconService {
  // cache com a lista de requisições realizadas
  private requests = new Map&amp;lt;string, Promise&amp;lt;any&amp;gt;&amp;gt;();

  getSvgContent(url: string): Observable&amp;lt;string&amp;gt; {
    // verificamos se já fizemos uma requisição para essa url
    let req = this.requests.get(url);

    if (!req) {
      // ainda não temos a requisição, então vamos criar uma
      req = fetch(url).then(response =&amp;gt; {
        if (response.ok) {
          return response.text();
        }

        return null;
      });

      // armazena a requisição para fazer o cache dela na lista
      this.requests.set(url, req);
    }

    // retorna um observable com a requisição do cache/criada
    return fromPromise(req);
  }
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora, vamos ao nosso componente &lt;code&gt;icon.component.ts&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// src/app/icon/icon.component.ts&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;import { ChangeDetectionStrategy, Component, HostBinding, Input, ViewEncapsulation } from &apos;@angular/core&apos;;
import { DomSanitizer, SafeHtml } from &apos;@angular/platform-browser&apos;;
import { Observable } from &apos;rxjs&apos;;
import { IconService } from &apos;./icon.service&apos;;
import { map } from &apos;rxjs/operators&apos;;

@Component({
  selector: &apos;app-icon&apos;,
  // O template simplesmente renderiza o SVG baixado em uma div interna
  template: `&amp;lt;div class=&quot;icon-inner&quot; [innerHTML]=&quot;svgContent | async&quot;&amp;gt;&amp;lt;/div&amp;gt;`,
  styleUrls: [&apos;./icon.component.scss&apos;],
  changeDetection: ChangeDetectionStrategy.OnPush,
  encapsulation: ViewEncapsulation.ShadowDom
})
export class IconComponent {
  @Input()
  @HostBinding(&apos;class&apos;)
    // Classes com tamanhos predefinidos
  size: &apos;small&apos; | &apos;large&apos; | &apos;default&apos; = &apos;default&apos;;

  // Variável com a requisição do SVG que vai ser renderizado
  public svgContent: Observable&amp;lt;SafeHtml&amp;gt; | undefined;

  constructor(
    private sanitizer: DomSanitizer,
    private iconService: IconService
  ) {}

  @Input()
  set src(value: string) {
    // Pegamos o caminho do SVG e invocamos o
    // nosso service que vai baixá-lo.
    this.setSvgContent(value);
  }

  private setSvgContent(src: string): void {
    // Baixamos o SVG do service e atribuímos
    // à nossa variável que é renderizada no template
    this.svgContent = this.iconService
      .getSvgContent(src)
      .pipe(map(
        content =&amp;gt; this.sanitizer.bypassSecurityTrustHtml(content)
      ));
  }
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Vamos adicionar o CSS:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// src/app/icon/icon.component.scss&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;:host {
  // O tamanho da fonte pode ser alterado via variável CSS
  --icon-font-size: 1em;

  display: inline-block;

  width: 1em;
  height: 1em;
  text-align: center;
  font-size: var(--icon-font-size);

  contain: strict;

  fill: currentColor;

  box-sizing: content-box !important;
}

.icon-inner {
  display: block;

  width: 100%;
  height: 100%;
}

svg {
  // Sobrescreve a altura e largura caso já venham setadas no SVG
  width: 100%;
  height: 100%;
  max-width: 100%;
  max-height: 100%;
}

:host(.small) {
  font-size: 18px;
}

:host(.large) {
  font-size: 44px;
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Declaramos o service no módulo de ícones e exportamos o componente:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// src/app/icon/icon.module.ts&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;import { NgModule } from &apos;@angular/core&apos;;
import { CommonModule } from &apos;@angular/common&apos;;
import { IconComponent } from &apos;./icon.component&apos;;
import { IconService } from &apos;./icon.service&apos;;

@NgModule({
  declarations: [IconComponent],
  imports: [CommonModule],
  exports: [IconComponent], // Exporta o componente a ser utilizado
  providers: [IconService] // Declara o service internamente
})
export class IconModule {}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Por último, vamos importar o módulo dentro do nosso &lt;code&gt;app.module.ts&lt;/code&gt; e utilizá-lo no componente de teste. Na seção &lt;strong&gt;imports&lt;/strong&gt;, adicione o &lt;code&gt;IconModule&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// src/app/app.module.ts&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;imports: [
  BrowserModule,
  IconModule
],&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora, podemos utilizar o componente criado no nosso player.&lt;/p&gt;
&lt;h2 id=&quot;utilizando-o-componente&quot;&gt;Utilizando o componente&lt;/h2&gt;
&lt;p&gt;Vamos trocar as tags &lt;code&gt;img&lt;/code&gt; pelo nosso componente:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;!-- src/app/app.component.ts --&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;app-icon size=&quot;large&quot; src=&quot;/assets/icons/previous.svg&quot;&amp;gt;&amp;lt;/app-icon&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;app-icon 
  (click)=&quot;alternate()&quot;
  class=&quot;action&quot;
  src=&quot;/assets/icons/{{ action }}.svg&quot;
&amp;gt;&amp;lt;/app-icon&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;app-icon size=&quot;large&quot; src=&quot;/assets/icons/next.svg&quot;&amp;gt;&amp;lt;/app-icon&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E adicionar um pouco de CSS para dar mais destaque ao play/pause, além de usar uma cor um pouco mais sutil.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// src/app/app.component.scss&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;app-icon {
  color: #34495e;
  vertical-align: middle;

  &amp;amp;.action {
    color: #2c3e50;
    --icon-font-size: 5em;
  }
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E eis o resultado final:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;O mesmo player com os ícones em cinza-azulado e o play maior, agora renderizados pelo componente de ícones&quot; width=&quot;1054&quot; height=&quot;844&quot; src=&quot;https://ricmello.com/_astro/image-03.Dl75TO9r_x27dE.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;É isso. Esse componente foi inspirado nos ícones do Ionic Framework, então é um padrão bastante utilizado e espero que agregue bastante nas suas aplicações.&lt;/p&gt;
&lt;p&gt;Altere-o conforme a realidade do seu projeto. Você pode concatenar o &lt;code&gt;/assets/icons&lt;/code&gt; automaticamente, setar outros padrões de tamanhos, criar classes com cores predefinidas… fica a gosto do freguês.&lt;/p&gt;</content:encoded><category>angular</category><category>frontend</category></item><item><title>Como o Discord aumentou a produtividade do meu time na quarentena</title><link>https://ricmello.com/posts/como-o-discord-aumentou-a-produtividade-do-meu-time/</link><guid isPermaLink="true">https://ricmello.com/posts/como-o-discord-aumentou-a-produtividade-do-meu-time/</guid><description>Como meu time trocou Ryver e Google Meet pelos canais de voz do Discord na quarentena, e como organizamos guildas, salas de reunião, rádio e cafezinho.</description><pubDate>Sat, 29 Aug 2020 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Arte com a logo do Discord ao lado esquerdo, e o aplicativo nas plataformas iOS, Android e PC do lado direito&quot; width=&quot;1200&quot; height=&quot;630&quot; src=&quot;https://ricmello.com/_astro/image-01.cz6ZusHi_2rVGWx.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Quando entramos em quarentena, a maioria das pessoas não estava preparada para trabalho remoto. No meu time não foi diferente.&lt;/p&gt;
&lt;p&gt;Nós já trabalhávamos de casa em dias pontuais, mas estávamos acostumados a trabalhar lado a lado a maior parte do tempo. Essa nova realidade trouxe vários desafios e testamos bastante algumas ferramentas até chegarmos no modelo atual. Antes de continuar, vou citar as principais.&lt;/p&gt;
&lt;h2 id=&quot;ryver&quot;&gt;Ryver&lt;/h2&gt;
&lt;p&gt;Pra quem não conhece, o &lt;a href=&quot;https://ryver.com&quot;&gt;Ryver&lt;/a&gt; concorre com o Slack e com o Trello ao mesmo tempo. É uma ferramenta de comunicação entre times com voz e videochamadas que também oferece um gerenciador de tarefas.&lt;/p&gt;
&lt;p&gt;Uma ótima ferramenta pra comunicação via texto, mas as chamadas de voz são meio instáveis. Era bem complicado fazer um daily meeting por ele, por exemplo. Além disso, a interface não era muito legal então a gente preferiu manter ele só pra texto e complementar com o Google Meet para as chamadas de vídeo.&lt;/p&gt;
&lt;h2 id=&quot;google-meet&quot;&gt;Google Meet&lt;/h2&gt;
&lt;p&gt;Esse cara tem uma qualidade sensacional nas chamadas. Mesmo se a conexão oscilar, ele consegue manter a voz da pessoa estável e é uma ótima ferramenta pra se fazer apresentações e reuniões. Nós utilizamos ele pra reuniões marcadas até hoje por conta da integração direta com o Google Calendar.&lt;/p&gt;
&lt;p&gt;Mas quando o assunto é a comunicação no dia a dia, o processo de criar sala e ficar enviando links é muito chato. Ou você guarda os links em algum documento e compartilha com a galera, ou você precisa ficar criando grupos, ou criando salas e enviando links por mensagem. Enfim… chato.&lt;/p&gt;
&lt;p&gt;Outro problema que não é exclusivo do Google Meet, mas à maioria das ferramentas de comunicação tradicionais, é que elas foram feitas pensando em chamadas privadas e apresentações. Isso significa que quando várias pessoas falam ao mesmo tempo, elas começam a cortar o áudio pra tentar priorizar o “apresentador”.&lt;/p&gt;
&lt;h2 id=&quot;discord&quot;&gt;Discord&lt;/h2&gt;
&lt;p&gt;Eu fiquei super reticente de adotar esse cara por conta do preconceito que a galera tem com o Discord:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;A gente vai ficar usando ferramenta de jogos pra trabalhar?&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Porém, conversando com alguns membros do time que também são gamers, ficou clara a diferença de qualidade entre as ferramentas de comunicação. E deixa eu puxar um pouco a sardinha pra minha galera gamer ❤&lt;/p&gt;
&lt;h3 id=&quot;gamers&quot;&gt;Gamers&lt;/h3&gt;
&lt;p&gt;&lt;img alt=&quot;Jogador de e-sports profissional em um torneio&quot; width=&quot;1400&quot; height=&quot;933&quot; src=&quot;https://ricmello.com/_astro/image-02.CrVnA8_4_L9nsA.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Fonte: Unsplash&lt;/p&gt;
&lt;p&gt;Quando se fala de trabalho em equipe e comunicação em tempo real, essa galera está anos-luz à frente de qualquer ferramenta baseada no agile. Em jogos, se você erra, você morre. Dependendo do tamanho do erro, o seu time inteiro perde.&lt;/p&gt;
&lt;p&gt;Eu faço parte dessa galera como um membro de clã de competição e posso dizer com propriedade que é muito ruim quando um membro faz o seu time perder. Mas a sensação é ainda pior quando nós é que somos esse membro.&lt;/p&gt;
&lt;p&gt;Isso faz com que essa galera tenha um trabalho em equipe absurdo pra evitar ao máximo que isso aconteça. Tudo em tempo real. Porque em jogos, um segundo faz toda diferença.&lt;/p&gt;
&lt;h3 id=&quot;voltando-ao-discord&quot;&gt;Voltando ao Discord&lt;/h3&gt;
&lt;p&gt;Os servidores do Discord são super simples. Qualquer um pode fazê-lo desde que tenha uma conta, que é gratuita.&lt;/p&gt;
&lt;p&gt;Nós criamos poucos canais de texto: Um geral, um pra galera pedir música pra rádio e um pra cada guilda compartilhar links (Front-end, Back-end, etc…).&lt;/p&gt;
&lt;p&gt;Já os canais de áudio… temos uma série deles. Esse realmente é o diferencial do Discord. São fantásticos. A comunicação, além de ter uma redução de ruído absurda, é instantânea, de forma que todo mundo fala ao mesmo tempo e conseguimos conversar como se realmente estivéssemos um do lado do outro. Isso permite à galera estar disponível pro time como se estivesse no escritório da empresa.&lt;/p&gt;
&lt;h3 id=&quot;canais-de-áudio&quot;&gt;Canais de áudio&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;O canal geral:&lt;/strong&gt; a ideia desse canal é ter um lugar pra comunicados gerais como uma reunião de time, ou um daily meeting.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Os canais das guildas:&lt;/strong&gt; esse é onde a gente passa a maior parte do tempo. Na minha, por exemplo, todos os front-ends ficam reunidos ali quando estão desenvolvendo pra que possamos tirar dúvidas rápidas sobre layout. Você joga a dúvida no ar e alguém vai te responder quase que imediatamente. Caso a gente precise de uma ajuda mais demorada ou um pair programming, vamos pra uma sala de reunião qualquer pra não lotar o canal.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;As infinitas salas de reunião:&lt;/strong&gt; feitas para que a galera consiga se juntar pra trabalhar em uma feature ou aplicação específica sem nunca na vida precisar brigar por sala.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;O canal da rádio:&lt;/strong&gt; lugar de quem quer focar no que tá fazendo mas também quer trocar experiências com a galera, compartilhando e ouvindo as músicas favoritas de cada um. Temos um bot que busca as músicas pedidas no canal de texto da rádio e toca pra galera ouvir. Às vezes até rola uma zoeira tipo &lt;a href=&quot;https://www.youtube.com/watch?v=QTSdp-92fmY&quot;&gt;Alípio Martins&lt;/a&gt;, mas na maior parte do tempo estamos focados no trabalho mesmo.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;O canal do cafezinho:&lt;/strong&gt; esse talvez seja o mais importante de todos. Com essa nova realidade, fica muito difícil ter contato com nossos colegas de trabalho. A gente não almoça junto, nem tem mais o happy hours e muito menos aqueles cafezinhos na copa, tão importantes pra descontrair e dar um “F5” na sua mente entre uma reunião e outra. &lt;strong&gt;Nesse canal, é proibido falar sobre trabalho.&lt;/strong&gt; Um legítimo oásis em meio ao emaranhado de coisas que temos que resolver no dia a dia.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Café cheio de gente conversando, comendo e mexendo no celular em mesas com cadeiras verdes&quot; width=&quot;1400&quot; height=&quot;893&quot; src=&quot;https://ricmello.com/_astro/image-03.B1gO1UX0_HCc50.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Fonte: Unsplash&lt;/p&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Os canais de áudio do Discord entregam um nível de comunicação que aumentou e muito a nossa produtividade. Temos um lugar central e super prático onde todos nós podemos nos falar com áudio de alta qualidade, compartilhar telas ou simplesmente conversarmos sobre o dia a dia.&lt;/p&gt;
&lt;p&gt;P.S.: às vezes precisamos de um nível de foco maior ou simplesmente queremos desestressar fazendo outra coisa, então o jeito é desconectar do Discord e ficar totalmente offline. É algo bem comum e a galera jamais deve ser julgada por não estar no Discord. Muito pelo contrário. O Discord é um lugar pra gente se encontrar, e não pra bater ponto.&lt;/p&gt;</content:encoded><category>trabalho-remoto</category><category>carreira</category><category>ferramentas</category></item><item><title>Desenvolva Aplicações Full-Stack com Angular CLI e Nx</title><link>https://ricmello.com/posts/aplicacoes-full-stack-com-angular-cli-e-nx/</link><guid isPermaLink="true">https://ricmello.com/posts/aplicacoes-full-stack-com-angular-cli-e-nx/</guid><description>Um tour pelo Nx: workspace full-stack com Angular e Nest, Jest e Cypress já configurados, affected no CI e o passo a passo pra criar o seu primeiro.</description><pubDate>Fri, 24 Jan 2020 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Logo do Nx com o slogan “Angular CLI power-ups for modern development”&quot; width=&quot;1080&quot; height=&quot;608&quot; src=&quot;https://ricmello.com/_astro/image-01.cES9Ismi_1LaQe9.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Quando trabalhamos com desenvolvimento em geral, sabemos que cada “new project” vem acompanhado de uma série de decisões estruturais. No caso do front-end, que é bem menos maduro que o back-end, surgem novos conceitos, bibliotecas e frameworks o tempo todo. Se Angular for a sua opção, eu listei alguns pontos importantes &lt;a href=&quot;https://ricmello.com/posts/como-estruturar-o-seu-front-end-com-angular/&quot;&gt;nesse artigo&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Saber dosar esses conceitos de forma eficiente exige uma visão bem ampla das tecnologias versus as necessidades do negócio. Você pode passar meses testando patterns para encontrar o mais adequado à sua realidade ou você pode seguir padrões bem estabelecidos pela comunidade e que foram testados em grandes empresas, mas você geralmente tem que pesquisar bastante até encontrar esses padrões.&lt;/p&gt;
&lt;p&gt;No meu primeiro grande “new project”, eu escolhi a primeira opção: testei vários padrões diferentes, bibliotecas diferentes, frameworks diferentes, conceitos diferentes, etc… Em resumo, um benchmark que durou em torno de 30 dias entre multirepos, monorepos, react cross-platform, angular cross-platform, vue.js, ionic, híbrido de react com angular e por aí vai.&lt;/p&gt;
&lt;p&gt;Eram tantas opções que eu realmente fiquei confuso em alguns momentos. Mas em meio a esse monte de pesquisa eu encontrei um cara chamado &lt;a href=&quot;https://nx.dev/angular&quot;&gt;Nx&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&quot;o-nx&quot;&gt;O Nx&lt;/h2&gt;
&lt;p&gt;Esse cara é uma coleção de schematics que adiciona várias funcionalidades ao Angular CLI. Além disso, ele traz alguns conceitos para o desenvolvimento como um todo. Conceitos esses que foram inspirados no modo Google de se trabalhar e já foram validados por várias empresas de mercado.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Logos de empresas que usam o Nx, como American Airlines, Cisco, FedEx, Microsoft e T-Mobile&quot; width=&quot;1400&quot; height=&quot;666&quot; src=&quot;https://ricmello.com/_astro/image-02.08Yg36-r_Gkcs4.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Algumas &quot;pequenas&quot; empresas que usam o Nx. Fonte: [https://nx.dev](https://nx.dev/angular)&lt;/p&gt;
&lt;h3 id=&quot;workspace&quot;&gt;Workspace&lt;/h3&gt;
&lt;p&gt;O Workspace do Nx consegue comportar &lt;strong&gt;toda a sua stack&lt;/strong&gt; desde que você utilize tecnologias compatíveis. Pra você ter uma ideia, atualmente é possível criar aplicações Angular + Nest ou React + Express em um mesmo workspace, e compartilhar códigos entre elas usando bibliotecas TypeScript.&lt;/p&gt;
&lt;p&gt;Por exemplo, o template &lt;code&gt;angular-nest&lt;/code&gt; gera uma aplicação Angular, uma API em Nest e uma biblioteca TypeScript contendo as interfaces para que front-end e back-end consumam sempre o mesmo modelo e as alterações sejam refletidas em ambas as aplicações.&lt;/p&gt;
&lt;p&gt;As tecnologias suportadas estão &lt;a href=&quot;https://nx.dev/angular/fundamentals/use-modern-tools&quot;&gt;nesse link&lt;/a&gt; (Angular) ou &lt;a href=&quot;https://nx.dev/react/fundamentals/use-modern-tools&quot;&gt;nesse link&lt;/a&gt; (React).&lt;/p&gt;
&lt;h3 id=&quot;ferramentas&quot;&gt;Ferramentas&lt;/h3&gt;
&lt;p&gt;&lt;img alt=&quot;Logos de Cypress, NestJS, React, Jest e um editor de código, ferramentas suportadas pelo Nx&quot; width=&quot;1400&quot; height=&quot;778&quot; src=&quot;https://ricmello.com/_astro/image-03.3DLagmK8_Z2uGxPJ.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Além dos frameworks citados, o Nx traz consigo uma série de ferramentas para o desenvolvimento. Se você trabalha com Angular, que é o meu caso, sabe que um projeto padrão vem com Karma/Jasmine para testes unitários e o Protractor para os e2e.&lt;/p&gt;
&lt;p&gt;Você também consegue escolher qual ferramenta usar via CLI sem a necessidade de nenhuma configuração adicional. Por padrão, ele traz o Jest para testes unitários e o Cypress para e2e. Além disso, o Prettier, que é um padrão super bem estabelecido de formatação, já vem configurado por padrão.&lt;/p&gt;
&lt;h3 id=&quot;affected&quot;&gt;Affected&lt;/h3&gt;
&lt;p&gt;&lt;img alt=&quot;Grafo de dependências do Nx com as apps client e admin; admin e suas dependências destacadas em vermelho como afetadas&quot; width=&quot;1400&quot; height=&quot;641&quot; src=&quot;https://ricmello.com/_astro/image-04.CuE8m0UX_ZLcAz4.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Grafo de dependências do Affected. Fonte: [https://nx.dev/angular/guides/monorepo-affected](https://nx.dev/angular/guides/monorepo-affected#affected)&lt;/p&gt;
&lt;p&gt;O affected é uma ferramenta incrível para o fluxo de desenvolvimento como um todo, mas em especial a integração contínua.&lt;/p&gt;
&lt;p&gt;Nele, você consegue comparar o diff de dois commits (geralmente o HEAD da sua branch com a dev ou a master) e verificar quais aplicações ou bibliotecas foram alteradas e/ou afetadas. Uma aplicação é considerada afetada quando ela consome alguma biblioteca (ou aplicação) que foi alterada. Sendo assim, o processo de build dela também precisa ser executado pra saber se algo foi quebrado. Isso facilita e muito o CI, porque você consegue ter um único build gerenciando todas as suas aplicações, além de builds incrementais.&lt;/p&gt;
&lt;h3 id=&quot;angular-console&quot;&gt;Angular Console&lt;/h3&gt;
&lt;p&gt;&lt;img alt=&quot;Logo do Angular Console: janela com sliders e o símbolo do Angular&quot; width=&quot;952&quot; height=&quot;498&quot; src=&quot;https://ricmello.com/_astro/image-05.CAE2FEyP_78Y1s.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Angular Console Logo&lt;/p&gt;
&lt;p&gt;O &lt;a href=&quot;https://angularconsole.com/&quot;&gt;Angular Console&lt;/a&gt; é uma extensão do VS Code que fornece uma interface gráfica para executar desde os comandos mais comuns como o &lt;code&gt;ng serve&lt;/code&gt; ou &lt;code&gt;ng test&lt;/code&gt;, até os mais complexos como o &lt;code&gt;ng generate&lt;/code&gt; ou o &lt;code&gt;ng add&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Eu gosto bastante do terminal e das IDEs da JetBrains então acabei não me adaptando, mas o Angular Console é uma ótima opção tanto pra quem está começando e ainda não conhece todos os comandos de cara, quanto pra quem já trabalha há bastante tempo mas não lembra todos os parâmetros de todos os comandos.&lt;/p&gt;
&lt;h2 id=&quot;criando-o-seu-próprio-workspace&quot;&gt;Criando o seu próprio Workspace&lt;/h2&gt;
&lt;p&gt;Depois de escrever tanto sobre a ferramenta, é hora de criar o seu workspace. Para isso, basta ter o npm (versão 5.2 ou superior) instalado e executar o seguinte comando no terminal:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;npx create-nx-workspace@latest myorg&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E o CLI vai te perguntar qual workspace deve ser criado:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Terminal do create-nx-workspace listando os presets: empty, web components, angular, angular-nest, react, react-express e next.js&quot; width=&quot;1400&quot; height=&quot;314&quot; src=&quot;https://ricmello.com/_astro/image-06.FC-kcRqJ_Z25WtG7.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Opções de Workspace exibidas no terminal&lt;/p&gt;
&lt;p&gt;Para o nosso exemplo, vamos usar o template &lt;code&gt;angular-nest&lt;/code&gt;, que monta o exemplo que eu citei: Uma aplicação Angular, uma Api Nest e uma biblioteca com as interfaces.&lt;/p&gt;
&lt;p&gt;Depois disso, basta preencher o nome da aplicação (eu escolhi &lt;code&gt;my-app&lt;/code&gt;) e o formato dos arquivos de estilo que ele irá gerar um workspace com essa estrutura:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Estrutura do workspace gerado: apps com api, my-app e my-app-e2e; libs com api-interfaces; tools com schematics&quot; width=&quot;704&quot; height=&quot;412&quot; src=&quot;https://ricmello.com/_astro/image-07.CZMBBhAx_BOD60.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;As aplicações ficam na pasta &lt;code&gt;apps&lt;/code&gt;, então nela você vai ter tanto a &lt;code&gt;api&lt;/code&gt; em Nest quanto o &lt;code&gt;my-app&lt;/code&gt;, que é a aplicação Angular.&lt;/p&gt;
&lt;p&gt;Já as bibliotecas ficam em &lt;code&gt;libs&lt;/code&gt;. Como criamos um workspace full-stack, também é gerada uma biblioteca com as interfaces usadas pela &lt;code&gt;api&lt;/code&gt; e pelo &lt;code&gt;my-app&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&quot;executando-as-aplicações&quot;&gt;Executando as aplicações&lt;/h3&gt;
&lt;p&gt;Agora, basta rodar &lt;code&gt;ng serve my-app&lt;/code&gt; e &lt;code&gt;ng serve api&lt;/code&gt;, depois abrir o navegador em &lt;code&gt;http://localhost:4200&lt;/code&gt; e ver a mensagem de boas vindas, com direito a um JSON vindo direto da API sendo exibido:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Página “Welcome to my-app!” com o logo do Nx e a mensagem “Welcome to api!” vinda da API&quot; width=&quot;1400&quot; height=&quot;730&quot; src=&quot;https://ricmello.com/_astro/image-08.CSbm5Uiy_ZeBad0.webp&quot;&gt;&lt;/p&gt;
&lt;h3 id=&quot;testes-unitários&quot;&gt;Testes Unitários&lt;/h3&gt;
&lt;p&gt;Ao executar os testes usando &lt;code&gt;ng test&lt;/code&gt;, você vai ver que eles são executados com o Jest:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Saída do ng test no terminal com os testes do my-app e da api passando no Jest&quot; width=&quot;1400&quot; height=&quot;669&quot; src=&quot;https://ricmello.com/_astro/image-09.DomPhi5G_2aNJNu.webp&quot;&gt;&lt;/p&gt;
&lt;h3 id=&quot;e2e&quot;&gt;E2E&lt;/h3&gt;
&lt;p&gt;E ao executar o &lt;code&gt;ng e2e&lt;/code&gt; para o teste end-to-end, o cypress irá executá-los:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Saída do Cypress no terminal com o teste e2e “should display welcome message” passando&quot; width=&quot;1400&quot; height=&quot;677&quot; src=&quot;https://ricmello.com/_astro/image-10.DxwuE4HU_1x8gBK.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Essa é uma introdução ao Nx e um pouco do que ele pode fazer sem a necessidade de configurações adicionais no projeto. São padrões bem estabelecidos e validados em grandes empresas, e que já foram testados e aprovados pelo meu time também. Você pode ver o resultado da nossa jornada usando monorepo &lt;a href=&quot;https://ricmello.com/posts/um-ano-de-monorepo/&quot;&gt;aqui&lt;/a&gt;.&lt;/p&gt;</content:encoded><category>nx</category><category>angular</category><category>monorepo</category><category>typescript</category></item><item><title>Um ano de Monorepo: o que aprendemos e por que você deveria usá-lo</title><link>https://ricmello.com/posts/um-ano-de-monorepo/</link><guid isPermaLink="true">https://ricmello.com/posts/um-ano-de-monorepo/</guid><description>Um ano de monorepo com Nx no time: bibliotecas compartilhadas sem npm link, CI com affected, PRs de ponta a ponta e os problemas que a gente enfrentou.</description><pubDate>Thu, 02 Jan 2020 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Comparação entre um único logo do Git (monorepo) e vários logos do Git espalhados (multirepo)&quot; width=&quot;885&quot; height=&quot;590&quot; src=&quot;https://ricmello.com/_astro/image-01.Du0MDf1m_Z1Lt1nG.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Fonte: [https://pliutau.com/pros_and_cons_golang_in_monorepo/](https://pliutau.com/pros_and_cons_golang_in_monorepo/)&lt;/p&gt;
&lt;p&gt;Quando o Angular 6 saiu, trouxe consigo o conceito de &lt;em&gt;Workspace&lt;/em&gt;. O tradicional ng new não geraria mais apenas uma aplicação, e sim um monorepo para que pudéssemos gerar aplicações e bibliotecas no mesmo local.&lt;/p&gt;
&lt;p&gt;O conceito era estranho demais pra quem trabalhou a vida inteira com multirepo. Imagina ter um só repositório com todas as aplicações e ter que organizá-lo para que múltiplas squads trabalhem em conjunto sem que uma interfira na outra. Ou atualizar a versão de uma única dependência e quebrar cinco projetos diferentes. Meio zoneado, né?&lt;/p&gt;
&lt;p&gt;Eu já tinha sido apresentado ao &lt;a href=&quot;https://lerna.js.org&quot;&gt;Lerna&lt;/a&gt; trabalhando no Ionic CLI, mas nunca tinha parado pra pensar o porque de usar aquele treco. Eis que eu li &lt;a href=&quot;https://medium.com/@Jakeherringbone/you-too-can-love-the-monorepo-d95d1d6fcebe&quot;&gt;esse artigo&lt;/a&gt; do Alex Eagle que me convenceu a testar essa cultura, que já é utilizada na Google há muito tempo e deu bastante certo por lá. Agora, vamos aos resultados dessa viagem usando monorepo aqui na TOTVS.&lt;/p&gt;
&lt;h2 id=&quot;está-tudo-ali&quot;&gt;Está tudo ali&lt;/h2&gt;
&lt;p&gt;Imagina que sua empresa tem 20 apps e você está trabalhando no app A, mas também precisa trabalhar numa biblioteca B que esse app consome e que você nunca usou na vida. Qual o procedimento padrão? Clona, faz um npm link e começa a trabalhar na aplicação e na biblioteca ao mesmo tempo. Quando precisar alterar outra biblioteca, faz o processo de novo. Se a biblioteca for usada em mais de um app, npm link neles. Vários devs… quantas vezes seu time terá feito isso no fim do dia? Entrou dev novo? Já monta um shell script que clone tudo pra ele não ter que fazer tudo na mão e se perder.&lt;/p&gt;
&lt;p&gt;Quando se tem um monorepo, você só precisa abrir a pasta. Tudo o que é necessário pro time trabalhar foi baixado quando você clonou o Workspace. desde aplicações a bibliotecas compartilhadas, está tudo ali.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;GIF do Andy, de Parks and Recreation, com cara de surpresa e empolgação numa reunião&quot; width=&quot;470&quot; height=&quot;376&quot; src=&quot;https://ricmello.com/_astro/image-02.gHNRVckd_1vLjpc.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;bibliotecas-compartilhadas&quot;&gt;Bibliotecas compartilhadas&lt;/h2&gt;
&lt;p&gt;Com pequenas configurações no tsconfig, você consegue fazer com que as bibliotecas sejam enxergadas por todas as aplicações do seu workspace. Se você desenvolve bibliotecas que só serão consumidas dentro do monorepo, nem precisa publicá-las. Basta definir os paths que eles estarão disponíveis para as aplicações.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;//tsconfig.json
{
  ...
  &quot;compilerOptions&quot;: {
    ...
    &quot;paths&quot;: {
      &quot;@mycompany/ui&quot;: [&quot;libs/ui/src/index.ts&quot;],
      &quot;@mycompany/common&quot;: [&quot;libs/common/src/index.ts&quot;],
      &quot;@mycompany/auth&quot;: [&quot;libs/auth/src/index.ts&quot;]
    }
  }
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Usando a configuração acima, eu posso importar qualquer módulo, componente, etc. que foi exportado no &lt;code&gt;index.ts&lt;/code&gt; de &lt;code&gt;@mycompany/ui&lt;/code&gt;, &lt;code&gt;@mycompany/common&lt;/code&gt; ou &lt;code&gt;@mycompany/auth&lt;/code&gt; nas minhas aplicações.&lt;br&gt;
Ex.: &lt;code&gt;import { Toolbar } from &apos;@mycompany/ui&apos;&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&quot;integração-contínua&quot;&gt;Integração contínua&lt;/h2&gt;
&lt;p&gt;Quando trabalhamos com bibliotecas compartilhadas, precisamos executar os pipelines de build (lint, test, build, etc.) de todas as aplicações que a consomem para que tenham a versão mais atual, ou deixar cada aplicação com sua versão da biblioteca, o que resulta em aplicações com dependências obsoletas.&lt;/p&gt;
&lt;p&gt;Usando um monorepo, você pode executar o build de todas as aplicações caso uma biblioteca seja alterada sem precisar criar links entre elas durante os pipelines. Com isso, todas as aplicações sempre terão as últimas versões das bibliotecas, e você consegue identificar caso uma alteração em uma biblioteca quebre uma aplicação.&lt;/p&gt;
&lt;p&gt;Existe ainda ferramentas que te dizem exatamente quais aplicações ou bibliotecas foram afetadas pela sua alteração, e executam o processo de build somente para o que foi afetado. A que eu uso e recomendo é o &lt;a href=&quot;https://nx.dev/angular/guides/monorepo-affected&quot;&gt;Nx&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&quot;pull-requests&quot;&gt;Pull requests&lt;/h2&gt;
&lt;p&gt;Num monorepo, os desenvolvedores de back e front-end podem trabalhar na mesma branch e abrir os PRs quando a feature estiver totalmente concluída. Um Sdet (Engenheiro especializado em QA) também pode baixar a branch inteira pra um smoke test.&lt;/p&gt;
&lt;p&gt;Você tem um controle maior de tudo o que entrou pra branch de desenvolvimento (ou master) sem ter que lidar com vários PRs em repositórios diferentes. E se alguma feature entrou de forma prematura, você só precisa reverter um único PR.&lt;/p&gt;
&lt;h2 id=&quot;problemas&quot;&gt;Problemas&lt;/h2&gt;
&lt;p&gt;Como nem tudo são flores, vou mostrar os problemas que encontramos no caminho e como os resolvemos.&lt;/p&gt;
&lt;h3 id=&quot;cultura&quot;&gt;Cultura&lt;/h3&gt;
&lt;p&gt;O time estranha, isso é fato. É complicado chegar pra uma galera que trabalhou a vida inteira usando multirepos e expor uma ideia dessas. Me olharam meio torto, mas já na primeira conversa a galera topou fazer um teste, que acabou se tornando nosso padrão.&lt;/p&gt;
&lt;h3 id=&quot;controle&quot;&gt;Controle&lt;/h3&gt;
&lt;p&gt;Você precisa fazer um trabalho mental e aceitar que todo mundo do seu time tem acesso a tudo, e que todo mundo pode alterar tudo desde que seja aprovado no processo de PR. Não chegou a ser um problema exatamente, mas foi uma questão levantada quando levei o tema para discussão então preferi apontá-la.&lt;/p&gt;
&lt;h3 id=&quot;mais-complexidade-para-o-devops&quot;&gt;Mais Complexidade para o DevOps&lt;/h3&gt;
&lt;p&gt;Como você só tem um repositório, os pipelines de CI e CD se tornam um pouco mais complexos porque eles precisam buildar não só uma aplicação, mas todas as aplicações que determinada alteração afeta. Nós usamos o affected do Nx e apanhamos bastante até criarmos um modelo eficiente de build incremental. Hoje nossos builds são muito mais rápidos do que eram antes de usarmos monorepos, e no caso do Front-End, temos um único build que consegue gerenciar o Workspace inteiro.&lt;/p&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Se você trabalha com microserviços e/ou microfrontends, ou possui várias aplicações e pretende criar bibliotecas compartilhadas entre elas, vai encontrar no monorepo uma ótima alternativa para gerenciar as suas aplicações. Se não, use mesmo assim, pois não custa nada e um dia o seu monolito pode precisar ser dividido.&lt;/p&gt;
&lt;p&gt;Nós apostamos e gostamos bastante. O que era pra ser complexo acabou se tornando simples graças ao &lt;a href=&quot;https://nx.dev/angular&quot;&gt;Nx&lt;/a&gt;, então a gente só teve a ganhar. No front-end, por exemplo, temos apenas um pipeline de build pra todas as nossas bibliotecas e aplicações, o que centralizou o gerenciamento e melhorou e muito o desempenho dos builds.&lt;/p&gt;
&lt;p&gt;E por último, a liberdade de criar um novo projeto sem precisar criar repositórios e pedir pro time inteiro cloná-lo também foi bem interessante. Principalmente pra nós que trabalhamos com microserviços e microfrontends.&lt;/p&gt;
&lt;p&gt;Resumindo: Vale muito a pena :)&lt;/p&gt;</content:encoded><category>monorepo</category><category>nx</category><category>angular</category><category>devops</category></item><item><title>Como Estruturar o seu Front-End com Angular</title><link>https://ricmello.com/posts/como-estruturar-o-seu-front-end-com-angular/</link><guid isPermaLink="true">https://ricmello.com/posts/como-estruturar-o-seu-front-end-com-angular/</guid><description>Os padrões que eu usava em 2019 pra estruturar um front-end Angular: Nx e monorepo, RxJS, bibliotecas compartilhadas, NgRx, Schematics e affected.</description><pubDate>Sun, 24 Nov 2019 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Prédio em construção com guindastes amarelos e um bando de pássaros no céu&quot; width=&quot;1400&quot; height=&quot;746&quot; src=&quot;https://ricmello.com/_astro/image-01.BQ9t4tj6_ZdAWB5.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Image by [Free-Photos](https://pixabay.com/photos/?utm_source=link-attribution&amp;amp;utm_medium=referral&amp;amp;utm_campaign=image&amp;amp;utm_content=768815) from [Pixabay](https://pixabay.com/?utm_source=link-attribution&amp;amp;utm_medium=referral&amp;amp;utm_campaign=image&amp;amp;utm_content=768815)&lt;/p&gt;
&lt;p&gt;Enquanto alguns o chamam de Framework, o Angular pode ser considerado uma grande plataforma, que te fornece todas as ferramentas necessárias para o desenvolvimento de aplicações Front-End. Além disso, tem um &lt;a href=&quot;https://cli.angular.io/&quot;&gt;CLI&lt;/a&gt; super poderoso em que podemos adicionar infinitas funcionalidades via &lt;a href=&quot;https://angular.io/guide/schematics&quot;&gt;Schematics&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;O Angular já possui um &lt;a href=&quot;https://angular.io/guide/styleguide&quot;&gt;Style Guide&lt;/a&gt; com padrões bem definidos. Porém, ainda há bastante coisa pra acrescentar, e é dessas coisas que vamos falar aqui:&lt;/p&gt;
&lt;h2 id=&quot;nx--&quot;&gt;Nx = ❤&lt;/h2&gt;
&lt;p&gt;Eu falo bastante do &lt;a href=&quot;https://nx.dev/&quot;&gt;Nx&lt;/a&gt; porque ele reduz e muito o tempo que você demora estruturando o projeto do zero. Ele foi criado por dois caras que eram da Google (Victor Savkin e Jeff Cross) e trabalham ativamente no projeto do Angular. Desde então eles prestam consultoria ensinando metodologias de desenvolvimento para aplicações de grande porte. Resumindo: Eles sacam muito de Angular.&lt;/p&gt;
&lt;h3 id=&quot;monorepo&quot;&gt;Monorepo&lt;/h3&gt;
&lt;p&gt;Utilizar um único repositório tem tantas vantagens que cabe num segundo artigo. Aqui eu vou destacar a integração instantânea entre diferentes aplicações e a facilidade de geração de releases.&lt;/p&gt;
&lt;p&gt;O Angular já vem com um monorepo padrão, mas ele é um tanto limitado e acaba misturando bibliotecas com aplicações. O Nx resolve isso dividindo o workspace em 3 áreas: apps ou aplicações, libs ou bibliotecas e tools que são ferramentas para facilitar o fluxo de desenvolvimento.&lt;/p&gt;
&lt;h2 id=&quot;programação-reativa&quot;&gt;Programação reativa&lt;/h2&gt;
&lt;p&gt;O Angular usa &lt;a href=&quot;https://rxjs-dev.firebaseapp.com/&quot;&gt;RxJS&lt;/a&gt; para implementar o padrão &lt;em&gt;Observer&lt;/em&gt;. Nele, temos um stream de vários eventos que podem ser manipulados como se estivéssemos manipulando um array.&lt;/p&gt;
&lt;p&gt;Se você usa Promises, como basicamente tudo no Angular usa RxJS, a recomendação é que você o aprenda e utilize ao invés de usar .toPromise() na sua aplicação inteira. Ele é bem mais poderoso e tem inúmeros operadores, então vale muito a pena investir.&lt;/p&gt;
&lt;h3 id=&quot;por-onde-começar&quot;&gt;Por onde começar:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://bognarjunior.wordpress.com/2018/09/30/rxjs-programacao-reativa-em-javascript/&quot;&gt;RxJS: Programação reativa em JavaScript&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://medium.com/olxbr-tech/por-que-programa%C3%A7%C3%A3o-reativa-8fba7e754a0f&quot;&gt;Por que programação reativa?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.learnrxjs.io/&quot;&gt;Learn RxJS&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://rxmarbles.com/&quot;&gt;RxJS Marbles: Interactive diagrams of Rx Observables&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;faça-micro-frontends&quot;&gt;Faça micro frontends&lt;/h2&gt;
&lt;p&gt;Divida a sua aplicação em micro aplicações, para que você possa evoluí-las sem que uma interfira na outra, e distribuí-las sem precisar fazer o deploy de todo o seu front-end caso você altere apenas uma pequena parte da sua aplicação. Tente identificar as diferentes aplicações que você irá desenvolver e as divida no Workspace.&lt;/p&gt;
&lt;h2 id=&quot;crie-bibliotecas&quot;&gt;Crie bibliotecas&lt;/h2&gt;
&lt;p&gt;Identifique aquilo que é compartilhado entre aplicações e organize em bibliotecas. No meu time de produto da TOTVS, nosso Workspace tem uma biblioteca de componentes de UI, uma biblioteca que contém tudo o que é comum para todas as aplicações (internacionalização, autenticação e uma série de interceptors), uma biblioteca pra cada micro serviço contendo os models e os services com as requisições REST, entre outras.&lt;/p&gt;
&lt;p&gt;Quando criamos uma biblioteca com o Nx, ele faz as configurações de TypeScript necessárias para que ela esteja disponível para todo o workspace.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Grafo de um workspace Nx: apps client e admin dependendo de libs de feature, data-access e components-shared&quot; width=&quot;1400&quot; height=&quot;630&quot; src=&quot;https://ricmello.com/_astro/image-02.DpoZl3dO_1W301K.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Workspace Nx ([https://github.com/nrwl/nx/wiki/Nx-and-Angular-CLI](https://github.com/nrwl/nx/wiki/Nx-and-Angular-CLI))&lt;/p&gt;
&lt;h2 id=&quot;use-gerenciamento-de-estado&quot;&gt;Use gerenciamento de estado&lt;/h2&gt;
&lt;p&gt;Fazer a comunicação entre diferentes componentes nem sempre é uma tarefa fácil, e você vai acabar se perdendo entre vários services e @Inputs/@Outputs quando precisar atualizar o estado da sua aplicação. A galera do React fez isso muito bem com o Redux, e o &lt;a href=&quot;https://ngrx.io/&quot;&gt;NgRx&lt;/a&gt; trouxe esse conceito pro Angular com o nosso amado &lt;a href=&quot;https://rxjs-dev.firebaseapp.com/&quot;&gt;RxJS&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Diagrama do ciclo do NgRx: component, action, reducer, store, selector, effects e service&quot; width=&quot;1400&quot; height=&quot;788&quot; src=&quot;https://ricmello.com/_astro/image-03.C_TtXeOm_ZOXtHM.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;NgRx Lifecycle ([https://ngrx.io/guide/store](https://ngrx.io/guide/store))&lt;/p&gt;
&lt;p&gt;Segue alguns links que podem te ajudar nessa jornada:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://medium.com/@luiguild/m%C3%A1quinas-de-estado-quando-usar-por-que-e-para-que-39dee6dd8e7c&quot;&gt;Máquinas de estado, quando usar e para que?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://movile.blog/construindo-aplicacoes-front-end-reativas-com-ngrx/&quot;&gt;Construindo aplicações front-end reativas com NgRx&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.youtube.com/watch?v=9taz2c-l2Yk&quot;&gt;Gerenciamento de estado no Angular com NgRx e programação reativa&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://nx.dev/angular/guides/misc-ngrx&quot;&gt;State Management With NgRx&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;schematics&quot;&gt;Schematics&lt;/h2&gt;
&lt;p&gt;Muitas das coisas que fazemos são repetitivas e podem ser automatizadas. Por meio do Schematics, conseguimos estender o CLI do Angular com comandos personalizados que gerem ou alterem código de acordo com nossos padrões internos. Você pode aprender mais sobre eles &lt;a href=&quot;https://ricmello.com/posts/schematics-criando-um-gerador-de-codigos-com-angular-parte-1/&quot;&gt;nesse artigo&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id=&quot;builds-com-affected&quot;&gt;Builds com Affected&lt;/h2&gt;
&lt;p&gt;Uma das ferramentas que eu mais gosto no Nx é o affected, que consegue mapear quais aplicações ou bibliotecas foram afetadas pelas alterações comparando a sua branch com a master (ou dev), ou dois commits diferentes (como a HEAD vs o commit anterior). Com ele, podemos gerar builds mais rápidos e precisos recompilando somente o que precisa ser recompilado. O affected também pode ser usado em testes, lints, etc.&lt;/p&gt;
&lt;h2 id=&quot;conclusão&quot;&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Usar o Nx para estruturar uma aplicação pode te poupar bastante dor de cabeça e trabalho configurando o Workspace. Separar suas aplicações em pedaços menores vai te ajudar lá na frente quando você precisar dividir a manutenção delas. Gerenciar o estado e usar programação reativa são duas coisas que ajudam bastante a reduzir a complexidade dos componentes e o Schematics é uma ferramenta super flexível pra ajudar o seu time a escrever menos código repetitivo. O affected fala por si só.&lt;/p&gt;</content:encoded><category>angular</category><category>frontend</category><category>nx</category><category>monorepo</category></item><item><title>Schematics: Criando um gerador de códigos com Angular — Parte 2</title><link>https://ricmello.com/posts/schematics-criando-um-gerador-de-codigos-com-angular-parte-2/</link><guid isPermaLink="true">https://ricmello.com/posts/schematics-criando-um-gerador-de-codigos-com-angular-parte-2/</guid><description>Parte 2 da série de Schematics: schema com prompt, collection padrão estendendo a do Angular e templates que geram um módulo com dois componentes.</description><pubDate>Wed, 12 Jun 2019 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Logo do Angular sobre fundo azul quadriculado, estilo blueprint&quot; width=&quot;1400&quot; height=&quot;411&quot; src=&quot;https://ricmello.com/_astro/image-01.BJ_eG0IL_Z6epCB.webp&quot;&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Este post é o segundo de uma série sobre o Schematics, que aborda desde os conceitos até termos um gerador de código funcional. Leia o primeiro post &lt;a href=&quot;https://ricmello.com/posts/schematics-criando-um-gerador-de-codigos-com-angular-parte-1/&quot;&gt;aqui&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;a href=&quot;https://ricmello.com/posts/schematics-criando-um-gerador-de-codigos-com-angular-parte-1/&quot;&gt;No post anterior&lt;/a&gt; nós aprendemos os principais conceitos do Schematics e criamos a nossa primeira Collection. Agora, vamos estruturar a nossa Collection e criar o nosso gerador.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Meme do Bob Esponja de óculos ao lado do Patrick: “Agora a coisa ficou séria”&quot; width=&quot;330&quot; height=&quot;330&quot; src=&quot;https://ricmello.com/_astro/image-02.BH9eYYEk_Z11fNvJ.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;criando-o-schema&quot;&gt;Criando o Schema&lt;/h2&gt;
&lt;p&gt;O Schema contém os metadados com as opções que o schematic permite e/ou precisa para funcionar. Pra adicionar um Schema ao nosso schematic padrão, vamos criar o arquivo &lt;code&gt;schema.json&lt;/code&gt; dentro da pasta &lt;code&gt;my-schematics&lt;/code&gt; com o seguinte conteúdo:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;schema.json&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;{
  &quot;$schema&quot;: &quot;http://json-schema.org/schema&quot;,
  &quot;id&quot;: &quot;my-schematics&quot;,
  &quot;type&quot;: &quot;object&quot;,
  &quot;properties&quot;: {
    &quot;path&quot;: {
      &quot;description&quot;: &quot;The path to create the module.&quot;,
      &quot;type&quot;: &quot;string&quot;,
      &quot;format&quot;: &quot;path&quot;,
      &quot;visible&quot;: false
    },
    &quot;project&quot;: {
      &quot;type&quot;: &quot;string&quot;,
      &quot;description&quot;: &quot;The name of the project.&quot;,
      &quot;$default&quot;: {
        &quot;$source&quot;: &quot;projectName&quot;
      }
    },
    &quot;name&quot;: {
      &quot;type&quot;: &quot;string&quot;,
      &quot;description&quot;: &quot;Custom module name&quot;,
      &quot;$default&quot;: {
        &quot;$source&quot;: &quot;argv&quot;,
        &quot;index&quot;: 0
      },
      &quot;x-prompt&quot;: &quot;What name would you like to use for the module?&quot;
    }
  },
  &quot;required&quot;: [&quot;name&quot;]
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Nele, nós definimos alguns atributos padrões, como o &lt;code&gt;path&lt;/code&gt;, que é fornecido pelo CLI, e o atributo &lt;code&gt;name&lt;/code&gt;, que será o nome do nosso módulo customizado.&lt;/p&gt;
&lt;p&gt;Nós conseguimos obter o nome do módulo pelo flag &lt;code&gt;--name&lt;/code&gt; e pelo &lt;code&gt;argv[0]&lt;/code&gt; que é o primeiro argumento passado pro comando (ex.: ng g my-schematics hello). Caso nenhum nome seja passado, o &lt;code&gt;x-prompt&lt;/code&gt; perguntará o nome do módulo. Lembrando que o nome está marcado como &lt;code&gt;required&lt;/code&gt;, tornando ele um parâmetro obrigatório.&lt;/p&gt;
&lt;p&gt;Esses parâmetros estarão disponíveis como atributos do no nosso objeto &lt;code&gt;_options&lt;/code&gt;, que a gente usou no hello world.&lt;/p&gt;
&lt;p&gt;Feito isso, vamos alterar o &lt;code&gt;collection.json&lt;/code&gt; novamente para que ele referencie o nosso schema:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;collection.json&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;{
  &quot;$schema&quot;: &quot;../node_modules/@angular-devkit/schematics/collection-schema.json&quot;,
  &quot;schematics&quot;: {
    &quot;my-schematics&quot;: {
      &quot;description&quot;: &quot;A custom module generator.&quot;,
      &quot;factory&quot;: &quot;./my-schematics/index#mySchematics&quot;,
      &quot;schema&quot;: &quot;./my-schematics/schema.json&quot;
    }
  }
}&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;definindo-a-collection-padrão&quot;&gt;Definindo a Collection padrão&lt;/h2&gt;
&lt;p&gt;Lembra que eu disse que é legal estender a collection do Angular pra gente não precisar ficar passando o nome da nossa collection o tempo todo? Pra isso, Vamos adicionar a linha &lt;code&gt;&quot;extends&quot;: [&quot;@schematics/angular&quot;]&lt;/code&gt; ao arquivo &lt;code&gt;collection.json&lt;/code&gt;. Ele vai ficar assim:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;collection.json&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;{
  &quot;$schema&quot;: &quot;../node_modules/@angular-devkit/schematics/collection-schema.json&quot;,
  &quot;extends&quot;: [&quot;@schematics/angular&quot;],
  &quot;schematics&quot;: {
    &quot;my-schematics&quot;: {
      &quot;description&quot;: &quot;A custom module generator.&quot;,
      &quot;factory&quot;: &quot;./my-schematics/index#mySchematics&quot;,
      &quot;schema&quot;: &quot;./my-schematics/schema.json&quot;
    }
  }
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Depois, vamos adicionar a chave &lt;code&gt;cli&lt;/code&gt; com a nossa collection no arquivo &lt;code&gt;angular.json&lt;/code&gt; do projeto:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// angular.json
...  
  &quot;cli&quot;: {
    &quot;defaultCollection&quot;: &quot;my-schematics&quot;
  }&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora, você pode executar o seu schematic da mesma forma que executa os comandos do Angular!&lt;/p&gt;
&lt;h2 id=&quot;configurando-o-gerador&quot;&gt;Configurando o gerador&lt;/h2&gt;
&lt;p&gt;Vamos configurar a &lt;code&gt;RuleFactory&lt;/code&gt; para gerar o nosso módulo conforme o template que ainda iremos definir. Para isso, substitua o conteúdo do arquivo &lt;code&gt;index.ts&lt;/code&gt; pelo arquivo abaixo:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;index.ts&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;import {
  apply,
  branchAndMerge,
  chain,
  mergeWith,
  move,
  renameTemplateFiles,
  Rule,
  SchematicContext,
  template,
  Tree,
  url
} from &apos;@angular-devkit/schematics&apos;;
import {
  basename,
  dirname,
  experimental,
  normalize,
  Path,
  strings
} from &apos;@angular-devkit/core&apos;;

export function mySchematics(_options: any): Rule {
  return (tree: Tree, context: SchematicContext) =&amp;gt; {
    const workspaceConfig = tree.read(&apos;/angular.json&apos;);
    if (!workspaceConfig) {
      throw new Error(&apos;Could not find Angular workspace configuration&apos;);
    }

    // convert workspace settings to string
    const workspaceContent = workspaceConfig.toString();

    // parse workspace string into JSON object
    const workspace: experimental.workspace.WorkspaceSchema = JSON.parse(
      workspaceContent
    );

    // get project name
    if (!_options.project) {
      _options.project = workspace.defaultProject;
    }

    const projectName = _options.project as string;
    const project = workspace.projects[projectName];
    const projectType = project.projectType === &apos;application&apos; ? &apos;app&apos; : &apos;lib&apos;;

    // Get the path to create files
    if (_options.path === undefined) {
      _options.path = `${project.sourceRoot}/${projectType}`;
    }

    const parsedPath = parseName(_options.path, _options.name);
    _options.name = parsedPath.name;
    _options.path = parsedPath.path;

    // Parse template files
    const templateSource = apply(url(&apos;./files&apos;), [
      renameTemplateFiles(),
      template({
        ...strings,
        ..._options,
        classify: strings.classify,
        dasherize: strings.dasherize
      }),
      move(normalize((_options.path + &apos;/&apos; + _options.name) as string))
    ]);

    // Return Rule chain
    return chain([branchAndMerge(chain([mergeWith(templateSource)]))])(
      tree,
      context
    );
  };
}

export function parseName(
  path: string,
  name: string
): { name: string; path: Path } {
  const nameWithoutPath = basename(name as Path);
  const namePath = dirname((path + &apos;/&apos; + name) as Path);

  return {
    name: nameWithoutPath,
    path: normalize(&apos;/&apos; + namePath)
  };
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A nossa &lt;code&gt;Rule&lt;/code&gt; pode ser resumida em três etapas:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Obtenção os dados do projeto a partir da configuração do workspace;&lt;/li&gt;
&lt;li&gt;Montagem do &lt;code&gt;path&lt;/code&gt; em que os arquivo serão criados;&lt;/li&gt;
&lt;li&gt;Parse dos arquivos de template.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;É necessário dar algumas voltas pra ter um schematic consistente e que funcione tanto dentro do projeto quanto a partir da raiz, assim como os schematics do próprio Angular. No final de tudo, o resultado é bem satisfatório.&lt;/p&gt;
&lt;h2 id=&quot;criando-o-template&quot;&gt;Criando o Template&lt;/h2&gt;
&lt;p&gt;Nós podemos trabalhar de várias formas com o schematics. Seja executando os schematics padrão para gerar uma estrutura de módulo personalizada ou alterando arquivos da tree. Como estamos falando em geração de código, vamos gerar o nosso módulo via template.&lt;/p&gt;
&lt;p&gt;Nosso template vai conter um módulo com dois componentes. O template do schematics não é nada diferente do que nós já estamos acostumados. A sintaxe lembra muito um cara old school chamado ASP.&lt;/p&gt;
&lt;p&gt;Como já temos o nosso &lt;code&gt;index.ts&lt;/code&gt; pronto pra compilar o nosso template, vamos ao trabalho!&lt;/p&gt;
&lt;h3 id=&quot;template-do-módulo&quot;&gt;Template do módulo&lt;/h3&gt;
&lt;p&gt;O primeiro arquivo a ser criado é o nosso módulo. Vamos criar uma pasta chamada &lt;code&gt;files&lt;/code&gt; dentro do diretório do nosso schematics e nela o arquivo: &lt;code&gt;__name@dasherize__.module.ts.template&lt;/code&gt;. Esse nome esquisito é necessário para que o parser gere o nome do arquivo utilizando a função &lt;code&gt;dasherize&lt;/code&gt; que irá converter o atributo &lt;code&gt;name&lt;/code&gt; para kebab-case.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;__name@dasherize__.module.ts.template&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;import { NgModule } from &apos;@angular/core&apos;;
import { CommonModule } from &apos;@angular/common&apos;;

import { &amp;lt;%= classify(name) %&amp;gt;ListComponent } from &apos;./&amp;lt;%= name %&amp;gt;-list.component&apos;;
import { &amp;lt;%= classify(name) %&amp;gt;FormComponent } from &apos;./&amp;lt;%= name %&amp;gt;-form.component&apos;;

@NgModule({
  imports: [CommonModule],
  declarations: [&amp;lt;%= classify(name) %&amp;gt;ListComponent, &amp;lt;%= classify(name) %&amp;gt;FormComponent],
})
export class &amp;lt;%= classify(name) %&amp;gt;Module {}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;No nosso template, nós utilizamos a função &lt;code&gt;classify&lt;/code&gt; para converter o atributo &lt;code&gt;name&lt;/code&gt; para PascalCase, e com isso gerar os nomes das classes dinamicamente.&lt;/p&gt;
&lt;h3 id=&quot;template-dos-componentes&quot;&gt;Template dos componentes&lt;/h3&gt;
&lt;p&gt;No caso dos componentes, a lógica é a mesma. Você pode criar um ou vários componentes no mesmo diretório ou em pastas separadas que o schematics respeitará a sua estrutura. No nosso caso, vamos criar os dois componentes (list e form) no mesmo diretório do módulo:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;__name@dasherize__-list.component.ts.template&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;import { Component, OnInit } from &apos;@angular/core&apos;;

@Component({
  selector: &apos;app-&amp;lt;%= dasherize(name) %&amp;gt;-list&apos;,
  template: `
    &amp;lt;p&amp;gt;
      list works!
    &amp;lt;/p&amp;gt;
  `,
  styles: []
})
export class &amp;lt;%= classify(name) %&amp;gt;ListComponent implements OnInit {

  constructor() { }

  ngOnInit() {
  }

}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;__name@dasherize__-form.component.ts.template&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;import { Component, OnInit } from &apos;@angular/core&apos;;

@Component({
  selector: &apos;app-&amp;lt;%= dasherize(name) %&amp;gt;-form&apos;,
  template: `
    &amp;lt;p&amp;gt;
      form works!
    &amp;lt;/p&amp;gt;
  `,
  styles: []
})
export class &amp;lt;%= classify(name) %&amp;gt;FormComponent implements OnInit {

  constructor() { }

  ngOnInit() {
  }

}&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;e-agora-josé&quot;&gt;E agora, José?&lt;/h2&gt;
&lt;p&gt;Vamos ver se esse treco todo funciona? Primeiro vamos rodar o &lt;code&gt;npm run build&lt;/code&gt; do projeto &lt;code&gt;my-schematics&lt;/code&gt; para compilar o projeto, navegar para o projeto &lt;code&gt;my-project&lt;/code&gt; e ficar feliz porque agora é hora da verdade! Vamos executar o nosso gerador:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ng g my-schematics awesome&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;RODOOOUU!! Geramos um módulo com dois componentes básicos dentro do nosso projeto. Agora basta definir as suas rotas e testar os seus componentes que acabaram de sair do forno. OU, fica a lição de casa: adicionar as rotas ao seu template do schematics também.&lt;/p&gt;
&lt;p&gt;Eu preferi padronizar tudo. Módulos, rotas, esqueletos de página e até mesmo os testes unitários foram adicionados ao template. Uma dica é: Crie um módulo completamente funcional do jeito que você quer padronizar e converta ele pra template somente quando estiver tudo pronto. Assim fica mais fácil de testar enquanto você está desenvolvendo.&lt;/p&gt;
&lt;p&gt;Até a próxima!&lt;/p&gt;</content:encoded><category>angular</category><category>schematics</category><category>ferramentas</category></item><item><title>Schematics: Criando um gerador de códigos com Angular — Parte 1</title><link>https://ricmello.com/posts/schematics-criando-um-gerador-de-codigos-com-angular-parte-1/</link><guid isPermaLink="true">https://ricmello.com/posts/schematics-criando-um-gerador-de-codigos-com-angular-parte-1/</guid><description>Introdução ao Schematics do Angular: como a Tree funciona, collections, RuleFactory e o seu primeiro schematic rodando no Angular CLI via npm link.</description><pubDate>Tue, 21 May 2019 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Logo do Angular sobre fundo azul quadriculado, estilo blueprint&quot; width=&quot;1400&quot; height=&quot;411&quot; src=&quot;https://ricmello.com/_astro/image-01.BJ_eG0IL_Z6epCB.webp&quot;&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Este post é o primeiro de uma série sobre o Schematics, que vai abordar desde os conceitos até termos um gerador de código funcional. Leia a parte 2 &lt;a href=&quot;https://ricmello.com/posts/schematics-criando-um-gerador-de-codigos-com-angular-parte-2/&quot;&gt;aqui&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Um sábio me disse algumas dezenas de vezes que se você passa grande parte do seu tempo criando telas de cadastro, é porque você está fazendo alguma coisa errada.&lt;/p&gt;
&lt;p&gt;O famoso Scaffolding, que era muito popular em frameworks MVC, acabou caindo em desuso ao longo do tempo. Bibliotecas como Formly são muito boas, mas deixam o template “engessado” demais. Pois bem, depois de criarmos mais um CRUD no nosso projeto, veio a pergunta:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Pra que diabos estamos criando telas de cadastro se estamos trabalhando com inovação?&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Obviamente nós precisávamos das telas, mas não fazia sentido criá-las do zero. Então, resolvemos nos aventurar criando nosso primeiro Schematics.&lt;/p&gt;
&lt;h2 id=&quot;como-o-schematics-funciona&quot;&gt;Como o Schematics funciona&lt;/h2&gt;
&lt;p&gt;No Schematics, você não faz alterações direto no sistema de arquivos. Ao invés disso, você modifica um elemento chamado &lt;code&gt;Tree&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;A &lt;code&gt;Tree&lt;/code&gt; é uma estrutura de dados que contém uma &lt;strong&gt;base&lt;/strong&gt; (com os arquivos que já existem) e uma área de &lt;strong&gt;staging&lt;/strong&gt; (uma lista de alterações a serem aplicadas na base). Qualquer semelhança com o git não é mera coincidência. Cada alteração que você faz é realizada em staging, e somente no final elas são aplicadas na base.&lt;/p&gt;
&lt;p&gt;Isso permite que o seu schematic suporte dry-runs sem que você se preocupe com a implementação. Em caso de erros durante a execução, os seus arquivos não serão afetados também.&lt;/p&gt;
&lt;h2 id=&quot;criando-o-seu-primeiro-schematics&quot;&gt;Criando o seu primeiro Schematics&lt;/h2&gt;
&lt;p&gt;Instale o CLI globalmente usando o seguinte comando:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;npm install -g @angular-devkit/schematics-cli&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E em seguida, crie o projeto:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;schematics blank --name=my-schematics&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Pronto! Seu projeto está criado. Mãos à obra!&lt;/p&gt;
&lt;h2 id=&quot;collections&quot;&gt;Collections&lt;/h2&gt;
&lt;p&gt;Uma collection nada mais é do que um coleção de schematics. A do Angular, por exemplo, chama-se &lt;code&gt;@schematics/angular&lt;/code&gt; que possui os geradores para &lt;code&gt;component&lt;/code&gt;, &lt;code&gt;module&lt;/code&gt;, etc. A do Nx é a &lt;code&gt;@nrwl/schematics&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Uma collection também pode estender outra collection. Assim, você pode usar os schematics do Angular junto aos seus sem precisar ficar alternando entre eles.&lt;/p&gt;
&lt;p&gt;O arquivo &lt;code&gt;collection.json&lt;/code&gt; é o arquivo que define a nossa collection:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;collection.json&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;{
  &quot;$schema&quot;: &quot;../node_modules/@angular-devkit/schematics/collection-schema.json&quot;,
  &quot;schematics&quot;: {
    &quot;my-schematics&quot;: {
      &quot;description&quot;: &quot;A blank schematic.&quot;,
      &quot;factory&quot;: &quot;./my-schematics/index#mySchematics&quot;
    }
  }
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;O &lt;code&gt;$schema&lt;/code&gt; contém o schema definindo o formato do nosso arquivo. O nosso schematic padrão está na chave &lt;code&gt;schematics&lt;/code&gt;, que define cada schematic da nossa collection. Por padrão, você vai ver um schematic chamado &lt;code&gt;my-schematic&lt;/code&gt;, apontando pra &lt;code&gt;factory&lt;/code&gt; que é a função &lt;code&gt;myComponent&lt;/code&gt; do arquivo &lt;code&gt;src/my-schematics/index.ts&lt;/code&gt;. Ele é a nossa &lt;code&gt;RuleFactory&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&quot;rulefactory&quot;&gt;RuleFactory&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;RuleFactory&lt;/code&gt; é uma função que define uma &lt;code&gt;Rule&lt;/code&gt;. Nós a podemos comparar à uma planta do que nós queremos fazer. Ela define os passos que o nosso schematic precisa pra funcionar.&lt;/p&gt;
&lt;p&gt;A nossa &lt;code&gt;RuleFactory&lt;/code&gt; padrão vem com o seguinte conteúdo:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;index.ts&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;import { Rule, SchematicContext, Tree } from &apos;@angular-devkit/schematics&apos;;

// You don&apos;t have to export the function as default. You can also have more than one rule factory
// per file.
export function mySchematics(_options: any): Rule {
  return (tree: Tree, _context: SchematicContext) =&amp;gt; {
    return tree;
  };
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Rule é uma função que recebe a &lt;code&gt;Tree&lt;/code&gt; e retorna uma outra &lt;code&gt;Tree&lt;/code&gt;. Um schematic pode ter uma ou mais &lt;code&gt;Rules&lt;/code&gt;, e são nelas que tudo acontece. Como a factory aponta pra função &lt;code&gt;mySchematics&lt;/code&gt;, ela é o ponto de entrada da execução.&lt;/p&gt;
&lt;p&gt;O objeto &lt;code&gt;_options&lt;/code&gt; contém os inputs que foram definidos no schema, mas vamos aprofundar um pouco mais sobre ele no próximo artigo.&lt;/p&gt;
&lt;p&gt;Como nossa função simplesmente está retornando a &lt;code&gt;Tree&lt;/code&gt; que ela recebe, vamos deixar a coisa um pouco mais interessante:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;index.ts&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;import { Rule, SchematicContext, Tree } from &apos;@angular-devkit/schematics&apos;;

// You don&apos;t have to export the function as default. You can also have more than one rule factory
// per file.
export function mySchematics(_options: any): Rule {
  return (tree: Tree, _context: SchematicContext) =&amp;gt; {
    tree.create(_options.name || &apos;hello&apos;, &apos;world&apos;);
    return tree;
  };
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora temos uma função que cria um arquivo com o nome passado via parâmetro &lt;code&gt;name&lt;/code&gt; e o conteúdo &lt;code&gt;world&lt;/code&gt;. Caso nenhum nome seja passado, ela cria um arquivo com o nome &lt;code&gt;hello&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Voilà! Acabamos de criar o nosso primeiro schematic. Para isso, precisamos compilar os arquivos typescript:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;npm run build&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E em seguida executá-lo:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;schematics .:my-schematics --name=awesome&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;O terminal vai te informar que um arquivo chamado &lt;code&gt;awesome&lt;/code&gt; foi criado na raiz do projeto. Não se preocupe. O arquivo não está lá porque por padrão o CLI é executado em modo debug. Se você quiser ver o arquivo, basta executar o mesmo comando passando &lt;code&gt;--dry-run=false&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&quot;adicionando-o-schematic-ao-seu-projeto&quot;&gt;Adicionando o Schematic ao seu projeto&lt;/h2&gt;
&lt;p&gt;Vamos criar um projeto Angular padrão:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ng new my-project&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Navegue para a pasta do seu projeto adicione o Schematic que a gente acabou de criar via &lt;code&gt;npm link&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cd my-project

npm link &amp;lt;path-to-schematics-project&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Troque o &lt;code&gt;&amp;lt;path-to-schematics-project&amp;gt;&lt;/code&gt; pelo caminho do seu projeto schematics. No meu caso os dois projetos estão no mesmo diretório, então eu executei&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;npm link ../my-schematics&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Feito isso, basta executar o schematic via Angular CLI:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ng g my-schematics:my-schematics --name=awesome&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Pronto! O arquivo &lt;code&gt;awesome&lt;/code&gt; foi criado na raiz do seu projeto. Pode conferir o conteúdo.&lt;/p&gt;
&lt;p&gt;Por mais que seja um exemplo pequeno, pudemos ver que com alguns passos nós podemos criar um gerador totalmente funcional que pode ser utilizado em nossa aplicação. No próximo artigo, vamos estruturar o nosso schema para criarmos o gerador de código.&lt;/p&gt;
&lt;p&gt;Continua &lt;a href=&quot;https://ricmello.com/posts/schematics-criando-um-gerador-de-codigos-com-angular-parte-2/&quot;&gt;aqui&lt;/a&gt;.&lt;/p&gt;</content:encoded><category>angular</category><category>schematics</category><category>ferramentas</category></item><item><title>Angular: Estendendo o HttpClient e criando Interceptors dinâmicos</title><link>https://ricmello.com/posts/angular-estendendo-o-httpclient-e-interceptors-dinamicos/</link><guid isPermaLink="true">https://ricmello.com/posts/angular-estendendo-o-httpclient-e-interceptors-dinamicos/</guid><description>Como eu estendi o HttpClient do Angular pra ligar e desligar interceptors por requisição, tipo esconder o loader só nos campos de autocomplete.</description><pubDate>Fri, 25 May 2018 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Alpinista de jaqueta vermelha escalando uma encosta de gelo com uma picareta&quot; width=&quot;1400&quot; height=&quot;608&quot; src=&quot;https://ricmello.com/_astro/image-01.5KwMFmOl_fo8j7.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Era uma sexta-feira, eu tinha acabado minha tarefa e parei pra consertar um tal “loader” que bloqueava a tela ao digitar nos campos de autocomplete. Esse loader era um interceptor exibido a cada Request.&lt;/p&gt;
&lt;p&gt;Se tratando de uma arquitetura recém construída, seria simples resolver o problema: Remove o loader de lá e faz o componente controlar o coitado, já que cada componente sabe de suas necessidades. OOOOUUU, encapsula o HttpClient em uma classe sua e adicione as suas próprias mágicas dentro dela.&lt;/p&gt;
&lt;p&gt;Porém, pela proporção “páginas que precisariam ser completamente refatoradas” versus “oculta o loader desse campinho aqui”, a solução mais rápida foi desabilitar o loader somente nos campos de autocomplete, pois todos nós temos um prazo. Nosso projeto também.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;P.S.: Apesar do motivo, essa solução pode se aplicar a adicionar/remover caminhos de API, controlar o cache ou se o token de autenticação deve ser utilizado ou não.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img alt=&quot;Meme do Ned Stark (Game of Thrones): “Finish your project, deadline is coming”&quot; width=&quot;460&quot; height=&quot;352&quot; src=&quot;https://ricmello.com/_astro/image-02.CPyE5m_s_TWnTG.webp&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;a-primeira-alternativa&quot;&gt;A primeira alternativa&lt;/h2&gt;
&lt;p&gt;A primeira alternativa foi a mais simples porém a menos elaborada: adiciona um param “hideLoader” e usa ele pra dizer se o loader pode ser exibido ou não. Porém, procurando nas issues do Angular, já existia uma pra isso (&lt;a href=&quot;https://github.com/angular/angular/issues/18155&quot;&gt;#18155&lt;/a&gt;), e a galera não curtiu muito essa ideia por conta de enviar os dados pro servidor.&lt;/p&gt;
&lt;p&gt;Pesquisando um pouco mais, cheguei à solução do &lt;a href=&quot;https://github.com/ngx-rocket/generator-ngx-rocket&quot;&gt;ngx-rocket&lt;/a&gt;, que estendeu o HttpClient em uma nova classe e passou a responder no lugar dele adicionando seus próprios métodos. Não sei se o que me atraiu foi a criatividade, a complexidade, ou o fato de eu poder mapear todos os lugares que usam os métodos customizados sem muito esforço (vai que a feature é incluída no Angular 7 e eu tenho que refatorar tudo), mas é dessa solução que a gente vai falar aqui.&lt;/p&gt;
&lt;h2 id=&quot;estendendo-omódulo&quot;&gt;&lt;strong&gt;Estendendo o módulo&lt;/strong&gt;&lt;/h2&gt;
&lt;p&gt;O Typescript tem um recurso bem interessante em que é possível estender um módulo. No nosso caso, vamos estender o módulo e exportar a interface HttpClient já com os métodos customizados. Para isso, vamos criar o arquivo &lt;strong&gt;http.service.ts&lt;/strong&gt; com o seguinte conteúdo:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;http.service.ts&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;declare module &apos;@angular/common/http/src/client&apos; {

  export interface HttpClient {
    hideLoader(hide?: boolean): HttpClient;
  }

}&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&quot;customizando-interceptors&quot;&gt;Customizando Interceptors&lt;/h3&gt;
&lt;p&gt;Aqui, vamos encadear a chamada dos interceptors e permitir a customização deles:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;http.service.ts&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;import { InjectionToken } from &apos;@angular/core&apos;;
import { HttpClient, HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from &apos;@angular/common/http&apos;;
import { Observable } from &apos;rxjs&apos;;

declare module &apos;@angular/common/http/src/client&apos; {

  export interface HttpClient {
    hideLoader(hide?: boolean): HttpClient;
  }

}

class HttpInterceptorHandler implements HttpHandler {

  constructor(private next: HttpHandler, private interceptor: HttpInterceptor) { }

  handle(request: HttpRequest&amp;lt;any&amp;gt;): Observable&amp;lt;HttpEvent&amp;lt;any&amp;gt;&amp;gt; {
    return this.interceptor.intercept(request, this.next);
  }

}

export const HTTP_DYNAMIC_INTERCEPTORS = new InjectionToken&amp;lt;HttpInterceptor&amp;gt;(&apos;HTTP_DYNAMIC_INTERCEPTORS&apos;);&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;o-httpclient-digo-o-nossoservice&quot;&gt;O HttpClient, digo… o nosso Service&lt;/h2&gt;
&lt;p&gt;Ainda no nosso HttpService, vamos criar a classe que dá nome a ele. O método hideLoader é o responsável por desabilitar o interceptor de loader. Já o request, sobrescreve o método original para utilizar os interceptors definidos no nosso array.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;http.service.ts&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;@Injectable()
export class HttpService extends HttpClient {

  constructor(private httpHandler: HttpHandler,
              private injector: Injector,
              @Optional() @Inject(HTTP_DYNAMIC_INTERCEPTORS) private interceptors: HttpInterceptor[] = []) {
    super(httpHandler);

    if (!this.interceptors) {
      // Configure default interceptors that can be disabled here
      this.interceptors = [
        this.injector.get(LoaderInterceptor),
      ];
    }
  }

  // Disable loader interceptor
  hideLoader(hide: boolean = true): HttpClient {
    return hide
      ? this.removeInterceptor(LoaderInterceptor)
      : this;
  }

  // Override the original method to wire interceptors when triggering the request.
  request(method?: any, url?: any, options?: any): any {
    const handler = this.interceptors.reduceRight(
      (next, interceptor) =&amp;gt; new HttpInterceptorHandler(next, interceptor),
      this.httpHandler
    );
    return new HttpClient(handler).request(method, url, options);
  }

  private removeInterceptor(interceptorType: Function): HttpService {
    return new HttpService(
      this.httpHandler,
      this.injector,
      this.interceptors.filter(i =&amp;gt; !(i instanceof interceptorType))
    );
  }

  private addInterceptor(interceptor: HttpInterceptor): HttpService {
    return new HttpService(
      this.httpHandler,
      this.injector,
      this.interceptors.concat([interceptor])
    );
  }

}&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;registrando-oservice&quot;&gt;Registrando o Service&lt;/h2&gt;
&lt;p&gt;Vamos registrar o HttpService substituindo o HttpClient para que o mesmo seja injetado em todos os lugares que o HttpClient já é utilizado. No meu caso, eu registrei direto no app.module.ts:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;app.module.ts&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;providers: [
  { provide: HttpClient, useClass: HttpService },
],&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;utilizando&quot;&gt;Utilizando&lt;/h2&gt;
&lt;p&gt;Por último, vamos utilizar o nosso método nos providers que chamam as URLs de autocomplete.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;my-service.ts&lt;/code&gt;&lt;/p&gt;&lt;pre&gt;&lt;code&gt;public getAutoCompleteResult(term: string) {
  return this.httpClient
    .hideLoader()
    .get(`http://my-domain/api/autocomplete`);
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Com isso, nós podemos utilizar métodos customizados no HttpClient e manter o resto da nossa aplicação funcionando, e também podemos rastrear onde eles foram utilizados caso ocorra alguma mudança na ferramenta.&lt;/p&gt;</content:encoded><category>angular</category><category>frontend</category></item><item><title>Capacitor: Aplicações Web Universais</title><link>https://ricmello.com/posts/capacitor-aplicacoes-web-universais/</link><guid isPermaLink="true">https://ricmello.com/posts/capacitor-aplicacoes-web-universais/</guid><description>Minhas primeiras impressões do Capacitor, a camada nativa do time do Ionic: projetos Android e iOS dentro do projeto web e mais controle que no Cordova.</description><pubDate>Mon, 05 Mar 2018 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Banner “Introducing Capacitor” com o logo do projeto&quot; width=&quot;800&quot; height=&quot;251&quot; src=&quot;https://ricmello.com/_astro/image-01.CQitRKWA_Z6YGFq.webp&quot;&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;O Capacitor está sendo projetado pela equipe do Ionic Framework como uma alternativa ao Cordova, embora a compatibilidade com versões anteriores de Cordova seja uma prioridade e esteja sendo trabalhada ativamente.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;No último dia 27 a comunidade do Ionic ganhou um novo projeto: &lt;a href=&quot;https://capacitor.ionicframework.com/&quot;&gt;Capacitor&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;O projeto Capacitor busca ser a camada nativa das aplicações Ionic, que hoje é responsabilidade do Cordova e seus plugins.&lt;/p&gt;
&lt;p&gt;Ao contrário do Cordova, o Capacitor traz um modelo de projeto que eu gostei bastante: nele, o projeto nativo Android/iOS fazem parte do projeto Ionic, não sendo mais tratados como projetos separados gerados pelo &lt;code&gt;cordova platform add &amp;lt;platform&amp;gt;&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Outro fato interessante é que os processos de build e deploy são realizados pela IDE utilizada na plataforma nativa. Combinando isso ao fato de termos os projetos nativos junto do projeto principal, podemos alcançar um nível de personalização e de controle da camada nativa bem maior que antes.&lt;/p&gt;
&lt;p&gt;Um ótimo exemplo desse nível de personalização é um mecanismo chamado &lt;a href=&quot;https://medium.com/android-dev-br/flavors-2fa7b2ba4a9a&quot;&gt;&lt;strong&gt;Product Flavors&lt;/strong&gt;&lt;/a&gt;&lt;strong&gt;.&lt;/strong&gt; Curiosamente, meu amigo &lt;a href=&quot;https://medium.com/u/4beb3c22425&quot;&gt;Samir Rolemberg&lt;/a&gt;, que é fera no Android e está experimentando trabalhar em um projeto Ionic, havia me perguntado sobre como fazer isso no Ionic alguns dias antes. Ainda não tive a oportunidade de testar o &lt;code&gt;cordova-plugin-flavors&lt;/code&gt;, que promete essa funcionalidade. Mas obviamente o processo seria mais simples se os projetos fossem um só como no Capacitor. Ainda mais pra um cara que já tem isso no sangue pela experiência com programação nativa.&lt;/p&gt;
&lt;p&gt;Você vai encontrar mais informações para testar a plataforma &lt;a href=&quot;https://capacitor.ionicframework.com/docs/getting-started/with-ionic&quot;&gt;aqui&lt;/a&gt;. Você pode instalar o Capacitor em um projeto Web, em um projeto Ionic ou criar um projeto do zero. Por ser tratar de um alpha ainda há bastante coisa a melhorar, mas ainda assim o processo é simples e rápido.&lt;/p&gt;
&lt;p&gt;O Capacitor traz uma ótima alternativa ao desenvolvimento de apps híbridos e promete ser mais uma revolução na comunidade do Ionic (Stencil ❤). Estamos ansiosos para ver o que mais vem por aí!&lt;/p&gt;</content:encoded><category>mobile</category><category>frontend</category></item><item><title>Angular: Rotas para aplicações Multi Tenant</title><link>https://ricmello.com/posts/angular-rotas-para-aplicacoes-multi-tenant/</link><guid isPermaLink="true">https://ricmello.com/posts/angular-rotas-para-aplicacoes-multi-tenant/</guid><description>Como usar route params e o paramsInheritanceStrategy do Angular 5.2 pra levar o tenant na URL, com bookmark e várias abas abertas em hotéis diferentes.</description><pubDate>Fri, 02 Mar 2018 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Escudo do Angular com um diagrama de árvore de rotas sobre fundo verde-água&quot; width=&quot;600&quot; height=&quot;300&quot; src=&quot;https://ricmello.com/_astro/image-01.D7C-nv8p_Zj3mGi.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;Esses dias fui designado para a missão de reestruturar uma aplicação Angular para multi-tenant. Teria sido mais complexo há alguns meses, mas graças à versão 5.2 do framework, essa realidade mudou.&lt;/p&gt;
&lt;h2 id=&quot;entendendo-asituação&quot;&gt;Entendendo a situação&lt;/h2&gt;
&lt;p&gt;Imagine que uma rede hoteleira possui vários hotéis e um usuário da rede geralmente tem acesso a mais de um hotel. Esse usuário pode ser um gerente responsável por várias unidades que precisa alternar entre elas rapidamente, e até mesmo adicionar aos favoritos para acessar posteriormente.&lt;/p&gt;
&lt;h2 id=&quot;tá-mas-eu-preciso-gerenciar-isso-no-front-end&quot;&gt;Tá, mas eu preciso gerenciar isso no front-end?&lt;/h2&gt;
&lt;p&gt;Sim e não. Depende muito do seu objetivo.&lt;/p&gt;
&lt;p&gt;Seria muito mais simples guardar o hotel selecionado no &lt;code&gt;localStorage&lt;/code&gt; e usar um botão para alternar entre eles. Porém, sabendo que o usuário precisa trabalhar em vários hotéis simultaneamente, fica a pergunta: Como permitir a rápida alternância entre hotéis e tornar isso transparente para o usuário? Como guardar a informação do hotel na URL e tornar possível o bookmark?&lt;/p&gt;
&lt;h2 id=&quot;route-parameters&quot;&gt;Route Parameters&lt;/h2&gt;
&lt;p&gt;O Angular possui o recurso de Route Parameters, que traduz a informação na URL em parâmetros acessíveis via &lt;code&gt;ActivatedRoute&lt;/code&gt;.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// src/app/app-routing.module.ts&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;export const routes: Routes = [
  {
    path: &apos;admin/:hotel&apos;,
    component: AdminTemplateComponent,
    children: [
      { path: &apos;&apos;, component: HotelConfigComponent }
    ]
  }
];&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;@NgModule({
  imports: [RouterModule.forRoot(routes)],
  exports: [RouterModule]
})&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;export class AppRoutingModule {}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Note que se eu acessar &lt;code&gt;/admin/1/config&lt;/code&gt;, o parâmetro hotel com o valor 1 estará disponível apenas no componente &lt;code&gt;AdminTemplateComponent&lt;/code&gt;. Porém, nesse caso, nenhum elemento filho consegue acessar os valores da rota do componente pai. Sendo assim, eu não conseguirei acessar o parâmetro hotel dentro de &lt;code&gt;HotelConfigComponent&lt;/code&gt;, e não terei os dados do hotel para enviar nas minhas requisições.&lt;/p&gt;
&lt;h2 id=&quot;herança-de-parâmetros&quot;&gt;Herança de parâmetros&lt;/h2&gt;
&lt;p&gt;Anteriormente, um componente só conseguia acessar os parâmetros de uma rota pai com algumas regras especiais (quando a rota tinha um caminho vazio, ou se não tivesse componente). Como na maioria dos casos é necessário um componente de template e/ou um container, essa opção não era muito atrativa.&lt;/p&gt;
&lt;p&gt;Porém, na versão 5.2, o Angular trouxe o recurso de herança de parâmetros chamado &lt;code&gt;paramsInheritanceStrategy&lt;/code&gt;, que quando setada para &lt;code&gt;always&lt;/code&gt;, faz com que todas as rotas filhas herdem os parâmetros das rotas pai.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// src/app/app-routing.module.ts&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;export const routes: Routes = [
  {
    path: &apos;admin/:hotel&apos;,
    component: AdminTemplateComponent,
    children: [
      { path: &apos;&apos;, component: HotelConfigComponent }
    ]
  }
];&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;@NgModule({
  imports: [RouterModule.forRoot(routes, {
    paramsInheritanceStrategy: &apos;always&apos;
  })],
  exports: [RouterModule]
})&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;export class AppRoutingModule {}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Editando o nosso arquivo de rotas e adicionando a configuração de herança, eu consigo acessar o parâmetro hotel em qualquer componente da aplicação. E caso o usuário tenha duas ou mais abas abertas, cada uma com um hotel diferente, eu posso diferenciá-las tranquilamente pelo parâmetro recebido via URL, oferecendo uma experiência melhor.&lt;/p&gt;</content:encoded><category>angular</category><category>frontend</category></item><item><title>Um Recomeço</title><link>https://ricmello.com/posts/um-recomeco/</link><guid isPermaLink="true">https://ricmello.com/posts/um-recomeco/</guid><description>Meu primeiro post, de 2016: como a paixão pelo PC do meu primo virou carreira, como os freelas me fizeram perder o rumo e a decisão de recomeçar.</description><pubDate>Wed, 11 May 2016 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;img alt=&quot;Homem caminhando sozinho no meio de uma estrada reta no deserto&quot; width=&quot;1400&quot; height=&quot;569&quot; src=&quot;https://ricmello.com/_astro/image-01.CDGgJMNj_Ez4ST.webp&quot;&gt;&lt;/p&gt;
&lt;p&gt;O mercado de tecnologia é fascinante. Ele te dá oportunidades incríveis e você se sente valorizado, reconhecido, parte de uma coisa gigante.&lt;/p&gt;
&lt;p&gt;Há pessoas que entram nesse mercado pra poder ganhar dinheiro, por vaidade ou por necessidade. Outras entram porque sempre gostaram de um computador, sempre quiseram fazer aquela coisa funcionar, se apaixonaram à primeira vista por aquele PC branco com Windows 98 do seu primo. PC esse que seus pais não tinham nenhuma condição de comprar, mas que, devido a grande amizade, ele deixava você brincar como se fosse seu. Eu me encaixava nessa última opção.&lt;/p&gt;
&lt;p&gt;Ainda no estágio consegui uma vaga pra freelancer em que eu continuaria no estágio e ganharia por hora nessa segunda empresa. O dinheiro é sempre bem-vindo quando você o consegue por mérito próprio e isso acabou me “corrompendo”. Pra que eu perderia tempo em projetos próprios que não deram certo — sdds ArenaArcade, se eu poderia fazer freelas, freelas e muito mais freelas pra poder “acumular grana”?&lt;/p&gt;
&lt;p&gt;Filho de um motorista de ônibus e uma dona de casa, sempre quis superar meu pai no quesito dinheiro pra poder ajudar em casa. Eu consegui. Hoje ganho muito mais que meu pai, ajudo um pouco em casa e o resto do dinheiro eu invisto no meu futuro apartamento. Banco a pizza do fim de semana, ajudo na infra necessária pros meus irmãos estudarem, entre outras coisas. Enfim, graças a mim, e principalmente aos meus pais, minha família alcançou um patamar que a gente nunca viveu — ANO PASSADO COMPRAMOS UMA TV DE LED!!&lt;/p&gt;
&lt;p&gt;Mas porque eu estudava mesmo? Aah, eh, porque eu gosto de tecnologia. Eu gosto não, AMO. E minha namorada que me desculpe, mas sim, ela tem que dividir o espaço. O ponto é que nesse meio tempo eu acabei me perdendo, e após quebrar a cara algumas vezes eu finalmente me reencontrei.&lt;/p&gt;
&lt;p&gt;A gente aprende bastante coisa no mercado corporativo, e eu quero utilizar tudo o que aprendi nesses pequenos 4 anos como full stack pra ensinar e aprender na comunidade. Sempre participei dos grupos de desenvolvimento de uma forma reativa e esse post é um compromisso de mudança que faço comigo mesmo, além de um pedido de aceitação à comunidade.&lt;/p&gt;
&lt;p&gt;Ainda estou processando essas mudanças mas, como diz a globo: “O futuro já começou”. Criei a minha conta no GitHub e estou procurando alguns projetos pra contribuir, além de já ter descoberto o FreeCodeCamp e ficado encantado com a ideia — pena que não tem java. Mas se alguém puder recomendar algum projeto próprio ou de terceiros é só postar nos comentários.&lt;/p&gt;
&lt;p&gt;Enfim, um recomeço. O meu recomeço.&lt;/p&gt;</content:encoded><category>carreira</category></item></channel></rss>