<?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 Fernanda on Medium]]></title>
        <description><![CDATA[Stories by Fernanda on Medium]]></description>
        <link>https://medium.com/@fnandaleite?source=rss-e59e26a64dca------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*am09p5C4KuYMOi4GGd3yLQ.jpeg</url>
            <title>Stories by Fernanda on Medium</title>
            <link>https://medium.com/@fnandaleite?source=rss-e59e26a64dca------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 15:41:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@fnandaleite/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[Containers sem complicação: o que realmente importa]]></title>
            <link>https://medium.com/@fnandaleite/containers-sem-complica%C3%A7%C3%A3o-o-que-realmente-importa-59cbd2e1a55a?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/59cbd2e1a55a</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[máquina-virtual]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Mon, 20 Apr 2026 10:31:01 GMT</pubDate>
            <atom:updated>2026-04-20T10:31:01.400Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*piYuDpQHlVnLtLXmvwkxlw.png" /></figure><h3>O que é um container</h3><p>Um container é uma unidade de software padronizada, uma espécie de “grande caixa” com o código e todas as dependências necessárias para executá-lo.</p><p>Por exemplo, se você construiu uma aplicação em Node.js, para que ela possa rodar, você também precisa do runtime do Node.js, baseado na engine V8 do Chrome, além de um sistema operacional que permita esse runtime funcionar.</p><p>Com isso, você forma uma unidade autossuficiente, que pode ser &quot;despachada&quot; para qualquer máquina de forma completa, dispensando a necessidade de instalação e configuração manual. O resultado é simples: sua aplicação passa a rodar da mesma forma em qualquer ambiente.</p><p>Mas além disso, existe outro problema que containers ajudam a resolver.</p><h3>O problema dos ambientes diferente</h3><p>O desenvolvimento moderno usa diferentes ambientes para a mesma aplicação. Temos ambientes de desenvolvimento, testes, produção, etc, e cada um deles irá rodar em uma máquina.</p><p>Imagine que sua aplicação Node está usando o módulo node:sqlite, adicionado na versão 22.5.0 do Node.</p><p>Se essa aplicação rodar na máquina de um servidor ou do colega de equipe está usando Node na versão 20, o código vai quebrar imediatamente com um erro de Module not found.</p><p>Agora imagine isso em projetos maiores, com dezenas de dependências, cada uma com sua própria versão. Basta apenas uma dessas dependências ter uma versão diferente, para que uma função ou módulo novo seja adicionado ou até deixe de existir.</p><p>Isso abre espaço para inconsistências nos times de desenvolvimento e muita perda de tempo, pois o erro não está na aplicação em si, mas no ambiente mal preparado. O container resolve esse problema ao garantir que todos estejam rodando exatamente o mesmo ambiente.</p><p>Isso se torna útil até para desenvolvedores independentes.</p><h3>Trabalhando em múltiplos projetos</h3><p>Em muitos momentos você irá trabalhar em mais de um projeto ao mesmo tempo, e talvez um deles necessite de Ruby 3.3 enquanto outro, por qualquer razão que seja, utiliza Ruby 2.7.</p><p>Você sempre pode mudar de versões manualmente, mas convenhamos, isso só cria trabalho extra e uma fonte constante de erro.</p><h3>Máquina virtuais</h3><p>O conceito de máquina virtual se assemelha bastante ao de containers. Isso faz com que algumas pessoas se perguntem se containers não seriam redundantes.</p><p>Máquinas virtuais criam ambientes isolados com seu próprio sistema operacional, rodando dentro de outra máquina.</p><p>Nesse novo ambiente, você pode instalar o que quiser, mantendo tudo isolado da máquina anfitriã.</p><p>Isso é parecido com o que containers fazem, encapsular um ambiente com tudo que a aplicação precisa para rodar.</p><p>Além disso, também é possível compartilhar essas configurações com outras pessoas, facilitando a reprodução do ambiente em outras máquinas.</p><p>No entanto, máquinas virtuais também trazem alguns problemas.</p><h4>Sobrecarga de recursos</h4><p>O principal deles é a sobrecarga gerada pelos sistemas operacionais das máquinas virtuais.</p><p>Isso porque cada máquina virtual é, na prática, um computador inteiro rodando em cima de outro computador.</p><p>Se precisarmos de várias máquinas virtuais para rodar diferentes projetos, isso irá gerar um enorme consumo de recursos, como memória, armazenamento e poder de processamento, causando lentidão.</p><h4>Complexidade de configuração</h4><p>A configuração de máquinas virtuais também pode ser um ponto de atrito.</p><p>Mesmo com ferramentas de automação como Vagrant, Terraform e Ansible, configurar máquinas virtuais ainda tende a ser mais trabalhoso do que deveria.</p><p>Elas são mais lentas para subir, mais pesadas e exigem mais esforço para manter.</p><h3>Diferenciais dos Containers</h3><p>O grande diferencial dos containers é a economia de recursos.</p><p>Eles ainda rodam em cima do sistema operacional da máquina anfitriã, mas, em vez de criar um novo sistema operacional completo como uma máquina virtual, utilizam recursos do próprio sistema para isolar a aplicação.</p><p>Isso significa que múltiplos containers podem rodar ao mesmo tempo compartilhando o mesmo sistema operacional, com baixo consumo de recursos, inicialização rápida e pouco uso de espaço em disco.</p><p>O Docker se apoia nisso para criar e gerenciar containers, sendo responsável por instanciar e executar cada um deles.</p><h3>Imagens</h3><p>Além disso, ao criar imagens, você consegue empacotar sua aplicação junto com todas as suas dependências e nada além disso. Isso facilita o compartilhamento e garante que tudo funcione da mesma forma em qualquer ambiente.</p><p>Diferente das máquinas virtuais, que precisam incluir um sistema operacional completo, os containers focam apenas no que é necessário para rodar a aplicação.</p><p>Quando o objetivo é simplicidade, leveza e consistência, o container se torna uma solução muito mais prática.</p><h3>Conclusão</h3><p>Containers não surgiram para substituir máquinas virtuais, mas para resolver um problema diferente.</p><p>Eles trazem uma forma mais leve, rápida e previsível de rodar aplicações, eliminando boa parte das inconsistências de ambiente que ainda são comuns no desenvolvimento.</p><p>E é justamente essa simplicidade que faz deles uma peça fundamental no desenvolvimento moderno.</p><p>No próximo artigo, vamos sair da teoria e colocar isso em prática com o Docker.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=59cbd2e1a55a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como evoluir sistemas sem parar tudo]]></title>
            <link>https://medium.com/@fnandaleite/como-evoluir-sistemas-sem-parar-tudo-87a82c10bdf2?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/87a82c10bdf2</guid>
            <category><![CDATA[sofware-development]]></category>
            <category><![CDATA[software-evolution]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[tech-debt]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Mon, 08 Sep 2025 21:19:07 GMT</pubDate>
            <atom:updated>2025-09-08T21:19:07.746Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Incremento contínuo, dívida técnica e como planejar melhorias sem travar entregas.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HYNskoUelboJAoz-AD-P3w.jpeg" /></figure><p>Todo sistema com algum tempo de vida tem dois lados: o que já funciona e o que precisa melhorar. Equilibrar evolução com entregas é uma das tarefas mais difíceis e mais importantes de qualquer time técnico.</p><p>Este artigo é sobre como melhorar um sistema em produção <em>sem precisar parar tudo</em> nem cair no extremo de empurrar a bagunça com a barriga.</p><h3>Dívida técnica não é falha de caráter</h3><p>Antes de tudo: acumular dívida técnica não é um pecado. Às vezes, foi a escolha certa para entregar no prazo. Outras vezes, ela veio porque não sabíamos ainda o suficiente sobre o problema.</p><p>O que importa é como o time lida com essa dívida depois que ela é percebida. Deixar a dívida crescer sem controle vira um problema real: código mais difícil de manter, novos bugs, tempo de onboarding dobrado.</p><h3>Evoluir sem travar</h3><p>Você não precisa “parar tudo” para resolver as coisas. Melhorias técnicas podem, e devem, ser tratadas como entregas incrementais. Aqui vão práticas que ajudam a avançar:</p><h4>1. Melhoria acoplada a tarefas de produto</h4><p>Vai mexer numa tela? Pode ser o momento ideal pra simplificar um componente inchado.</p><p>Vai alterar uma API? Que tal normalizar os parâmetros ou remover duplicações antigas?</p><p>Esse tipo de melhoria localizada é uma forma leve e realista de evoluir sem frear o time.</p><h4>2. Issues técnicas visíveis e priorizadas</h4><p>Dívida técnica que não é registrada vira dívida esquecida. Crie tarefas claras, com contexto, e leve para a priorização junto com as demais.</p><p>Mesmo que algumas fiquem pro backlog, isso mostra que o time está cuidando do sistema com responsabilidade.</p><h4>3. Refatorações pequenas e seguras</h4><p>“Vamos reescrever tudo” costuma ser o começo do caos. Grandes reescritas parecem tentadoras, mas quase sempre são arriscadas e custosas. Refatorar não é destruir para reconstruir… é transformar com cuidado.</p><p>Prefira mudanças incrementais:</p><ul><li>Quebre a melhoria em partes menores.</li><li>Escreva testes que validem o comportamento atual.</li><li>Faça deploys pequenos e reversíveis.</li></ul><p>Com essa abordagem, você melhora sem travar e evita o risco de uma reescrita que nunca termina.</p><h3>Planejamento técnico é trabalho estratégico</h3><p>É comum deixar melhorias de lado com o argumento de que “não dá tempo”. Mas um bom planejamento técnico reduz bugs, melhora a velocidade de entrega e dá longevidade ao sistema.</p><p>Se o time se envolve nas decisões técnicas desde o planejamento, é mais fácil:</p><ul><li>Prever riscos e dependências</li><li>Negociar escopo de forma responsável</li><li>Reservar espaço real para melhorias</li></ul><p>Planejar não é burocracia. É maturidade técnica.</p><h3>Qualidade vem da consistência, não da revolução</h3><p>Evoluir um sistema não é sobre fazer uma grande virada. É sobre dar passos consistentes, conscientes, e que respeitam a realidade do time e do produto.</p><p>O que dá certo no longo prazo é o trabalho cuidadoso, visível e sustentado, aquele que entrega valor enquanto mantém a base saudável.</p><h3>Mini guia de priorização de melhorias técnicas</h3><pre># Mini guia: como priorizar melhorias técnicas<br><br>Nem toda melhoria técnica precisa ser feita agora, mas nenhuma deve ser esquecida.  <br>Este guia rápido ajuda seu time a decidir o que priorizar.<br><br>---<br><br>## 1. Qual o impacto desta melhoria?<br><br>- Afeta diretamente a produtividade do time? (ex: build lento, testes quebrando, onboarding difícil)<br>- Previne bugs frequentes?<br>- Facilita entregas de produto que estão no roadmap?<br><br>**Quanto mais impacto claro e imediato, maior a prioridade.**<br><br>---<br><br>## 2. Qual o custo de não fazer?<br><br>- O código vai piorar com o tempo?<br>- Vai ser mais caro corrigir depois?<br>- Está bloqueando ou atrasando entregas?<br><br>**Custo de inação alto = sinal de urgência.**<br><br>---<br><br>## 3. É possível fazer de forma incremental?<br><br>- Podemos quebrar em etapas pequenas?<br>- Dá para acoplar a entregas de produto?<br><br>**Se sim, vale encaixar mesmo sem dedicar um ciclo inteiro.**<br><br>---<br><br>## 4. Existe contexto suficiente para agir agora?<br><br>- Sabemos o suficiente para começar?<br>- Precisamos investigar mais antes?<br><br>**Evite “refatorar por refatorar”. Clareza evita retrabalho.**<br><br>---<br><br>## Dica final<br><br>📌 Mantenha um board visível com as melhorias técnicas.  <br>📌 Atualize o impacto esperado.  <br>📌 Trate isso como parte da estratégia do time, não como &quot;tarefas paralelas&quot;.</pre><h3>Este artigo faz parte da série Engenharia de Software na Vida Real</h3><p>Uma coleção de textos curtos, práticos e sinceros sobre qualidade, processos, cultura de time e melhorias sustentáveis.<br>Se você gostou, talvez curta também:</p><ul><li><a href="https://medium.com/URL">Documentar de forma útil (e sem virar burocrata)</a></li><li><a href="https://medium.com/URL">Refatorar com segurança (e apoio do time)</a></li><li><a href="https://medium.com/URL">Workflows que funcionam de verdade</a></li></ul><p>Você pode seguir a tag da série ou salvar este artigo para ler de novo quando bater aquele caos no código.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=87a82c10bdf2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Workflows que funcionam de verdade]]></title>
            <link>https://medium.com/@fnandaleite/workflows-que-funcionam-de-verdade-824ad446df64?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/824ad446df64</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[workflow]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Mon, 01 Sep 2025 10:37:36 GMT</pubDate>
            <atom:updated>2025-09-01T10:37:36.152Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Do caos ao fluxo: como processos simples ajudam a ganhar produtividade sem engessar.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x14ZBUijp-rHnkUDu263Sw.jpeg" /></figure><p>Nem todo time começa com processos claros. E mesmo os que têm, muitas vezes acumulam regras, rituais e etapas que serviram em algum momento… mas que hoje mais atrapalham do que ajudam.</p><p>Fluxo não é rigidez. É clareza.</p><p>E quando o time tem clareza sobre como o trabalho anda, tudo melhora: a colaboração, a produtividade, a confiança mútua e até a saúde mental.</p><h3>Processo bom é processo que resolve problema real</h3><p>Não adianta copiar modelos de grandes empresas, ou seguir fórmulas “ágil raiz” se isso não conversa com a sua realidade. Antes de propor qualquer mudança de fluxo, vale se perguntar:</p><ul><li>Onde o time está perdendo tempo?</li><li>Onde há retrabalho ou desalinhamento?</li><li>Onde surgem mais frustrações ou conflitos?</li></ul><p>Um bom workflow responde a esses pontos com soluções simples. Por exemplo:</p><ul><li>O time está perdido sobre prioridades? Use um board visual claro (Kanban, Linear, Notion, qualquer um) com poucos estados e responsáveis definidos.</li><li>Há muito retrabalho por causa de escopos mal entendidos? Comece cada tarefa com uma descrição clara sobre “o que” e “o porquê”.</li><li>Pull Requests demoram dias pra serem revisados? Combine revisões em horários fixos ou adote pares rotativos para revisão leve e rápida.</li></ul><h3>Regras mínimas, alinhamento máximo</h3><p>Processos são acordos. E quanto mais leves forem, mais fácil mantê-los vivos. Algumas regras mínimas que tendem a funcionar bem:</p><ul><li><strong>Toda tarefa deve começar com contexto claro.</strong> Isso evita suposições e acelera a execução.</li><li><strong>Toda entrega deve ser revisada por alguém.</strong> Code review não é burocracia, é conversa.</li><li><strong>Toda semana deve ter um momento de alinhamento.</strong> Pode ser 30 minutos pra falar sobre o que está indo bem e o que pode melhorar. Não precisa virar uma cerimônia fixa.</li></ul><p>O segredo está em manter esses rituais mínimos e ajustá-los com o time, sem culpa de mudar, simplificar ou até abandonar algo que não está mais funcionando.</p><h3>O que ajuda o fluxo (sem pesar o time)</h3><p>Algumas práticas simples que já vi fazerem diferença real:</p><ul><li><strong>Uso de etiquetas (tags) com significado real</strong> . Exemplo: bug, ajuda necessária, esperando decisão, etc. Essas tags facilitam triagens, filtros e priorização.</li><li><strong>Checklist de PR enxuto. </strong>Lembrar de testes, revisão de segurança, impacto em performance, etc.</li></ul><pre>- [ ] Testes manuais realizados (ou motivo para não testar)<br>- [ ] Testes automatizados cobrindo o que foi alterado<br>- [ ] Impacto em performance considerado<br>- [ ] Segurança: dados sensíveis, permissões ou autenticação verificados<br>- [ ] Documentação atualizada (README, comentários, changelog)<br>- [ ] Código compreensível e revisado</pre><ul><li><strong>Registro de aprendizados</strong>. Cada tarefa pode gerar uma pequena anotação que melhora o próximo ciclo. Pode ser no commit message, Slack ou Notion. Exemplo:<em>[#ticket-9823] Ao integrar com a API X, descobrimos que o campo user_id pode ser nulo em algumas situações. Adicionamos uma validação. Isso evita erro 500 em produção.</em></li></ul><h3>Evite o culto à produtividade</h3><p>Times que buscam fluxo constante podem cair na armadilha da pressa sem propósito: muita entrega, pouco valor. Ou pior: entrega rápida com dívida técnica crescente!</p><p>Por isso, manter um workflow saudável significa que o time é capaz de:</p><ul><li>Saber dizer não pra tarefas mal pensadas</li><li>Reservar tempo para melhorias técnicas e refatorações</li><li>Proteger o foco coletivo: menos interrupções, mais respeito ao deep work</li></ul><p>Workflow saudável é aquele em que o time sabe onde está, o que importa agora, e tem espaço para evoluir junto.</p><h3>Este artigo faz parte da série</h3><p><a href="https://medium.com/@fnandaleite/engenharia-de-software-no-mundo-real-quando-o-ideal-encontra-o-poss%C3%ADvel-1fcb9718d168"><strong>Engenharia de Software no mundo real</strong></a><br>Uma sequência de textos sobre código, times e decisões técnicas com impacto real. Se você está acompanhando a série, fique por perto: o próximo artigo fecha o ciclo e amarra todos os aprendizados.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=824ad446df64" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testes automatizados na prática]]></title>
            <link>https://medium.com/@fnandaleite/testes-automatizados-na-pr%C3%A1tica-cfae19832440?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/cfae19832440</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[automation-testing]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Mon, 28 Jul 2025 22:56:34 GMT</pubDate>
            <atom:updated>2025-07-28T22:56:34.339Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Como decidir o que testar, evitar sobrecarga de testes e garantir que eles realmente agreguem valor.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*G5dWskquTKfitaLuMP5oUg.jpeg" /></figure><h3>Testar é sobre confiança — não obsessão</h3><p>Testes não servem para encher cobertura. Servem para que você durma tranquilo depois de um deploy.</p><p>Mesmo assim, é comum ver dois extremos:</p><ul><li>Times que evitam escrever testes porque “dá muito trabalho”.</li><li>Times que testam tudo, mas não conseguem manter nem entender os próprios testes.</li></ul><p>Ambos acabam no mesmo lugar: <strong>sem confiança</strong>.</p><p>A chave está no equilíbrio. E isso exige uma pergunta honesta, feita várias vezes ao longo do trabalho:</p><blockquote><strong><em>Esse teste vai realmente ajudar alguém a confiar mais nesse código?</em></strong></blockquote><h3>O que vale a pena testar e o que você pode (sim) deixar passar</h3><p>Testes são investimentos. E todo investimento tem custo e retorno.<br>Por isso, vale priorizar:</p><ul><li><strong>Fluxos críticos</strong>: pagamentos, login, cálculos, autorizações.</li><li><strong>Regras de negócio não óbvias</strong>: o que só vive na cabeça de alguém do time.</li><li><strong>Integrações com sistemas externos</strong>: porque o que está fora do seu controle pode mudar sem aviso.</li></ul><p>Por outro lado, vale o desapego em:</p><ul><li>Código muito simples e puro (ex: funções utilitárias triviais).</li><li>Comportamentos transitórios que mudam o tempo todo.</li><li>Testes duplicados que só tornam a suite mais lenta.</li></ul><p><strong>Nem todo código precisa de teste. Mas o código que importa precisa de testes bons.</strong></p><h3>Evite os testes que não testam nada</h3><p>Alguns testes existem só pra “cumprir tabela”. Mas não protegem ninguém.</p><p>Exemplos comuns:</p><ul><li>Testes que só verificam se um componente renderiza.</li><li>Testes que apenas espelham a implementação, linha por linha.</li><li>Testes que passam mesmo se você quebrar o código de propósito.</li></ul><p>Esses testes não aumentam a confiança. Pior: viram ruído e manutenção desnecessária.</p><p>Prefira testes que capturam <strong>comportamento esperado</strong>, não implementação interna.</p><h3>Como começar uma cultura de testes, na prática</h3><p>Você não precisa escrever testes pra tudo amanhã. Pode começar assim:</p><ul><li>Sempre que corrigir um bug, escreva um teste que impediria ele de voltar.</li><li>Em novas features, escreva pelo menos um teste para o fluxo principal e um para casos de erro.</li><li>Quando revisar Pull Requests, valorize bons testes tanto quanto bom código.</li><li>Comemore coberturas parciais, mas úteis. Você não precisa de 100%.</li></ul><p><strong>Testes não são só sobre ferramentas. São sobre hábito.</strong></p><h3>E se o sistema for um caos sem teste nenhum?</h3><p>Ainda dá pra melhorar. Comece devagar:</p><ul><li>Escreva <strong>testes de caracterização</strong> para códigos que você precisa refatorar. Eles garantem que o comportamento atual (mesmo esquisito) continue funcionando.</li><li>Use <strong>testes de integração simples</strong> nas partes mais críticas.</li><li>Automatize testes de <strong>contrato de APIs</strong>.</li><li>Adicione <strong>logs claros</strong> para validar comportamentos em produção.</li></ul><p>Com o tempo, esses testes viram base para melhorar o sistema sem medo.</p><h3>Testar bem é um ato de cuidado</h3><p>Testes bons não são aqueles que testam tudo. São os que protegem o que mais importa, com clareza e leveza. Você não precisa ser purista, mas precisa ser estratégico.</p><p><strong>Boas decisões sobre testes não nascem de regras fixas., nascem de maturidade técnica e prioridade real.</strong></p><h3>Material extra: Checklist prático</h3><p><strong>Testes úteis x testes inúteis</strong></p><pre># Checklist: Testes úteis x Testes inúteis<br><br>## Testes úteis (vale manter e incentivar):<br>- [ ] Cobre fluxos críticos do sistema (ex: pagamento, login, autorização)<br>- [ ] Valida regras de negócio importantes e não óbvias<br>- [ ] Garante a comunicação entre sistemas (ex: APIs, filas, banco de dados)<br>- [ ] Quebra se um bug antigo reaparecer<br>- [ ] Verifica comportamento, não implementação<br>- [ ] É fácil de entender e dá confiança ao time<br>- [ ] Funciona como documentação viva do sistema<br><br>## Testes inúteis (evite ou reescreva):<br>- [ ] Só verifica se um componente renderiza sem erro<br>- [ ] Reproduz a implementação linha por linha<br>- [ ] Passa mesmo se o código estiver quebrado<br>- [ ] É tão frágil que quebra por qualquer detalhe visual ou estrutural<br>- [ ] Ninguém sabe o que exatamente está testando<br>- [ ] É redundante com outros testes mais relevantes</pre><p>Este artigo faz parte da série <strong>Engenharia de Software no mundo real.</strong> Uma sequência de textos sobre código, times e decisões técnicas com impacto real. Se você está gostando da série, siga aqui no Medium para receber os próximos artigos. Compartilhar com colegas também ajuda a manter essa conversa viva dentro dos times.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cfae19832440" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Qualidade de software vai além dos testes]]></title>
            <link>https://medium.com/@fnandaleite/qualidade-de-software-vai-al%C3%A9m-dos-testes-667bc05a8c82?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/667bc05a8c82</guid>
            <category><![CDATA[culture-development]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Thu, 10 Jul 2025 01:20:08 GMT</pubDate>
            <atom:updated>2025-07-10T21:29:35.020Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Como pensar qualidade como cultura, desde o planejamento até a entrega.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A03OXkariYJPn10wDBgyuw.png" /></figure><p>Quando a gente fala de qualidade de software, é comum que a primeira imagem seja a de testes automatizados. Eles são importantes, sem dúvida. Mas se limitar a isso é como achar que a segurança de um carro depende só do airbag.</p><p>Qualidade de verdade começa antes da primeira linha de código — e continua muito depois do deploy. Ela está na clareza do problema que queremos resolver. Na comunicação entre as pessoas envolvidas. Nas decisões que tomamos, mesmo sob pressão.</p><h3>Qualidade é uma cultura, não um checklist</h3><p>Num time maduro, qualidade é responsabilidade de todos — e aparece em pequenos hábitos:</p><ul><li>Fazer perguntas no início do planejamento, para evitar retrabalho depois.</li><li>Escolher nomes claros para variáveis, funções e commits.</li><li>Escrever código fácil de entender (inclusive para o seu “eu” de daqui a 3 meses).</li><li>Revisar código pensando em impacto, e não só em estilo.</li><li>Evitar soluções “rápidas e sujas” que viram dívida eterna.</li></ul><h3>Boas decisões técnicas também são sobre qualidade</h3><p>Muita gente acha que qualidade só aparece quando temos tempo. Mas, na real, boas práticas podem <em>salvar</em> tempo. Refatorar uma função confusa, documentar uma decisão, automatizar um teste crítico — tudo isso reduz o risco de bugs e economiza horas de suporte no futuro.</p><h3>E o que você pode fazer, na prática?</h3><p>Aqui vão algumas ideias simples, aplicáveis mesmo em contextos apertados:</p><ul><li><strong>Durante o planejamento:</strong> pergunte <em>“como vamos saber que isso deu certo?”</em>. Essa pergunta já aponta para critérios de qualidade.</li><li><strong>Durante o desenvolvimento:</strong> adicione logs úteis, trate erros com cuidado e evite espalhar suposições não validadas.</li><li><strong>Na entrega:</strong> teste como um usuário. Pense em fluxos quebrados, dados inesperados, falhas de conexão. Não espere que o QA descubra tudo.</li><li><strong>Depois do deploy:</strong> monitore e esteja aberto a feedback. Corrigir rápido também é qualidade.</li></ul><h3>Qualidade se constrói em camadas</h3><p>Ela não vem de um único esforço heroico. Vem de muitos pequenos atos, consistentes. E sim — isso exige cultura, não só ferramentas</p><p>Cada melhoria local que você faz, cada ponto de atenção que você compartilha, cada pedaço de código que você deixa mais claro — tudo isso conta. Mesmo que ninguém veja. Mesmo que pareça pequeno.</p><p>E, mais importante: qualidade é contagiosa.<br> Quando você se importa, outras pessoas percebem.<br> Quando você explica o “porquê” de uma decisão, ensina.<br> Quando você cuida de um código que nem é seu, mostra maturidade.</p><p>É assim que nasce a cultura: no exemplo, na repetição, na confiança.</p><p>Qualidade, no fim, é sobre isso: cuidado com as pessoas que vão usar, manter, ou depender do que você constrói.</p><p><strong>Esse artigo faz parte da série “Engenharia de Software no mundo real”.</strong><br> Se você gostou, tem mais vindo aí. E se ainda não leu, recomendo:<br> 📌 <em>“</em><a href="https://medium.com/@fnandaleite/refatorar-com-seguran%C3%A7a-e-apoio-do-time-94dede1e6ce1"><em>Refatorar com segurança (e apoio do time)</em></a><em>”</em><br> 📌 <em>“</em><a href="https://medium.com/@fnandaleite/como-entender-sistemas-grandes-sem-enlouquecer-3a8b10cf5b3b"><em>Como entender sistemas grandes sem enlouquecer</em></a><em>”</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=667bc05a8c82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Documentar de forma útil (e sem virar burocrata)]]></title>
            <link>https://medium.com/@fnandaleite/documentar-de-forma-%C3%BAtil-e-sem-virar-burocrata-8e4161516c82?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/8e4161516c82</guid>
            <category><![CDATA[ágil]]></category>
            <category><![CDATA[documentação]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Mon, 30 Jun 2025 14:56:43 GMT</pubDate>
            <atom:updated>2025-07-03T03:01:05.908Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Menos formalismo, mais clareza. Como deixar rastros que ajudam em vez de atrapalhar</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*drbfEbnVXSdB23rxCOxSYQ.png" /></figure><blockquote><em>“Documentar é como plantar placas de sinalização no caminho — não precisa explicar a estrada inteira, mas deve evitar que o próximo caia no mesmo buraco.”</em></blockquote><h3>1. Documentação não é tarefa extra, é parte do trabalho</h3><p>Muita gente ainda vê documentação como “coisa chata” ou “algo que vou fazer depois” (e esse depois raramente chega). Mas documentar não é sobre criar PDFs perfeitos, e sim sobre <strong>deixar rastros úteis</strong>: decisões que você tomou, caminhos que testou, armadilhas que descobriu.</p><p>Se a pessoa que vier depois conseguir entender algo <strong>sem te chamar no chat</strong>, isso já é um sucesso.</p><h3>O que realmente precisa ser documentado?</h3><p>Nem tudo merece virar doc. Mas alguns tipos de informação têm altíssimo retorno quando registrados:</p><ul><li><strong>Decisões técnicas. </strong>Por que escolhemos o caminho A e não o B? Quais trade-offs pesaram?</li><li><strong>Fluxos e integrações. </strong>Como os sistemas conversam entre si? O que quebra se esse endpoint mudar?</li><li><strong>Coisas que deram trabalho pra entender. </strong>Se você precisou cavar fundo pra descobrir algo, escreva. Vai poupar tempo de alguém (inclusive do seu futuro eu).</li></ul><h3>Formato importa menos do que clareza</h3><p>Não precisa seguir um template gigante. Às vezes um bom comentário no código, uma issue bem escrita ou uma página rápida no Notion resolvem mais do que um “documento oficial”.</p><p>O segredo é:<br><strong>→ Pense em quem vai ler.</strong><br>Use linguagem direta, exemplos, e explique como usar, quando usar, e o que evitar. Se possível, revise depois com os olhos de alguém que nunca viu aquilo antes.</p><h3>Como documentar sem burocracia</h3><p>Se você já passou por empresas onde tudo tinha que virar um artefato oficial, sabe como isso mata a motivação. O ideal é documentar <strong>no fluxo do trabalho</strong>:</p><ul><li>Terminou uma tarefa complexa? Comente direto no PR ou issue.</li><li>Fez uma descoberta importante? Anota num doc curto ou comenta no Slack, fixando pra consulta.</li><li>Criou uma lib interna? Escreva um README básico que ensine a usar, com exemplos reais.</li></ul><p>Não precisa ser bonito. Precisa ser encontrável e útil.</p><h3>O que você documenta hoje, você consulta amanhã</h3><p>Um efeito colateral poderoso de documentar com leveza: <strong>você passa a confiar mais no time e no processo</strong>. Porque ninguém precisa lembrar de tudo. Basta saber onde procurar.</p><p>É menos sobre ter tudo escrito, mais sobre não depender da memória oral do time.</p><p>Boa documentação não é um manual chato, é uma forma de cuidar do futuro. Do seu futuro, do seu time, e do sistema.</p><p>Este artigo faz parte da série <strong>“Engenharia de Software no mundo real”</strong>, que mostra os bastidores do código: os dilemas, atalhos, práticas e decisões que fazem diferença, mas nem sempre estão nos tutoriais.</p><p>👉 Se perdeu os anteriores, dá uma olhada:</p><ul><li><a href="#">Refatorar com segurança (e apoio do time)</a></li><li><a href="#">Comunicação em times de engenharia</a></li><li><a href="#">Como entender sistemas grandes sem enlouquecer</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8e4161516c82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Comunicação em times de engenharia]]></title>
            <link>https://medium.com/@fnandaleite/comunica%C3%A7%C3%A3o-em-times-de-engenharia-361e9c355f92?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/361e9c355f92</guid>
            <category><![CDATA[engenharia-de-software]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[comunicação]]></category>
            <category><![CDATA[programação]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Tue, 24 Jun 2025 00:16:39 GMT</pubDate>
            <atom:updated>2025-06-24T00:18:59.379Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Por que a qualidade do software depende tanto de conversas quanto de código.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6hjTgynHj2yHRE9H" /><figcaption>Photo by <a href="https://unsplash.com/@jasongoodman_youxventures?utm_source=medium&amp;utm_medium=referral">Jason Goodman</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Quem comunica, cuida do código</h3><p>Software é feito por pessoas. E onde há pessoas, há interpretações, decisões, falhas e entendimentos diferentes. Boas conversas, bem direcionadas, têm um impacto silencioso, mas profundo, na qualidade final de um sistema.</p><h3>Problemas técnicos que nascem da falta de conversa</h3><p>Talvez você já tenha vivido isso:</p><ul><li>Uma mesma feature implementada de dois jeitos diferentes em lugares distintos.</li><li>Um bug reintroduzido porque alguém não sabia que já tinha sido resolvido.</li><li>Refatorações desfeitas por falta de alinhamento com outras áreas.</li></ul><p>Quase sempre, não é má vontade. É falta de contexto. E contexto vem de conversas claras, frequentes e com espaço para dúvidas.</p><h3>Conversas que evitam retrabalho</h3><p>Algumas conversas simples, quando viram rotina, reduzem retrabalho e melhoram decisões:</p><ul><li><em>“Por que estamos fazendo isso?”</em> — antes de escrever código, entender a real motivação.</li><li><em>“Isso já foi tentado antes?”</em> — história do sistema vale ouro.</li><li><em>“Tem alguém que deveria opinar aqui?”</em> — envolver as pessoas certas evita retrabalho.</li></ul><h3>Feedback não é só pull request</h3><p>A revisão de código é importante — mas feedback técnico pode (e deve) acontecer antes do PR:</p><ul><li>Discutir abordagens em um doc ou chat técnico.</li><li>Validar suposições com o time.</li><li>Pedir ajuda pra quebrar problemas grandes.</li></ul><p>PRs longos com decisões solitárias tendem a gerar frustração ou atrasos. O código melhora quando as ideias circulam antes.</p><h3>Silêncio gera dívida</h3><p>A falta de comunicação cria outro tipo de débito: decisões não documentadas, contextos que se perdem, expectativas desalinhadas. Pode parecer “mais rápido” no curto prazo — mas é como pular testes: o problema vai aparecer, só que depois (e pior).</p><h3>Comunicar é parte do trabalho técnico</h3><p>Não é sobre virar a “pessoa comunicadora da squad”. É sobre ver a comunicação como uma ferramenta técnica. Quanto mais você compartilha e escuta, melhor se torna seu código, suas decisões e sua autonomia.</p><h3>Pequenos passos contam (e contam muito)</h3><p>Se comunicar melhor em times técnicos não significa virar extrovertido, falar o tempo todo ou se expor além do que faz sentido pra você. Comece pequeno, com gestos simples:</p><ul><li>Deixe claro quando você está com dúvida — isso é sinal de cuidado, não de fraqueza.</li><li>Prefira mensagens assíncronas se isso te dá mais conforto (Slack, comentários, docs).</li><li>Faça perguntas objetivas, como: <em>“Esse caminho faz sentido pra você?”</em> ou <em>“Existe algo que eu deveria saber antes de seguir?”</em></li><li>Combine sinais de disponibilidade com seu time (<em>“Estou de fone, mas é só chamar se precisar”</em>).</li><li>E se estiver inseguro, escreva antes de falar — isso ajuda a organizar ideias e dar mais clareza à conversa.</li></ul><p>Com o tempo, isso vira prática. Você vai perceber que não precisa se tornar outra pessoa para contribuir com mais impacto.</p><p>Este artigo faz parte da série <strong>“</strong><a href="https://medium.com/@fnandaleite/engenharia-de-software-no-mundo-real-quando-o-ideal-encontra-o-poss%C3%ADvel-1fcb9718d168"><strong>Engenharia de Software no mundo real</strong></a><strong>”</strong>, uma coletânea sobre o que não vem nos tutoriais — mas faz toda diferença na prática.</p><p>Se você curtiu, os artigos anteriores podem te interessar:</p><ul><li><a href="https://medium.com/@fnandaleite/boas-pr%C3%A1ticas-vs-vida-real-53aaec0e95d6"><strong>Boas práticas vs. vida real</strong></a><strong><br></strong><em>Por que nem sempre dá pra seguir o livro — e por que isso não significa desistir da qualidade.</em></li><li><a href="https://medium.com/@fnandaleite/como-entender-sistemas-grandes-sem-enlouquecer-3a8b10cf5b3b"><strong>Como entender sistemas grandes sem enlouquecer</strong></a><strong><br></strong><em>Técnicas práticas para navegar em código legado, sistemas sem documentação e arquiteturas confusas.</em></li><li><a href="https://medium.com/@fnandaleite/refatorar-com-seguran%C3%A7a-e-apoio-do-time-94dede1e6ce1"><strong>Refatorar com segurança (e apoio do time) </strong></a><strong><br></strong><em>Como propor melhorias sem causar pânico — e como ganhar confiança técnica e política.</em></li></ul><p>E vem mais por aí:</p><ul><li><strong>Documentar de forma útil (e sem virar burocrata)<br></strong><em>Menos formalismo, mais clareza — como deixar rastros que ajudam em vez de atrapalhar.</em></li><li><strong>Qualidade de software vai além dos testes</strong><br> <em>Como pensar qualidade como cultura, desde o planejamento até a entrega.</em></li><li><strong>Testes automatizados na prática</strong><br><em>Como decidir o que testar, evitar sobrecarga de testes e garantir que eles realmente agreguem valor.</em></li><li><strong>Workflows que funcionam de verdade</strong><br> <em>Do caos ao fluxo: como processos simples ajudam a ganhar produtividade sem engessar.</em></li><li><strong>Como evoluir sistemas sem parar tudo</strong><br> <em>Incremento contínuo, dívida técnica e como planejar melhorias sem travar entregas.</em></li></ul><p>Se quiser acompanhar, me siga aqui no Medium ou se inscreva para receber atualizações.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=361e9c355f92" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Refatorar com segurança (e apoio do time)]]></title>
            <link>https://medium.com/@fnandaleite/refatorar-com-seguran%C3%A7a-e-apoio-do-time-94dede1e6ce1?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/94dede1e6ce1</guid>
            <category><![CDATA[testes-automatizados]]></category>
            <category><![CDATA[refatoração]]></category>
            <category><![CDATA[testes-de-software]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[engenharia-de-software]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Fri, 13 Jun 2025 18:24:28 GMT</pubDate>
            <atom:updated>2026-04-19T00:49:10.075Z</atom:updated>
            <content:encoded><![CDATA[<h3>Refatorar código sem quebrar tudo (e sem comprar briga com o time)</h3><p><em>Como propor melhorias sem causar pânico, e como ganhar confiança técnica e política</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IZ_8kog8Ip4wWF69aJMwZg.jpeg" /></figure><p>Refatorar é uma palavra poderosa. Ela pode despertar entusiasmo em quem vê o potencial de melhoria ou causar calafrios em quem já sofreu com quebras inesperadas.</p><p>Se você já propôs uma mudança “simples” e ouviu um “melhor não mexer nisso agora”, sabe do que estou falando. Refatorar com segurança vai além de código limpo. O mais importante é saber quando, como e o que mudar.</p><h3>O primeiro passo: ganhar contexto</h3><p>Antes de propor qualquer refatoração, entenda profundamente o sistema. Não se trata de sair caçando “código feio”, mas de entender o que realmente prejudica:</p><ul><li>Onde estão os pontos de dor do time?</li><li>Que bugs se repetem?</li><li>O que é difícil de dar manutenção?</li></ul><p>Mapeie esses pontos e vá conectando os porquês. Melhorias relevantes são aquelas que resolvem problemas reais, não só estéticos.</p><h3>Refatoração não é um evento, é uma rotina</h3><p>Em vez de propor grandes reescritas (que raramente são aprovadas), pense em<strong> mudança pequena e frequente</strong>:</p><ul><li>Comece com uma melhoria dentro de uma feature nova.</li><li>Ou extraia aquela função que já estava ilegível.</li><li>Ou isole um comportamento em um módulo mais reutilizável.</li></ul><p>Pequenas refatorações contínuas geram confiança. Elas mostram que dá pra melhorar <strong>sem travar o time</strong> nem criar riscos desnecessários.</p><h3>Ganhar confiança técnica e política</h3><p>Para ter liberdade de refatorar, você precisa de duas coisas:</p><ol><li><strong>Provar que você entende o sistema.</strong></li><li><strong>Mostrar que suas mudanças agregam valor.</strong></li></ol><p>Seus colegas e líderes não têm medo de refatorações, eles têm medo de instabilidade. Quando você mostra que entende o impacto do que está propondo (e se responsabiliza por isso), começa a se tornar uma referência confiável. É aí que o apoio começa a vir.</p><p>E quando você envolve outras pessoas, em vez de decidir tudo sozinho, ganha ainda mais força. Refatorações discutidas e planejadas em grupo são mais difíceis de barrar e mais fáceis de manter.</p><h3>Segurança vem da cobertura</h3><p>Não dá pra falar de refatorar com segurança sem falar de testes. Se o sistema já tem testes confiáveis, maravilha. Se não tem, comece aos poucos:</p><ul><li><strong>Testes de integração nas partes críticas: </strong>como fluxos de pagamento, autenticação ou regras de negócio essenciais. Isso garante que você não quebrou o que é vital.</li><li><strong>Testes de contrato em APIs: </strong>mesmo que simples, ajudam a validar que inputs e outputs continuam consistentes em endpoints internos ou externos.</li><li><strong>Logs e monitoramento para validar comportamentos: </strong>use logs explícitos e métricas para detectar comportamentos inesperados logo após uma mudança.</li><li><strong>Antes de refatorar, escreva testes de caracterização: </strong>eles registram o comportamento atual de um código estranho, ajudando você a saber se “quebrou algo” ao mudar a implementação.</li></ul><p>Quanto mais suporte o sistema te dá, mais livre (e confiante) você fica pra melhorar.</p><h3>Quando a refatoração é um investimento</h3><p>Refatorar dá trabalho. Mas <em>não refatorar</em> também. A dívida técnica cresce, o time desacelera, bugs aumentam. A diferença é que o custo da refatoração é visível e o da estagnação, silencioso.</p><p>Se você quiser que uma melhoria seja aprovada, mostre o retorno.</p><ul><li>Vai reduzir retrabalho?</li><li>Vai permitir mais testes?</li><li>Vai facilitar o onboarding?</li><li>Vai destravar uma feature que hoje é impossível?</li></ul><p>Você não precisa buscar perfeição. O foco é sempre demonstrar que vale a pena.</p><h3>Conclusão: melhorar é uma construção coletiva</h3><p>Refatorar com segurança é, antes de tudo, um trabalho de escuta, contexto e conexão.</p><p>É sobre evoluir sistemas enquanto cuida das pessoas que trabalham com eles. E com o tempo, essas pequenas melhorias viram cultura.</p><blockquote>Este artigo faz parte de uma série sobre Engenharia de Software no mundo real. Nos próximos, vou falar sobre testes automatizados, sistemas legados, e como manter a qualidade viva mesmo em times com pressa.</blockquote><blockquote>Se quiser acompanhar, me siga aqui no Medium ou se inscreva para receber atualizações.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94dede1e6ce1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como entender sistemas grandes sem enlouquecer]]></title>
            <link>https://medium.com/@fnandaleite/como-entender-sistemas-grandes-sem-enlouquecer-3a8b10cf5b3b?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a8b10cf5b3b</guid>
            <category><![CDATA[big-tech]]></category>
            <category><![CDATA[desenvolvimento]]></category>
            <category><![CDATA[engenharia-de-software]]></category>
            <category><![CDATA[repositórios]]></category>
            <category><![CDATA[sistemas]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Thu, 05 Jun 2025 16:06:20 GMT</pubDate>
            <atom:updated>2025-06-05T16:06:20.839Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Técnicas práticas para navegar em código legado, sistemas sem documentação e arquiteturas confusas.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*l0KlX6GrMmKq6HcD" /><figcaption>Photo by <a href="https://unsplash.com/@lukechesser?utm_source=medium&amp;utm_medium=referral">Luke Chesser</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>O baque do primeiro contato.</p><p>Você abre o repositório. O número de arquivos intimida. As camadas parecem confusas. O código tem referências cruzadas que não fazem sentido ainda. Você navega um pouco, acha algo familiar… mas logo se perde de novo. E começa a se perguntar: <strong>“Como alguém entende isso tudo?”</strong></p><p>Respira. A verdade é que ninguém entende um sistema grande de uma vez só — nem mesmo quem escreveu ele.</p><h3>Desmistificando a ideia de “entender tudo”</h3><p>Se você acha que precisa entender 100% do sistema para começar a contribuir, está se colocando uma meta inalcançável.<br>Em sistemas grandes, não existe um “mapa completo” na mente de ninguém. O que existe são <strong>estratégias de navegação</strong> e <strong>pontos de apoio</strong>, que com o tempo formam um entendimento funcional — o suficiente para tomar boas decisões e seguir em frente.</p><p>A chave é substituir a ansiedade de entender tudo pela curiosidade de entender <strong>o necessário, com profundidade, no momento certo</strong>.</p><h3>Crie seus próprios mapas mentais</h3><p>Ao explorar um sistema grande, comece identificando <strong>pontos de entrada e saídas claras</strong>: APIs, interfaces, comandos CLI, páginas principais, ou fluxos recorrentes. Escolha uma funcionalidade central e trace o caminho que ela percorre no código.</p><p>💡 <em>Dica prática:</em><br> Crie seus próprios diagramas simples, mesmo que à mão. Anote dependências, nomes de arquivos, nomes de funções. Essas anotações viram seus mapas pessoais — que você vai revisar, corrigir e expandir com o tempo.</p><h3>Ferramentas e técnicas de sobrevivência</h3><p>Alguns recursos técnicos ajudam demais a explorar sistemas desconhecidos:</p><ul><li><strong>git blame</strong>: para descobrir quem escreveu cada parte e quando — pode indicar contexto, decisões e até bugs antigos.</li><li><strong>Logs de produção</strong> (ou de ambiente local): revelam o que de fato está em execução.</li><li><strong>Breakpoints e debuggers</strong>: nada como ver o sistema rodando passo a passo.</li><li><strong>Análise por chamadas</strong>: comece com a interface ou endpoint e vá seguindo o caminho.</li><li><strong>Busca por palavras-chave</strong>: às vezes, buscar por um termo exato (como uma label de UI ou nome de tabela) economiza muito tempo.</li></ul><p>💡 <em>Dica prática:</em> Use extensões no seu editor (como “Code Outline”, “Structure”, ou navegadores de dependências) para facilitar o rastreio de funções e arquivos.</p><h3>Não tente entender tudo sozinho</h3><p>Você não precisa, nem deve, decifrar tudo no isolamento. Perguntar com inteligência é uma habilidade valiosa: antes de acionar alguém, tente formular sua dúvida com clareza. Traga trechos de código, suposições, e mostre o que já investigou. Isso demonstra comprometimento — e tende a gerar conversas ricas.</p><blockquote>💬 Uma boa pergunta pode render uma explicação, um atalho ou até uma melhoria no sistema que ninguém havia priorizado.</blockquote><h3>Conclusão — Entender é um processo, não um requisito inicial</h3><p>Entender um sistema grande é como explorar uma cidade nova: você começa pelo bairro onde vai trabalhar, aprende os caminhos principais, e com o tempo, descobre os atalhos.<br>Cada pull request, cada conversa, cada bug resolvido vira mais um pedaço do mapa.</p><p>Você não precisa esperar entender tudo para contribuir com algo de valor.<br>Você só precisa dar o primeiro passo com foco, estratégia — e paciência.</p><h3>Próximos passos?</h3><p>Se esse tema te interessa, fique por perto. Em breve, vou compartilhar um guia gratuito com técnicas e templates para navegar sistemas complexos com mais confiança — seja você dev pleno, sênior ou tech lead.</p><p>🔁 E se você ainda não leu, o primeiro artigo da série fala sobre como adaptar boas práticas à vida real sem abrir mão da qualidade.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a8b10cf5b3b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Boas práticas vs. vida real]]></title>
            <link>https://medium.com/@fnandaleite/boas-pr%C3%A1ticas-vs-vida-real-53aaec0e95d6?source=rss-e59e26a64dca------2</link>
            <guid isPermaLink="false">https://medium.com/p/53aaec0e95d6</guid>
            <category><![CDATA[software]]></category>
            <category><![CDATA[vida-real]]></category>
            <category><![CDATA[engenharia]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[boas-práticas]]></category>
            <dc:creator><![CDATA[Fernanda]]></dc:creator>
            <pubDate>Sat, 31 May 2025 15:28:38 GMT</pubDate>
            <atom:updated>2026-04-19T00:33:46.109Z</atom:updated>
            <content:encoded><![CDATA[<h3>Quando “boas práticas” pioram seu código</h3><p><em>Por que nem sempre dá pra seguir o livro, e isso não significa desistir da qualidade.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kUzJggjoE6mK6QUd" /><figcaption>Photo by <a href="https://unsplash.com/@cgower?utm_source=medium&amp;utm_medium=referral">Christopher Gower</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Quando começamos a estudar engenharia de software, somos apresentados a um mundo ideal: arquiteturas limpas, testes completos, pipelines automatizados, documentação clara, decisões técnicas bem justificadas... Tudo faz sentido.</p><p>Mas a realidade, principalmente em empresas que estão crescendo rápido (ou que nunca valorizaram tanto a engenharia), é bem mais caótica: <strong>prazos curtos, código legado sem testes, decisões apressadas</strong>. Nem sempre temos autonomia, apoio, tempo ou clareza do negócio pra aplicar o que aprendemos “no livro”. A teoria continua válida, mas parece cada vez mais distante da prática.</p><h3>Por que é tão difícil seguir o “livro”?</h3><p>O problema nem sempre é falta de conhecimento. <strong>Muitas vezes, é o contexto que limita.</strong> Há pressão por entregar rápido, o sistema é grande e cheio de decisões antigas, a equipe está sobrecarregada ou ainda amadurecendo.</p><p>Em alguns lugares, qualidade nem é pauta! O foco é entregar e manter o negócio de pé.</p><p>E nesse cenário, <strong>até profissionais cuidadosos se veem obrigados a abrir mão de certas práticas.</strong></p><h3>O risco de desistir</h3><p>Quando os obstáculos são muitos, é comum adotar uma postura resignada:</p><blockquote>“Minha sugestão vai passar batida. Melhor seguir o fluxo e não criar atrito.”<br>“Se eu tentar melhorar, só vou atrasar tudo e ainda parecer improdutivo.”<br>“Já tentei sugerir mudanças antes… mas aqui o foco é só entregar.”<br>“Queria fazer direito, mas o sistema já está tão engessado que qualquer melhoria vira um desafio político.”</blockquote><p>O problema é que essa atitude gera um efeito dominó:</p><ul><li>o acúmulo de dívidas técnicas</li><li>a perda de confiança no código</li><li>a queda na motivação da equipe</li></ul><p>E a longo prazo, <strong>isso compromete a saúde do software — e das pessoas.</strong></p><h3>O caminho do possível</h3><blockquote><strong>Buscar qualidade em cenários imperfeitos não é ingenuidade, é maturidade.</strong></blockquote><p>Às vezes, não dá pra aplicar todas as boas práticas de uma vez. Mas dá pra começar com o que está ao nosso alcance. Que tal imaginar algumas possibilidades?</p><h4>E se…</h4><ul><li>Você começasse com micro melhorias em uma parte do código que já conhece bem?</li><li>Usasse uma daily pra lançar uma ideia simples de refatoração ou teste?</li><li>Fizesse uma documentação rápida pra ajudar o “você do futuro” (ou alguém novo no time)?</li><li>Começasse a escrever testes para as partes mais críticas do sistema — ou pelo menos para as novas funcionalidades?</li></ul><p><strong>Essas pequenas melhorias sustentam evoluções maiores.</strong></p><h3>Conclusão</h3><p>Seguir boas práticas nem sempre é viável, mas a engenharia de software não perde o valor por isso.</p><p>Ela é justamente o que nos ajuda a navegar a complexidade com mais clareza, segurança e consistência.</p><p>Mesmo em contextos difíceis, <strong>vale a pena lutar por decisões melhores, código mais legível e um software mais saudável. </strong>Porque cada passo na direção da qualidade é um passo em direção a um software mais confiável e a uma equipe mais orgulhosa do que constrói.</p><blockquote><em>Em breve, quero compartilhar um material gratuito com ideias práticas de processos que funcionam mesmo em times sob pressão. Me segue aqui no Medium que vem coisa boa por aí.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53aaec0e95d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>