<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ítalo Assunção on Medium]]></title>
        <description><![CDATA[Stories by Ítalo Assunção on Medium]]></description>
        <link>https://medium.com/@itossauro?source=rss-a90d67f60bdc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*i1P_p0VnAhP16hsaA8kftQ.jpeg</url>
            <title>Stories by Ítalo Assunção on Medium</title>
            <link>https://medium.com/@itossauro?source=rss-a90d67f60bdc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 15:28:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@itossauro/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Gerenciamento de Estado no React: do Redux ao Zustand]]></title>
            <link>https://medium.com/geekieeducacao/gerenciamento-de-estado-no-react-do-redux-ao-zustand-3efceab86dfa?source=rss-a90d67f60bdc------2</link>
            <guid isPermaLink="false">https://medium.com/p/3efceab86dfa</guid>
            <category><![CDATA[zustand]]></category>
            <category><![CDATA[state-management]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[redux]]></category>
            <dc:creator><![CDATA[Ítalo Assunção]]></dc:creator>
            <pubDate>Tue, 16 Apr 2024 13:58:51 GMT</pubDate>
            <atom:updated>2024-04-16T13:58:51.778Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Exemplo do fluxo de estado padrão do Redux, com Actions, Reducers, Stores e Views" src="https://cdn-images-1.medium.com/max/549/0*7B61cWC1AYa9qqfN.jpeg" /><figcaption>Fonte: <a href="https://fe-tool.com/awesome-react-state-management">fe-tool.com</a></figcaption></figure><p>Sempre que estamos desenvolvendo uma aplicação React chegamos em um ponto onde é necessário que um pedaço de estado (por exemplo, informações de produtos, formulários etc.) sejam consumidos e modificados por diversas partes do código, de forma que passar essa informação por “<em>prop drilling</em>”, além de nada elegante, acaba sendo uma dor de cabeça a mais na hora de desenvolver ou realizar manutenção.</p><p>Essa dor, experienciada por todas as pessoas que desenvolveram em React em algum momento, incentivou fortemente a criação de bibliotecas de <strong>gerenciamento de estado</strong>. Nesse artigo, vamos entender um pouco mais sobre a evolução dessas ferramentas e suas propostas e diferenças.</p><h3>O Problema do Paradigma MVC</h3><p>O MVC (Model-View-Container), um dos mais difundidos paradigmas do desenvolvimento web, embora muito útil e usado com outras linguagens e frameworks, no ambiente React não fazia tanto sentido. O problema do MVC com o React tinha a ver com o fato do fluxo de dados no React não ser linear: uma View poderia disparar uma ação que alteraria o Model de outra View e assim por diante, sendo que a maioria poderia estar sendo exibida e computada ao mesmo tempo no mesmo lugar.</p><figure><img alt="Um exemplo da arquitetura MVC (Model, View, Controller) com uma Action apontando para um Controler que aponta para 7 Models que apontam, aleatoriamente, para varias Views que também apontam de volta para alguns modelos, de forma desorganizada" src="https://cdn-images-1.medium.com/max/581/1*wmp_90mLEDzKnpQ9OpwzMQ.png" /><figcaption>Fonte: <a href="https://facebookarchive.github.io/flux/docs/in-depth-overview/">Flux In-Depth Overview</a></figcaption></figure><p>Essas relações em excesso geravam uma árvore muito grande de interdependências e, para lidar com ela, era necessário buscar os dados (como os estados da aplicação) em um nó próximo da raiz e sair passando para todos os componentes ao longo dos galhos da árvore, até que os componentes que realmente precisavam do dado o recebessem. Essa prática poderia, inclusive, causar diversos <em>re-renders </em>indesejados.</p><h3>A Arquitetura Flux</h3><p>Compreendendo a dor dos excessivos “prop dillings” necessários para grandes aplicações React, o Facebook (atual Meta e criador e mantenedor oficial do React) criou a <a href="https://facebookarchive.github.io/flux/docs/in-depth-overview">arquitetura Flux</a> como solução para esse problema.</p><p>Essa arquitetura propunha um fluxo de dados linear. Para isso, foram desenhados 4 componentes principais:</p><ul><li>Actions: representam eventos que acontecem na aplicação, como interações com o usuário ou até em resposta a outros eventos.</li><li>Dispatcher: é um orquestrador das Actions, recebe todas as Actions disparadas pela aplicação e simplesmente as redireciona para as Stores interessadas.</li><li>Store: local onde estão armazenados o estado da aplicação, a regra de negócio e a lógica de atualização do estado. Quando uma Action chega na Store ela é processada e, então, é emitido um evento para que todas as Views que se interessam possam receber o estado atualizado.</li><li>Views: basicamente são os componentes React, que vão receber os estados (e suas atualizações) diretamente da Store e, quando necessário, enviar Actions para o Dispatcher.</li></ul><figure><img alt="Proposta da arquitetura flux com uma Action desconectada sendo enviada para o Dispatcher, que repassa para a Store e essa para a View, que manda outra Action para o Dispatcher e o fluxo segue linearmente." src="https://cdn-images-1.medium.com/max/870/1*Y9UnngpiQp4ZY-Y6ocTjLA.png" /><figcaption>Fonte: <a href="https://facebookarchive.github.io/flux/docs/in-depth-overview/">Flux In-Depth Overview</a></figcaption></figure><p>Dessa forma, o fluxo de dados da aplicação ficaria muito mais previsível e fácil de entender.</p><h3>Redux: O “Marco Zero”</h3><p>Pautado completamente na arquitetura Flux nasce o <a href="https://redux.js.org/">Redux</a>: a biblioteca de gerenciamento de estado mais amplamente usada (com bastante folga para o segundo lugar) do React.</p><p>O Redux implementa basicamente a emissão de eventos do Dispatcher, de forma que ainda é necessário criar a Store, as Actions e a camada de lógica de atualização de estado, chamada de Reducer. Os códigos abaixo mostram um setup extremamente simples com o Redux antigo (spoiler: foi deprecado e tem substituto oficial):</p><p>*É necessário baixar as bibliotecas redux e react-redux além do setup normal do React para rodar os exemplos abaixo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b9c3d82cfd98eb2f8e2bf5f68fb7107b/href">https://medium.com/media/b9c3d82cfd98eb2f8e2bf5f68fb7107b/href</a></iframe><p>Nesse setup, tudo começa nos Reducers. Um Reducer nada mais é do que uma função que recebe o estado da aplicação e a Action disparada e, baseado no tipo da Action (action.type), altera o estado de acordo (essa Action é apenas um objeto normal, então pode conter outras propriedades que se façam necessárias para as alterações de estado).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/00a50974ee1efe42fe2c2514ea8ad2d9/href">https://medium.com/media/00a50974ee1efe42fe2c2514ea8ad2d9/href</a></iframe><p>Depois de definir o Reducer (ou Reducers, que provavelmente será o necessário numa aplicação maior), precisamos criar a Store. Aqui recebemos uma mensagem avisando que o createStore está deprecado, mas fica comigo que a gente vai ver como fazer da forma atual já já!</p><p>Também aplicamos o Provider do react-redux, que é o responsável por permitir que os nossos componentes internos da árvore acessem a Store.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5bcfcec82f8a578e3ed0c65c99d94155/href">https://medium.com/media/5bcfcec82f8a578e3ed0c65c99d94155/href</a></iframe><p>Por último, usamos o useSelector para ter acesso ao estado que criamos e o useDispatch para podermos disparar as Actions que criamos. Dessa forma, quando clicarmos no botão Increment, vamos disparar a Action INCREMENT_COUNTER que, ao chegar no Reducer, vai somar 1 ao valor do estado counter e, quando clicarmos no botão Decrement, vamos disparar a ActionDECREMENT_COUNTER que, também ao chegar no Reducer, vai subtrair 1.</p><p>Note que o valor da variável count já é atualizado automaticamente ao chamarmos as Actions, isso porque quando um Reducer atualiza um estado, ele envia um evento para a Store para que todas as Views inscritas no determinado estado sejam atualizadas.</p><p><strong>Considerações</strong></p><p>Embora seja, disparada, a biblioteca de gerenciamento de estado mais baixada (claro que muito por conta dos projetos legado) entre as outras que veremos ainda nesse artigo, essa versão do Redux já é considerada <strong>deprecada</strong>, não sendo recomendada mais.</p><p>Ela solucionou o problema inicial implementando a arquitetura Flux, mas trouxe consigo outros problemas:</p><ul><li>Tem uma curva de aprendizado íngreme;</li><li>Código boilerplate excessivo, para cada novo estado é necessário criar Actions e Reducers específicos;</li><li>Problemas de performance: por conta de todo o estado ficar num mesmo lugar, dependendo da implementação e tamanho da aplicação, os <em>re-renders</em> das Views inscritas nesse estado podem ser excessivos (e se realmente for uma aplicação grande, <a href="https://redux.js.org/faq/performance/">bem custosos e acabar baixando a performance</a>).</li></ul><h3>React Context: A Solução(?) Nativa</h3><p>Spoiler: não é solução para os problemas de gerenciamento de estado!</p><p>A grande diferença, e o motivo pelo qual não vou me aprofundar muito nisso, é que o propósito dela não é <strong>gerenciar </strong>estado, apenas tornar mais fácil acessar estados de várias partes do código sem precisar correr para o <em>prop drilling</em>, como dito na <a href="https://react.dev/learn/passing-data-deeply-with-context">própria documentação</a>. Por conta disso, não cabe discutir e comparar ele às outras soluções.</p><p>Qualquer implementação do React Context unida ao useState vai funcionar similarmente ao gerenciamento de estado, mas não é o indicado, não é o objetivo para o qual essa API foi criada e, inclusive, é bastante propenso a <em>re-renders</em>.</p><p>A recomendação é sempre usar com cautela, se realmente for necessário, tentar separar os contextos ao máximo para evitar <em>re-renders </em>e ponderar com calma se outra solução real de gerenciamento de estado não deveria ser usada no lugar.</p><h3>Redux-Toolkit: Novo, Melhor, Mais Elegante</h3><p>O <a href="https://redux-toolkit.js.org/">Redux-Toolkit</a>, ou “RTK”, é a forma mais atual (desde 2019) a implementar o Redux, de acordo com a própria <a href="https://redux.js.org/introduction/why-rtk-is-redux-today">documentação</a> dele. Foi criado para resolver os dois primeiros problemas citados acima: ser complicado demais e ter muito código boilerplate.</p><p>É, basicamente, uma nova API cheia de utilitários para melhorar a experiência de desenvolvimento da tecnologia. Vamos ver abaixo como fica o código com essa nova implementação:</p><p>*É necessário baixar as bibliotecas @reduxjs/toolkit e react-redux além do setup normal do React para rodar os exemplos abaixo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/04ef1abc37538b933ed0f32e58cb8af1/href">https://medium.com/media/04ef1abc37538b933ed0f32e58cb8af1/href</a></iframe><p>O RTK agora introduz o conceito de Slice. Um Slice é como uma “fatia” do estado, que tem seus Reducers, valores e estados iniciais totalmente escopados e separados dos demais. Se você precisasse, por exemplo, lidar com estado de um usuário, poderia criar um arquivo userSlice.js com um código parecido, mudando o name, initialState e os Reducers. Dessa forma, não é mais necessário verificar qual é o action.type e toda a lógica referente ao seu estado estará exatamente no mesmo lugar. Muito mais limpo e elegante, não é?</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fcbc0385c4d116a5a5b692b52a36b087/href">https://medium.com/media/fcbc0385c4d116a5a5b692b52a36b087/href</a></iframe><p>Agora, ao invés de chamarmos a função createStore que estava deprecada, o RTK nos fornece a função configureStore que recebe um objeto com a prop reducer que é um outro objeto onde as chaves são os name dos Slices e os valores são os slice.reducer.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5270677e01130511a1ccc8787ef86b6a/href">https://medium.com/media/5270677e01130511a1ccc8787ef86b6a/href</a></iframe><p>E por fim, ao invés de dispararmos uma Action que é um objeto com um type e outras propriedades se necessário, agora chamamos as Actions diretamente do Slice, passando parâmetros se necessário. E com isso não temos que nos preocupar mais com os types das Actions, os estados estão mais isolados e temos mais facilidade para incrementar/dar manutenção em toda a árvore de estados.</p><p><strong>Considerações</strong></p><p>O RTK tem um ar bem mais novo e é uma experiência consideravelmente melhor usar ele do que o Redux original, principalmente em codebases maiores e ajuda com a curva de aprendizado no geral.</p><h3>Recoil: A Promessa Inspiradora</h3><p>O Recoil é uma biblioteca experimental desenvolvida pelo Facebook (Meta) que traz uma proposta bastante diferente da arquitetura Flux proposta por eles mesmo (vai entender…). Nela, todo estado é um Átomo, que por sua vez é um objeto composto por uma key única por toda a aplicação e um valor padrão. Além dessa estrutura nova, o Recoil fornece hooks para pegar e atualizar esses estados de forma global na aplicação.</p><p>*É necessário baixar apenas a biblioteca recoil além do setup normal do React para rodar os exemplos abaixo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0c11ee1cc63e8641411dc4eb4e5d1be0/href">https://medium.com/media/0c11ee1cc63e8641411dc4eb4e5d1be0/href</a></iframe><p>Aqui temos um Atom. Simples assim. Não precisamos de Actions, Reducers, Models, Controllers, nada! Basta criar o objeto atom e exportá-lo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/22ecc57b6568053d92d33e14ad8c6c3c/href">https://medium.com/media/22ecc57b6568053d92d33e14ad8c6c3c/href</a></iframe><p>De novo, a escolha da biblioteca é a <strong>simplicidade</strong>: não precisamos criar uma Store nem nada do tipo. Apenas chamar o RecoilRoot e ele automaticamente sabe o que fazer!</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7888faec2fe3e151b516924812770006/href">https://medium.com/media/7888faec2fe3e151b516924812770006/href</a></iframe><p>E por fim, aqui está a grande inovação do Recoil: mudança de estado global da aplicação e consumo dele de forma simples e fácil, exatamente como quando usamos o nativo useState!</p><p>O grande problema do Recoil é… que ele foi abandonado 😓. Embora exista desde o inicio de 2020, até hoje não alcançou a versão 1.0 estável. Além disso, a última atualização já faz <a href="https://github.com/facebookexperimental/Recoil/releases/tag/0.7.7">quase um ano</a> e o principal mantenedor foi <a href="https://github.com/facebookexperimental/Recoil/discussions/2171#discussioncomment-5075683">dispensado em um dos layoffs da empresa</a>, então a comunidade no geral não tem muitas esperanças da biblioteca voltar a vida…</p><p><strong>Considerações</strong></p><p>Como não está mais sendo ativamente continuado, não é uma boa escolha para novos projetos e seu futuro é incerto.</p><p>Contudo, o Recoil trouxe inspiração para diversas outras bibliotecas, provando que a simplicidade ideal podia ser alcançada, além ser uma solução para os possíveis (embora raros) problemas de performance do Redux, isolando os estados em átomos.</p><h3>Jotai: O Filho Brilhante</h3><p>Inspirado pelas diversas inovações do Recoil nasce o Jotai. O conceito principal do Jotai é o gerenciamento de estado a partir de átomos, também tendo uma sintaxe extremamente similar ao useState do React.</p><p>Além dessa funcionalidade (que é só o que vou mostrar aqui), o Jotai também conta com diversas utilidades como trabalhar com persistência no localStorage e async de forma nativa e fácil de incrementar no código, além de várias extensões para atender aos requisitos complexos de uma aplicação de grande escala.</p><p>*É necessário baixar apenas a biblioteca jotai além do setup normal do React para rodar os exemplos abaixo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4a88f35ccea3fa9a5ecf8ad2660fcc8e/href">https://medium.com/media/4a88f35ccea3fa9a5ecf8ad2660fcc8e/href</a></iframe><p>Similar a criação de um átomo no Recoil, mas ainda mais simples! No Jotai não é necessário criar uma key única, o próprio átomo cuida disso! O único dado necessário é o valor inicial.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/efffb8c147877a82e53c270eda3ad3b7/href">https://medium.com/media/efffb8c147877a82e53c270eda3ad3b7/href</a></iframe><p>E é assim que fica o nosso entrypoint. Espera… 😱 sem Provider? É! O jotai simplesmente não precisa de um provider nem nada do tipo, ele apenas sabe o que fazer assim que recebe um átomo nos seus hooks.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cf723a52b6bfa14a1d1fb123470aad86/href">https://medium.com/media/cf723a52b6bfa14a1d1fb123470aad86/href</a></iframe><p>E, por fim, o nosso componente fica praticamente idêntico ao do Recoil, apenas mudando o nome do hook agora para useAtom.</p><p>É com essa simplicidade que o Jotai se torna uma das bibliotecas mais convidativas para adotar numa codebase, já que é basicamente um <em>drop-in replacement </em>para o nativo<em> </em>useState, além de trazer muita performance e facilidade na hora de editar e mapear o estado da aplicação!</p><p><strong>Considerações</strong></p><p>O Jotai é uma ferramenta bastante interessante, revigorante e fácil de ser implementada, ao mesmo tempo ainda sendo suficiente para usos complexos do gerenciamento de estado.</p><p>Um ponto fraco, para algumas pessoas, é que, assim como no useState, a função que altera o estado é genérica e seu funcionamento depende exclusivamente de quem a chama. Isso é uma consequência da facilidade de implementação do código base mas de modo geral não afeta a qualidade de código.</p><p>Para quem gostava do Recoil, fica a recomendação!</p><h3>Zustand: O Redux 2.0</h3><p>Também muito embasado na arquitetura Flux, mas tentando ser ainda mais simples de usar do que o Redux Toolkit, temos o Zustand. Com seu mascote bonitinho e usabilidade maravilhosa, a biblioteca entrega um gerenciamento de estado eficiente, fácil de dar manutenção e conceitualmente similar ao Redux, o que o torna ainda mais fácil de compreender para pessoas que já vem desse contexto.</p><p>Além do básico do gerenciamento de estado, o Zustand traz uma utilidade fantástica e inovadora (que também não vou entrar em detalhe aqui, se não o artigo não termina 😅) que são os <a href="https://github.com/pmndrs/zustand?tab=readme-ov-file#transient-updates-for-often-occurring-state-changes"><em>transient updates</em></a>. Essa feature é basicamente uma forma <strong>manual</strong> de escutar as alterações de estado, sem que elas causem um render de fato!!</p><p>*É necessário baixar apenas a biblioteca zustand além do setup normal do React para rodar os exemplos abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/563f2453d929ede57b7a2e210aa32604/href">https://medium.com/media/563f2453d929ede57b7a2e210aa32604/href</a></iframe><p>Como eu disse, o Zustand tem similaridades com o Redux nos conceitos da arquitetura Flux. Portanto, claro que começaríamos criando uma Store! Contudo, essa Store é bem mais básica do que as do Redux e Redux-Toolkit, sendo apenas um objeto onde as chaves com valores não-funcionais são os estados, e as chaves com valores funcionais podem usar a função set para atualizar o estado.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2641ea5eded6d3f11de664065052e465/href">https://medium.com/media/2641ea5eded6d3f11de664065052e465/href</a></iframe><p>Assim como no Jotai, no Zustand não é necessário encapsular seus componentes com nenhum provider nem nada do tipo (essas bibliotecas modernas estão com tudo!!)</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/146790df545504feed772ce83990231b/href">https://medium.com/media/146790df545504feed772ce83990231b/href</a></iframe><p>Por fim, basta pegarmos o estado e as Actions diretamente da store que criamos e usá-los! Consegue ser ainda mais simples do que o RTK, né?</p><p><strong>Considerações</strong></p><p>Além de buscar simplicidade na hora de ser implementado, o Zustand continua sendo capaz de entregar funcionalidades necessárias para grandes aplicações.</p><p>Vejo o Zustand como a nova encarnação do Redux, quem era muito fã provavelmente gostará desse também e, pela facilidade de uso, eventualmente deve ser mais popular ainda. Claro que desbancar o pai vai ser uma tarefa bem difícil 😅.</p><h3>Legal, mas e agora… qual eu escolho? 😨</h3><p>Tá! Falamos de várias ferramentas aqui, desde os primórdios da arquitetura que rege a maioria, mas não chegamos a uma conclusão 🤔…</p><p>A resposta que toda pessoa desenvolvedora dá, mas ao mesmo tempo odeia receber é: “não existe escolha certa”. Nenhuma dessas bibliotecas é uma bala de prata e absolutamente nada garante que amanhã não vai surgir uma outra melhor ainda que vai roubar a cena.</p><p>Se tratando de gerenciamento de estado, o uso pode ser extremamente diferente de aplicação para aplicação, bem como o costume e maneirismos de cada dev.</p><p>Mesmo assim, a minha regra pessoal é sempre (que possível, é claro, vamos evitar quebrar apps em prod xD) testar ferramentas mais atuais porque na maioria das vezes elas entregam funcionalidades iguais, se não mais ainda, com uma <em>developer experience </em>mais aprimorada, já que com certeza quem criou a ferramenta usou sua precedente e pensou em melhorias para si mesmo.</p><p>Ou seja… para novos apps eu recomendaria testar o Jotai e o Zustand e ver com qual você se encaixa melhor, mas mesmo assim, jamais abrir mão dos Redux e qualquer outra ferramenta, já que cada uma serve seu propósito, tem sua comunidade e funcionam de jeitos diferentes.</p><h3>Até mais, e obrigado pelos peixes 👋</h3><p><strong>Enquete</strong>: deixe nos comentários qual é a sua biblioteca de gerenciamento de estado favorita! Mudou depois de ler esse artigo? 👀</p><p>Se tiver qualquer dúvida, sugestão ou comentário, sinta-se livre e encorajado a deixar aqui embaixo também!!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3efceab86dfa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/geekieeducacao/gerenciamento-de-estado-no-react-do-redux-ao-zustand-3efceab86dfa">Gerenciamento de Estado no React: do Redux ao Zustand</a> was originally published in <a href="https://medium.com/geekieeducacao">Geekie Educação</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lâmpadas de Lava: A Entropia na Segurança Digital]]></title>
            <link>https://medium.com/geekieeducacao/l%C3%A2mpadas-de-lava-a-entropia-na-seguran%C3%A7a-digital-9f6445009b74?source=rss-a90d67f60bdc------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f6445009b74</guid>
            <category><![CDATA[cloudflare]]></category>
            <category><![CDATA[aletoriedade]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[segurança-da-informação]]></category>
            <category><![CDATA[criptografia]]></category>
            <dc:creator><![CDATA[Ítalo Assunção]]></dc:creator>
            <pubDate>Tue, 21 Nov 2023 13:59:40 GMT</pubDate>
            <atom:updated>2023-11-21T21:13:46.476Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Uma lâmpada de lava amarela" src="https://cdn-images-1.medium.com/max/1024/1*bUTtOT25EAlcowQu-2xRRw.jpeg" /></figure><p>Bateu a curiosidade para saber como esse icônico item decorativo pode ter algo a ver com segurança digital? Está com dúvidas sobre o que é entropia? Viveu os anos 70 e sentiu uma nostalgia? Então fica aqui que vamos falar um pouquinho de tudo isso!</p><p><strong>Para começar… o quê é uma Lâmpada de Lava?</strong></p><p>Bom, talvez você seja jovem demais para conhecer, mas ela é uma espécie de abajur com dois líquidos que não se misturam dentro, normalmente água para a base e parafina (ou algum tipo de cera) para as bolas. Essas lâmpadas funcionam iluminando a câmara de vidro (afinal, sem luz não é uma lâmpada 😅) e aquecendo sua base ligeiramente. Como a densidade dos componentes não é muito diferente, o calor causa expansão nas bolas de cera e as faz perder um pouco de densidade, provocando uma subida vagarosa. Chegando no topo, elas se resfriam, aumentando a densidade novamente, e voltam para o fundo. É, assim, gerada uma movimentação super característica que dá todo o charme dessa engenhoca.</p><p><strong>Entendi! E o que um abajur engraçado tem a ver com segurança digital?</strong></p><p>Bom, antes de explicar isso, precisamos entender um pouco mais sobre alguns conceitos básicos de segurança digital.</p><p>Por conceitos básicos, me refiro especialmente à qualquer parte da segurança digital que necessite de números verdadeiramente aleatórios, como por exemplo:</p><ul><li>Geração de chaves criptográficas, como as chaves de uma conexão por SSH;</li><li>Assinaturas digitais com chave privada;</li><li>Criptografias baseadas em chaves pública e privada, como os exemplos mais populares: RSA, AES, ECC;</li><li>Códigos aleatórios de autenticação, como o Google Auth, métodos de login sem senha, envios de código de confirmação de conta e reset de senha;</li><li>Números de cartões de crédito;</li><li>Criptografia de dados em repouso, que consiste em criptografar dados armazenados num disco ou em uma mídia de backup.</li></ul><p>Pouco importante, né? 😬</p><p>Mas não entre em pânico! Essas funcionalidades estão bastante seguras, pois usam geradores de números verdadeiramente aleatórios, chamados de RNG (Random Number Generators, se você pensou na outra sigla você com certeza tem um bom número de jogos RPG jogados 🎲).</p><p><strong>Como assim números verdadeiramente aleatórios? 🤔</strong></p><p>Surpresa! Os números que geramos com as conhecidas funções Math.random() do JavaScript, randint() do Python ou essencialmente qualquer uma nativa ou de biblioteca não especializada na geração de números verdadeiramente aleatórios não são aleatórios! 🤯</p><p>E se você parar para pensar… faz total sentido! Tente imaginar uma maneira completamente matemática, uma fórmula onde sem <em>input</em> algum, você consiga diferentes <em>outputs</em> toda vez que a executar. Não existe! Isso porque a matemática é <strong>determinística</strong>, o que significa que todas as suas regras e princípios são baseados em relações precisas e previsíveis, sendo incapaz de gerar vários resultados diferentes para um mesmo cálculo.</p><p>Esses algoritmos muito rasos de geração de números aleatórios são chamados de PRNG (Pseudo-Random Number Generators). São funções matemáticas que recebem algum tipo de <em>input</em>, comumente chamado de seed, e com base nesse <em>input</em> fazem vários cálculos em cima (principalmente manipulação de bits), para gerar outros números. Qual o problema disso? Uma mesma seed vai gerar exatamente os mesmos números, na mesma ordem, sempre que for executada novamente com seu estado inicial.</p><p>De cara já dá pra ver um problemão nisso. Imagine que os casos que citei lá em cima fossem PRNGs: se de alguma forma uma pessoa mal intencionada descobrisse a seed original do gerador de números de cartões de crédito, ela teria acesso a todos os cartões que aquele banco geraria! 😱</p><p>Um caso bastante comum de falta de segurança nesses números aleatórios mais &quot;fracos&quot; é o sistema de PRNG de jogos, como o Pokemon. Alguns jogos da franquia, principalmente o Pokemon Diamond e Pearl, geram os números com uma seed baseada na hora exata em que o console (Nintendo DS) foi ligado depois de uma descarga total na bateria. Isso significa que, se você conseguir reproduzir exatamente essa condição e ligar o Nintendo DS na hora exata, você vai ter os mesmos Pokemons gerados, em ordem, que outra pessoa pode ter tido em outro console. Isso é muito usado como <em>cheat</em> para tentar capturar Pokemons mais raros (shiny), e, é claro, já existem programas para fazer isso automaticamente numa hora específica.</p><p>Essa técnica do jogo Pokemon traz uma camada de segurança extra, gerando a seed a partir de um dado pouco previsível (se usado de maneira normal), embora ainda claramente manipulável e inseguro.</p><p>Uma das técnicas para deixar um PRNG mais próximos do verdadeiro RNG é o uso de um <em>input</em> externo de um dado realmente aleatório para a seed. É o que chamamos de extração da <strong>ENTROPIA.</strong></p><p><strong>O que é, onde encontro e como extraio entropia?</strong></p><p>Entropia é o conceito que se refere à natureza caótica, desordenada e aleatória de um sistema. Onde você pode encontrá-la? Oras… em tudo! É a natureza do Universo inteiro. Pense bem! A chuva não cai num padrão exato, ondas de som não viajam exatamente na mesma velocidade, a temperatura não varia sempre do mesmo jeito… tudo nesse colossal universo é regado de verdadeiro e completamente aleatório CAOS.</p><p>Sabendo disso, os pontos começam a se ligar…</p><p>O jogo do Pokemon usa uma seed que não é entrópica: a hora em que o console foi ligado. Caso você não saiba, o próprio conceito de tempo, na verdade, não existe e foi criado por seres humanos apenas para conseguirem se organizar com algumas coisas. Então, de aleatório não tem nada. Ajuda naquele caso porque, pelo menos, dá um trabalho extra para quem for tentar burlar o sistema, além de ser uma forma de gerar números diferentes em momentos diferentes.</p><p>Voltando a falar um pouco sobre as funções básicas: no Math.random(), a definição da implementação fica a critério do próprio navegador, bastando apenas seguir as diretrizes do ECMAScript:</p><blockquote>Returns a Number value with positive sign, greater than or equal to 0 but less than 1, chosen randomly or pseudo randomly with approximately uniform distribution over that range, using an implementation-dependent algorithm or strategy. This function takes no arguments.</blockquote><p>Tradução não oficial:</p><blockquote>Retorna um valor Number positivo, maior ou igual a 0 porém menor do que 1, escolhido de maneira aleatória ou pseudo aleatória com distribuição uniforme aproximada sobre o intervalo, usando um algoritmo dependente de implementação ou estratégia. Essa função não recebe argumentos.</blockquote><p>A titulo de curiosidade, a maioria dessas implementações, não apenas do JavaScript, mas de grande parte dessas funções básicas, utiliza capturas de ruído atmosférico com microfones quando possível, ou variações de temperatura do processador da máquina detectadas com sensores de calor, adicionalmente rodando algum algoritmo de geração de números em cima que já são medidas bem mais seguras que o simples horário, mas ainda podem ser simuladas, mesmo que com muito mais dificuldade.</p><p>Hoje, o algoritmo mais usado nos navegadores é o xorshift128. Uma simples implementação dele se parece com isso:</p><pre>class XORShift128 {<br>  constructor(seed1, seed2) {<br>    this.s0 = seed1;<br>    this.s1 = seed2;<br>  }<br><br>  // Gera um número aleatório de 32 bits.<br>  random() {<br>    let x = this.s0;<br>    const y = this.s1;<br>    this.s0 = y;<br>    x ^= (x &lt;&lt; 23) &amp; 0xFFFFFFFF;<br>    x ^= (x &gt;&gt;&gt; 17) &amp; 0xFFFFFFFF;<br>    x ^= (x &lt;&lt; 26) &amp; 0xFFFFFFFF;<br>    this.s1 = x;<br>    return (x + y) &amp; 0xFFFFFFFF;<br>  }<br>}</pre><p><strong>Então a lâmpada de lava serve como fonte de entropia para geração de números aleatórios?</strong></p><p>Exatamente, <em>padawan</em>! Uma das mais criativas e seguras dentre as milhares formas de extrair entropia é com uso da dinâmica de fluidos das lâmpadas de lava!</p><p>A empresa que provavelmente mais contribuiu para disseminação desse conhecimento foi a CloudFlare, uma das maiores empresas de segurança na Internet do mundo, que em sua sede possui uma enorme parede cheia de lâmpadas de lava e uma câmera apontada para ela, que tira várias fotos periodicamente. Essas fotos então são convertidas de uma stream de bytes para um número e <em>voilá</em>! Temos uma seed verdadeiramente aleatória e extremamente difícil de reproduzir, dado que cada lâmpada por si só já é imprevisível e vai gerar uma parte aleatória desse valor geral.</p><figure><img alt="Uma foto de uma parede cheia de lâmpadas de lava no escritório matriz da CloudFlare" src="https://cdn-images-1.medium.com/max/1024/0*GReTul0S5KguGMxM" /><figcaption>Fonte: <a href="https://thedanigrant.com/">Dani Grant</a></figcaption></figure><p><strong>Conclusão</strong></p><p>Com isso, espero que tenha dado para entender e aprender um pouco mais sobre segurança digital, números aleatórios, a capacidade de gerá-los digitalmente e lâmpadas de lava.</p><p>Sinta-se livre para deixar qualquer dúvida, comentário ou sugestão aí embaixo! 😄</p><p>Deixe um comentário falando sobre as lâmpadas de lava. Você já conhecia? Acha legal? Bateu uma vontade de comprar uma?</p><p>Até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f6445009b74" width="1" height="1" alt=""><hr><p><a href="https://medium.com/geekieeducacao/l%C3%A2mpadas-de-lava-a-entropia-na-seguran%C3%A7a-digital-9f6445009b74">Lâmpadas de Lava: A Entropia na Segurança Digital</a> was originally published in <a href="https://medium.com/geekieeducacao">Geekie Educação</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Optimizing Your App’s Performance by Using Redis as a Caching Layer]]></title>
            <link>https://medium.com/better-programming/optimizing-your-apps-performance-by-using-redis-as-a-caching-layer-dc48ce7551ab?source=rss-a90d67f60bdc------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc48ce7551ab</guid>
            <category><![CDATA[cache]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[redis]]></category>
            <category><![CDATA[postgres]]></category>
            <dc:creator><![CDATA[Ítalo Assunção]]></dc:creator>
            <pubDate>Thu, 26 Jan 2023 17:35:14 GMT</pubDate>
            <atom:updated>2023-02-13T19:53:36.047Z</atom:updated>
            <content:encoded><![CDATA[<h4>A step-by-step guide to eliminating unnecessary, time-consuming read queries to your databases</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Ci01Iu02cZJBfIFG3Aq4aQ.png" /><figcaption>Node.js, PostgreSQL, and Redis logos</figcaption></figure><p>Are you looking to give your application a performance boost? If the answer is “no,” maybe after reading this article, you’ll change your mind (I hope so, at least).</p><p>One of the ways you can achieve this is by eliminating unnecessary time-consuming read queries to your often queried database. What do I mean by that?</p><p>Well… say you have an e-commerce app with hundreds or thousands of products and many users. I bet there will probably be a smaller cluster of items bought way more frequently than the others, so why would you query through your whole data when it’s not needed? That’s where Redis can help you by turning your frequently read data into a highly available, fast, and reliable cache.</p><p>So… let’s begin talking about all of this and putting it into practice.</p><h4><strong>First, what is caching, and how can it help?</strong></h4><p>Caching stores frequently accessed data into a fast and temporary (or not, but that’s a topic for another time) data storage that you can access easier and faster when needed.</p><p>That technique can help improve performance by making the query to the cache before checking the main DB (let’s say, the top 20 most frequently bought products). If that value exists, you already have it, way faster than querying the main DB. If it doesn’t exist, you then make the query to the main DB and store its result in the cache. You can also set an expiring time to it, and sequential queries will find it faster.</p><h4><strong>OK, but what about Redis?</strong></h4><p>Redis, according to its own definition, is an:</p><blockquote>Open source, in-memory data store used by millions of developers as a database, cache, streaming engine, and message broker.</blockquote><p>This means it’s a database that runs on RAM instead of the usual databases on the hard drive. Another important detail is that a NoSQL database uses key-value pairs.</p><p>It supports varied data structures as values, for example, strings, hashes, lists, sets, geospatial indexes, and even some more use-specific but still extremely useful, like hyperloglogs.</p><p>As you may have noticed, the Redis description mentions other use cases, and it sure can make a lot of cool stuff — even things like full-text search, work with JSON, GraphQL, and more! But in this particular article, we’ll focus only on its caching usage. Maybe if you like it, I can write new articles about its other uses 😀.</p><p>As if there were not enough reasons for you to use Redis, as seen in the <a href="https://survey.stackoverflow.co/2022/#technology-most-loved-dreaded-and-wanted">latest (2022) Stack Overflow survey</a>, Redis (and Postgres) are the most loved and least dreaded databases!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tSmA0OB0EByPOZ4-bznAEw.png" /></figure><h4><strong>Now that you know what caching and Redis are, we can get to work, right?</strong></h4><p>In this article, I’ll show you some comparisons and code samples made with <a href="https://nodejs.org/en/download/">Node.js</a>, <a href="https://www.postgresql.org/download/">PostgreSQL</a> as the main DB, and <a href="https://redis.io/download/">Redis</a>. So, if you don’t have them installed, click it, and you’ll be redirected to the download page. In this article, I’ll run PostgreSQL and Redis through <a href="https://www.docker.com/products/docker-desktop/">Docker</a>, which I find easier and faster to test and prototype. Feel free to download it if you want or run each individually.</p><h3><strong>Running PostgreSQL</strong></h3><p>Start the PostgreSQL service the way you prefer. In my case, it will be through Docker with this command:</p><pre>docker run --name postgres --p 5432:5432 -e POSTGRES_PASSWORD=postgres -d postgres</pre><p>This command will download (if needed) the Postgres image from the official docker repositories. It will also run the container with the name postgres, bind its port 5432 to the local machine’s 5432, and set up the POSTGRES_PASSWORD environment variable (as the Postgres image requires it) as postgres.</p><h4>Creating the PostgreSQL table</h4><p>Run the psql command in your Postgres terminal. For Docker, we need to enter the container’s terminal as follows:</p><pre>docker exec -it postgres bash</pre><p>Once we run this command, we’ll be inside our container’s terminal, where we can run our psql command, as shown below:</p><pre>psql -c &#39;create table products (id serial, title varchar, purchases int);&#39; -U postgres</pre><p>This will create a table called products with the columns id, title and purchases and give the default user postgresaccess to it.</p><h4>Running Redis</h4><p>Start the Redis server.</p><pre>docker run --name redis -p 6379:6379 -d redis</pre><p>This will start a Redis container and bind its default port 6379 to the local machine’s port, similar to what we’ve done with Postgres.</p><h4>Set up the Node.js app</h4><p>We’ll begin by creating our project folder and initializing our node project with the following code:</p><pre>mkdir redis-cache &amp;&amp; \<br>cd redis-cache &amp;&amp; \<br>npm init -y</pre><p>With that, we now have a file called package.json that will store our dependencies and scripts, so it’s time to install them. Here’s the command to do that:</p><pre>npm install redis knex express</pre><p>We’re installing the <a href="https://www.npmjs.com/package/redis">Redis JavaScript client library</a>, <a href="https://knexjs.org/">Knex</a> (a SQL query builder to interact with our Postgres easily), and <a href="https://expressjs.com/">Express</a> (a web framework for us to put our app to the test).</p><p>And finally, we’ll add a last (and global) dependency:</p><pre>npm i autocannon -g</pre><p><a href="https://www.npmjs.com/package/autocannon">Autocannon</a> is a tool to benchmark our express API and check whether or not Redis made a difference.</p><h4>Adding initial code and populating DB</h4><p>Create a file called index.js in the redis-cache directory, and inside it, we will import and setup knex and populate our Postgres DB. Here’s the code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d786e1f4f23f8fd21dbcbb8ac60e5dd5/href">https://medium.com/media/d786e1f4f23f8fd21dbcbb8ac60e5dd5/href</a></iframe><p>Now run this snippet with node index and wait for the products inserted log. Then, if we check our database, we should see the following:</p><pre>psql -c &#39;select count(*) from products;&#39; -U postgres</pre><p>And it should show we now have 25,000 items:</p><pre> count<br>-------<br> 25000<br>(1 row)</pre><h3>Making Our First Benchmark</h3><p>Now that we have actual data in our Postgres DB, we can make a benchmark and see how our app is performing. To do this, we need to remove that main function and use expressto create a GET endpoint that will return the 20 most-purchased items in our DB:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0fbd3ddd13b06cd2541819b9a85fa5d8/href">https://medium.com/media/0fbd3ddd13b06cd2541819b9a85fa5d8/href</a></iframe><p>If we run the file now, we should see the Listening on port 3000 log, and the server will run. We can check if it’s working by making an HTTP call to that endpoint on another terminal instance</p><pre>curl http://localhost:3000</pre><p>and that should show us the 20 most-purchased items:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0pPI-7a5gI-TZgtsq6zivw.png" /></figure><p>OK, fine, it’s working. But I want to know if it’s fast!</p><p>To check its performance, we’ll use autocannon to benchmark it with a bunch of requests to our running API with the following command:</p><pre>autocannon localhost:3000</pre><p>Once it’s done benchmarking, it will show us something like this (it may change a bit depending on your machine’s specs)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/929/1*Oy7oxqpsgPuW1iFmtz4hzg.png" /></figure><p>This screenshot contains a lot of information, but in ten seconds, with ten simultaneous connections, our API responded to 14,000 requests. OK, that’s not that bad, right? But can it get faster?</p><h4>Adding the cache layer and benchmarking again</h4><p>Now our goal is to make it even faster by adding our Redis cache. To do that, we need to create our Redis client, connect to it, and query it before querying the data inside the Postgres DB, then return it if it exists or populate it if not.</p><p><strong>Important: </strong>all data inside Redis (without any plugins) is saved as a string, so we need to parse and stringify it during Redis reads and insertions.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/91b51109890fd0419cc6d1c6a954c526/href">https://medium.com/media/91b51109890fd0419cc6d1c6a954c526/href</a></iframe><p>Now, if we don’t have the data cached, we can cache it and set the expiring value to five seconds after its insertion (of course, this value in real use cases will be higher, but it must be the time your application needs before the data gets too old), which means that we’ll need to query the data from the main DB twice in the ten-second benchmark.</p><p>If we rerun our server, the data it returns shouldn’t have changed. And when we run a new benchmark, the numbers might make you happy:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/838/1*-tlZdDtM3cczvFux6cS89Q.png" /></figure><p>Impressive! In the same ten seconds and ten simultaneous connections, we responded to 38,000 requests. That’s more than double what it was before the cache🤯!</p><p>And to put it even more in perspective: I’m running both databases and the API on my local machine, so it has low latency. When we move our setup to the cloud, with each being on separate machines (which is most likely), the result difference is even bigger.</p><h3>Conclusion</h3><p>Caching your data greatly impacts performance, even for small and quick queries. Redis proves to be a solid, reliable, and blazingly fast tool to deal with that technique.</p><p>You can find all of this code in <a href="https://github.com/itodevio/redis-cache-example">this repository</a>.</p><pre><strong>Want to Connect?<br></strong><br><br>Any questions, complaints, tips, or suggestions are welcome, <br>as this was my first article ever! Tell me what you thought about it! <br>If you want, you can find me on my <a href="https://www.linkedin.com/in/italodev/">LinkedIn</a>.</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc48ce7551ab" width="1" height="1" alt=""><hr><p><a href="https://medium.com/better-programming/optimizing-your-apps-performance-by-using-redis-as-a-caching-layer-dc48ce7551ab">Optimizing Your App’s Performance by Using Redis as a Caching Layer</a> was originally published in <a href="https://betterprogramming.pub/">Better Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>