<?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 Rebeca Barbosa Lourenço on Medium]]></title>
        <description><![CDATA[Stories by Rebeca Barbosa Lourenço on Medium]]></description>
        <link>https://medium.com/@rebecallourenco7?source=rss-24a68fbf5371------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*FF8-vREgRgvUneNrkKv2kQ.jpeg</url>
            <title>Stories by Rebeca Barbosa Lourenço on Medium</title>
            <link>https://medium.com/@rebecallourenco7?source=rss-24a68fbf5371------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 20:23:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rebecallourenco7/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[A evolução do Java: como a linguagem mudou do Java 8 ao Java 25]]></title>
            <link>https://medium.com/@rebecallourenco7/a-evolu%C3%A7%C3%A3o-do-java-como-a-linguagem-mudou-do-java-8-ao-java-25-c3e5a0b228d0?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/c3e5a0b228d0</guid>
            <category><![CDATA[poo]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Wed, 01 Jul 2026 02:45:48 GMT</pubDate>
            <atom:updated>2026-07-01T02:45:48.606Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HP1g8HKGmS5eDCbaBe8n2w.png" /></figure><p>Quando comecei a estudar Java, uma dúvida sempre aparecia: <strong>por que existem tantas versões?</strong></p><p>Java 8, Java 11, Java 17, Java 21… afinal, o que realmente muda entre elas? Será que vale a pena aprender todas? Ou basta estudar a mais recente?</p><p>Essas perguntas também aparecem com frequência nas minhas aulas. Muitos estudantes acreditam que cada nova versão muda completamente a linguagem, mas não é bem assim.</p><p>Na prática, o Java evolui de forma gradual. Algumas versões trouxeram pequenas melhorias, enquanto outras mudaram significativamente a maneira como desenvolvemos software. Neste artigo, quero apresentar justamente essas versões que considero mais importantes e explicar por que elas marcaram a evolução da plataforma.</p><h3>Java 8</h3><p>Se eu tivesse que escolher uma versão que mudou a história do Java, provavelmente seria o Java 8.</p><p>Foi nessa versão que conhecemos recursos como <strong>Lambda Expressions</strong>, <strong>Streams</strong>, <strong>Optional</strong> e a nova API de Data e Hora (java.time).</p><p>Esses recursos reduziram bastante a quantidade de código que precisávamos escrever. Antes, era comum criar classes enormes apenas para realizar tarefas simples. Com o Java 8, o código passou a ficar mais enxuto e muito mais legível.</p><p>Além disso, foi o início da programação funcional dentro do Java, algo que influenciou praticamente todas as versões lançadas depois.</p><h3>Java 11</h3><p>Depois da chegada do Java 8, muita coisa aconteceu.</p><p>O Java passou a receber novas versões a cada seis meses e surgiu uma dúvida no mercado: <strong>qual versão utilizar em produção?</strong></p><p>Foi justamente nesse cenário que o Java 11 ganhou destaque.</p><p>Por ser uma versão <strong>LTS (Long-Term Support)</strong>, muitas empresas adotaram essa versão como padrão. Além da estabilidade, ela trouxe melhorias importantes, como o novo HTTP Client e diversas otimizações de desempenho. Até hoje ainda encontramos muitas aplicações executando Java 11.</p><h3>Java 17</h3><p>Na minha opinião, o Java 17 foi uma das versões mais elegantes da linguagem. Os <strong>Records</strong> reduziram bastante aquele código repetitivo que escrevíamos apenas para criar classes de dados. As <strong>Sealed Classes</strong> deram mais controle sobre herança. E o <strong>Pattern Matching</strong> deixou verificações utilizando instanceof muito mais simples.</p><p>São mudanças que talvez pareçam pequenas isoladamente, mas, quando utilizadas no dia a dia, fazem bastante diferença. Não é por acaso que o Java 17 se tornou uma das versões mais utilizadas pelas empresas.</p><h3>Java 21</h3><p>Se o Java 8 mudou a forma de escrever código, acredito que o Java 21 mudou a forma como pensamos concorrência.</p><p>O grande destaque foi a chegada das <strong>Virtual Threads</strong>. Durante muito tempo, trabalhar com milhares de threads simultaneamente era algo custoso. Com as Virtual Threads, ficou muito mais simples criar aplicações altamente concorrentes utilizando menos recursos.</p><p>Além delas, o Java 21 trouxe melhorias como Record Patterns, Pattern Matching para switch e Sequenced Collections. É uma versão que mostra claramente como a linguagem continua acompanhando as necessidades do desenvolvimento moderno.</p><h3>Java 25</h3><p>O Java 25 representa a mais recente versão LTS. Diferente do Java 8 ou do Java 21, ele não trouxe uma única funcionalidade capaz de transformar completamente a linguagem. Seu foco está na evolução contínua da plataforma: melhorias de desempenho, otimizações na JVM e amadurecimento de recursos introduzidos em versões anteriores.</p><p>Esse também é um dos pontos fortes do Java. Nem toda evolução precisa ser uma revolução. Às vezes, pequenas melhorias constantes fazem muito mais diferença ao longo do tempo.</p><p>Uma coisa que gosto no Java é justamente a forma como ele evolui. A linguagem continua moderna, incorpora novos recursos e acompanha as necessidades do mercado, mas sem abandonar a compatibilidade que sempre foi uma de suas principais características.</p><p>Entender essa evolução ajuda não apenas a escolher uma versão para estudar, mas também a compreender por que tantos sistemas continuam utilizando Java mesmo depois de quase três décadas.</p><p>E, olhando para o ritmo das últimas atualizações, tudo indica que essa história ainda está longe de terminar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c3e5a0b228d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entendendo os Testes Unitários e Sua Importância no Desenvolvimento de Software]]></title>
            <link>https://medium.com/@rebecallourenco7/entendendo-os-testes-unit%C3%A1rios-e-sua-import%C3%A2ncia-no-desenvolvimento-de-software-60a8343da800?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/60a8343da800</guid>
            <category><![CDATA[testes-unitários]]></category>
            <category><![CDATA[testes-de-software]]></category>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Fri, 15 May 2026 22:01:57 GMT</pubDate>
            <atom:updated>2026-05-15T22:01:57.906Z</atom:updated>
            <content:encoded><![CDATA[<p>Quando falamos em desenvolvimento de software, uma das maiores preocupações dos programadores é garantir que o sistema funcione corretamente. Afinal, um pequeno erro em uma funcionalidade pode gerar grandes problemas para os usuários e até prejuízos para empresas. É justamente nesse contexto que entram os testes unitários.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/324/1*w8J4tDNuRRvVjgEm3OnSYw.png" /></figure><p>Os testes unitários são uma das práticas mais importantes da engenharia de software moderna. Eles permitem validar pequenas partes do código de forma automática, ajudando o desenvolvedor a identificar falhas antes mesmo que o sistema seja utilizado em produção.</p><h3>O que são testes unitários?</h3><p>De maneira simples, um teste unitário é um pequeno trecho de código criado para verificar se uma funcionalidade específica está funcionando como deveria. Em vez de testar o sistema inteiro de uma vez, o objetivo é analisar cada parte separadamente.</p><p>Imagine, por exemplo, um método responsável por realizar uma soma entre dois números. Mesmo sendo algo aparentemente simples, ainda existe a possibilidade de erros durante a implementação. Um desenvolvedor pode, sem perceber, utilizar uma operação incorreta ou alterar a lógica futuramente. O teste unitário serve exatamente para impedir que esse tipo de problema passe despercebido.</p><h3>Por que os testes unitários são importantes?</h3><p>Os testes automatizados ajudam a aumentar a qualidade do software. Eles funcionam como uma espécie de “rede de segurança” para o desenvolvedor.</p><p>Sempre que uma alteração é feita no código, os testes podem ser executados novamente para garantir que tudo continua funcionando corretamente. Isso reduz bastante o risco de quebrar funcionalidades já existentes durante atualizações ou correções.</p><p>Além disso, os testes unitários oferecem outras vantagens importantes:</p><ul><li>Facilitam a manutenção do código;</li><li>Ajudam a encontrar erros rapidamente;</li><li>Tornam o sistema mais confiável;</li><li>Melhoram a organização do projeto;</li><li>Dão mais segurança para realizar mudanças no sistema.</li></ul><h3>Como funciona um teste unitário?</h3><p>Normalmente, um teste unitário segue uma estrutura bastante simples, dividida em três etapas:</p><h3>1. Preparação</h3><p>Primeiro, o ambiente necessário para o teste é preparado. Isso pode incluir a criação de objetos, definição de variáveis e configuração dos dados que serão utilizados.</p><h3>2. Execução</h3><p>Depois, o método que será testado é executado com determinados parâmetros.</p><h3>3. Validação</h3><p>Por fim, o resultado retornado é comparado com o resultado esperado. Se ambos forem iguais, o teste passa. Caso contrário, ele falha.</p><p>Essa validação é extremamente importante porque garante que o comportamento do método permaneça correto ao longo do tempo.</p><h3>Testar cenários diferentes faz toda diferença</h3><p>Um dos pontos mais interessantes dos testes unitários é que eles não servem apenas para validar situações “perfeitas”.</p><p>Além dos cenários válidos, também é possível testar entradas inválidas, erros inesperados e comportamentos extremos do sistema. Isso ajuda a criar aplicações muito mais estáveis e preparadas para diferentes situações do mundo real.</p><p>Por exemplo:</p><ul><li>O que acontece se um valor nulo for enviado?</li><li>Como o sistema reage a números negativos?</li><li>O método continua funcionando com valores muito grandes?</li></ul><p>Esses cenários ajudam a evitar falhas futuras e tornam a aplicação mais robusta.</p><h3>Testes precisam ser rápidos</h3><p>Outra característica importante dos testes unitários é a velocidade.</p><p>Como eles focam apenas em pequenas partes do sistema, normalmente são executados em poucos milissegundos. Para isso, recursos externos como bancos de dados, APIs e conexões HTTP costumam ser simulados através de objetos falsos, conhecidos como mocks.</p><p>Dessa forma, o teste valida somente a lógica do método, sem depender de internet, servidores ou outros serviços externos.</p><h3>Conclusão</h3><p>Os testes unitários se tornaram essenciais no desenvolvimento moderno de software. Eles ajudam a construir sistemas mais seguros, organizados e confiáveis, além de reduzir erros e facilitar a manutenção do código.</p><p>Embora muitas pessoas iniciantes enxerguem os testes como algo opcional, na prática eles representam um grande diferencial na qualidade de um projeto. Quanto maior o sistema, maior também será a importância de possuir testes bem estruturados.</p><p>No final das contas, testar não é apenas encontrar erros. É garantir confiança no software que está sendo desenvolvido.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60a8343da800" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Máquina Virtual vs Docker]]></title>
            <link>https://medium.com/@rebecallourenco7/m%C3%A1quina-virtual-vs-docker-92fb09acca88?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/92fb09acca88</guid>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Wed, 18 Feb 2026 03:10:04 GMT</pubDate>
            <atom:updated>2026-02-18T03:10:04.710Z</atom:updated>
            <content:encoded><![CDATA[<p>Em ambientes modernos de desenvolvimento e infraestrutura, dois conceitos são frequentemente utilizados para isolar sistemas e aplicações: a máquina virtual e o Docker. Embora ambos permitam executar softwares em ambientes controlados e reproduzíveis, suas abordagens são diferentes e impactam diretamente o consumo de recursos, a velocidade de execução e a forma como aplicações são distribuídas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*5jpoBKL0a63iwbuk.png" /></figure><p>A máquina virtual é uma tecnologia mais antiga e consolidada. Ela consiste na simulação de um computador completo dentro de outro computador físico. Para isso, utiliza-se um software chamado hipervisor, responsável por dividir os recursos do hardware real em várias máquinas virtuais independentes. Cada máquina virtual possui seu próprio sistema operacional, com kernel, bibliotecas e drivers próprios. Isso significa que, ao iniciar uma máquina virtual, um sistema operacional inteiro é carregado na memória, como se fosse um computador real funcionando dentro de outro.</p><p>Esse modelo oferece um alto nível de isolamento, pois cada máquina virtual funciona de forma independente. É possível, por exemplo, executar um sistema Linux dentro de um computador com Windows ou rodar vários servidores distintos no mesmo hardware físico. No entanto, essa independência tem um custo: máquinas virtuais consomem mais memória, mais processamento e levam mais tempo para iniciar. Por exigirem um sistema operacional completo, tornam-se mais pesadas e menos ágeis em cenários que exigem rápida inicialização e escalabilidade.</p><p>O Docker surge em um contexto diferente, voltado principalmente para a execução de aplicações de forma padronizada e leve. Em vez de virtualizar um computador inteiro, o Docker cria containers, que são ambientes isolados apenas no nível da aplicação. Um container inclui o código da aplicação, suas dependências e configurações necessárias para rodar, mas utiliza o mesmo kernel do sistema operacional do host. Isso elimina a necessidade de carregar um sistema operacional completo para cada instância de aplicação.</p><p>Como resultado, os containers são muito mais leves que máquinas virtuais. Eles iniciam rapidamente, consomem menos recursos e podem ser replicados com facilidade. Esse comportamento tornou o Docker uma ferramenta fundamental em processos de integração contínua, entrega contínua e arquiteturas baseadas em microserviços. Em vez de configurar manualmente um servidor para cada ambiente, o desenvolvedor empacota a aplicação em um container e garante que ela será executada da mesma forma em qualquer máquina que tenha Docker instalado.</p><p>A diferença central entre máquina virtual e Docker está, portanto, no nível de virtualização. A máquina virtual virtualiza o hardware e executa um sistema operacional completo. O Docker virtualiza apenas o ambiente necessário para a aplicação, executando processos isolados dentro do sistema operacional já existente. Essa distinção impacta diretamente o desempenho e a escalabilidade. Máquinas virtuais são mais robustas e indicadas para simular infraestruturas completas, enquanto containers são mais rápidos e adequados para distribuir aplicações.</p><p>No cenário atual, essas tecnologias não competem diretamente. Em muitos ambientes de produção, especialmente em provedores de nuvem, a infraestrutura é composta por máquinas virtuais que servem de base para a execução de containers Docker. Dessa forma, a máquina virtual fornece a camada de hardware virtualizado e isolamento mais profundo, enquanto o Docker organiza e executa as aplicações de maneira eficiente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92fb09acca88" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CI/CD: como a automação conecta código à entrega de valor]]></title>
            <link>https://medium.com/@rebecallourenco7/ci-cd-como-a-automa%C3%A7%C3%A3o-conecta-c%C3%B3digo-%C3%A0-entrega-de-valor-8902e1666400?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/8902e1666400</guid>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Mon, 26 Jan 2026 23:55:29 GMT</pubDate>
            <atom:updated>2026-01-26T23:55:58.384Z</atom:updated>
            <content:encoded><![CDATA[<p>Durante muito tempo, desenvolver software significava escrever código, testar manualmente e “subir para produção” na mão. Esse modelo funcionava quando sistemas eram pequenos e mudanças raras. Hoje, com aplicações grandes, times distribuídos e entregas constantes, esse processo simplesmente não escala. É nesse contexto que o CI/CD se torna essencial.</p><p>CI/CD é a prática que automatiza o caminho entre escrever código e entregar software funcionando. Não é apenas uma ferramenta, mas uma forma moderna de organizar o trabalho de desenvolvimento para reduzir erros, acelerar entregas e aumentar a confiança no sistema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*U1Jh1YPj6EdaH_uZX4ziEg.webp" /></figure><h3>O que realmente é CI/CD</h3><p>CI/CD é a junção de dois conceitos: <strong>Integração Contínua (CI)</strong> e <strong>Entrega/Implantação Contínua (CD)</strong>.</p><p>A Integração Contínua parte de uma ideia simples: todo código novo deve ser integrado ao projeto principal o mais cedo possível. Sempre que alguém faz um commit, o sistema automaticamente valida se aquele código funciona, geralmente executando build e testes. Isso evita que erros se acumulem e só apareçam no final.</p><p>Já o CD cuida do passo seguinte: garantir que o software validado esteja sempre pronto para ser entregue. Dependendo da estratégia da empresa, essa entrega pode exigir uma aprovação manual (continuous delivery) ou acontecer automaticamente (continuous deployment).</p><p>O ponto central é que não existe improviso. O caminho do código até a produção é previsível, repetível e automatizado.</p><h3>Como funciona na prática</h3><p>Na prática, tudo gira em torno de um <strong>pipeline</strong>, que é uma sequência de etapas automatizadas.</p><p><strong>O fluxo costuma ser assim:</strong></p><p>O desenvolvedor envia o código → o pipeline inicia → o sistema constrói a aplicação → executa testes → valida qualidade → libera ou faz o deploy.</p><p>Se algo der errado no meio do caminho, o processo para ali. Nada quebrado chega à produção. Isso muda completamente a dinâmica do time: erros aparecem cedo, correções são menores e o risco diminui drasticamente.</p><p>Ferramentas como GitHub Actions, GitLab CI e Jenkins existem justamente para orquestrar esse pipeline, mas a lógica independe da ferramenta. O valor está no processo, não no nome da tecnologia.</p><h3>Por que CI/CD virou padrão?</h3><p>Empresas adotam CI/CD porque ele resolve problemas reais do dia a dia.<br> Com pipelines bem definidos, o time consegue entregar com mais frequência, reduzir falhas em produção e ter previsibilidade. Além disso, o código deixa de depender de pessoas específicas para “saber como publicar”, o que aumenta a maturidade do projeto.</p><p>Outro ponto importante é a ligação direta com o negócio. Quando o caminho até a produção é confiável, a empresa consegue responder mais rápido ao mercado, corrigir problemas com agilidade e evoluir o produto de forma contínua.</p><p><strong>CI/CD não é só automação e nem apenas uma etapa técnica. É a ponte entre código e valor entregue.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8902e1666400" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[var, let e const: a diferença REAL no JavaScript moderno]]></title>
            <link>https://medium.com/@rebecallourenco7/var-let-e-const-a-diferen%C3%A7a-real-no-javascript-moderno-5fb1f74b31ee?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/5fb1f74b31ee</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Sun, 25 Jan 2026 21:41:17 GMT</pubDate>
            <atom:updated>2026-01-25T21:45:12.132Z</atom:updated>
            <content:encoded><![CDATA[<p>Durante muito tempo, o JavaScript contou apenas com uma forma de declarar variáveis: var. Com a evolução da linguagem e a chegada do ES6, surgiram let e const, trazendo mais segurança, previsibilidade e controle de escopo. Apesar disso, ainda hoje existe muita confusão, especialmente quando o assunto envolve <strong>imutabilidade</strong>, <strong>referências</strong> e <strong>React</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gE7CPqAYCOS4eQ5Q" /></figure><p>Este artigo explica, de forma prática e técnica, <strong>o que realmente muda entre </strong><strong>var, </strong><strong>let e </strong><strong>const</strong>, e por que const se tornou o padrão no desenvolvimento moderno.</p><h3>var: a herança problemática do JavaScript antigo</h3><p>A palavra-chave var foi a primeira forma de declarar variáveis no JavaScript. O grande problema é que ela <strong>não respeita escopo de bloco</strong>, apenas escopo de função. Isso significa que variáveis declaradas dentro de estruturas como if ou for podem “vazar” para fora do bloco.</p><p>Além disso, var permite redeclaração no mesmo escopo, o que facilita a criação de bugs difíceis de identificar.</p><p>Esses comportamentos tornaram o código imprevisível e frágil em aplicações maiores. Por esse motivo, var caiu em desuso e <strong>não deve ser utilizado em código JavaScript moderno</strong>.</p><h3>let: mutável, previsível e com escopo correto</h3><p>O let foi criado para resolver os principais problemas do var. Ele respeita <strong>escopo de bloco</strong>, não permite redeclaração no mesmo contexto e torna o código muito mais seguro.</p><p>Variáveis declaradas com let podem ter seus valores alterados ao longo do tempo, o que é útil em situações específicas, como contadores, iterações ou estados intermediários.</p><p>Mesmo assim, no JavaScript moderno, let <strong>não é o padrão</strong>, mas sim uma exceção consciente.</p><h3>const: o padrão do JavaScript moderno</h3><p>Hoje, const é a forma recomendada para declarar variáveis. O ponto mais importante é entender <strong>o que o </strong><strong>const realmente garante</strong>.</p><p>const <strong>não impede que valores internos mudem</strong>. O que ele impede é a <strong>troca da referência</strong>.</p><p>Quando usamos const com tipos primitivos, o valor não pode mudar. Mas quando usamos const com objetos ou arrays, o conteúdo interno pode ser alterado, desde que a referência permaneça a mesma.</p><p>Onde entra o React (e onde a confusão começa)</p><p>O erro mais comum não está no const, mas na <strong>mutação direta de estado</strong>.</p><p>No React, estado não é apenas um objeto comum. Estado é algo:</p><ul><li>controlado pelo React</li><li>criado com useState</li><li>que <strong>só deve ser atualizado via setter (</strong><strong>setState)</strong></li></ul><p>O React detecta mudanças comparando <strong>referências</strong>, não valores internos. Se a referência não muda, o React assume que nada mudou e não renderiza novamente.</p><p>Por isso, mutar diretamente um objeto que está no estado causa um <strong>bug silencioso</strong>: o dado muda, mas a interface não atualiza.</p><p>A forma correta de atualizar estado no React é <strong>criando um novo objeto</strong>, ou seja, uma nova referência, e passando essa referência para o setter.</p><p>Quem cria a nova referência <strong>não é o </strong><strong>const</strong>, mas o novo objeto passado ao setState.<br> O const apenas mantém a referência atual protegida contra reatribuições indevidas.</p><h3>Separando conceitos que não devem ser misturados</h3><p>Existe uma confusão comum entre dois assuntos diferentes:</p><ul><li>const vs let (JavaScript)</li><li>imutabilidade de estado (React)</li></ul><p>Mesmo que o estado fosse declarado com let, mutá-lo diretamente continuaria sendo errado. O problema <strong>não é o </strong><strong>const</strong>. O problema é <strong>alterar estado sem criar uma nova referência</strong>.</p><p>React foi projetado para ser usado com const. Ele espera imutabilidade e atualização via setters.</p><h3>Regra prática</h3><p>No JavaScript moderno:</p><ul><li>evite var</li><li>use const como padrão</li><li>use let apenas quando reatribuição for realmente necessária</li></ul><p>No React:</p><ul><li>nunca mutar estado diretamente</li><li>sempre criar novas referências ao atualizar dados</li><li>sempre usar o setter (setState)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5fb1f74b31ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como os Modelos de Linguagem “Lembram” do que Foi Dito?]]></title>
            <link>https://medium.com/@rebecallourenco7/como-os-modelos-de-linguagem-lembram-do-que-foi-dito-066318ddbacc?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/066318ddbacc</guid>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[prompt]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Thu, 15 Jan 2026 15:59:58 GMT</pubDate>
            <atom:updated>2026-01-15T15:59:58.080Z</atom:updated>
            <content:encoded><![CDATA[<p>À primeira vista, parece que a IA tem memória, acompanha o diálogo e guarda informações como um ser humano. Mas a realidade é bem diferente e muito mais interessante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*q5_s8lJaTGcTfqd2" /></figure><p>Modelos de linguagem não têm memória no sentido humano. Eles não guardam lembranças, não recuperam eventos passados e não “recordam” conversas anteriores por vontade própria.O que acontece é uma ilusão de memória, criada por um mecanismo técnico chamado <strong>janela de contexto</strong>.</p><h4>O que é a janela de contexto?</h4><p>A janela de contexto é a quantidade máxima de texto que o modelo consegue considerar ao mesmo tempo. Dentro dessa janela estão:</p><ul><li>O prompt inicial</li><li>As mensagens anteriores</li><li>A pergunta atual</li></ul><p>Tudo isso é processado como se fosse um único texto contínuo. Enquanto algo estiver dentro dessa janela, o modelo consegue:</p><ul><li>Manter coerência</li><li>Retomar assuntos</li><li>Usar informações já mencionadas</li></ul><p>Fora dela, o conteúdo simplesmente deixa de existir para o modelo.</p><h4>Como o contexto é usado na prática?</h4><p>A cada nova resposta:</p><ol><li>O sistema envia novamente o histórico relevante;</li><li>O modelo lê tudo de uma vez;</li><li>Ele calcula probabilidades com base nesse texto completo;</li><li>Gera a próxima resposta.</li></ol><p>Ou seja: Não existe recuperação de memória. Não existe busca no passado. Existe apenas releitura do contexto atual.</p><h4>O papel do mecanismo de atenção</h4><p>O que faz o modelo parecer “atento” ao que foi dito antes é o mecanismo de atenção (<em>attention</em>).</p><p>Ele permite que o modelo:</p><ul><li>Observe todas as palavras do contexto</li><li>Dê mais peso às partes mais relevantes</li><li>Relacione informações distantes no texto</li></ul><p><strong>Por exemplo, se você menciona um nome no início da conversa, o modelo consegue relacionar esse nome com perguntas feitas depois , desde que tudo ainda esteja dentro da janela de contexto.</strong></p><h4>Por que o modelo “esquece” coisas?</h4><p>O esquecimento acontece por dois motivos principais:</p><ol><li><strong>Limite da janela de contexto</strong></li></ol><p>Quando a conversa fica longa demais, mensagens antigas são cortadas para dar espaço às novas.</p><p>Quando isso acontece:</p><ul><li>O modelo não vê mais aquele conteúdo</li><li>Ele não tem como “lembrar”</li><li>A informação deixa de influenciar a resposta</li></ul><p><strong>2. Falta de reforço no texto</strong></p><p>Se algo foi mencionado apenas uma vez e nunca mais retomado, ele pode perder relevância estatística dentro do contexto atual.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XC3BOmhWzd1K0BLD.jpg" /></figure><h3>Memória de curto prazo vs. memória de longo prazo</h3><p>A memória de curto prazo em modelos de linguagem funciona apenas dentro da conversa atual. Ela depende totalmente da chamada janela de contexto, que é o limite de texto que o modelo consegue analisar de uma só vez. Enquanto as informações estiverem presentes nessa janela, o modelo consegue manter coerência, retomar assuntos e usar dados mencionados anteriormente. No entanto, quando a conversa termina ou quando partes antigas do diálogo saem da janela de contexto, essas informações simplesmente deixam de existir para o modelo.</p><p>Já a chamada “memória de longo prazo” não pertence ao modelo de linguagem em si. Quando uma inteligência artificial aparenta lembrar preferências do usuário ao longo do tempo, isso acontece por causa de sistemas externos que ficam ao redor do modelo, como bancos de dados, configurações salvas e camadas de aplicação responsáveis por armazenar e reutilizar essas informações. O modelo apenas recebe esses dados novamente como texto de entrada. Ele não aprende durante a conversa, não cria lembranças próprias e não guarda informações pessoais por conta própria. Tudo o que parece memória persistente vem de fora, nunca do modelo em si.</p><p>Em resumo, o que chamamos de “memória” em modelos de linguagem é, na verdade, o resultado de mecanismos técnicos bem definidos, e não de lembranças reais ou aprendizado contínuo. Esses modelos operam sempre no presente, utilizando apenas o texto que recebem naquele momento para calcular probabilidades e gerar respostas coerentes. A continuidade da conversa, a retomada de assuntos e a aparente capacidade de lembrar informações são efeitos do uso da janela de contexto e do mecanismo de atenção, não de uma memória consciente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=066318ddbacc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como os Modelos de Linguagem Entendem um Prompt?]]></title>
            <link>https://medium.com/@rebecallourenco7/como-os-modelos-de-linguagem-entendem-um-prompt-17937cf20a8e?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/17937cf20a8e</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[engenharia-de-prompt]]></category>
            <category><![CDATA[prompt]]></category>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Thu, 15 Jan 2026 15:44:43 GMT</pubDate>
            <atom:updated>2026-01-15T15:45:48.451Z</atom:updated>
            <content:encoded><![CDATA[<p>Quando escrevemos um prompt para uma inteligência artificial, é comum termos a sensação de que ela “entendeu” o que pedimos, quase como se estivesse pensando. Mas essa percepção é enganosa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/0*bauZaWig8acBnj8k.jpg" /></figure><p>Modelos de linguagem não entendem intenção, contexto ou significado da forma como humanos entendem. O que eles fazem é algo muito diferente e, ao mesmo tempo, impressionante.</p><h4>O que é um modelo de linguagem?</h4><p>Um modelo de linguagem é um sistema treinado com grandes volumes de texto para aprender padrões da linguagem humana, como:</p><ul><li>Quais palavras costumam aparecer juntas</li><li>Qual palavra tende a vir depois da outra</li><li>Como frases e estruturas linguísticas se organizam</li></ul><p>Ele não pensa, não raciocina conscientemente e não tem intenção. Em essência, um modelo de linguagem faz apenas uma coisa:<br> predizer o próximo token mais provável.</p><h4>O que é um prompt para a IA?</h4><p>Para o modelo, um prompt não é um pedido, uma pergunta ou uma ordem. Ele é apenas:</p><ul><li>Uma sequência de texto</li><li>Convertida em tokens</li><li>Transformada em números</li><li>Usada como entrada para cálculos matemáticos</li></ul><p>Ou seja, o prompt funciona como um estado inicial, a partir do qual o modelo começa a gerar probabilidades.</p><h4>Tokenização: o primeiro passo</h4><p>Antes de qualquer processamento, o texto passa por uma etapa chamada tokenização.</p><p>Nessa fase, o prompt é dividido em partes menores chamadas <em>tokens</em>, que podem ser:</p><ul><li>Palavras inteiras</li><li>Partes de palavras</li><li>Símbolos</li><li>Pontuação</li></ul><p>Por exemplo, a frase:</p><blockquote><em>“Como modelos de linguagem entendem prompts?”</em></blockquote><p>Pode ser quebrada em algo como:</p><pre>[Como] [modelos] [de] [linguagem] [entendem] [prompt] [?]</pre><p><strong>Cada token recebe um identificador numérico.</strong></p><h4>De palavras a vetores</h4><p>Depois de virar números, os tokens são transformados em vetores matemáticos.</p><p>Esses vetores representam:</p><ul><li>Relações estatísticas entre palavras</li><li>Similaridade semântica aproximada</li><li>Contexto aprendido durante o treinamento</li></ul><p>Palavras com significados parecidos ficam próximas no espaço vetorial, mesmo que nunca tenham sido explicitamente definidas como sinônimos.</p><h4>Atenção: como o contexto é considerado</h4><p>Modelos modernos utilizam um mecanismo chamado <strong>atenção</strong> (<em>attention</em>).</p><p>Ele permite que o modelo:</p><ul><li>Observe todo o prompt ao mesmo tempo</li><li>Avalie quais partes são mais relevantes</li><li>Relacione palavras distantes dentro da mesma frase</li></ul><p>Isso cria a sensação de que o modelo “entendeu o contexto”, mas, na prática, ele apenas atribui pesos matemáticos diferentes aos tokens.</p><p>Não há compreensão consciente , apenas cálculo.</p><h4>A predição da próxima palavra</h4><p>Aqui está o ponto central de tudo:<strong> </strong>O modelo não decide uma resposta completa. Ele prediz uma palavra (ou token) por vez.</p><p>O processo funciona assim:</p><ol><li>Analisa o prompt</li><li>Calcula probabilidades para o próximo token</li><li>Escolhe um deles</li><li>Repete o processo, token por token</li></ol><p>Todo o texto gerado é o resultado dessa sequência de previsões.</p><h4>Por que prompts bem escritos funcionam melhor?</h4><p>Porque o modelo depende exclusivamente do texto fornecido. Ele:</p><ul><li>Não adivinha intenções ocultas</li><li>Não corrige ambiguidades sozinho</li><li>Não sabe o que você “quis dizer”</li></ul><p>Prompts claros:</p><ul><li>Reduzem interpretações erradas</li><li>Direcionam melhor os padrões aprendidos</li><li>Aumentam a probabilidade de respostas úteis</li></ul><p>Por isso, engenharia de prompt não é truque, é clareza.</p><p>Compreender como modelos de linguagem funcionam ajuda a:</p><ul><li>Escrever prompts mais eficientes</li><li>Evitar frustrações e expectativas irreais</li><li>Usar IA de forma mais crítica e responsável</li><li>Projetar sistemas melhores baseados em IA</li></ul><p>Quanto mais claro o prompt, mais previsível e controlável será o resultado. Modelos de linguagem não entendem prompts como pessoas entendem. Eles processam texto como tokens, vetores e probabilidades. Ainda assim, quando bem utilizados, conseguem gerar respostas úteis, coerentes e sofisticadas, não por consciência, mas por estatística em escala massiva.</p><p><strong>Entender isso não diminui a IA. Pelo contrário: nos permite usá-la melhor, com mais técnica e menos ilusão.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17937cf20a8e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOLID em Java: explicando de forma simples]]></title>
            <link>https://medium.com/@rebecallourenco7/solid-em-java-explicando-de-forma-simples-a7e7af07f1d1?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/a7e7af07f1d1</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[solid-principles]]></category>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Wed, 07 Jan 2026 22:12:37 GMT</pubDate>
            <atom:updated>2026-01-07T22:21:06.936Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você está aprendendo Java ou programação orientada a objetos, provavelmente já ouviu falar de SOLID. No começo, esse nome parece algo complicado, mas a verdade é que SOLID são apenas regras de bom senso para escrever código melhor.</p><p>Neste artigo, vou explicar cada princípio do SOLID de forma simples, com exemplos fáceis em Java.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/0*4Jst6kTTITK5N8Pz" /></figure><h3>O que é SOLID?</h3><p>SOLID é um conjunto de cinco princípios que ajudam desenvolvedores a criar sistemas mais organizados, flexíveis e fáceis de evoluir.</p><p>Esses princípios são amplamente utilizados em Java e em qualquer linguagem orientada a objetos.</p><p>O nome SOLID vem das iniciais de:</p><ul><li>S — Single Responsibility Principle</li><li>O — Open/Closed Principle</li><li>L — Liskov Substitution Principle</li><li>I — Interface Segregation Principle</li><li>D — Dependency Inversion Principle</li></ul><h3>S — Single Responsibility Principle (Responsabilidade Única)</h3><p>Uma classe deve ter <strong>apenas uma responsabilidade</strong>, ou seja, <strong>apenas um motivo para mudar</strong>.</p><p>Quando uma classe faz muitas coisas diferentes, ela se torna difícil de entender, testar e manter.</p><h3>Exemplo incorreto:</h3><pre>class Usuario {<br>    void salvarNoBanco() {}<br>    void enviarEmail() {}<br>}</pre><p>Essa classe cuida do usuário, do banco de dados e do envio de e-mails ao mesmo tempo.</p><h3>Exemplo correto:</h3><pre>class Usuario {<br>    String nome;<br>}</pre><pre>class UsuarioRepository {<br>    void salvar(Usuario usuario) {}<br>}</pre><pre>class EmailService {<br>    void enviarEmail(Usuario usuario) {}<br>}</pre><p>Cada classe agora tem uma responsabilidade bem definida.</p><h3>O — Open/Closed Principle (Aberto para extensão, fechado para modificação)</h3><p>Uma classe deve estar <strong>aberta para extensão</strong>, mas <strong>fechada para modificação</strong>.</p><p>Isso significa que novas funcionalidades devem ser adicionadas sem alterar código que já funciona.</p><h3>Exemplo incorreto:</h3><pre>class Calculadora {<br>    double calcular(String tipo) {<br>        if (tipo.equals(&quot;soma&quot;)) return 10 + 5;<br>        if (tipo.equals(&quot;subtracao&quot;)) return 10 - 5;<br>        return 0;<br>    }<br>}</pre><p>Sempre que surge uma nova operação, essa classe precisa ser modificada.</p><h3>Exemplo correto:</h3><pre>interface Operacao {<br>    double calcular();<br>}</pre><pre>class Soma implements Operacao {<br>    public double calcular() {<br>        return 10 + 5;<br>    }<br>}</pre><pre>class Subtracao implements Operacao {<br>    public double calcular() {<br>        return 10 - 5;<br>    }<br>}</pre><p>Agora é possível adicionar novas operações criando novas classes, sem alterar as existentes.</p><h3>L — Liskov Substitution Principle (Substituição de Liskov)</h3><p>Uma classe filha deve poder <strong>substituir a classe pai sem causar comportamentos inesperados</strong>.</p><p>Se a herança quebra a lógica do programa, ela está errada.</p><h3>Exemplo incorreto:</h3><pre>class Ave {<br>    void voar() {}<br>}</pre><pre>class Pinguim extends Ave {<br>    // Pinguim não voa<br>}</pre><p>O pinguim não consegue cumprir o comportamento esperado da classe pai.</p><h3>Exemplo correto:</h3><pre>class Ave {}</pre><pre>class AveVoadora extends Ave {<br>    void voar() {}<br>}</pre><pre>class Pinguim extends Ave {}</pre><p>A herança agora respeita os comportamentos reais de cada classe.</p><h3>I — Interface Segregation Principle (Segregação de Interfaces)</h3><p>Classes não devem ser obrigadas a implementar métodos que não utilizam.</p><p>Interfaces grandes demais acabam forçando implementações desnecessárias.</p><h3>Exemplo incorreto:</h3><pre>interface Animal {<br>    void andar();<br>    void voar();<br>}</pre><p>Nem todo animal voa, mas todas as classes seriam obrigadas a implementar esse método.</p><h3>Exemplo correto:</h3><pre>interface Animal {<br>    void andar();<br>}</pre><pre>interface AnimalVoador {<br>    void voar();<br>}</pre><p>Agora cada classe implementa apenas o que realmente precisa.</p><h3>D — Dependency Inversion Principle (Inversão de Dependência)</h3><p>Classes devem depender de <strong>abstrações</strong>, não de implementações concretas.</p><p>Isso aumenta a flexibilidade do sistema.</p><h3>Exemplo incorreto:</h3><pre>class Motor {<br>    void ligar() {}<br>}</pre><pre>class Carro {<br>    Motor motor = new Motor();<br>}</pre><p>O carro fica acoplado a um único tipo de motor.</p><h3>Exemplo correto:</h3><pre>interface Motor {<br>    void ligar();<br>}</pre><pre>class MotorEletrico implements Motor {<br>    public void ligar() {}<br>}</pre><pre>class Carro {<br>    Motor motor;</pre><pre>    Carro(Motor motor) {<br>        this.motor = motor;<br>    }<br>}</pre><p>Agora o carro pode funcionar com qualquer tipo de motor que implemente a interface.</p><p>Os princípios SOLID não servem para decorar, mas para serem aplicados aos poucos no dia a dia. Conforme os projetos crescem, seguir esses princípios reduz bugs, facilita manutenção e melhora a qualidade do código.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a7e7af07f1d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O que é Terraform? A Receita Mágica para sua Infraestrutura Digital]]></title>
            <link>https://medium.com/@rebecallourenco7/o-que-%C3%A9-terraform-a-receita-m%C3%A1gica-para-sua-infraestrutura-digital-437cea4d4fdd?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/437cea4d4fdd</guid>
            <category><![CDATA[terraform]]></category>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Sat, 23 Aug 2025 17:25:20 GMT</pubDate>
            <atom:updated>2025-08-23T17:25:20.427Z</atom:updated>
            <content:encoded><![CDATA[<p>No universo da tecnologia, gerenciar servidores, redes e bancos de dados em serviços de nuvem como AWS, Azure ou Google Cloud pode ser um processo complexo e demorado. Clicar em centenas de botões, copiar e colar configurações e garantir que tudo está no lugar certo é uma tarefa manual propensa a erros.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/0*J2bsK_aMD3z3xAHr" /></figure><p>Mas e se houvesse uma “receita” capaz de automatizar todo esse trabalho, criando ambientes digitais inteiros com apenas alguns comandos? É exatamente essa a proposta do Terraform.</p><h3>Afinal, o que é o Terraform?</h3><p>Em sua essência, o <strong>Terraform é uma ferramenta que permite criar e gerenciar toda a sua infraestrutura digital usando código</strong>.</p><p>Esqueça a necessidade de acessar interfaces gráficas e navegar por menus complexos. Com o Terraform, você escreve um arquivo de texto simples e conciso, descrevendo exatamente o que sua infraestrutura precisa ter. Por exemplo: “Eu quero um servidor com 8GB de RAM, uma rede privada e um banco de dados conectado a ele”.</p><p>O Terraform lê essa “receita” e se encarrega de ir até o provedor de nuvem (AWS, por exemplo) para construir e configurar todos esses recursos para você, de forma automática e padronizada.</p><h3>Os Pilares do Terraform</h3><p>O poder dessa ferramenta se apoia em alguns conceitos fundamentais que a tornam indispensável para equipes de desenvolvimento e DevOps.</p><h4>1. Infraestrutura como Código (IaC)</h4><p>Este é o conceito central. A sua infraestrutura não é mais uma série de configurações manuais, mas sim um <strong>código</strong> que pode ser salvo, versionado (como em um repositório Git), compartilhado e reutilizado.</p><p>Isso significa que você pode criar o mesmo ambiente de produção, testes ou desenvolvimento com apenas um comando, garantindo que todos os ambientes sejam idênticos e livres de erros humanos.</p><h4>2. Abordagem Declarativa: O “O quê” em vez do “Como”</h4><p>Diferente de scripts que dizem “Passo 1: Crie o servidor; Passo 2: Configure a rede…”, o Terraform é <strong>declarativo</strong>. Você simplesmente declara o <strong>estado final que você deseja</strong>.</p><p>Seu trabalho é dizer ao Terraform o que você quer que a infraestrutura seja, e a ferramenta se encarrega de descobrir e executar os passos necessários para alcançar esse objetivo, de forma inteligente e eficiente.</p><h4>3. Plano de Execução: Segurança em Primeiro Lugar</h4><p>Uma das funcionalidades mais valiosas do Terraform é o <strong>Plano de Execução</strong>. Antes de fazer qualquer mudança na sua infraestrutura, a ferramenta gera um “plano” que detalha exatamente o que será criado, modificado ou apagado.</p><p>Você pode revisar esse plano para garantir que as alterações estão corretas, evitando surpresas indesejadas e dando total controle sobre o processo.</p><h4>4. Ambientes Descartáveis e Reutilizáveis</h4><p>Imagine precisar de um ambiente completo para rodar um teste rápido. Com o Terraform, você pode ter esse ambiente pronto em questão de minutos e, após o teste, simplesmente excluí-lo com um comando.</p><p>Essa capacidade de criar e destruir infraestruturas de forma rápida e segura permite que as equipes trabalhem com ambientes “descartáveis”, otimizando custos e agilizando o ciclo de desenvolvimento.</p><h4>5. Compatibilidade com Múltiplos Provedores</h4><p>O Terraform não se limita a um único serviço de nuvem. Ele possui suporte para os maiores provedores do mercado (AWS, Azure, Google Cloud, Oracle Cloud, etc.), além de outras ferramentas e serviços, o que o torna uma solução versátil para qualquer ecossistema.</p><h3>Conclusão</h3><p>O Terraform é muito mais do que uma simples ferramenta de automação. Ele é um facilitador para o modelo DevOps, que promove a colaboração e a agilidade ao tratar a infraestrutura como um software.</p><p>Ao transformar a complexidade do gerenciamento de recursos em um processo simples, seguro e padronizado, o Terraform se consolidou como uma peça-chave para profissionais que buscam construir, replicar e gerenciar ambientes digitais de forma eficiente e escalável. Seja você um desenvolvedor ou um especialista em infraestrutura, entender essa ferramenta é um passo fundamental para o futuro da tecnologia.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=437cea4d4fdd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prisma no Node.js: uma abordagem moderna para trabalhar com bancos de dados]]></title>
            <link>https://medium.com/@rebecallourenco7/prisma-no-node-js-uma-abordagem-moderna-para-trabalhar-com-bancos-de-dados-41ba61121f91?source=rss-24a68fbf5371------2</link>
            <guid isPermaLink="false">https://medium.com/p/41ba61121f91</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[prisma]]></category>
            <category><![CDATA[node]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Rebeca Barbosa Lourenço]]></dc:creator>
            <pubDate>Fri, 16 May 2025 17:38:22 GMT</pubDate>
            <atom:updated>2025-05-16T17:38:22.834Z</atom:updated>
            <content:encoded><![CDATA[<p>Quando estamos desenvolvendo aplicações com Node.js, um dos grandes desafios é a integração com o banco de dados. Escrever queries SQL, validar dados manualmente e manter a consistência da base pode ser um trabalho complexo e propenso a erros. Foi para resolver essas dificuldades que surgiu o <strong>Prisma: </strong>um ORM moderno e poderoso que vem ganhando espaço entre desenvolvedores JavaScript e TypeScript.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/0*UOiMOq8_-y9Wekz6" /></figure><h3>O que é o Prisma?</h3><p>O Prisma é uma ferramenta de ORM (Object-Relational Mapping) que permite mapear e manipular dados de bancos relacionais (e também MongoDB) diretamente com código JavaScript ou TypeScript.</p><p>A principal proposta do Prisma é simplificar o acesso ao banco de dados, oferecendo <strong>inteligência de tipos, autocomplete, validações automáticas e performance</strong>. Em vez de escrever SQL puro, você interage com o banco por meio de métodos intuitivos e seguros.</p><p>Exemplo de uma consulta com Prisma:</p><blockquote>const users = await prisma.user.findMany();</blockquote><p>Com essa simples linha de código, você busca todos os registros da tabela user, sem precisar escrever uma única linha de SQL.</p><h3>Como o Prisma funciona?</h3><p>O Prisma é estruturado em três etapas principais:</p><h3>1. Schema Prisma</h3><p>O coração da configuração do Prisma está no arquivo schema.prisma. Nele, você define os modelos do seu banco (equivalentes às tabelas), além de configurar a conexão com o banco de dados.</p><p>Exemplo:</p><blockquote>model User {<br> id Int <a href="http://twitter.com/id">@id</a> <a href="http://twitter.com/default">@default</a>(autoincrement())<br> name String<br> email String <a href="http://twitter.com/unique">@unique</a><br>}</blockquote><p>Essa definição cria uma tabela User com os campos id, name e email, sendo id a chave primária e email um campo único.</p><h3>2. Prisma Client</h3><p>Após definir o schema, o comando npx prisma generate gera automaticamente o Prisma Client, uma biblioteca personalizada que permite consultar, criar, atualizar e deletar dados com facilidade e segurança.</p><p>Com esse client, você interage com o banco usando código que possui autocompletar e verificação de tipos em tempo de desenvolvimento.</p><h3>3. Migrações</h3><p>Se desejar aplicar mudanças estruturais ao banco de dados diretamente pelo Prisma, você pode utilizar o sistema de migrações. Com o comando:</p><blockquote>npx prisma migrate dev — name init</blockquote><p>O Prisma cria e aplica a estrutura definida no schema ao banco de dados, gerando um histórico versionado das alterações.</p><h3>Vantagens do Prisma</h3><p>O Prisma se destaca por diversas razões:</p><ul><li>Tipagem estática com suporte completo ao TypeScript</li><li>Autocompletar no editor de código (especialmente no VSCode)</li><li>Redução de erros de SQL em tempo de desenvolvimento</li><li>Sistema de migrações versionadas</li><li>Integração com os principais bancos de dados (PostgreSQL, MySQL, SQLite, SQL Server, MongoDB)</li><li>Excelente documentação oficial e comunidade ativa</li></ul><h3>Exemplo prático: criando um usuário</h3><p>Abaixo, um exemplo simples de como criar um novo usuário com Prisma:</p><blockquote>import { PrismaClient } from ‘<a href="http://twitter.com/prisma/client">@prisma/client</a>’;</blockquote><blockquote>const prisma = new PrismaClient();</blockquote><blockquote>async function main() {<br> const user = await prisma.user.create({<br> data: {<br> name: ‘Robson’,<br> email: ‘<a href="/service/mailto:robson@email.com">robson@email.com</a>’,<br> },<br> });</blockquote><blockquote>console.log(user);<br>}</blockquote><blockquote>main();</blockquote><p>Esse código conecta-se ao banco e insere um novo registro na tabela User, com o mínimo de complexidade.</p><h3>Prisma + TypeScript: produtividade e segurança</h3><p>O Prisma foi pensado para funcionar perfeitamente com TypeScript. Isso significa que todos os modelos definidos no schema são automaticamente tipados no client, garantindo mais segurança no desenvolvimento e mais produtividade com ferramentas como o IntelliSense.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=41ba61121f91" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>