<?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 Elisandro Mello Corrêa on Medium]]></title>
        <description><![CDATA[Stories by Elisandro Mello Corrêa on Medium]]></description>
        <link>https://medium.com/@elisandromello?source=rss-c15a1be5dee6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*hK0OZMVq7Wv9VeM_g8e0sw.png</url>
            <title>Stories by Elisandro Mello Corrêa on Medium</title>
            <link>https://medium.com/@elisandromello?source=rss-c15a1be5dee6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 19:09:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@elisandromello/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[O Herbie Invisível: Como Gargalos Ocultos Travam a Alta Performance em Times de Software]]></title>
            <link>https://elisandromello.medium.com/o-herbie-invis%C3%ADvel-como-gargalos-ocultos-travam-a-alta-performance-em-times-de-software-651a34cd60d0?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/651a34cd60d0</guid>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Thu, 30 Oct 2025 14:03:50 GMT</pubDate>
            <atom:updated>2025-10-30T14:03:50.688Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GijK4P9ER0p-Lz9FsTzSDA.png" /></figure><p>Corrente, Escoteiro e Código: Como as Lições de <strong>Goldratt</strong>, <strong>Brooks</strong> e <strong>McKeown</strong> Explicam os Gargalos Invisíveis na Engenharia de Software.</p><p>Este artigo busca sintetizar lições práticas de três clássicos da engenharia e gestão — <strong><em>A Meta</em></strong>, <strong><em>O Mítico Homem-Mês</em></strong> e <strong><em>Essencialismo</em></strong> — aplicadas ao contexto de times de software modernos.</p><p>Já esteve em um time que parecia correr, mas nunca chegava? Toda equipe de alta performance carrega um <strong>Herbie invisível</strong>, o ponto que, silenciosamente, limita o progresso do todo. <em>“Uma corrente é tão forte quanto seu elo mais fraco”</em>. É uma frase clichê e grandemente popularizada, mas isso não a torna menos verdadeira, aplicável em diversos contextos, seja em âmbitos pessoal, social ou corporativo. Neste artigo, aplicarei esse princípio para analisar seu impacto em times de alta performance.</p><h3>A Corrente: O que limita o fluxo</h3><p>Em primeira análise, a frase citada relaciona-se diretamente à <strong>Teoria das Restrições (TOC — Theory of Constraints)</strong>, que foi introduzida pelo físico israelense <strong>Eliyahu M. Goldratt</strong> no clássico livro <em>“A Meta” (The Goal, 1984)</em>. Esta teoria parte de uma ideia simples, mas profunda:</p><blockquote><em>“O desempenho de um sistema é limitado por um pequeno número de restrições, geralmente apenas uma principal, e a melhoria real só acontece quando se atua sobre essas restrições.”</em></blockquote><p>Toda organização, processo ou sistema carrega um ponto de limitação, a restrição que determina seu desempenho global. Esse gargalo representa o elo mais vulnerável da corrente e, assim como nela, a força do conjunto depende da resistência de sua parte mais fraca.</p><p>Sob uma perspectiva mais ampla, a <strong>Teoria das Restrições (TOC) </strong>propõe que o esforço principal deve se concentrar em fortalecer esse elo crítico até que ele deixe de comprometer o fluxo. O princípio é simples: aprimorar o sistema como um todo produz resultados muito mais expressivos do que tentar otimizar partes isoladas, mesmo aquelas que já apresentam alto desempenho.</p><h3>O Ponto de Partida: A Meta e a Teoria das Restrições</h3><p>Em A Meta, o protagonista <strong>Alex Rogo</strong> é um gerente de uma fábrica que está enfrentando sérios problemas de produtividade e ameaça de fechamento. Ao longo da história, ele busca soluções para melhorar os processos da planta, com a ajuda de seu antigo professor <strong>Jonah (um alter ego do próprio autor Eliyahu M. Goldratt)</strong>. Durante a narrativa, são tratados temas como lucro contínuo e sustentável, foco no tratamento de estrangulamentos de produção, melhoria contínua e otimização de <em>Throughput</em>: quanto dinheiro a empresa gera por meio de vendas.</p><p>Podemos analisar o que Goldratt descreve como teoria da restrição, a ideia de que sempre há um <em>bottleneck</em> limitando o desempenho de um sistema.</p><p>Sendo assim, o principal objetivo deve ser identificar esse “ponto de flexão” e corrigi-lo imediatamente. Ou seja, melhorar qualquer coisa fora do gargalo principal não melhora o desempenho geral.</p><h3>A Trilha do Escoteiro</h3><p>No livro <em>Essencialismo</em>, o autor <strong>Greg McKeown</strong> aborda o princípio da restrição, relacionando com os argumentos sobre foco e produtividade, pilares do essencialismo.</p><p>McKeown apresenta o conceito de <strong><em>Subtrair (Eliminar)</em></strong> para produzir mais por meio da remoção de obstáculos, ou seja, em termos de requisitos, evitando o perfeccionismo não essencial. Você estabelece um limite de tempo (um <em>Limitar</em>) e define critérios de “suficientemente bom”.</p><p>McKeown resgata a parábola do escoteiro <strong>Herbie (originalmente usada por Goldratt em <em>A Meta</em>)</strong> para ilustrar como o foco na remoção da contenção se alinha perfeitamente com o princípio de Subtrair. Na parábola Alex Rogo era chefe escoteiro, e possuía a missão de levar um grupo de escoteiros, entre eles seu filho, de volta ao acampamento antes do pôr do sol.</p><p>Para isso era importante estabelecer um ritmo com boa intensidade e, mais importante, com consistência. Manter um grupo de garotos nesse padrão já seria desafiador, mas Alex logo perceberia que havia outro problema. Alguns escoteiros andam bem depressa e outros, muito devagar. Entre os mais lentos, um garoto destacava-se; seu nome é <strong>Herbie</strong>. A diferença entre o ritmo de Herbie e os garotos mais rápidos era tamanho que resultava em uma distância superior a dois quilômetros.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pHaqftELRDJ-iNXr" /><figcaption>Figura 1 — Imagem ilustrativa demonstrando escoteiros em uma trilha.</figcaption></figure><h3>O Escoteiro: A restrição visível</h3><p>A primeira iniciativa de Alex é fazer com que o pelotão da frente pare e espere os demais os alcançarem. Isso resulta em um grupo único por algum tempo, mas logo a mesma lacuna começa a se formar novamente. Então, Alex adota outra estratégia. Ele põe Herbie na frente do grupo e organiza todos os outros meninos por ordem de velocidade: do mais lento ao mais rápido. Parece contraproducente deixar o garoto mais veloz no final da fila, mas isso faz com que o grupo se desloque em um bloco homogêneo.</p><p>Assim, ele consegue acompanhar o movimento do grupo, garantindo que todos cheguem juntos ao acampamento. Contudo, o ritmo do deslocamento de todo o grupo é definido pelo garoto mais lento: Herbie, o que fará com que todos cheguem muito depois do prazo estipulado.</p><p>Com isso Alex precisa repensar sua abordagem. O que fazer para garantir que todos cheguem juntos ao acampamento e dentro do prazo estipulado? A resposta, como Alex descobre, é concentrar todos os esforços para que Herbie possa melhorar seu desempenho. Se Herbie, que está no início do pelotão, melhorar sua velocidade, todo o grupo chegará mais rápido no destino. Ou seja, qualquer melhora de Herbie, por menor que seja, irá resultar em uma melhora imediata no ritmo de toda a equipe. Desta maneira Alex decide reduzir o peso que Herbie estava transportando em sua mochila (retirou a comida e os suprimentos que trouxe com ele), distribuindo com o restante dos garotos. De fato, com menor peso, a velocidade de Herbie melhora consideravelmente, na mesma hora a velocidade do grupo todo melhora, culminando na chegada ao acampamento dentro do prazo previsto.</p><p>A partir desta experiência Alex Rogo percebe que a mesma abordagem pode ser aplicada aos desafios de desempenho que enfrenta na fábrica, e que precisam ser aprimorados. Ao invés de melhorar todos os aspectos produtivos da operação, é preciso identificar o “Herbie”: a parte do processo de menor performance em relação a todos os outros. Ao descobrir <strong>“o elo”</strong> de menor desempenho, e trabalhar na melhora de sua eficiência, resultando em maior eficiência do próximo “caminhante lento” e assim por diante, até que toda a cadeia produtiva tenha um aumento gradativo em seu desempenho.</p><p>Como define Greg McKeown:</p><blockquote><em>“A pergunta é: qual é o caminhante mais lento de seu trabalho ou de sua vida? Qual obstáculo o impede de alcançar o que é importante? Ao identificar e remover sistematicamente essa “restrição”, você conseguirá reduzir de forma significativa o atrito que o impede de executar o essencial.”</em></blockquote><p>É importante enfatizar que não podemos eliminar restrições de forma aleatória. Apenas melhorar alguns processos e consertar pontos tangenciais de problemas, pode provocar no máximo pequenas melhorias a curto prazo; Em casos extremos, pode resultar em desperdício de tempo e esforço em soluções de pouco impacto no funcionamento total do sistema.</p><p>O propósito dessa metáfora, utilizada por McKeown, é utilizar o personagem Herbie como uma ferramenta poderosa e literal para ensinar a importância de identificar e remover a maior barreira ao progresso e à produtividade. O foco não deve se restringir aos pontos fortes, mas sim em fortalecer ativamente o elo mais fraco para que ele não se torne um ponto de falha, garantindo a integridade do sistema ou grupo.</p><h3>O Herbie Invisível: A Comunicação como Gargalo Oculto</h3><p>Se o Herbie de Alex Rogo era fácil de enxergar, um garoto cansado, com uma mochila pesada, o Herbie dos times de desenvolvimento de software costuma ser muito mais sutil. Muitas vezes ele não aparece nos gráficos de produtividade, nem nas retrospectivas de sprint. Mas está lá, presente em cada mensagem mal compreendida, em cada reunião sem propósito e em cada dependência que se perde em meio ao excesso de conversas. Em equipes modernas, o Herbie invisível costuma se chamar comunicação deficiente.</p><p>Na Teoria das Restrições, Goldratt ensina que o desempenho de um sistema é limitado por seu elo mais fraco. Em times de software, esse elo muitas vezes não é técnico, é humano; o desalinhamento sobre o que deve ser feito, por que e em que ordem. Em times multidisciplinares, com desenvolvimento de soluções intrinsecamente interdependente entre squads, desenvolver funcionalidades que não estejam alinhadas com a estratégia de negócio, ou mesmo em “timing” de desenvolvimento equivocado pode ser mais nocivo do que problemas técnicos de entrega ou mesmo bugs de funcionalidades.</p><p>Greg McKeown, em Essencialismo, argumenta que a falta de foco e clareza é o maior ladrão de produtividade. Toda vez que um time perde tempo tentando entender algo que já deveria estar claro, consome-se energia em tarefas não essenciais. Ou, nas palavras de McKeown:</p><blockquote><em>“Se você não definir suas prioridades, alguém o fará por você.”</em></blockquote><p>Em outras palavras, se o time não tem uma comunicação essencial, clara, objetiva e direcionada ao que realmente importa, o ruído se torna o refreamento principal.</p><h3>A multiplicação do ruído</h3><p>Em outra obra de referência, no que se trata na gestão de projetos de software, <strong>Frederick P. Brooks, </strong>em seu livro <em>O Mítico Homem-Mês</em>, trouxe uma das observações mais valiosas sobre o impacto da comunicação no desempenho de times.</p><p>Ele demonstrou que, conforme o time cresce, a complexidade da comunicação bidirecional cresce de forma exponencial:</p><blockquote><em>“O número de canais de comunicação possíveis entre n pessoas é n × (n−1) / 2.”</em></blockquote><p>Em outras palavras, quanto mais pessoas, mais caminhos de comunicação, e mais possibilidades de ruído. Quando um projeto de software começa pequeno, a comunicação é simples e direta.</p><p>À medida que o time cresce, surgem mais interdependências, contextos e interpretações diferentes da mesma informação. O que anteriormente era fluído, torna-se ponto de fricção. O <em>throughput</em> intelectual do time cai, não por falta de capacidade técnica, mas por excesso de conversas desnecessárias e mal alinhadas.</p><p>Para ilustrar o aumento na complexidade cognitiva, a partir do crescimento dos times, imagine uma squad de desenvolvimento com os seguintes papéis:</p><ul><li>2 desenvolvedores back-end</li><li>2 desenvolvedores front-end</li><li>1 QA (testes)</li><li>1 Tech lead</li><li>1 PO (Product Owner)</li><li>1 Ux Designer</li></ul><p>O time possui oito pessoas. Aplicando a fórmula proposta por Brooks teremos</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ySX0_2mSd8CM5ysS" /><figcaption>Figura 2 — Exemplo aplicado da fórmula de Brooks para cálculo de canais de comunicação bidirecional em uma squad com oito membros.</figcaption></figure><p>Ou seja, existem 28 possíveis conexões de comunicação direta dentro dessa squad. Cada novo membro não adiciona apenas uma linha de comunicação, ele multiplica a complexidade de coordenação e alinhamento.</p><p>Abaixo apresento uma tabela, que ilustra o impacto do custo cognitivo na comunicação a partir da inclusão de novos elementos na dinâmica operacional de uma squad. Por exemplo um time que possui 4 membros, possui um número de 6 canais de comunicação diretos, mas, se adicionarmos apenas mais um membro na squad o número de canais passa para 10 conexões de comunicação, ou seja, um aumento de 67%. Se dobrarmos o tamanho do time, de 4 para 8 participantes, a complexidade de alinhamento cresce de 6 para 28 canais, um aumento de cerca de 367%, sendo mais do que quadruplicada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ec1ZbP4BrSmcdEge" /><figcaption>Tabela 1 — Tabela apresentando exemplos de cálculo de crescimento dos canais de comunicação bidirecional em times multidisciplinares.</figcaption></figure><p>Mesmo com Slack, Jira e dailies, o aumento no número de pessoas eleva o custo cognitivo para manter o alinhamento.</p><h3>Mais comunicação nem sempre é melhor comunicação</h3><p>Brooks alerta que adicionar mais pessoas a um projeto atrasado tende a aumentar o tempo total de entrega, justamente porque adiciona mais complexidade à comunicação. Esse é um dos grandes paradoxos da engenharia de software:</p><blockquote><em>“Tentar acelerar o trabalho adicionando mais gente pode ser a própria causa do atraso” — Frederick Brooks.</em></blockquote><p>Sob a ótica da TOC, Goldratt explica que, ao tentar aumentar o <em>throughput</em> de produção (entregas, tarefas, velocidade), sem atacar a restrição real, ocasionaríamos um congestionamento no fluxo operacional a partir do aumento na complexidade cognitiva de entendimento e coordenação, o resultado é o oposto: mais atrito e menos valor.</p><p>Já <strong>Greg McKeown</strong> chamaria isso de <strong>“atividade não essencial disfarçada de progresso”</strong>. A equipe parece ocupada, cheia de reuniões, relatórios e mensagens. Entretanto, na prática o time está movendo rapidamente em direções divergentes, o que no fim, equivale a não se mover.</p><blockquote>Lembre-se: Aceleração é diferente de agilidade. A primeira é apenas velocidade; a segunda é mover-se rápido, mas na direção certa.</blockquote><p>Assim como Alex Rogo retirou os suprimentos da mochila de Herbie para aliviar seu peso, times modernos precisam aliviar a sobrecarga de comunicação. Isso significa identificar o que realmente é essencial no fluxo informacional, e eliminar o resto.</p><h3>As 9 Grávidas e o Paradoxo da Aceleração</h3><p>Frederick Brooks, apresentou uma metáfora que atravessou décadas e ainda ecoa com precisão nas squads modernas:</p><blockquote><em>“Uma mulher leva nove meses para gerar um filho. Nove mulheres não o farão em um mês.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*N4lCznzsMA0psjix" /><figcaption>Figura 3 — Imagem ilustrativa representando a analogia de uma mulher grávida e 9 mulheres.</figcaption></figure><p>Essa afirmação, aparentemente simples, carrega um dos maiores paradoxos do trabalho intelectual: a falsa ideia de que adicionar mais pessoas a um projeto atrasado o tornará mais rápido. Na verdade, no contexto da engenharia de software, o efeito é o oposto. Quanto mais pessoas se inserem em um sistema sobrecarregado, mais o fluxo desacelera.</p><p>O paradoxo da aceleração revela a ironia de que, em projetos complexos, adicionar mais pessoas em busca de velocidade frequentemente causa o efeito oposto, lentidão. Isso ocorre porque o trabalho intelectual, diferentemente do físico, não se divide linearmente: cada nova pessoa introduz custos de comunicação, curva de aprendizado e necessidade de sincronização que crescem exponencialmente com o tamanho do time.</p><p>Assim, enquanto se espera que o aumento de força de trabalho reduza o tempo de entrega, na prática, ele expande a entropia organizacional, aumenta o retrabalho e desorganiza o fluxo. <strong>Brooks</strong> sintetiza esse dilema com maestria ao afirmar que <strong>“nove mulheres não fazem um bebê em um mês”</strong>, uma metáfora que ecoa a essência da Teoria das Restrições e do Essencialismo: velocidade real não nasce da pressa, mas da remoção deliberada dos impedimentos que limitam o fluxo natural de valor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XjaAuE7BV_s9hNoJ" /><figcaption>Figura 4 — Tirinha Dilbert satirizando a pressão por prazos irrealistas em times de desenvolvimento (ADAMS, 2025)</figcaption></figure><p>A partir da Teoria das Restrições, proposta por Eliyahu Goldratt, compreendemos que todo sistema tem um ponto de estrangulamento, um obstáculo que determina a vazão máxima do todo. O gargalo pode estar, por exemplo, no alinhamento das features com a estratégia de negócio, na construção das histórias, ou no refinamento com o time técnico. É importante notar que qualquer um desses problemas impacta muito mais o propósito final, entregar valor para o cliente, do que a introdução de um bug técnico ou problema de performance em um elemento do time. Isso ocorre porque erros pontuais possuem um impacto limitado, enquanto erros estratégicos ou de compreensão provocam o desenvolvimento de funcionalidades condenadas à depreciação. Ou seja, resulta em desperdício de esforço, estagnação do produto e retrabalho no desenvolvimento do código. Dobrar o número de desenvolvedores não muda o <em>throughput</em>, apenas aumenta o <em>work in progress</em> (trabalho em progresso, tarefas iniciadas, mas ainda não concluídas).</p><p>A análise do acréscimo de recursos em projetos sob a ótica do Essencialismo, proposto por <strong>McKeown</strong> (<em>A Disciplinada Busca por Menos</em>), descreve o princípio de que o foco no essencial é a única forma sustentável de produzir impacto real. Na engenharia de software, isso significa que a velocidade não é alcançada por meio de “fazer mais coisas”, mas sim de fazer menos e melhor. Cada reunião desnecessária, cada história mal refinada, e cada contexto mal definido são forças contrárias ao essencial.</p><h3>Conclusão</h3><p>Em engenharia de software, e em qualquer sistema humano complexo, os maiores entraves raramente são técnicos. São invisíveis, silenciosos e, quase sempre, humanos. Estão nas falhas de comunicação, nas prioridades difusas, nas decisões que se arrastam e nos fluxos cheios de ruído. Esses são os Herbies modernos: os elos frágeis que limitam o potencial coletivo sem que percebamos.</p><p>Remover restrições visíveis é simples: basta monitorar métricas, otimizar pipelines ou revisar processos. Mas remover as restrições invisíveis exige algo mais profundo: discernimento e coragem para enxergar o que realmente está travando o fluxo de valor. Às vezes é o excesso de urgência, o medo de dizer “não”, ou a falta de alinhamento entre propósito e execução.</p><p>O primeiro passo para liderar times de alta performance é enxergar o Herbie, e não culpá-lo, mas aliviá-lo. Goldratt nos lembra que todo sistema é tão forte quanto o seu elo mais fraco. Brooks nos alerta que tentar acelerar o que não está pronto é apenas multiplicar o caos. E McKeown nos desafia a escolher o essencial, porque foco também é uma forma de remover restrições.</p><p>No fim, todo time carrega um Herbie , às vezes um processo lento, outras, uma comunicação confusa, quase sempre invisível até que alguém decida olhar. A excelência não nasce de acelerar, mas de liberar o fluxo. E o primeiro passo é ter coragem de perguntar: qual é o Herbie que o meu time ainda carrega nas costas? Pois, a verdadeira agilidade começa quando paramos de correr e começamos a remover os pesos que nós mesmos colocamos na mochila.</p><h3>Referências</h3><p>ADAMS, Scott. Dilbert. [S.l.]: Scott Adams/Andrews McMeel Syndication, [20 — ]. Disponível em: <a href="https://dilbert.com/">https://dilbert.com</a>. Acesso em: 15 out. 2025.</p><p>BROOKS, Frederick P. Jr. O Mítico Homem-Mês: ensaios sobre engenharia de software. Tradução de José Augusto C. Pereira. 2. ed. São Paulo: Edições LTC, 1995.</p><p>GOLDRATT, Eliyahu M.; COX, Jeff. A Meta: um processo de aprimoramento contínuo. Tradução de Heloísa Moura. 3. ed. Rio de Janeiro: Nobel, 2014.</p><p>McKEOWN, Greg. Essencialismo: a disciplinada busca por menos. Tradução de Ivo Korytowski. 1. ed. Rio de Janeiro: Sextante, 2015.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=651a34cd60d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Atomicidade em sistemas distribuídos: 2PC explicado de forma simples.]]></title>
            <link>https://elisandromello.medium.com/atomicidade-em-sistemas-distribu%C3%ADdos-2pc-explicado-de-forma-simples-65012e991d9d?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/65012e991d9d</guid>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Wed, 01 Oct 2025 17:34:31 GMT</pubDate>
            <atom:updated>2025-10-01T17:34:31.873Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JLTR6xxf5FF-yfqM__Ur5w.jpeg" /></figure><p>Desenhar sistemas e arquitetar soluções é uma tarefa que exige muito mais do que conhecimento técnico. O arquiteto precisa de visão sistêmica e raciocínio dedutivo. Sua missão vai além de resolver problemas: ele deve orquestrar fluxos paralelos e prever cenários de exceção. Quando tratamos de sistemas distribuídos e arquiteturas orientadas a eventos, os desafios se multiplicam. Contudo, encontrar soluções para escalar essas plataformas de forma estável e resiliente é o que diferencia um bom desenvolvedor de um verdadeiro Arquiteto de Software.</p><p>Nesse sentido, como afirma <strong>Grady Booch</strong>, <em>“a arquitetura representa as decisões significativas de design que moldam um sistema, onde a significância é medida pelo custo da mudança”</em>. Essa definição evidencia que escolhas arquiteturais não dizem respeito apenas ao presente, mas impactam diretamente a capacidade futura de adaptação e evolução da solução.</p><p>Para construir um <em>System Design</em> eficiente, é essencial compreender os princípios fundamentais de arquiteturas resilientes, mesmo que determinadas estruturas não sejam implementadas nas fases iniciais. O arquiteto deve avaliar cuidadosamente o impacto dessas decisões, equilibrando os requisitos imediatos da solução com os débitos técnicos aceitos nas versões preliminares. Esse processo, conhecido como <em>trade-off</em>, consiste em ajustar as entregas de acordo com os recursos e prazos disponíveis, de modo a garantir valor ao produto, ainda que alguns recursos, tecnologias ou boas práticas não estejam contemplados na versão inicial.</p><p>Ainda assim, é indispensável que o arquiteto conheça, mapeie e documente esses débitos técnicos para que possam ser implementados posteriormente. Para isso, além do conhecimento técnico e arquitetural, é essencial que a solução inicial permita a escalabilidade, tanto na adição de novos recursos quanto na incorporação dos débitos mapeados, sem que seja necessária a reconstrução da arquitetura. Dessa forma, torna-se possível enfrentar futuros problemas de escalabilidade decorrentes dos trade-offs assumidos nas fases iniciais do projeto.</p><h3>Atomicidade Transacional</h3><p>Em sistemas distribuídos, onde a informação e o processamento estão espalhados por múltiplos nós (servidores, bancos de dados, microsserviços etc.), garantir a atomicidade de uma transação é um desafio crucial. A atomicidade significa que a transação deve ser tratada como uma única unidade: ou todas as operações são concluídas com sucesso (commit — confirmação), ou nenhuma delas é, e todas são desfeitas (<em>abort</em> — cancelamento).</p><p>Imagine uma transferência de dinheiro entre duas contas bancárias, onde cada conta está em um servidor de banco de dados diferente. Para que a transação seja consistente, o débito na primeira conta e o crédito na segunda precisam ocorrer de forma atômica. Se um deles falhar, o outro também deve ser desfeito para evitar inconsistências (por exemplo, dinheiro sumir do sistema).</p><h3>Two-Phase Commit (2PC)</h3><p>Dentro do contexto de arquitetar sistemas distribuídos, um dos padrões fundamentais é o protocolo Two-Phase Commit (2PC), amplamente descrito nas obras de Jim Gray, Andrew Tanenbaum e Martin Kleppmann. Todo Arquiteto de Software deve dominar o conceito, mesmo que opte por não implementar em suas soluções devido aos seus desafios. Por exemplo, em soluções baseadas em arquitetura de microsserviços o padrão SAGA, mostra-se mais resiliente e flexível. Contudo, em bancos de dados distribuídos tradicionais, o 2PC ainda é amplamente usado. Portanto, entender sua mecânica, benefícios e limitações é obrigação de qualquer profissional que se intitule Arquiteto de Software.</p><p>O Two-Phase Commit (2PC) é um protocolo de coordenação transacional projetado exatamente para resolver o problema de atomicidade transacional em sistemas distribuídos. Ele garante que uma transação seja atômica, mesmo em caso de falhas parciais.</p><p>O 2PC representa um dos mecanismos basilares do conceito de atomicidade em transações distribuídas. Em cenários nos quais múltiplos nós participam de uma mesma operação, é essencial garantir que todas as mudanças ocorram de forma completa ou, em caso de falha, sejam totalmente desfeitas. Desta forma, a propriedade de atomicidade é essencial para a confiabilidade em sistemas de transações, já que impede que inconsistências se propaguem entre diferentes componentes de um sistema distribuído.</p><p>O protocolo é coordenado por um nó central, denominado coordenador, que se comunica com os demais nós envolvidos, chamados participantes. Essa relação garante que as operações ocorram de forma consistente entre todos os envolvidos.</p><p>Na primeira fase, conhecida como <em>prepare phase</em> (fase de votação), o coordenador atua como líder do processo de consenso. Ele envia uma mensagem de <em>prepare</em> (preparar) a todos os participantes, solicitando que verifiquem a possibilidade de efetivar a transação. Ao receber essa mensagem, cada participante executa a operação de forma local, registrando suas intenções em um log persistente. Esse registro garante que, mesmo diante de falhas, o estado da decisão local possa ser recuperado. Se o participante estiver apto a prosseguir, responde ao coordenador com um voto <em>yes</em> (sim); caso contrário, envia um <em>no</em> (não), sinalizando impossibilidade de commit (confirmação).</p><p>A segunda fase, chamada <em>commit/abort</em> (fase de conclusão), depende diretamente do resultado obtido na fase de votação. Se o coordenador receber respostas afirmativas de todos os participantes, ele envia uma mensagem de commit, instruindo-os a tornar permanentes as mudanças previamente preparadas. Entretanto, se qualquer participante votar negativamente ou falhar em responder dentro do tempo esperado, o coordenador envia uma mensagem de abort, determinando que todos revertam suas operações. Essa lógica garante consistência global, mesmo em situações de falha parcial.</p><h3>Logs e Timeouts</h3><p>Além disso, é fundamental destacar o papel dos logs persistentes e dos timeouts no funcionamento do 2PC. Cada participante registra suas intenções de <em>commit</em> (confirmação) ou <em>abort</em> (cancelamento) em um log estável (geralmente em disco), de modo que, em caso de falha, seja possível recuperar o estado da transação e retomar o processo corretamente. Esse mecanismo de <em>redo/undo logging</em> garante a durabilidade e evita inconsistências mesmo após reinicializações. Da mesma forma, o uso de <em>timeouts</em> é essencial para lidar com a incerteza em sistemas distribuídos: se o coordenador ou algum participante não responder dentro de um intervalo definido, assume-se a falha e medidas apropriadas são tomadas, como abortar a transação ou iniciar protocolos de recuperação. Sem esses mecanismos, o 2PC estaria muito mais suscetível a bloqueios indefinidos e perda de confiabilidade.</p><h3>Problemas e Limitações</h3><p>Embora o 2PC seja um protocolo robusto e amplamente utilizado, autores como Kleppmann destacam que ele não é isento de limitações, principalmente em relação ao bloqueio de recursos e ao impacto de falhas no coordenador. Ainda assim, permanece como um alicerce conceitual e prático no estudo e implementação de sistemas de transações distribuídas.</p><p>Apesar de sua relevância histórica e de sua adoção em diversos sistemas de transações distribuídas, o protocolo Two-Phase Commit (2PC) apresenta desafios e limitações que precisam ser cuidadosamente considerados. Compreender esses aspectos é fundamental para avaliar se sua utilização é adequada a um determinado contexto, uma vez que o 2PC pode impor custos significativos em termos de complexidade, disponibilidade e desempenho. Assim, embora seja eficaz em assegurar a atomicidade das operações, nem sempre representa a melhor escolha arquitetural, sobretudo em sistemas de larga escala e alta concorrência.</p><p>Um dos principais problemas está associado ao ponto único de falha. O principal risco do 2PC está na dependência do coordenador: se ele falhar após a fase de votação, os participantes podem permanecer indefinidamente em estado de incerteza, bloqueando recursos e comprometendo a disponibilidade do sistema. Essa vulnerabilidade demonstra como a dependência excessiva de um nó centralizado se torna um fator crítico de risco em ambientes distribuídos.</p><p>Outro desafio notável é o fato de o 2PC ser um protocolo bloqueante. Durante sua execução, os participantes mantêm bloqueios sobre os recursos envolvidos na transação até que o coordenador defina a decisão de commit ou abort. Em sistemas de alto volume de requisições, esse bloqueio prolongado pode reduzir a concorrência e impactar negativamente o desempenho, limitando a escalabilidade da solução. Como destacado por autores como Jim Gray e Martin Kleppmann, essa característica torna o protocolo pouco eficiente em cenários de transações longas ou ambientes que exigem alta responsividade.</p><p>Diante dessas limitações, observa-se que o 2PC, embora conceitualmente robusto, deve ser aplicado com cautela. Seu uso tende a ser mais adequado em cenários nos quais a consistência estrita é um requisito inegociável e o volume de transações é relativamente moderado. Em contrapartida, para sistemas que demandam baixa latência, resiliência a falhas e escalabilidade horizontal, alternativas como o Three-Phase Commit (3PC) ou padrões arquiteturais como o SAGA podem se mostrar mais apropriados.</p><h3>Three-Phase Commit (3PC)</h3><p>O protocolo Three-Phase Commit (3PC) surge como uma evolução do 2PC, especificamente para mitigar a principal limitação deste: o problema de bloqueio em caso de falha do coordenador. Ao adicionar uma terceira fase, o 3PC busca garantir a atomicidade das transações com maior resiliência. O protocolo introduz uma fase intermediária, chamada <em>preCommit</em>, entre as fases <em>canCommit</em> (a votação) e <em>commit/abort</em> (a confirmação/cancelamento). Nessa fase adicional, o coordenador confirma com os participantes que eles estão prontos para o <em>commit</em>, antes de enviar a decisão final. Essa etapa extra reduz significativamente o risco de os participantes ficarem indefinidamente bloqueados, aguardando uma decisão que nunca chegará, caso o coordenador falhe. Contudo, mesmo com esta melhoria, o 3PC ainda é um protocolo complexo e pode ser vulnerável a falhas severas.</p><h3>Modelo SAGA</h3><p>Nesse contexto, o padrão <em>SAGA</em> surge como uma abordagem descentralizada para lidar com transações distribuídas, substituindo o bloqueio de recursos do 2PC por um mecanismo de compensação. Enquanto no 2PC a atomicidade é garantida pela coordenação centralizada e pela decisão única do coordenador, no SAGA cada operação é tratada como uma transação independente, acompanhada por uma operação compensatória em caso de falha. Isso significa que, embora o SAGA não assegure a atomicidade estrita no mesmo nível do 2PC, ele favorece a disponibilidade, a resiliência a falhas e a flexibilidade arquitetural, características essenciais em sistemas modernos baseados em microsserviços.</p><p>Assim, a escolha entre 2PC e SAGA exige avaliar prioridades distintas. O 2PC privilegia a consistência forte, garantindo que todas as transações sejam atômicas e concluídas de forma uniforme, mas à custa de maior complexidade e risco de bloqueio em caso de falhas. Já o SAGA abre mão dessa atomicidade estrita e opera sob o modelo de consistência eventual, compensando falhas por meio de operações reversas. Em contrapartida, oferece maior disponibilidade, resiliência a falhas e escalabilidade, características que o tornam mais adequado a sistemas distribuídos modernos, especialmente em arquiteturas baseadas em microsserviços.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a7iFiBVeRukh16mg0DO07g.png" /></figure><h3>Exemplo de Implementação em TypeScript</h3><p>O exemplo a seguir simula o processo do 2PC usando classes e async/await para representar o Coordenador e os Participantes. Note que esta é uma simulação didática e não uma implementação de produção, que exigiria gerenciamento de logs persistentes, tratamento de falhas e timeouts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WSemnAMi3BFFX-8B0mRJbg.png" /></figure><p>O código acima implementa um protocolo de transação de duas fases (2PC), um padrão comum em sistemas distribuídos para garantir que todos os participantes de uma transação concordem em finalizá-la ou abortá-la de forma consistente. A classe Participant (Participante) representa um nó ou componente dentro dessa transação. Na primeira fase, conhecida como prepare (preparação), cada participante decide se pode ou não concluir a transação e envia seu “voto” ao coordenador. A segunda fase, de commit (confirmação) ou abort (abortar), ocorre quando o coordenador, com base nos votos recebidos, envia a decisão final para todos os participantes. Se todos votaram “sim”, a transação é confirmada e os participantes a finalizam (<em>commit</em>). Caso contrário, a transação é abortada e todos desfazem as alterações (<em>abort</em>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5N_Q0pi12zfNksBkGpG2OA.png" /></figure><p>No protocolo de duas fases, a classe <em>Coordinator</em> (Coordenador) tem a função de orquestrar a transação. Ela centraliza a comunicação e as decisões entre os diferentes Participantes. Primeiramente, na Fase 1 (Votação), o coordenador envia a solicitação de preparação para todos os participantes e espera pelas respostas. Em seguida, ele avalia os “votos” (<em>true</em> para “sim”, <em>false</em> para “não”). Se todos os participantes votarem <em>true</em>, o coordenador avança para a Fase 2 (Confirmação), enviando o comando de <em>commit</em> para que todos finalizem suas operações. Caso um único participante que seja falhe ou vote <em>false</em>, o coordenador imediatamente envia o comando de abort para todos, garantindo que a transação seja desfeita de forma consistente em todo o sistema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WKJMRxA_vm7XPfrezFd9bA.png" /></figure><p>Este trecho final do código demonstra a aplicação prática do protocolo de duas fases através de dois cenários de teste. O successScenario (cenário de sucesso) simula uma situação ideal onde todos os Participantes estão aptos a concluir a transação (<em>canCommit: true</em>). Nesse caso, o Coordinator obtém um consenso total e avança para a fase de <em>commit</em>. Por outro lado, o failureScenario (cenário de falha) representa uma situação real e mais complexa, onde um dos participantes é deliberadamente configurado para não poder realizar a transação (<em>canCommit: false</em>). Isso força o Coordinator a detectar a falha e, em vez de prosseguir com o commit, ele instrui todos os participantes a abortar a transação. Essa abordagem assegura a integridade do sistema, evitando que a transação seja concluída apenas parcialmente.</p><p>Executando o código, você verá como o Coordenador toma a decisão de <em>comitar</em> ou abortar a transação, garantindo a atomicidade, mesmo quando um dos participantes falhar.</p><h3>Conclusão</h3><p>O protocolo Two-Phase Commit (2PC) permanece como um marco no estudo e na implementação de sistemas de transações distribuídas, fornecendo a base conceitual para compreender os desafios de atomicidade, consistência e coordenação em ambientes descentralizados. Apesar de suas limitações em termos de desempenho, bloqueio (<em>lock</em>) de recursos e vulnerabilidade a falhas no coordenador, o 2PC continua relevante tanto do ponto de vista acadêmico quanto prático, especialmente em contextos que exigem consistência estrita.</p><p>No entanto, à medida que arquiteturas modernas, baseadas em microsserviços e nuvem, demandam maior escalabilidade e resiliência, abordagens alternativas como o padrão SAGA têm ganhado espaço como soluções mais adequadas. Em um artigo futuro, exploraremos em profundidade o funcionamento do SAGA, seus mecanismos de compensação e os cenários em que ele se mostra mais vantajoso em relação ao 2PC.</p><h3>Referências</h3><p>BOOCH, Grady. Análise e projeto orientados a objetos com aplicações. Tradução de Fulano de Tal. 2. ed. Rio de Janeiro: Campus, 1995.</p><p>GRAY, Jim; REUTER, Andreas. Transaction Processing: Concepts and Techniques. San Francisco: Morgan Kaufmann, 1993.</p><p>KLEPPMANN, Martin. Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems. 1. ed. Sebastopol: O’Reilly Media, 2017.</p><p>TANENBAUM, Andrew S.; VAN STEEN, Maarten. Distributed Systems: Principles and Paradigms. 2. ed. Upper Saddle River: Pearson Prentice Hall</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65012e991d9d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O desenvolvedor de software vai morrer?]]></title>
            <link>https://elisandromello.medium.com/o-desenvolvedor-de-software-vai-morrer-0304186583ab?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/0304186583ab</guid>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Tue, 23 Sep 2025 18:54:24 GMT</pubDate>
            <atom:updated>2025-09-23T18:54:24.781Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PFUq8yEaz_xObl1imN0qEA.png" /></figure><h3>O desenvolvedor de software vai morrer? — Entenda por que a profissão está em profunda transformação.</h3><p>Como líder de Engenharia montei diversas equipes de alta performance por meio da identificação e do desenvolvimento de talentos, e construí culturas sólidas de entrega a partir da implementação de um mindset de delivery. E posso dizer: o que estamos vivendo agora não é apenas uma mudança incremental. É uma ruptura.</p><p>O futuro do desenvolvedor está em jogo. Mais do que seguir tendências, é preciso compreender para onde a engenharia de software está sendo empurrada.</p><p>Com esse propósito, procuro acompanhar não apenas tendências, mas também discussões que possam orientar os rumos da Engenharia de Software, permitindo a tomada de decisões estratégicas, arquiteturais e de negócios de forma mais consciente. Recentemente, deparei-me com a participação de <strong>Fabio Akita</strong> no <strong>Flow Podcast</strong>. Akita é um dos engenheiros de software mais influentes da tecnologia brasileira, com uma trajetória que se estende desde os anos 1990 e abrange diversas áreas do desenvolvimento. Tornou-se amplamente reconhecido pelo blog <a href="http://akitaonrails.com/">AkitaOnRails.com</a> e pelo canal no YouTube <strong>Akitando</strong>. Cofundador de uma das consultorias mais renomadas do setor, a <strong>Codeminer 42</strong>, e um dos primeiros autores a publicar literatura sobre Ruby on Rails em português, Akita consolidou sua reputação pela visão crítica e pelo pragmatismo em relação às tendências, defendendo que engenheiros de software construam carreiras sólidas e resilientes. Ou seja, poucos nomes no Brasil provocam tanto quanto Fabio Akita.</p><p>Por isso, estar atento a uma figura como Akita é essencial para compreender os possíveis caminhos que a carreira em Engenharia de Software pode tomar. Neste artigo, vou resumir alguns dos principais tópicos e ideias defendidas por Akita na entrevista concedida a <strong>Igor Coelho (Igor 3K)</strong> e, ao mesmo tempo, compartilhar insights e minhas próprias percepções.”</p><h3>A Bolha da Programação (2014–2019)</h3><p>A análise de Akita sobre a bolha da programação inicia a discussão, destacando como o movimento ‘Aprenda a Codificar’ impulsionou um aumento expressivo de interessados na área, atraídos pela promessa de altos salários. Esse fenômeno gerou um mercado inflado, no qual muitos recorreram aos famosos bootcamps curtos. Esses cursos ofereciam treinamento superficial, com a promessa de aprendizado rápido e ganhos relevantes em pouco tempo.</p><p>Esse fenômeno resultou em muitos profissionais com formações rápidas e, em muitos casos, conhecimento limitado em engenharia de software. Akita os chama de “programadores de miojo”, explicando que, se a demanda é apenas pelo básico, “basta água fervente e três minutos”. Porém, para construir sistemas escaláveis e resilientes, é necessário muito mais do que isso.</p><h3>Análise do Autor</h3><p>Não sou contra os bootcamps, desde que ofereçam conteúdo consistente e propostas claras. O problema está no impacto negativo que muitos deles causaram na formação de desenvolvedores, ao disseminar a falsa ideia de que seriam suficientes para preparar engenheiros para os desafios reais do desenvolvimento de software. Pior ainda, alimentaram a expectativa de salários elevados e de uma senioridade precoce. É verdade que alguns bons engenheiros surgiram desses movimentos, mas isso ocorreu não por causa dos bootcamps, e sim porque esses profissionais compreenderam as demandas do mercado e buscaram um preparo sólido por meio de estudo intenso e dedicação.</p><p>Essas ideias se alinham ao que <strong>Filipe Deschamps</strong>, ex-CTO da <a href="http://pagar.me/">Pagar.me</a>, comentou recentemente, traçando um paralelo entre a febre do ouro e os ‘vendedores de cursos de programação’ da atualidade. Argumentando que muitos “garimpeiros” (alunos de cursos) voltam de mãos vazias, enquanto os “comerciantes” (vendedores de cursos) ficam milionários. Ele critica a venda de “picaretas”, que são cursos que prometem sucesso rápido, em vez de conhecimento honesto e consistente.</p><h3>O Impacto da COVID-19 (2019–2021)</h3><p>Akita esperava que a bolha estourasse por volta de 2019, acreditava que haveria um movimento natural de “peneira”, filtrando os talentos resilientes que realmente entregavam valor. Mas, a pandemia da COVID-19 atuou como um ‘Cisne Negro’, prolongando artificialmente o efeito da bolha.</p><p>Com todos em casa, serviços online como Netflix, iFood e Amazon explodiram em demanda. O efeito foi imediato: uma corrida desenfreada por contratações em tecnologia. Grandes empresas puxaram a fila. Logo, todos os segmentos seguiram. O clima era de urgência. Sem presença online, o negócio estava condenado. Criou-se então a percepção de que os empregos em programação eram infinitos.</p><p>Como toda expansão sem base sólida, a bolha estourou em 2022. Demissões em massa se tornaram realidade em muitas empresas de tecnologia. Para agravar, a Inteligência Artificial — liderada pelo ChatGPT — emergiu com força, acelerando transformações que já estavam em curso.</p><h3>Análise do Autor</h3><p>A pandemia criou um ecossistema anômalo: a necessidade de serviços digitais provocou uma corrida frenética pelo desenvolvimento de soluções. Essa necessidade era legítima, e irreversível, escalando abruptamente a demanda por programadores. As Big Techs, em especial, contrataram em excesso, muitas vezes sem projetos claros, apenas para reter mão de obra e evitar escassez futura.</p><p>Esse movimento trouxe um efeito secundário pouco discutido: o “achatamento artificial” do tempo de maturação profissional. Desenvolvedores com apenas dois anos de experiência passaram a se identificar como seniores e a reivindicar salários antes compatíveis apenas com quem possuía domínio técnico e arquitetural muito superior. Naturalmente, com a acomodação do mercado, haveria uma refração: sobreviveriam apenas os profissionais capazes de sustentar qualidade e impacto em suas entregas.</p><p>Por um período, desenvolvedores com formação frágil se mantiveram empregados graças à estratégia de constantes recolocações. Passavam pouco tempo em cada empresa, eram desligados por baixa performance e logo se reposicionavam no mercado aquecido.</p><p>Esse ciclo, porém, começou a ruir com os grandes layoffs das Big Techs, que devolveram ao mercado uma massa de profissionais. Ao mesmo tempo, é claro que nesses cortes também saíram talentos preparados, efeito colateral inevitável de demissões em larga escala. Afinal, quando se define um número de dispensas, não há espaço para avaliar cada desempenho individualmente.</p><p>A diferença é que engenheiros experientes logo se recolocam. Nesse contexto, o cenário se torna ainda mais difícil para aqueles que migraram sem construir uma base sólida de conhecimento. Conforme Akita define, esses ‘seniores de miojo’, com pouca bagagem técnica e baixa experiência, encontram enorme dificuldade em se reposicionar com o mesmo cargo ou remuneração.</p><p>E como é típico do ser humano, ninguém aceita ser rebaixado em seu status ou valor percebido, ao menos não de imediato. Só quando o próprio mercado comprova que o profissional estava supervalorizado e não entregava o suficiente, ocorre a dolorosa aceitação.</p><p>Esse processo costuma gerar uma reação previsível: uma onda de queixas sobre cobranças abusivas e má gestão. O termo que mais se espalhou no LinkedIn nesse período foi “burnout”. Mas fica a provocação: será que todas as acusações de políticas abusivas se referiam, de fato, a ambientes tóxicos? Ou não seriam, em muitos casos, o mercado reagindo a entregas frágeis, que não escalavam e não geravam valor consistente?</p><h3>A Bolha Estoura e a Ascensão da IA (2022)</h3><p>Simultaneamente à readequação do mercado de tecnologia, o especialista Fabio Akita destaca a ascensão da inteligência artificial, em especial do ChatGPT. Ele aponta como a percepção pública sobre a necessidade de desenvolvedores mudou drasticamente em pouco tempo: de “a melhor profissão do mundo” para “a pior”.</p><p>Neste ponto, Akita argumenta que nenhum desses extremos corresponde à realidade. A IA — seja ChatGPT, Gemini, Copilot, DeepSeek, Grok, Claude ou qualquer outra ferramenta — não é uma inimiga que veio roubar empregos. Ela é, na verdade, uma ferramenta poderosa com suas próprias limitações. O autor exemplifica essa questão com o desenvolvimento de soluções para diagnósticos médicos ou documentos legais gerados por IA, onde a precisão é vital e um erro pode ser catastrófico.</p><p>A IA pode automatizar tarefas repetitivas e de baixo nível, auxiliar na escrita e depuração de código e até gerar ideias. Contudo, ela não substitui o raciocínio crítico, a criatividade, a capacidade de arquitetar soluções complexas e, acima de tudo, a responsabilidade final que recai sobre os engenheiros. A IA não entende o contexto de negócio em sua totalidade, não negocia com stakeholders, não lidera equipes nem lida com as nuances humanas dos projetos.</p><h3>Análise do Autor</h3><p>O ecossistema de startups, antes um terreno fértil para profissionais em transição de carreira, vive hoje um cenário completamente diferente. Muitos CEOs que, não faz muito tempo, precisavam destinar uma parte significativa de seus recursos para manter equipes de engenharia, agora veem na IA generativa a promessa de construir soluções sem esse peso no orçamento.</p><p>Não é coincidência que alguns dos principais defensores da ideia de que “a era dos desenvolvedores acabou” são justamente os executivos que lideram empresas de IA. Sam Altman (OpenAI) e Dario Amodei (Anthropic) reforçam essa visão. Amodei, por exemplo, previu que em apenas um ano todo o código poderia ser gerado por IA. Emad Mostaque (ex-Stability AI) foi além, decretando: “não haverá programadores em cinco anos”. Naveen Tewari (InMobi) engrossa a fila ao afirmar que seus engenheiros “desaparecerão” em dois anos, e Jensen Huang (Nvidia) projeta um futuro em que programar deixará de ser uma atribuição humana. Com essas narrativas, o recado que ecoa pelas empresas é simples e pragmático: “antes de pensar em contratar um desenvolvedor, prove que não consigo fazer isso com IA”.</p><p>Contudo, uma análise fundamental, e que nem sempre é feita, é que a maioria desses “profetas” do extermínio de desenvolvedores está em “pitch mode”, ou seja, vendendo seus produtos. Frases como a de Amodei — “Em apenas 12 meses, quase todo o código poderá ser gerado por IA. E em 3 a 6 meses a IA estará escrevendo 90% do código”. Essa profecia, feita em março de 2025, já mostra sinais de envelhecimento, pois ainda não apresenta nenhum sinal de concretização a médio prazo. Na verdade, o que temos visto é uma reversão de expectativa. Após diversos atrasos no lançamento da versão 5 do ChatGPT, Sam Altman declarou em agosto de 2025: — “O mercado de IA pode estar em uma bolha”. Essa declaração se junta ao anúncio de Mark Zuckerberg, realizado no mesmo período, de congelar contratações para o time Superintelligence Labs, de desenvolvimento de IA, devido a temores de uma bolha.</p><p>Em entrevista ao podcast apresentado por Matthew Berman, Matt Garman, CEO da AWS, afirmou categoricamente que substituir colaboradores iniciantes por recursos de IA — como agentes autônomos — é ‘uma das coisas mais idiotas que já ouvi’. A frase circulou amplamente como um alerta para os riscos de se negligenciar o desenvolvimento de novos talentos.</p><h3>Ceticismo em Relação ao Hype da IA</h3><p>Akita demonstra ceticismo em relação às narrativas criadas por líderes de IA como Sam Altman. Para ele, muitas dessas falas soam mais como estratégias de marketing do que como fatos concretos, lembrando figuras do passado que venderam expectativas irreais.</p><p>Um exemplo, citado por Fabio Akita, é a aquisição da empresa de design de Johnny Ive, a LoveFrom, pela OpenAI. Críticos apontam que a operação teve mais relação com imagem e hype do que com produto tangível.</p><p>Antes da compra, a startup LoveFrom não havia desenvolvido ou comercializado nenhum produto relevante. Seu foco era pesquisa e desenvolvimento estratégico em hardware, com o objetivo de preparar uma nova geração de dispositivos que poderiam, no futuro, ser lançados. Mesmo sem realizações expressivas, a OpenAI pagou aproximadamente US$ 6,5 bilhões pela empresa.</p><h3>Análise do Autor</h3><p>É fato que os CEOs de empresas de IA precisam se esforçar para manter suas companhias em evidência e relevância. Afinal, lidam com um capital intangível, de difícil valoração. Por isso, sustentar o frenesi midiático é quase obrigatório, servindo para justificar os bilhões aportados por investidores. O próprio Jensen Huang (Nvidia) tem interesse em proclamar a autonomia resolutiva das IAs, já que sua empresa fornece o hardware essencial para os gigantescos datacenters que sustentam essas operações.</p><p>Mas nem todos compram essa narrativa. Satya Nadella (Microsoft) admite que cerca de 30% do código já é gerado por IA, mas não decreta o fim dos engenheiros — pelo contrário, aposta em ganhos de produtividade. Arvind Krishna (IBM) fala em 20% a 30% de automação, mas vê isso como um impulso para os profissionais, não como uma ameaça. Todd McKinnon (Okta) chega a rir da hipótese de menor necessidade de engenheiros no futuro. Thomas Dohmke (ex-GitHub) reforça que as empresas mais inteligentes vão investir ainda mais em talentos humanos capazes de integrar a IA no dia a dia. Até Shantanu Narayen (Adobe) é direto: não é a IA que substituirá programadores, mas sim os programadores que souberem — ou não — usá-la.</p><h3>A IA Não É o Fim, É o Início de Uma Nova Era</h3><p>Segundo notícia veiculada pelo Código Fonte TV: “A startup de empregos Final Round AI entrevistou 12 CEOs e CTOs de grandes empresas para entender o que mudou nas contratações de desenvolvedores na era da IA. Eles descobriram que, em 2025, a prioridade na contratação deixou de ser velocidade na codificação ou domínio de sintaxe, focando mais em pensamento crítico e capacidade de analisar e auditar o código gerado por IA, que frequentemente é confiante mas errado.”</p><p>É notório que a profissão de desenvolvedor está em transformação, como todas as demais, a mudança sempre foi uma constante na história evolutiva de qualquer profissão.</p><p>Na minha opinião, o codificador tradicional está condenado, ou ao menos com os dias contados. O perfil do desenvolvedor que atua isoladamente, focado apenas em escrever grandes volumes de código sem pensar criticamente sobre impacto e alinhamento ao negócio, tende a desaparecer.</p><p>Ainda sobre a pesquisa: os entrevistados valorizam profissionais capazes de identificar falhas introduzidas pelo código gerado por IA. Veremos em poucos anos, ou menos, um grande aumento na necessidade de desenvolvedores, que possuam capacidade significativa de debugging, para refatorar e escalar soluções que hoje estão sendo desenvolvidas por IA quase que integralmente, ou por desenvolvedores juniores alavancados por IA. A figura do Arquiteto de Software/Soluções irá ganhar ainda maior proeminência, pois as plataformas atualmente desenvolvidas, tendem a ter graves problemas de escalabilidade e resiliência.</p><p>A Inteligência Artificial desenvolve soluções e as coloca em produção em tempo recorde. Mas, o que não se pode esquecer é que “colocar no ar”, nem de longe é a mesma coisa que escalar uma solução a milhões de requisições compondo todas as regras de negócios necessárias.</p><p>Ou seja, menos terrorismo ocupacional. A história nos mostra que o trabalho nunca permaneceu estático: ele é moldado pela tecnologia e pelos ciclos econômicos. Se a máquina a vapor desestruturou o artesanato e inaugurou a era da produção em massa, a eletricidade levou essa transformação a um novo patamar, reorganizando fábricas inteiras. A informática, por sua vez, não apenas otimizou máquinas, mas digitalizou processos que antes exigiam papel, tempo e esforço humano. Em cada etapa, houve medo e resistência — como os luddites, trabalhadores que atacaram máquinas têxteis por medo da perda de renda no século XIX, mas também uma recomposição inevitável, em que novas indústrias surgiram, novos serviços foram criados e a demanda por profissionais capacitados voltou a crescer.</p><p>É nesse ponto que o conceito de Creative Destruction, idealizado por Joseph Schumpeter, ajuda a entender que inovação não é só ruptura, mas motor de expansão. Cada onda tecnológica carrega consigo um período de desalento, marcado pela queda de ocupações tradicionais e pela necessidade de requalificação, mas logo abre janelas de oportunidade, exigindo novas competências e multiplicando funções que sequer existiam antes. O que muda hoje é a velocidade do processo: da eletricidade ao computador passaram-se décadas; da internet à inteligência artificial, apenas anos. E é justamente essa aceleração que torna urgente a preparação dos profissionais para a próxima curva de alta.</p><h3>O Que Fazer Agora? A Base é a Chave para a Escalabilidade da Sua Carreira</h3><p>Analisando as ideias de Akita e Deschamps, somadas às falas de grandes CEOs do setor de tecnologia, a mensagem é clara: trata-se de uma provocação e de um chamado à ação. É hora de se preparar para sobreviver, e prosperar, nesta nova era. Esqueçam a corrida atrás da “tecnologia da moda”. O que realmente importa, agora mais do que nunca, é o conhecimento fundamental: aquilo que aprendemos nas universidades, os princípios de arquitetura de software robusta, padrões de design, algoritmos, estruturas de dados e boas práticas de engenharia. Esses pilares são os que garantem a capacidade de adaptação diante de qualquer nova tecnologia, inclusive a IA.</p><p>Decisões de carreira não devem ser delegadas a modismos ou a algoritmos. A responsabilidade pela evolução profissional continua sendo individual. Questionem o hype, especialmente o que orbita certas figuras da IA mais preocupadas em criar expectativas irreais do que em entregar valor concreto. A verdadeira inovação nasce da substância, não do marketing.</p><p>Para engenheiros de software e arquitetos, o momento é de afiar as habilidades mais profundas. Sejam os mestres da arquitetura, capazes de erguer sistemas escaláveis e resilientes, de compreender trade-offs e tomar decisões que moldam o futuro. A IA será uma ferramenta poderosa em suas mãos, mas a mente estratégica e a capacidade de resolver problemas complexos continuarão sendo inestimáveis.</p><h3>Referências</h3><p>Luddites: foram trabalhadores ingleses do início do século XIX, principalmente do setor têxtil, que reagiram violentamente à introdução de máquinas industriais que ameaçavam seus empregos e formas tradicionais de trabalho. Temendo a perda de renda e a desvalorização de suas habilidades, organizaram protestos e chegaram a destruir equipamentos em fábricas, tornando-se símbolo da resistência às transformações trazidas pela Revolução Industrial.</p><p>Creative Destruction: Joseph Schumpeter cunhou o conceito de creative destruction (destruição criativa) para explicar como o capitalismo se renova continuamente: inovações tecnológicas e modelos de negócio disruptivos destroem estruturas antigas, ao mesmo tempo em que criam novas formas de produção, consumo e organização econômica. Esse processo é paradoxal — gera instabilidade e quebra de paradigmas, mas também impulsiona crescimento, produtividade e o surgimento de setores inteiros que substituem os obsoletos.</p><p>AKITA, Fabio. Programação ainda é a profissão do futuro? Fabio Akita 100% sincero no Flow. Disponível em: <a href="https://www.youtube.com/watch?v=d4j02XdB77g&amp;t=1088s">https://www.youtube.com/watch?v=d4j02XdB77g&amp;t=1088s</a>. Acesso em: 08 set. 2025.</p><p>CÓDIGO FONTE TV. CTOs e CEOs abrem o jogo sobre desenvolvedores e IA. Disponível em: <a href="https://www.youtube.com/watch?v=K9sXOSvl5Jg&amp;list=PL6pcNpce899lkQPSFtEYs78ENRjs0J23D&amp;index=9">https://www.youtube.com/watch?v=K9sXOSvl5Jg&amp;list=PL6pcNpce899lkQPSFtEYs78ENRjs0J23D&amp;index=9</a>. Acesso em: 08 set. 2025.</p><p>DESCHAMPS, Filipe. Fala viraliza: “É burrice trocar devs juniores por IA”. Disponível em: <a href="https://m.youtube.com/watch?v=iM3N8oeIkd0&amp;t=60s">https://m.youtube.com/watch?v=iM3N8oeIkd0&amp;t=60s</a>. Acesso em: 08 set. 2025.</p><p>GARMAN, Matt. White Collar Jobs, Hyperscalers, AI Coding, Open vs Closed, Agents, and more! Disponível em: <a href="https://www.youtube.com/watch?v=nfocTxMzOP4">https://www.youtube.com/watch?v=nfocTxMzOP4</a>. Acesso em: 08 set. 2025.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0304186583ab" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python pode quebrar sua arquitetura de negócio — e quase ninguém está pronto para essa conversa.]]></title>
            <link>https://elisandromello.medium.com/python-pode-quebrar-sua-arquitetura-de-neg%C3%B3cio-e-quase-ningu%C3%A9m-est%C3%A1-pronto-para-essa-conversa-ae4183420e37?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae4183420e37</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[iamelisandromello]]></category>
            <category><![CDATA[breathingcode]]></category>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Mon, 16 Jun 2025 12:32:40 GMT</pubDate>
            <atom:updated>2025-06-16T12:32:40.775Z</atom:updated>
            <content:encoded><![CDATA[<h3>Python pode quebrar sua arquitetura de negócio — e quase ninguém está pronto para essa conversa.</h3><h4>O problema não é usar Python. É usá-lo onde ele começa a lutar contra a arquitetura que você precisa escalar.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FS-FK6eT_XMjobuIKoEXYA.png" /></figure><p>Python é uma das linguagens mais populares do mundo — simples, expressiva e com um ecossistema vasto. Não à toa, é presença garantida em projetos de automação, ciência de dados, machine learning e até mesmo backend web. Mas quando o assunto é arquitetura distribuída, microserviços serverless e sistemas orientados a eventos, a escolha da linguagem deixa de ser apenas preferência e passa a ser uma decisão arquitetural crítica.</p><p>Neste artigo, quero abordar de forma objetiva por que Python pode ser um gargalo silencioso em plataformas modernas com alta complexidade de negócio, múltiplos domínios, forte necessidade de rastreabilidade e execução concorrente. Ainda que possível, seu uso em sistemas assim demanda um nível de engenharia e disciplina tão alto que, muitas vezes, torna-se um ‘tiro no pé’, no longo prazo.</p><p>Mas não se trata de descartar Python por completo. Veremos também em quais cenários ele ainda brilha, e quando realmente vale a pena adotá-lo como parte da solução — sem comprometer a escalabilidade, a manutenção e a evolução saudável da sua arquitetura.</p><p>Se você está construindo uma fintech, plataforma de cobrança, orquestrador B2B ou qualquer sistema orientado a eventos, este artigo vai te ajudar a tomar decisões mais sólidas sobre a base tecnológica do seu produto.</p><h3>As limitações técnicas do Python em arquiteturas modernas</h3><h3>1. Tipagem Fraca e Dinâmica: riscos em sistemas distribuídos</h3><p>Python é uma linguagem dinamicamente tipada, o que significa que as garantias de tipo são verificadas apenas em tempo de execução. Em sistemas com múltiplos domínios, interfaces bem definidas e integrações entre serviços, a ausência de contratos explícitos (como interfaces e types) dificulta a rastreabilidade e a prevenção de regressões. Ferramentas como mypy e pydantic ajudam, mas não substituem a robustez nativa que linguagens como TypeScript ou C# oferecem.</p><p>A ausência de tipagem estática forte dificulta a manutenção, refatoração segura e a navegação entre domínios conforme o sistema cresce.</p><p>Em arquiteturas baseadas em microserviços e eventos, a clareza de contrato entre componentes é crítica.</p><h3>Análise de Caso de Uso</h3><p>Mudanças em contratos entre módulos (DTOs, services, etc.) podem causar falhas em tempo de execução, não detectáveis em tempo de compilação.</p><p>Python é dinamicamente tipado, então não há validação estática dos contratos entre produtores e consumidores de eventos (ex: payloads JSON via SQS).</p><p>Isso aumenta o risco de quebra silenciosa de contrato, o que em ambientes distribuídos e assíncronos pode ser catastrófico.</p><p>Por exemplo: Dois microserviços se comunicam via SQS (ou outro broker). O produtor envia um JSON com customer_id: int, mas o consumidor espera um customer_id: str. Essa inconsistência não é capturada em tempo de desenvolvimento no Python, mas poderia ser evitada em linguagens com tipagem estática, como TypeScript.</p><h3>Python (com tipagem dinâmica)</h3><p>Producer (responsável por publicar o evento):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tURk2sF675W1JqYE" /></figure><p>Consumer (espera um str, mas recebe int):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RBgKvtT_hOjm5gHk" /></figure><p>Erro só ocorre em tempo de execução. Sem IDEs, linters ou compiladores que alertem da divergência.</p><p>Mesmo com pydantic:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*d119LhSa_xdocrFE" /></figure><p>Ainda é validado em runtime, não em tempo de desenvolvimento ou build.</p><h3>TypeScript (com tipagem estática)</h3><p>Contrato compartilhado via interface:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zQeh9E8ir8DS_dId" /></figure><p>Producer:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mJ3Oa06SeaBGSvN7" /></figure><p>Erro detectado na hora, em tempo de codificação no editor de código utilizado.</p><p>Consumer:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zpBDhWpS1t1tLzNH" /></figure><p>Resumo Comparativo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*40JPsS4Oe10HpADO" /></figure><p>Linguagens com tipagem estática, como TypeScript, Java e C#, oferecem recursos nativos ou ecossistemas maduros que permitem gerar tipos diretamente a partir de contratos formais como JSON Schema, Avro ou Protobuf, promovendo consistência entre serviços. Essa tipagem forte garante que qualquer divergência nos contratos entre produtor e consumidor seja detectada ainda durante a compilação, reduzindo drasticamente a chance de falhas em tempo de execução e aumentando a previsibilidade e a segurança em arquiteturas distribuídas.</p><h3>2. Falta de ferramentas nativas para enforce de arquitetura</h3><p>Em sistemas compostos por múltiplos domínios e regras de negócio complexas, manter os limites entre contextos (Bounded Contexts) é essencial para a escalabilidade e a saúde da arquitetura. No entanto, Python não impõe restrições estruturais que incentivem boas práticas arquiteturais — como namespaces fortes, encapsulamento real entre módulos ou mecanismos nativos para isolamento de pacotes.</p><p>Tudo é acessível via import, independentemente da camada ou do domínio, o que significa que violações entre contextos podem ocorrer livremente e, pior, sem alertas visíveis. Em ambientes com múltiplos desenvolvedores ou times distribuídos, isso aumenta significativamente o risco de architecture erosion, onde a arquitetura planejada vai se degradando com o tempo.</p><p>Ao contrário de linguagens como TypeScript (com seu suporte a módulos ES e sistemas de path mapping) ou C# (com projetos isolados por solução e controle de visibilidade entre assemblies), que permitem impor barreiras de acoplamento entre domínios diretamente no design da aplicação, Python exige uma disciplina rigorosa, sustentada apenas por convenções e organização manual.</p><p>Manter a integridade de um Bounded Context ou aplicar com precisão os princípios de Domain-Driven Design (DDD) em Python é possível, mas exige esforço contínuo e tooling complementar — e é exatamente nesse ponto que entram algumas ferramentas do ecossistema que tentam mitigar essa fragilidade estrutural.</p><h3>Como mitigar esses problemas em Python</h3><p>Embora o ecossistema Python ofereça ferramentas que tentam compensar essa ausência de enforcement estrutural, como o import-linter, para impor regras de dependência entre pacotes; o layer-linter, para validar fronteiras entre camadas arquiteturais; ou o pydeps, que permite mapear visualmente dependências entre módulos. Todas essas soluções dependem de configuração manual, disciplina constante e execução contínua de análises automatizadas ou revisões estruturadas.</p><p>Em contraste com linguagens como TypeScript ou C#, que oferecem mecanismos nativos ou integrados ao compilador para impor limites arquiteturais desde o design do código, em Python tais garantias precisam ser construídas artificialmente, sustentadas por convenções internas e tooling externo. Essa lacuna impõe um custo contínuo à engenharia, que precisa fiscalizar ativamente a integridade da arquitetura a cada entrega.</p><p>Em cenários de rápida evolução, múltiplas squads ou pipelines de integração contínua, esse esforço se torna rapidamente um ponto de fragilidade. E mais: não basta contar apenas com ferramentas — é fundamental ter uma equipe com nível de senioridade consistente, capaz de absorver a carga cognitiva imposta por esse modelo. Sem essa base sólida, a arquitetura inevitavelmente tende à degradação, comprometendo sua coesão, legibilidade e evolução sustentável ao longo do tempo.</p><h3>3. Testabilidade e cobertura de regras complexas</h3><h3>A ausência de tipagem forte exige mais testes</h3><p>Sem uma tipagem forte, frameworks de teste e linters precisam compensar verificações que seriam automáticas em linguagens como TypeScript, Java ou C#. Em sistemas com domínio complexo, isso se traduz em uma carga extra de testes automatizados apenas para garantir a integridade básica do sistema. Contratos de entrada e saída, como parâmetros de funções, payloads de eventos e retornos de métodos, não são garantidos de forma explícita pelo compilador.</p><h3>Estruturas dinâmicas e o uso de dict</h3><p>A análise estática em Python, por meio de ferramentas como mypy ou pyright, é inteiramente opcional e pode ser facilmente ignorada, sobretudo em equipes grandes ou com menor maturidade técnica. Além disso, a linguagem não impõe validação estrutural de tipos complexos, como DTOs aninhados ou Value Objects. Na prática, qualquer estrutura pode ser representada como um dict, o tipo embutido do Python que funciona como um mapa chave-valor flexível e dinâmico. Embora versátil, essa abordagem reduz drasticamente a previsibilidade e a segurança do código, já que não há garantias em tempo de execução nem validações em tempo de compilação sobre a forma, os tipos ou a profundidade dos dados manipulados. O resultado é uma base de código mais propensa a erros sutis e difíceis de rastrear.</p><h3>Exemplo prático com dict vs TypedDict e dataclass</h3><p>Por exemplo, ao representar um pedido com cliente e valor total, é comum encontrar algo assim em Python:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DiFlD4otrDChC5I-" /></figure><p>Alternativas mais seguras incluem o uso de <em>TypedDict</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*k21gBBsRjlwakEsj" /></figure><p>Ou <em>dataclass</em>, para validação mais robusta e estilo orientado a objetos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uCH4RWzXIKh9iGPK" /></figure><p>Essas abordagens tornam o código mais explícito e seguro, mas exigem disciplina e tooling adicional, já que o Python não obriga seu uso nem realiza verificações em tempo de compilação como linguagens com tipagem estática forte fazem por padrão.</p><p>Consequência: Testes precisam compensar o que o compilador não faz. Em sistemas com regras de negócio complexas, isso leva a:</p><h3>Aumento exponencial de cenários de testes unitários e de integração, para validar:</h3><ul><li>Verificação de estrutura e tipo dos dados (ex: presença de campos obrigatórios).</li><li>Comportamento de objetos frente a variações de entrada.</li><li>Reações esperadas a erros de tipo ou ausência de atributos..</li></ul><h3>Dificuldade em fazer refatorações seguras, pois:</h3><ul><li>Alterar a assinatura de métodos ou estruturas de dados não gera erro em tempo de compilação.</li><li>Regressões só são detectadas em tempo de execução — se houver teste cobrindo o cenário.</li></ul><h3>Cobertura de testes inflada, mas não qualitativa:</h3><ul><li>Grande parte dos testes acaba validando a infraestrutura defensiva (ex: se um campo é número), e não a lógica de negócio.</li><li>Isso eleva o custo de manutenção e pode mascarar falhas mais relevantes.</li></ul><h3>Resultado direto no ciclo de vida do software</h3><p>A ausência de tipagem forte em Python impacta diretamente o ciclo de vida do software, tornando o tempo de manutenção e testes mais longo, uma vez que regras que poderiam ser automaticamente protegidas por tipos precisam ser verificadas manualmente.</p><p>Isso dificulta a escalabilidade tanto da equipe quanto da base de código, pois a falta de segurança em tipos exige que os desenvolvedores possuam um conhecimento tácito profundo do sistema para evitar erros. Além disso, cria-se um acoplamento maior entre os testes e a implementação, o que dificulta mudanças estruturais no código.</p><p>Em contraste, linguagens com tipagem estática, como TypeScript, utilizam o compilador como o primeiro “testador” da aplicação, que intercepta erros de tipo, uso incorreto de métodos e contratos inválidos entre módulos antes mesmo da execução. Dessa forma, os testes podem se focar nas regras de negócio reais, liberando a equipe de validar aspectos básicos.</p><p>Refatorações tornam-se mais seguras e confiáveis, já que a IDE e o compilador indicam todos os pontos afetados de maneira precisa, facilitando mudanças estruturais sem riscos inesperados.</p><h3>4. Manutenção e Evolução: tipagem e IDE tooling limitados</h3><p>IDEs como VS Code e PyCharm evoluíram significativamente no suporte ao ecossistema Python, oferecendo recursos como linting e verificação de tipos com ferramentas como mypy. No entanto, ainda enfrentam dificuldades para lidar com estruturas arquitetônicas mais sofisticadas, como as utilizadas em Domain-Driven Design (DDD), envolvendo múltiplos domínios, agregados, serviços e mapeamentos complexos.</p><p>Por outro lado, linguagens com tipagem estática, como TypeScript, proporcionam uma experiência de desenvolvimento mais robusta, com suporte avançado a refatorações seguras, detecção precoce de erros e contratos explícitos via interfaces e tipos. Embora existam boas opções de IDEs para Python, o suporte a recursos avançados de produtividade, navegação entre abstrações e segurança de código ainda é, em geral, inferior ao oferecido por linguagens fortemente tipadas.</p><p>Aqui estão os principais pontos por trás dessa limitação:</p><h3>Inferência de Tipos Limitada</h3><ul><li>Python é dinamicamente tipado: o tipo de uma variável é definido em tempo de execução.</li><li>IDEs têm dificuldade para prever o tipo de variáveis ou retorno de funções, principalmente em código grande ou com muita metaprogramação.</li></ul><p>Isso limita recursos como:</p><ul><li>Auto-complete preciso</li><li>Navegação entre símbolos com segurança</li><li>Refatorações confiáveis (ex: renomear métodos)</li></ul><h3>Validação em Tempo de Escrita Inferior</h3><ul><li>Em linguagens como TypeScript, o compilador e a IDE identificam erros de tipo, argumentos inválidos ou interfaces não implementadas durante a escrita do código.</li><li>Em Python, muitos erros só são detectados em tempo de execução (a menos que você use ferramentas como mypy, que ainda têm limitações).</li></ul><h3>Refatoração Menos Segura</h3><p>Ferramentas como VSCode ou PyCharm oferecem refatoração limitada (renomear, extrair, mover) em Python porque:</p><ul><li>Sem tipagem, é difícil garantir que mudanças não quebrem o sistema.</li><li>O uso extensivo de duck typing e decorators dificulta a análise estática do código.</li></ul><p>Obs: Duck typing é um conceito da programação dinâmica, especialmente comum em linguagens como Python, onde o tipo de um objeto é determinado pelo seu comportamento e não pela sua classe explícita. Ou seja: não importa a classe ou tipo de um objeto, importa se ele tem os métodos ou atributos esperados. Se o objeto não tiver o método esperado, o erro só aparece em tempo de execução, não na compilação ou escrita.</p><h3>Suporte a Lint e Teste Menos Integrado</h3><ul><li>Embora existam linters como flake8, pylint e formatadores como black, a integração entre lint, análise estática e testes não é tão profunda quanto em TypeScript (ESLint + TSConfig + Jest + tsc).</li><li>Testes de tipo e cobertura de edge cases exigem mais esforço do time.</li></ul><p>Obs: Edge cases (ou “casos de borda”) são execuções que ocorrem nos limites de comunicação entre os Bounded Contexts. Eles testam como o software se comporta quando recebe entradas fora do padrão, como valores nulos, vazios, muito grandes, muito pequenos ou formatos inválidos. Tratar adequadamente edge cases é essencial para garantir robustez e previsibilidade de comportamento do sistema.</p><h3>Menor Integração com Clean Architecture / DDD</h3><p>Embora você possa escrever Clean Architecture e aplicar DDD com Python, a experiência de desenvolvimento é significativamente inferior comparada a linguagens com tipagem estática e suporte robusto em IDEs — como TypeScript, C# ou Java. Isso se deve à falta de contratos explícitos (tipos, interfaces e classes abstratas), o que dificulta análise estática, sugestões inteligentes e refatorações seguras.</p><h3>Domínios com contratos implícitos (sem interfaces)</h3><ul><li>Em Python, você pode passar qualquer objeto, desde que tenha os métodos esperados (duck typing).</li><li>Isso é flexível, mas o IDE não sabe quais métodos são esperados ali.</li><li>Exemplo: um PaymentService pode depender de um CreditValidator, mas o tipo de CreditValidator pode ser uma classe qualquer — não há garantia estrutural.</li></ul><h3>Agregados, Serviços e Repositórios</h3><ul><li>No DDD, esses elementos devem seguir interfaces bem definidas para permitir inversão de dependência, testes e composição de contextos.</li><li>Em linguagens com suporte estático, você cria IPaymentRepository, ICreditService, etc. A IDE mostra todos os métodos esperados, sugere implementações e valida implementações incorretas.</li><li>Em Python, realizado de forma implícita, sem contratos formais, o desenvolvedor precisa lembrar da assinatura correta ou consultar documentação/comentários.</li></ul><h3>Exemplo prático comparativo</h3><p>TypeScript:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*etxVcg8Oh5RBJjyl" /></figure><p>IDE entende o contrato: mostra erro se validate estiver ausente, sugere assinatura correta, autocompleta parâmetros, oferece refatoração segura.</p><p>Python:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nTe-1wZezodfupDa" /></figure><p>Nenhuma garantia de que MyValidator está aderente a um contrato. A IDE não pode ajudar com refatorações nem validações.</p><p>Python não tem um tooling pobre, mas depende demais da disciplina da equipe, ferramentas adicionais e boa cobertura de testes para compensar o que o compilador/IDE não faz automaticamente. Em projetos com muitos domínios, contratos entre contextos e evolução contínua, essas limitações impactam diretamente na produtividade e na segurança da manutenção.</p><h3>5. Cold Start no AWS Lambda com Python</h3><p>Em AWS Lambda, o tempo de inicialização (cold start) é crucial. Python tende a iniciar mais lentamente que Node.js ou Go, especialmente quando usa bibliotecas pesadas como boto3 ou pandas. Em arquiteturas orientadas a eventos com alta taxa de requisições SQS, isso pode gerar latência indesejada ou obrigar o uso de provisioned concurrency, elevando custos.</p><h3>AWS Lambda tem comportamento diferente dependendo da linguagem usada.</h3><ul><li>Python tem um cold start maior do que Go ou Node.js, especialmente quando bibliotecas como pandas, boto3 ou requests são usadas.</li><li>Em aplicações com alta carga baseada em eventos SQS, isso pode resultar em aumento de latência ou necessidade de provisioned concurrency (o que encarece).</li></ul><p>Comparativo:</p><ul><li>Go e Node.js iniciam mais rápido.</li><li>Java tem warm-up demorado, mas com GraalVM ou SnapStart o problema é mitigável.</li></ul><p>Um cold start ocorre quando a AWS precisa criar uma nova instância do container da Lambda para processar uma invocação. Isso inclui:</p><ul><li>Inicialização do runtime da linguagem.</li><li>Carregamento do código-fonte do handler.</li><li>Execução do bloco de inicialização (fora do handler).</li><li>Inicialização de bibliotecas externas e conexão com serviços.</li></ul><p>Essa latência afeta especialmente workloads com:</p><ul><li>Alta frequência de eventos curtos (ex: SQS, Kinesis).</li><li>Alta variabilidade de carga (picos e períodos ociosos).</li><li>Requisitos de latência baixa.</li></ul><h3>Por que Python tende a ter cold start mais lento?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jSIxhYJmIVFpEncv" /></figure><p>Obs: Em benchmarks práticos da AWS, Lambdas em Python podem ter cold starts entre <em>500ms</em> e <em>2s</em>, dependendo da complexidade e do pacote de dependências.</p><p>Benefícios do Node.js + TypeScript no contexto da AWS Lambda</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*G64ou2ilMyQaGRUs" /></figure><h3>Estratégias de mitigação que funcionam melhor com Node.js</h3><ul><li>Bundling inteligente com esbuild → reduz drasticamente tempo de carregamento.</li><li>Reuso de conexões persistentes (ex: RDS Proxy, DynamoDB client) sem penalidade no warm-up.</li><li>Uso de Lazy Imports + Singleton → apenas o que for necessário é carregado.</li><li>Cold start quase nulo com provisioned concurrency mínima, com custo menor que em Python.</li></ul><h3>6. Concorrência e execução paralela limitada</h3><p>Embora o modelo serverless da AWS Lambda isole execuções (cada invocação é um processo separado), certas partes das regras de negócio internas de uma função podem se beneficiar de concorrência local — como a execução paralela de múltiplas validações, consultas simultâneas a serviços externos ou transformações entre domínios. Nesses cenários, a capacidade da linguagem de lidar com concorrência interna influencia diretamente a performance e escalabilidade local da função Lambda.</p><h3>Limitação Principal do Python: o GIL</h3><p>O Global Interpreter Lock (GIL) impede que múltiplas threads executem código Python puro simultaneamente, mesmo em máquinas com múltiplos núcleos. Isso limita o paralelismo real em workloads CPU-bound, como cálculos intensivos, parsing complexo, enriquecimentos ou agregações entre domínios. Mesmo que você crie múltiplas threads, apenas uma será executada por vez no interpretador.</p><p>Funciona bem quando:</p><ul><li>O trabalho é I/O-bound (espera por rede, arquivos, etc.) e se usa asyncio</li><li>Usa bibliotecas nativas escritas em C que liberam o GIL (numpy, pandas, etc.)</li></ul><p>Funciona mal quando:</p><ul><li>O código é CPU-bound (ex: cálculo, parsing, agregação, enriquecimento de dados)</li></ul><p>Entretanto, é importante destacar que essa limitação não se aplica a bibliotecas escritas em C que liberam o GIL, como numpy ou pandas, amplamente utilizadas em cenários de data science e engenharia de dados. Nestes contextos, Python continua sendo extremamente eficiente, pois delega a execução para código nativo de alta performance que roda fora do GIL, permitindo o aproveitamento de múltiplos núcleos reais do processador.</p><h3>Impacto na Lambda</h3><p>No contexto de AWS Lambda e Event-Driven Architecture:</p><ul><li>Se uma função Lambda Python precisa orquestrar múltiplas validações, enriquecimentos ou agregações entre bounded contexts, ela pode se tornar um gargalo.</li><li>Mesmo com asyncio, ainda há overhead de cooperação manual, e o GIL ainda limita tarefas CPU-bound.</li><li>A solução seria usar processos (multiprocessing), mas isso aumenta latência e memória, crítico em ambientes serverless.</li></ul><p>Embora seja possível usar concorrência com asyncio em Python, o GIL limita o paralelismo real, tornando-o menos eficiente para funções Lambda com lógica densa e paralela (como agregações entre domínios ou enriquecimentos simultâneos). Linguagens como Node.js e Go oferecem modelos de concorrência mais adequados para esse tipo de necessidade, especialmente em ambientes event-driven e serverless, onde cada milissegundo conta para custo e escalabilidade.</p><h3>7. Monitoramento, observabilidade e tracing</h3><p>Soluções de tracing distribuído como AWS X-Ray, OpenTelemetry e Datadog oferecem suporte a Python, mas com menor profundidade e cobertura que em linguagens como Node.js ou Java. Muitas bibliotecas Python ainda exigem instrumentação manual para garantir propagation de contexto em ambientes assíncronos, tornando o tracing mais frágil e propenso a falhas.</p><p>Sistemas distribuídos e orientados a eventos (microserviços + AWS Lambda + SQS), exigem observabilidade total, ou seja:</p><ul><li>Tracing distribuído para entender o fluxo ponta a ponta dos eventos e requisições</li><li>Logs estruturados e contextualizados (por request ID, user ID, correlation ID)</li><li>Métricas customizadas (latência, taxa de erro, throughput por domínio/evento)</li><li>Context propagation confiável entre chamadas assíncronas e síncronas</li></ul><p>Sem isso, fica impossível depurar falhas, medir eficiência de domínios ou prever gargalos de negócio.</p><p>Ao implantar microserviços utilizando Lambda Functions, desenvolvidos em Python, temos diversas desvantagens nesse contexto:</p><h3>Integração limitada com tracing nativo da AWS (X-Ray)</h3><p>Python tem SDK oficial (aws-xray-sdk), mas:</p><ul><li>Não cobre automaticamente bibliotecas comuns (ex: requests, sqlalchemy, boto3, pika)</li><li>Não propaga corretamente contextos em fluxos assíncronos (asyncio)</li><li>Requer instrumentação manual para serviços externos, banco de dados, filas, etc.</li></ul><h3>Baixo suporte automático a context propagation</h3><ul><li>O tracing distribuído depende da correta propagação de contextos (trace-id, parent-id) em chamadas internas e externas.</li><li>Python não tem suporte maduro a context propagation automática em asyncio, threads e coroutines, ao contrário de linguagens como Java (OpenTelemetry + Spring) ou Node.js (AsyncLocalStorage).</li></ul><h3>Observabilidade reativa, não proativa</h3><ul><li>Ferramentas como OpenTelemetry para Python ainda sofrem com gaps na cobertura de bibliotecas populares, exigindo “patches” manuais ou wrappers</li><li>Isso aumenta o acoplamento com código de infraestrutura e reduz a confiabilidade da rastreabilidade</li></ul><p>Vale destacar que o ecossistema Python tem evoluído no suporte a observabilidade, especialmente com o avanço do OpenTelemetry. O uso de wrappers e bibliotecas de instrumentação está se tornando mais acessível e abrangente, o que tem melhorado a integração com ferramentas como AWS X-Ray, Datadog e Prometheus. Ainda assim, essa maturação segue atrás de linguagens como Node.js e Java, exigindo instrumentação manual em muitos casos. Ou seja, apesar dos avanços, o cenário ainda demanda esforço adicional, e deve ser considerado com cautela em arquiteturas distribuídas que dependem fortemente de tracing confiável.</p><h3>Comparativo: Python vs. TypeScript para microserviços serverless</h3><h3>Modelagem de Domínio</h3><p>TypeScript permite modelar domínios complexos com interfaces, types, generics e abstract classes, promovendo coesão entre camadas e facilitando refatorações seguras. Já no Python, apesar do suporte a dataclasses, attrs e pydantic, os contratos são verificados apenas em tempo de execução, o que eleva a necessidade de testes automatizados para garantir integridade básica.</p><h3>Performance e Latência</h3><p>Em ambientes AWS Lambda, Node.js (TypeScript) apresenta cold start mais rápido e menor consumo de memória, o que é crucial em sistemas reativos com alto volume de eventos. Python, ao carregar grandes bibliotecas (como boto3 ou pandas), pode causar atrasos perceptíveis e exigir provisioned concurrency para mitigar o impacto.</p><h3>Concorrência</h3><p>TypeScript, com seu modelo baseado em event loop e promises, permite simular paralelismo de forma eficiente mesmo em contextos single-thread. Já o Python sofre com o GIL (Global Interpreter Lock), limitando execuções paralelas em multithreading. Mesmo com asyncio, o paralelismo é cooperativo e não resolve casos de workloads intensivos em CPU.</p><h3>Observabilidade</h3><p>Ferramentas como AWS X-Ray, Datadog e OpenTelemetry oferecem suporte mais estável e abrangente para Node.js, com bibliotecas que propagam contexto assíncrono de forma mais confiável. Em Python, integrações com tracing distribuído ainda requerem muita instrumentação manual.</p><p>Em contrapartida ao utilizar Node.js/TypeScript para o desenvolvimento das Lambdas Functions, temos diversas vantagens:</p><h3>Suporte nativo ao AWS X-Ray e OpenTelemetry</h3><p>Bibliotecas como @opentelemetry/sdk-node, @opentelemetry/instrumentation-aws-sdk, @opentelemetry/instrumentation-http já fazem:</p><ul><li>Auto-instrumentação</li><li>Propagação de contexto automática via AsyncLocalStorage</li><li>Suporte direto a express, axios, mysql, postgres, amqplib, kafkajs, sqs-consumer, etc.</li></ul><h3>Melhor visibilidade do que acontece entre domínios</h3><p>É possível:</p><ul><li>Capturar um request/event e traçá-lo até sua resposta ou erro final, com breadcrumbs</li><li>Correlacionar logs, métricas e traces via correlation IDs automaticamente</li><li>Integrar com ferramentas como AWS X-Ray, Datadog, NewRelic, Sentry, Prometheus com mínimo esforço</li></ul><h3>Logging estruturado e tipado</h3><p>Com TypeScript, é mais fácil:</p><ul><li>Criar modelos de log padronizados e validados</li><li>Usar middlewares genéricos para logar todos os eventos com o mesmo schema</li><li>Garantir consistência e completude de informações no log</li></ul><p>Se seu sistema precisa de alta rastreabilidade entre eventos (ex: cobrança → verificação → renegociação → pagamento), com visibilidade total sobre cada agregação e domínio, Node.js com TypeScript oferece um ecossistema mais maduro, com menor esforço e maior confiabilidade operacional do que Python, especialmente em ambientes serverless e distribuídos.</p><h3>Manutenção e Escalabilidade de Equipe</h3><p>Projetos em TypeScript oferecem maior previsibilidade na manutenção: as interfaces tornam os contratos claros, e a IDE ajuda com sugestões, detecção de erros e refatoração segura. Python depende de disciplina e ferramentas externas para alcançar resultados semelhantes, o que aumenta a carga cognitiva do time.</p><h3>Tabela Comparativa — Python vs. TypeScript em Microserviços Serverless</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/0*YeALK7MdljT2uFx5" /></figure><h3>Quando Python é altamente recomendável</h3><p>Apesar de suas limitações em arquiteturas distribuídas e sistemas com alta complexidade de domínio, Python continua sendo uma linguagem extremamente eficaz em uma série de contextos bem definidos, desde que seja usada de forma estratégica e consciente de suas fronteiras técnicas. O ponto central é entender que Python brilha como ferramenta de execução especializada, mas não deve ser a espinha dorsal arquitetural de plataformas complexas baseadas em microsserviços, eventos e rastreabilidade entre domínios.</p><h3>Processos isolados e pipelines de dados</h3><p>Python é altamente produtivo em tarefas como ETL, web scraping, automação de relatórios, análises estatísticas e manipulação de dados em geral. Sua vasta coleção de bibliotecas, como pandas, numpy, requests e beautifulsoup, aliada a uma sintaxe enxuta e legível, oferece uma curva de desenvolvimento extremamente rápida. Esses cenários, por serem geralmente autocontidos, não exigem contratos interserviços rigorosos ou mecanismos avançados de rastreabilidade, tornando o uso da linguagem ideal e eficiente.</p><h3>Times com forte expertise em Python</h3><p>Quando a equipe domina profundamente a linguagem e adota práticas maduras, como o uso consistente de mypy, pydantic, pytest, FastAPI e celery, é possível mitigar muitos dos riscos associados ao dinamismo do Python. Mesmo em sistemas mais exigentes, um time sênior e disciplinado consegue construir serviços confiáveis. No entanto, esse nível de controle exige investimento contínuo em testes, validações e governança técnica, o que nem sempre é viável em ambientes de rápido crescimento ou com múltiplas squads.</p><h3>Microserviços de propósito específico</h3><p>Python é especialmente eficaz como linguagem de apoio em serviços especializados de domínio reduzido, como geração de PDFs, processamento de arquivos, enriquecimento de dados, execução de modelos de machine learning ou cálculos estatísticos. Nessas funções pontuais, que geralmente atuam como workers, ou seja, consumidores de eventos que executam tarefas específicas e isoladas, sua simplicidade e poder expressivo oferecem grande valor. Python não deve ser posicionado como core orchestrator, onde a linguagem precisa lidar com múltiplos domínios, regras de negócio densas e validações complexas entre contextos, um cenário no qual sua flexibilidade se transforma em fragilidade.</p><h3>Conclusão</h3><p>Escolher a linguagem certa não é apenas uma questão de preferência pessoal ou do que está “em alta” no mercado. Em sistemas distribuídos, com alta complexidade de domínio, necessidade de rastreabilidade, concorrência e evolutividade, a linguagem torna-se parte integrante das decisões de arquitetura.</p><p>Python é poderoso, expressivo e altamente produtivo em muitos contextos. Mas sua tipagem dinâmica, limitações de concorrência, cold start menos eficiente e tooling mais frágil para ambientes complexos colocam a linguagem em desvantagem frente a alternativas como TypeScript (Node.js), Go, C# ou Java — especialmente em arquiteturas orientadas a eventos e baseadas em microsserviços serverless.</p><p>Não se trata de eliminar Python da stack, mas de entender onde ele brilha e onde impõe custos desnecessários. Times maduros podem usá-lo com segurança em serviços de baixo acoplamento e alta especialização. Para os demais casos, adotar linguagens que oferecem contratos explícitos, performance previsível e integração nativa com ferramentas modernas é um investimento estratégico que reduz risco técnico e acelera a evolução do produto.</p><p>Em suma, Python é excelente como ferramenta de suporte ou microsserviços especializados, mas não deve ser a fundação de uma plataforma distribuída com domínios interdependentes, arquiteturas orientadas a eventos e lógica de negócio densa. Nestes casos, a preferência deve ser por linguagens que ofereçam fundamentos técnicos mais sólidos e sustentáveis.</p><h3>Referências</h3><p>AWS. Optimizing AWS Lambda cold start performance. Disponível em: <a href="https://aws.amazon.com/blogs/compute/optimizing-lambda-cold-start-performance/">https://aws.amazon.com/blogs/compute/optimizing-lambda-cold-start-performance/</a>. Acesso em: 25 mai. 2025.</p><p>BUIZEN, Mark; CLEMENTS, Nick. Clean Architectures in Python: A practical approach to better software design. 2. ed. Independently published, 2022.</p><p>EVANS, Eric. Domain-Driven Design: Tackling Complexity in the Heart of Software. Boston: Addison-Wesley, 2004.</p><p>FOWLER, Martin. Patterns of Enterprise Application Architecture. Boston: Addison-Wesley, 2003.</p><p>GITHUB. OpenTelemetry Documentation. Disponível em: <a href="https://opentelemetry.io/docs/">https://opentelemetry.io/docs/</a>. Acesso em: 25 mai. 2025.</p><p>KROONENBURG, Peter Sbarski. Serverless Architectures on AWS: With examples using AWS Lambda. Shelter Island: Manning Publications, 2017.</p><p>MICROSOFT. TypeScript Handbook. Disponível em: <a href="https://www.typescriptlang.org/docs/">https://www.typescriptlang.org/docs/</a>. Acesso em: 25 mai. 2025</p><p>MORONEY, Laurence. AI and Machine Learning for Coders: A Programmer’s Guide to Artificial Intelligence. Sebastopol: O’Reilly Media, 2020.</p><p>PYTHON SOFTWARE FOUNDATION. Global Interpreter Lock (GIL). Disponível em: <a href="https://docs.python.org/3/c-api/init.html#thread-state-and-the-global-interpreter-lock">https://docs.python.org/3/c-api/init.html#thread-state-and-the-global-interpreter-lock</a>. Acesso em: 25 mai. 2025.</p><p>TILKOV, Stefan; VOGEL, Eberhard. Service-Oriented Architecture: Distilled. Boston: Addison-Wesley, 2005.</p><p>VERNON, Vaughn. Implementing Domain-Driven Design. Boston: Addison-Wesley, 2013.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae4183420e37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setup Profissional de Terminal no macOS: Workflow Eficiente com Git Aliases, Plugins Zsh e…]]></title>
            <link>https://elisandromello.medium.com/setup-profissional-de-terminal-no-macos-workflow-eficiente-com-git-aliases-plugins-zsh-e-343eb50af39b?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/343eb50af39b</guid>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Mon, 26 May 2025 13:08:31 GMT</pubDate>
            <atom:updated>2025-05-26T13:08:31.444Z</atom:updated>
            <content:encoded><![CDATA[<h3>Setup Profissional de Terminal no macOS: Workflow Eficiente com Git Aliases, Plugins Zsh e VSCode/Cursor</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-_wq3Y2hTBHp_b0V" /></figure><p>Atuando como Arquiteto de Software, uma das minhas principais preocupações é manter um ambiente de desenvolvimento produtivo — especialmente por meio de personalizações que ofereçam recursos, visualizações e integrações capazes de facilitar e agilizar o processo de codificação.</p><p>Como já disse certa vez Abraham Lincoln:</p><blockquote><em>“Se eu tivesse seis horas para derrubar uma árvore, passaria as primeiras quatro afiando o machado.”</em></blockquote><p>Seguindo esse princípio, investir tempo na configuração do ambiente de trabalho — especialmente do terminal e do editor — pode gerar ganhos não apenas estéticos, mas também reais em produtividade.</p><p>Com frequência, outros desenvolvedores me perguntam sobre as personalizações que utilizo e sobre os aspectos visuais do meu editor. Por isso, este artigo tem como objetivo compartilhar práticas que aumentam a produtividade no VSCode e no Cursor: desde a automação de tarefas repetitivas com atalhos no Git, até o uso de plugins que tornam a experiência de terminal mais fluida, além de melhorias visuais que ajudam na leitura e organização das informações.</p><h3>Pre-settings</h3><p>Antes de realizarmos todo o processo de configuração, otimização e personalização devemos verificar alguns requisitos de ambiente para habilitarmos a implementação dos recursos que desejamos. O primeiro passo é verificarmos se o Path do Code (ou do Cursor) está corretamente instalado para o terminal. sso pode ser feito executando o comando ‘code — help’ no terminal, se tudo funcionar corretamente, veremos a lista de comandos disponíveis no Code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NQ0cfZwGhS42A8Es" /><figcaption>Imagem 1: comando para verificar a instalação do PATH.</figcaption></figure><p>Caso retorne a mensagem ‘comando não encontrado’, será necessário corrigir o caminho do Code no terminal.</p><p>Abra o Visual Studio Code.</p><p>Podemos abrir a paleta de comandos tocando na engrenagem no canto inferior esquerdo e selecionando a opção da paleta de comandos ou com o atalho de teclado ‘CMD + Shift + P’ no MAC (tanto no VSCode ou Cursor).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JxYvQiiVw8ahof83" /><figcaption>Imagem 2: paleta de comandos para instalar o PATH.</figcaption></figure><ul><li>Na guia que foi aberta, digite o seguinte código: ‘&gt; Shell Command: Install ‘code’ command in PATH’ (ou ‘Shell Command: Install ‘cursor’ command in PATH’).</li><li>Pressione Enter para confirmar e aguarde até que a instalação seja concluída.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ATeIozhDvLj4-UG3" /><figcaption>Imagem 3: editor com a confirmação do PATH.</figcaption></figure><ul><li>Repita o comando ‘code — help’ no terminal para verificar se tudo foi instalado corretamente. Desta vez deve aparecer a lista de comandos do editor.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/935/0*WhuWLA55o-x0MtLi" /><figcaption>Imagem 4: lista de comandos do editor.</figcaption></figure><h3>Alterar editor padrão do Git</h3><p>Alterar o editor padrão do Git de Vim para o VSCode ou Cursor oferece uma experiência muito mais amigável, especialmente para quem está habituado a trabalhar com editores modernos. Enquanto o Vim exige conhecimento prévio de comandos e modos de navegação pouco intuitivos, o VSCode e o Cursor proporcionam uma interface gráfica limpa, com suporte a realce de sintaxe, autocompletar, atalhos de teclado, e extensões inteligentes. Essa mudança facilita tarefas como editar mensagens de commit, resolver conflitos de merge ou ajustar configurações diretamente com todos os recursos de produtividade que esses editores oferecem, reduzindo erros e acelerando o fluxo de trabalho no dia a dia.</p><p>Com o caminho do Code instalado, podemos iniciar as configurações desejadas. Primeiramente, vamos definir o VSCode ou o Cursor como editor padrão do Git. Para isso, basta abrir o terminal e copiar um dos comandos abaixo:</p><ul><li><strong>‘git config — global core.editor ‘code — wait’’ ou ‘git config — global core.editor ‘cursor — wait’’</strong></li></ul><ol><li><strong>‘git config’:</strong> Comando do Git para configurar opções.</li><li><strong>‘ — global’:</strong> Define escopo global (para todos os repositórios).</li><li><strong>‘core.editor’:</strong> Chave que define o editor padrão utilizado pelo Git.</li><li><strong>‘cursor’:</strong> Abre o app chamado Cursor (nome exato do aplicativo).</li><li><strong>‘ — wait’:</strong>Espera o app ser fechado antes de retornar ao terminal. Isso é crucial para que o Git aguarde o término da edição (por exemplo, de uma mensagem de commit).</li></ol><p>Para verificarmos se a configuração foi corretamente aplicada, execute o seguinte comando no terminal:</p><ul><li><strong>‘git config — global -e’</strong></li></ul><p>Esse comando abre o arquivo de configuração global do Git (o ‘.gitconfig’) no editor padrão.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zM4ra3Ju9l6bo8wL" /><figcaption>Imagem 5: arquivo de configuração do Git.</figcaption></figure><p>Se quisermos realizar uma verificação rápida e avaliarmos qual o editor padrão atual, podemos usar o comando:</p><ul><li><strong>‘git config — global core.editor’</strong></li></ul><p>E o terminal deve irá retornar qual seu editor atual:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nsfxgj243pYEktxe" /><figcaption>Imagem 6: comando para verificar o editor padrão.</figcaption></figure><h3>Pré-Requisitos Zsh</h3><p>O Zsh (Z Shell) é um interpretador de comandos moderno e poderoso que oferece recursos avançados como autocompletar inteligente, <em>globbing</em> aprimorado, histórico compartilhado e personalização profunda da linha de comando. Ele é um pré-requisito fundamental para que possamos utilizar o Oh My Zsh, uma estrutura de código aberto que permite estender e customizar o terminal com temas, plugins e atalhos altamente produtivos. A partir do macOS Catalina, o Zsh já vem instalado como shell padrão, o que facilita sua adoção.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3FGTxpP9j3UGjjxL" /><figcaption>Imagem 7: verificar instalação e versão do Zsh.</figcaption></figure><p>Para garantir que está utilizando o Zsh, basta verificar a versão com zsh — version e, se necessário, definir o Zsh como shell padrão em Terminal &gt; Preferências &gt; Aba “Geral”. Sem ele, as personalizações que iremos implementar — como temas avançados (ex: Powerlevel10k), plugins de produtividade e aprimoramentos visuais — não funcionarão corretamente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5a5Sbvpt0cMMcz82" /><figcaption>Imagem 8: aba de verificação do shell utilizado no terminal.</figcaption></figure><h3>Git Aliases: Automatizando o Dia a Dia</h3><p>Após as etapas de pré-settings e pré-requisitos, vamos iniciar de maneira mais efetiva nosso primeiro processo de otimização no ambiente de desenvolvimento, a partir de alguns atalhos para o Git. A utilização de “aliases” irá permitir otimizar o trabalho do dia a dia, resultando em melhor experiência e principalmente no aumento de produtividade.</p><p>Para tanto vamos abrir o arquivo .gitconfig responsável pelas opções de configuração do GIT, utilizando no terminal o comando, já utilizado anteriormente:</p><ul><li><strong>‘git config — global -e’</strong></li></ul><p>No arquivo de configuração, .gitconfig, devemos incluir a sessão ‘alias’, caso a mesma não exista no arquivo. Realize a declaração desta nova sessão no final do arquivo, procedendo com a inclusão da expressão alias entre colchetes:</p><ul><li><strong>‘[alias]’</strong></li></ul><h3>git status -s</h3><p>Após a declaração da sessão, podemos proceder com a configuração de nosso primeiro atalho para os métodos do Git. Iremos criar um atalho para o comando git status, simplificando sua utilização. Atente para o parâmetro -s no final do atalho.</p><ul><li><strong>s:</strong> Nome do atalho: o comando curto que vamos digitar (ex: git s).</li><li><strong>=:</strong> Define o valor associado ao atalho.</li><li><strong>!:</strong> Indica que o Git deve executar o comando como script de shell externo.</li><li><strong>‘git status -s’:</strong> O comando real que será executado.</li></ul><h3>Sobre o -s (ou — short):</h3><p>Esse parâmetro mostra um status simplificado, muito mais compacto do que o tradicional. Em vez de listar os arquivos modificados em várias linhas, ele exibe uma tabela com colunas indicando o estado (ex: M para modified, ?? para não rastreado etc.).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dxbZrk2VoYU3QbBR" /><figcaption>Imagem 9: visualização de execução do alias para o git status.</figcaption></figure><h3>git add — all &amp;&amp; git commit -m</h3><p>O segundo atalho que iremos criar será para o nosso processo de commit. Esse alias permite executarmos dois comandos encadeados com um só atalho, digitando apenas: ‘git c “mensagem do commit”’.</p><p><strong>O Git irá:</strong></p><ul><li>Adicionar todos os arquivos modificados ao staged (como se tivesse rodado ‘git add — all’)</li><li>Fazer o commit com a mensagem fornecida (‘git commit -m “sua mensagem”’)</li></ul><p>Nesta configuração utilizaremos os parâmetros ‘ — all’, que adiciona todos os arquivos para o staged de mudanças, e logo em seguida (‘&amp;&amp;’) executa o commit com o parâmetro -m que nos permite incluir a mensagem descritiva do nosso commit.</p><ul><li><strong>‘c’:</strong> Nome do atalho. Vamos usar git c no terminal.</li><li><strong>!: </strong>Diz ao Git que deve rodar esse comando como se fosse no shell.</li><li><strong>‘git add — all’:</strong> Adiciona todos os arquivos modificados, criados ou deletados ao staged.</li><li><strong>‘&amp;&amp;’:</strong> Só executa o próximo comando se o anterior for bem-sucedido.</li><li><strong>‘git commit -m’:</strong> Inicia o commit com a mensagem inline (a ser completada pelo usuário).</li></ul><p>Importante: a mensagem do commit precisa ser passada ao chamar o comando:</p><ul><li><strong>‘git c: </strong>“feat: adiciona nova função de login”’</li></ul><p>Caso digitemos apenas git c, o terminal pode retornar erro por falta de mensagem para o -m.</p><p><strong>Obs.: </strong>lembre-se que caso não queiramos adicionar todos os arquivos alterados para o processo de commit, deve-se incluir individualmente os arquivos que desejamos com o comando tradicional ‘git add [nome do arquivo]’ e depois executarmos o comando ‘git commit -m “[Mensagem Descritiva]”’. Ou seja, o processo tradicional.</p><h3>git log</h3><p>Também incluiremos o atalho para o comando ‘git log’, utilizando opções de personalização do comando, permitindo uma visualização mais amigável e descritiva.</p><p>Para isso utilizaremos o parâmetro ‘ — prety=format’, que permitirá personalizar a apresentação dos logs, a partir do atalho que iremos criar, com algumas opções específicas:</p><ul><li><strong>‘%h’:</strong> o percentual com a letra ‘h’ minúscula irá apresentar o hash reduzido do commit;</li><li><strong>‘%d’:</strong> o percentual com a letra ‘d’ minúscula irá mostrar a branch, e também a tag caso exista, do commit;</li><li><strong>‘%s’:</strong> o percentual com a letra ‘s’ minúscula (de subject) irá demonstrar a mensagem do commit;</li><li><strong>‘%cn’:</strong> nome da pessoa que realizou o commit;</li><li><strong>‘%cr’: </strong>a data relativa do commit.</li></ul><p>Além dos parâmetros de configuração, utilizaremos a opção de habilitar cores diferentes para cada coluna, o que facilita a visualização, utilizado o parâmetro % com a letra C maiuscula (%C) seguido da cor que desejamos entre parênteses (cor), ex.: %C(blue) → azul.</p><ul><li><strong>‘%C(blue)%h’: </strong>coloca em destaque azul o hash do commit;</li><li><strong>‘%C(red)%d’:</strong> coloca em destaque vermelho a branch e também a tag, caso exista, do commit;</li><li><strong>‘%C(white)%s’:</strong> destaca com a mensagem do commit na cor branca;</li><li><strong>‘%C(cyan)%cn’:</strong> o nome do proprietário do commit é destacado em ciano;</li><li><strong>‘%C(green)%cr’:</strong> em verde é destacado a data relativa (ex: “2 hours ago”).</li></ul><p><strong>‘l = !git log — pretty=format:”%C(blue)%h%C(red)%d %C(white)%s — %C(cyan)%cn, %C(green)%cr”’</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Xm3zbSCNgc96woK_" /><figcaption>Imagem 10: visualização da saída do alias para o git log.</figcaption></figure><p>Com cores aplicadas, a visualização no terminal fica muito mais clara e elegante. Desta forma, o comando permite uma melhor leitura do histórico. Além disso, a apresentação, neste formato, permite mais contexto, otimizado em uma única linha destacando o hash, a referência, mensagem, autor e o tempo do commit. Tudo isso a partir de um visual limpo e colorido diretamente no terminal.</p><p>Vamos aproveitar e incluir uma versão aprimorada do alias ‘l’, configurado anteriormente, que, além de mostrar os commits formatados e coloridos, também exibe a lista de arquivos modificados em cada commit:</p><p><strong>‘lg = !git log — pretty=format:”%C(blue)%h%C(red)%d %C(white)%s — %C(cyan)%cn, %C(green)%cr” — name-only’</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0NGrma5yb2aha5Ii" /><figcaption>Imagem 11: visualização de saída do alias para o git log com lista de arquivos modificados.</figcaption></figure><p>Esse ‘alias’ exibe um resumo colorido do commit em uma linha, o que foi mantido do alias anterior, e acrescenta, abaixo de cada commit, os nomes dos arquivos alterados (um por linha). Esta apresentação é excelente para ter visão rápida do que foi alterado, sem precisar usar o verboso git show. Desta forma a visualização se mantém compacta, mas traz o mínimo necessário para uma revisão, ajudando a navegar e entender o histórico sem sair do terminal.</p><p>A personalização de aliases no Git é uma etapa simples, mas extremamente eficaz para otimizar o fluxo de trabalho diário. Ao substituir comandos longos e repetitivos por atalhos intuitivos, ganhamos agilidade, legibilidade e uma experiência de uso mais fluida no terminal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cNo0pt3Er0IhcXkd" /><figcaption>Imagem 12: exemplo do arquivo de configuração do Git, após configurações dos aliases.</figcaption></figure><p>Além de facilitar operações comuns como status, commit e log, os aliases permitem configurar saídas mais informativas e visuais, contribuindo diretamente para a produtividade e compreensão do histórico de alterações no projeto. Essa prática, apesar de frequentemente negligenciada, representa um diferencial importante no dia a dia de qualquer desenvolvedor.</p><h3>Bloco Adicional</h3><p>Vou disponibilizar um bloco personalizado com outros aliases Git que utilizo, voltados à produtividade no terminal, especialmente úteis para desenvolvedores que usam Git com frequência. É possível adicionar diretamente ao ‘~/.gitconfig’, na sessão alias. Contudo, o mais importante é que possam entender a lógica, a partir destes exemplos, e criar seus próprios aliases conforme suas necessidades.</p><h3>Bloco personalizado</h3><p>[alias]</p><p># Status simplificado</p><p>s = ‘!git status -s’</p><p># Adiciona todos os arquivos e commita com mensagem inline</p><p>c = ‘!git add — all &amp;&amp; git commit -m’</p><p># Log formatado, colorido e compacto</p><p>l = ‘!git log — pretty=format:”%C(blue)%h%C(red)%d %C(white)%s — %C(cyan)%cn, %C(green)%cr”’</p><p># Log formatado + arquivos modificados</p><p>lg = ‘!git log — pretty=format:”%C(blue)%h%C(red)%d %C(white)%s — %C(cyan)%cn, %C(green)%cr”’ — name-only</p><p># Ver branches em árvore</p><p>tree = ‘log — graph — all — decorate — oneline’</p><p># Ver último commit de cada autor (útil para colaboração)</p><p>authors = ‘shortlog -sne’</p><p># Reset do último commit sem perder mudanças</p><p>undo = ‘reset — soft HEAD~1’</p><p># Adicionar arquivo e abrir o editor para escrever o commit</p><p>ac = ‘!git add . &amp;&amp; git commit’</p><p># Buscar e mostrar todos os remotos atualizados</p><p>up = ‘!git fetch — all — prune &amp;&amp; git status’</p><p># Checkout com nome simplificado</p><p>co = ‘checkout’</p><h3>Personalização do Terminal</h3><h3>Oh My Zsh</h3><p>Oh My Zsh é uma poderosa ferramenta de personalização do terminal baseada no shell Zsh (Z Shell). Ele oferece uma ampla variedade de temas visuais e plugins que ajudam a tornar o terminal mais funcional e produtivo. Com recursos como autocompletar inteligente, realce de sintaxe, atalhos de comandos e integração com ferramentas como Git, Docker e Node.js, o Oh My Zsh melhora significativamente a experiência no terminal. O enfoque está em automatizar tarefas repetitivas e navegar com mais eficiência no ambiente de linha de comando.</p><p>Instale o Oh My Zsh via curl simplesmente rodando o comando:</p><pre>sh -c &quot;$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4HwqKH3ncekZrgjj" /><figcaption>Imagem 13: instalação do Oh My Zsh.</figcaption></figure><p>Isso instalará a base de personalização.</p><h3>Configurações iniciais</h3><p>Após instalar o Oh My Zsh, o primeiro passo para personalizar sua experiência no terminal é editar o arquivo de configuração ‘.zshrc’, localizado no seu diretório pessoal. Esse arquivo é responsável por definir como o Zsh será carregado, incluindo o tema visual e os plugins que desejamos utilizar.</p><p>Para começar, abra o terminal e use o editor de sua preferência. Se estiver usando o Visual Studio Code, por exemplo, basta rodar o comando:</p><pre>code ~/.zshrc</pre><p>ou se estiver usando o Cursor</p><pre>cursor ~/.zshrc</pre><p>Ao abrir o arquivo, vamos encontrar diversas configurações pré-definidas, algo como isso:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XcslYTuCPvqCNQuK" /><figcaption>Imagem 14: arquivo de configuração do Oh My Zsh.</figcaption></figure><p>A primeira alteração que vamos proceder se refere a linha que define o tema:</p><pre>ZSH_THEME=&quot;robbyrussell&quot;</pre><p>Essa linha indica qual tema será carregado pelo terminal. O tema padrão é o “robbyrussell”, mas o Oh My Zsh oferece uma grande variedade de temas, localizados na pasta ~/.oh-my-zsh/themes/. Para trocar o visual do seu terminal, basta substituir o nome do tema, como por exemplo:</p><pre>ZSH_THEME=&quot;agnoster&quot;</pre><p>Caso prefira um perfil aleatório, alterando o tema aleatoriamente a cada nova sessão, podemos definir:</p><pre>ZSH_THEME=&quot;random&quot;</pre><p>Com isso, o Oh My Zsh carregará um tema aleatório sempre que o terminal for iniciado.</p><p>Esse processo inicial é simples, mas poderoso: nos permite personalizar o terminal de acordo com nosso gosto e necessidades, tornando sua rotina mais visual, informativa e produtiva.</p><p>Após reiniciar o terminal deveremos ter uma visualização similar a imagem apresentada abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JpUq5X-gEwtiDLYP" /><figcaption>Imagem 15: terminal após alteração do tema default.</figcaption></figure><p>Note, na imagem acima, que alguns caracteres especiais não são exibidos corretamente. Isso ocorre porque a apresentação desses caracteres especiais necessita de fontes específicas que suportam o tema agnoster. Entre as fontes disponíveis temos a Powerline fonts (que possui um pacote com várias tipografias com esses caracteres) e a ‘Fira Code’. Particularmente prefiro a ‘Fira Code’, mas as duas podem ser instaladas da mesma forma.</p><p>Para instalar a ‘Fira Code’, baixe o zip: <a href="https://github.com/tonsky/FiraCode">https://github.com/tonsky/FiraCode</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yME4iAvb7V1F3sxW" /><figcaption>Imagem 16: fonte Fira Code monospaced com ligaduras.</figcaption></figure><p>Após instalar a fonte, podemos realizar a configuração apropriada no terminal. Para isso, acesse as preferências do terminal e depois a aba perfis. Clique para mudar a fonte e escolha a ‘Fira Code’. Pode ser preciso alterar o ‘Line Spacing’ para um melhor alinhamento, no meu terminal alterei para 1,004. Veja só:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sBk6qcp01LPGB3YY" /><figcaption>Imagem 17: aba para configuração da fonte do terminal.</figcaption></figure><p>Após ajustar a fonte apropriada, reinicie o terminal. Como resultado devemos ter a visualização apresentada a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0lj4QV_7Iarlz7F3" /><figcaption>Imagem 18: terminal após configuração da fonte específica para o tema.</figcaption></figure><h3>Powerlevel10k</h3><p>Se desejarmos levar a personalização do seu terminal a outro nível, pode instalar temas que não vêm por padrão no pacote do Oh My Zsh. Um dos mais populares e completos é o Powerlevel10k, conhecido por seu visual moderno, alta performance e diversas opções de customização visual.</p><p>Para que possamos proceder com a instalação do Powerlevel10k, devemos clonar o repositório dentro da pasta de temas personalizados do Oh My Zsh. Para facilitar o processo vamos acessar o diretório de temas: ‘cd ~/.oh-my-zsh/custom/themes’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jYlDQyWvM8in0qFs" /><figcaption>Imagem 19: diretório default para os temas do Oh My Zsh.</figcaption></figure><p>Dentro da pasta de temas personalizados do Oh My Zsh podemos clonar o repositório Powerlevel10k. Execute o comando abaixo no terminal:</p><pre>git clone --depth=1 https://github.com/romkatv/powerlevel10k.git \ &quot;${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k&quot;</pre><h3>Configure o novo tema</h3><p>Após a clonagem, é hora de ativar o Powerlevel10k. Para isso, abra o arquivo de configuração ‘.zshrc’ no seu editor preferido, repetindo o processo realizando anteriormente, agora alterando para o tema ‘ZSH_THEME=powerlevel10k/powerlevel10k’.</p><p>Encontre a linha que define o tema atual, normalmente algo como:</p><pre>ZSH_THEME=&quot;agnoster&quot;</pre><p>Substitua por:</p><pre>ZSH_THEME=&quot;powerlevel10k/powerlevel10k&quot;</pre><p>Depois de salvar as alterações, reinicie o terminal. Ao abrir novamente, o Powerlevel10k iniciará um assistente interativo de configuração que permite personalizar o prompt de forma visual, escolhendo fontes, símbolos e estrutura da interface.</p><p>Rode a configuração interativa:</p><pre>p10k configure</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HUzchDgkCSX6tbGS" /><figcaption>Imagem 20: wizard de configuração para o Oh My Zsh.</figcaption></figure><p>A configuração pelo wizard é bem completa e irá gerar um arquivo na sua ‘home ~/.p10k.zsh’ contendo todo o setup. A qualquer momento poderemos alterar as configurações editando esse arquivo</p><h3>Layout e recursos após personalização</h3><p>Após a conclusão das configurações propostas no wizard, ou executadas manualmente no arquivo .p10k.zsh, por meio do comando: ‘cursor ~/.p10k.zsh’ (utilizando o Cursor como editor) ou ‘code ~/.p10k.zsh’ (quando o VSCode for o editor), iremos ter uma visualização do terminal similar a proposta abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*o1Ek6HturnIIMmDA" /><figcaption>Imagem 21: visual e recursos do terminal após personalizações.</figcaption></figure><p>Recursos visuais:</p><ol><li>Truncate do path: para que o terminal não apresente o caminho completo do projeto, o que tornaria a visualização poluída, optei por apresentar apenas o diretório raiz do projeto, omitindo a hierarquia de pastas completa;</li><li>Descrição da branch: apresentação da branch atual do projeto, permitindo fácil identificação;</li><li>Marcadores verde/amarelo: se a branch estiver com todas as suas alterações registradas em commit, o marcador da branch será verde, caso existam arquivos não comitados o marcador se encontra na cor amarela e demonstra o número de arquivos alterados desde o último registro;</li><li>Símbolo do SO: logo referente ao sistema operacional em uso. Neste caso, funciona mais como um recurso de estilização. Contudo, se mostra útil na formatação de documentação técnica, pois já explicita qual o SO está sendo utilizado</li><li>Versão da linguagem: apresentação da versão da linguagem de desenvolvimento utilizada no projeto. Informação essencial para gestão de dependências e compatibilidade de recursos;</li><li>Horário: registra o horário da execução do último comando no terminal.</li></ol><h3>Plugins</h3><p>Depois de configurar o tema do seu terminal, o próximo passo para turbinar sua experiência com o Oh My Zsh é adicionar plugins. Esses complementos oferecem funcionalidades poderosas como sugestões automáticas, realce de sintaxe, busca avançada no histórico e navegação inteligente entre pastas. A instalação é simples, e os ganhos são imediatos!</p><p>Acesse o diretório de plugins personalizados:</p><p>Abra o terminal e vá até a pasta onde os plugins customizados do Oh My Zsh devem ser adicionados:</p><pre>cd ~/.oh-my-zsh/custom/plugins</pre><p>Clone os repositórios dos plugins desejados:</p><p>Aqui estão alguns dos plugins mais úteis para começar:</p><pre>git clone https://github.com/zsh-users/zsh-autosuggestions<br>git clone https://github.com/zsh-users/zsh-completions<br>git clone https://github.com/zsh-users/zsh-history-substring-search<br>git clone https://github.com/zsh-users/zsh-syntax-highlighting</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fiO4SF5zzXCauANO" /><figcaption>Imagem 22: diretório default para os plugins do Oh My Zsh.</figcaption></figure><p>Após clonar os repositórios, dos plugins, para o diretório padrão do Oh My Zsh devemos ativar estes recursos no arquivo de configuração ‘.zshrc’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6Lyh1smIU4INvvAP" /><figcaption>Imagem 23: habilitar plugins no arquivo de configuração .zshrc.</figcaption></figure><h3>Carregue manualmente os plugins que precisam ser iniciados por último</h3><p>Alguns plugins do Oh My Zsh, como: zsh-autosuggestions e zsh-syntax-highlighting, atuam diretamente sobre o comportamento visual e funcional do prompt enquanto digitamos. Eles mexem com a forma como comandos são exibidos (com sugestão em cinza claro, por exemplo), também alteram a cor da sintaxe (verde para comandos válidos, vermelho para inválidos) e às vezes até com os bindings de teclado</p><pre>source ~/.oh-my-zsh/custom/plugins/zsh-autosuggestions/zsh-autosuggestions.zsh<br>source ~/.oh-my-zsh/custom/plugins/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh</pre><p>Essa ordem garante que os plugins sejam interpretados corretamente pelo shell, evitando bugs ou comportamento inesperado.</p><p>Para garantir a implantação das alterações execute novamente o comando:</p><pre>source ~/.zshrc</pre><h3>Descrição dos plugins</h3><h3>1. zsh-autosuggestions</h3><p>Sugere comandos anteriores automaticamente, em cinza claro à direita enquanto digitamos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MP8M7p3bgcAv3U0M" /><figcaption>Imagem 24: exemplo do uso do plugin zsh-autosuggestions.</figcaption></figure><p>Dica: pressione → (seta para direita) para aceitar a sugestão.</p><h3>2. zsh-completions</h3><p>Melhora e amplia a autocompletação de comandos, opções e argumentos.</p><p>Digite no terminal:</p><pre>git checkout [TAB][TAB]</pre><p>Ele deve listar todas as branches disponíveis com autocompletar inteligente.</p><p>Esse plugin é sutil — ele expande a quantidade de opções reconhecidas, então somente percebemos usando comandos variados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ii5Tn4k0cu1efifF" /><figcaption>Imagem 25: exemplo do uso do plugin zsh-completions.</figcaption></figure><h3>3. zsh-history-substring-search</h3><p>Permite pesquisar comandos do histórico digitando qualquer parte do comando, e navegando com as setas.</p><p>Vamos digitar parte de um comando que já tenhamos usado, por exemplo:</p><pre>docker</pre><p>Pressione as setas ↑ ou ↓.Ele deve trazer comandos anteriores que contenham ‘docker’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UGuGrrgKkmXOV--X" /><figcaption>Imagem 26: exemplo do uso do plugin zsh-history-substring-search.</figcaption></figure><h3>4. zsh-syntax-highlighting</h3><p>Destaca comandos válidos em verde, inválidos em vermelho, argumentos em amarelo, etc.</p><p>Digite um comando válido:</p><pre>ls -la</pre><p>Ele deve aparecer colorido e destacado (verde normalmente).</p><p>Digite um comando inválido:</p><pre>lss -la</pre><p>Ele deve aparecer vermelho, indicando erro de sintaxe.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*56czYdE5x-zvcbOK" /><figcaption>Imagem 27: exemplo do uso do plugin zsh-syntax-highlighting.</figcaption></figure><h3>Conclusão</h3><p>Personalizar o ambiente de desenvolvimento vai muito além da estética — trata-se de criar um ecossistema alinhado ao seu fluxo de trabalho, que favoreça agilidade, clareza e prazer em codar. Ao integrar ferramentas como Oh My Zsh, VSCode e Cursor com configurações otimizadas, temas inteligentes e plugins poderosos, é possível transformar o terminal em um verdadeiro hub de produtividade. Espero que este guia tenha servido como ponto de partida para explorarmos ainda mais as possibilidades de personalização, e que as práticas aqui compartilhadas contribuam para tornar seu dia a dia como desenvolvedor mais fluido, eficiente e agradável.</p><h3>Referências</h3><p>CURSOR. Getting Started — Cursor Documentation. Disponível em: <a href="https://docs.cursor.com/get-started/welcome">https://docs.cursor.com/get-started/welcome</a>. Acesso em: 15 abr. 2025.</p><p>MICROSOFT. Visual Studio Code Documentation. Disponível em: <a href="https://code.visualstudio.com/docs">https://code.visualstudio.com/docs</a>. Acesso em: 15 abr. 2025.</p><p>OH MY ZSH. Oh My Zsh Wiki. GitHub, 2025. Disponível em: <a href="https://github.com/ohmyzsh/ohmyzsh/wiki">https://github.com/ohmyzsh/ohmyzsh/wiki</a>. Acesso em: 15 abr. 2025.</p><p>OPENAI. ChatGPT — Assistente baseado em IA. OpenAI, 2025. Disponível em: <a href="https://chat.openai.com/">https://chat.openai.com/</a>. Acesso em: 15 abr. 2025.</p><p>THE GIT COMMUNITY. Git Documentation. Disponível em: <a href="https://git-scm.com/doc">https://git-scm.com/doc</a>. Acesso em: 15 abr. 2025.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=343eb50af39b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[EWV — Encapsulate What Varies : A Arte de Tornar o Código Preparado para Mudanças]]></title>
            <link>https://elisandromello.medium.com/ewv-encapsulate-what-varies-a-arte-de-tornar-o-c%C3%B3digo-preparado-para-mudan%C3%A7as-221bb604f1dc?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/221bb604f1dc</guid>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Fri, 11 Apr 2025 18:23:43 GMT</pubDate>
            <atom:updated>2025-04-11T18:23:43.161Z</atom:updated>
            <content:encoded><![CDATA[<h3>EWV — Encapsulate What Varies : A Arte de Tornar o Código Preparado para Mudanças</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zAPjg32BU_MW4YUm" /></figure><p>No artigo <a href="https://www.linkedin.com/pulse/princ%C3%ADpios-que-todo-engenheiro-s%C3%AAnior-deveria-voc%C3%AA-mello-corr%C3%AAa-kuiif/?trackingId=v%2Bkgug54RvixXoUNApr%2BXQ%3D%3D">Princípios que todo Engenheiro Sênior deveria conhecer. Você conhece?</a>, propus uma série de textos abordando os principais princípios de codificação. Demorei mais do que esperava, mas esta é a primeira parte da série Princípios de Design para a Vida.</p><p>Seguir esses fundamentos permitirá que você faça a escolha “certa” na maioria das situações. É claro que sempre haverá exceções — as regras não são absolutas. Deixar de seguir um padrão pode ser aceitável, desde que você compreenda claramente por que está escolhendo um caminho alternativo em vez de seguir uma estrutura extensivamente testada pelos melhores programadores.</p><p>Para iniciar esta série, vamos analisar o princípio EWV — Encapsulate What Varies, que propõe o encapsulamento de elementos sujeitos a variação, promovendo maior estabilidade diante de mudanças. Sabemos que o melhor teste para avaliar um bom design de software é a sua capacidade de lidar bem com mudanças futuras.</p><p>A única constante é a mudança. Inevitavelmente, qualquer pedaço de software em uso será solicitado a evoluir — seja porque as necessidades do negócio mudaram, porque o problema passou a ser melhor compreendido ou por outros motivos. Um bom design permite essa evolução com pouco esforço. Um design ruim, por outro lado, torna qualquer ajuste um verdadeiro desafio.</p><h3>Compreendendo o princípio “Encapsular o que varia”</h3><p>Encapsular o que varia significa isolar as partes do código mais suscetíveis a mudanças, separando-as das estruturas mais estáveis. Essa prática facilita a manutenção, os testes, a extensibilidade e a reutilização do código, além de reduzir o impacto de alterações futuras.</p><p>O princípio Encapsulate What Varies (EWV) é um dos fundamentos do design orientado a objetos descritos no clássico da engenharia de software Design Patterns: Elements of Reusable Object-Oriented Software (1994), de Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides, conhecidos como Gang of Four (GoF). Nesse livro, os autores afirmam:</p><blockquote><em>❝Identifique os aspectos da sua aplicação que variam e separe-os do que permanece o mesmo.❞ (GoF, 2000)</em></blockquote><p>Esse enunciado representa a raiz do princípio EWV. Ele sugere que as partes do sistema com maior propensão a mudanças devem ser extraídas, isoladas ou encapsuladas, de forma a preservar a estabilidade e integridade das demais estruturas do sistema.</p><p>O princípio Encapsulate What Varies é mencionado logo no início do capítulo introdutório como uma filosofia central por trás de diversos padrões de projeto, especialmente:</p><ul><li>Strategy</li><li>Decorator</li><li>Observer</li><li>State</li></ul><blockquote><em>❝Projetar para mudança é um dos objetivos mais importantes do design orientado a objetos. A chave para esse objetivo é encapsular os aspectos da aplicação que estão sujeitos a mudanças.❞ — GoF, Cap. 1 — Introduction</em></blockquote><p>Considerado uma verdadeira pedra angular do design de software, o princípio EWV enfatiza a importância de isolar as partes de um sistema que provavelmente evoluirão. Essa abordagem visa minimizar o impacto de modificações na base de código como um todo, promovendo maior manutenibilidade, adaptabilidade e resiliência frente a requisitos em constante transformação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/978/0*BMb-mqtvbcDltGFh" /><figcaption>Imagem 1: ilustração do conceito de encapsulamento dos elementos variáveis, permitindo que sejam melhor gerenciados</figcaption></figure><p>Em sua essência, o princípio Encapsulate What Varies defende a separação entre componentes estáveis e aqueles que estão mais sujeitos a modificações. Ao isolar elementos propensos a mudanças, os desenvolvedores conseguem reduzir o efeito cascata de alterações, o que simplifica a manutenção e torna futuras atualizações mais controláveis. Essa abordagem não apenas contribui para o gerenciamento da complexidade, como também oferece suporte à escalabilidade do software, permitindo que ele evolua de maneira mais fluida ao longo do tempo.</p><p>No livro Head First Design Patterns, os autores Eric Freeman e Elisabeth Robson apresentam o princípio EWV como um dos pilares conceituais para aplicação de padrões como Strategy e State:</p><blockquote><em>❝O primeiro princípio de design é Encapsular o que varia. Esse é o mantra que permite que você escreva um código flexível e sustentável, pegando as partes do seu programa que estão sujeitas a mudanças e isolando-as daquelas que não estão.❞ — Head First Design Patterns, Cap. 1 — Welcome to Design Patterns</em></blockquote><p>Na prática, isso significa identificar os aspectos do sistema que tendem a mudar com maior frequência — como regras de negócio, algoritmos, formatos de entrada/saída, protocolos de comunicação, entre outros — e encapsulá-los utilizando mecanismos apropriados, como interfaces, composição, herança, injeção de dependência ou padrões de projeto. Ao adotar essa estratégia, cria-se uma base de código mais modular, resiliente e preparada para evoluções contínuas.</p><h3>Características Essenciais do Princípio “Encapsular o que Varia”</h3><p>A adoção de boas práticas de design de software é essencial para construir sistemas robustos, sustentáveis e preparados para a mudança. Um dos princípios fundamentais nesse processo é a separação entre o que varia e o que permanece constante. A seguir, exploramos algumas estratégias práticas para identificar e lidar com a variabilidade no desenvolvimento de software, promovendo um design mais modular, flexível e de fácil manutenção.</p><ul><li><strong>Identificação de Variabilidade:</strong> Uma etapa inicial crítica é identificar componentes dentro do sistema que podem estar sujeitos a modificações frequentes. Esses componentes variáveis podem incluir recursos, algoritmos ou até mesmo integrações externas, e reconhecê-los logo no início pode orientar escolhas de design eficazes.</li><li><strong>Isolamento de Componentes Variáveis:</strong> Uma vez identificados, os componentes variáveis devem ser encapsulados dentro de módulos ou componentes dedicados. Esse isolamento garante que as alterações nessas áreas permaneçam contidas, prevenindo efeitos colaterais não intencionais em todo o aplicativo.</li><li><strong>Utilização de Abstração e Interfaces:</strong> Encapsular componentes variáveis envolve abstrair sua implementação por meio de interfaces ou classes abstratas, permitindo que diferentes implementações sejam usadas de forma intercambiável. Esse desacoplamento da implementação do uso promove a flexibilidade, facilitando a troca de partes do sistema sem interromper sua estrutura geral.</li><li><strong>Flexibilidade e Extensibilidade Aprimoradas:</strong> Ao isolar a variabilidade, esse princípio aprimora significativamente a flexibilidade e a extensibilidade do sistema. Com módulos bem definidos em vigor, os desenvolvedores podem adicionar novos recursos, modificar os existentes ou substituir componentes conforme necessário, tudo isso preservando a integridade do aplicativo mais amplo.</li></ul><h3>O EWV no SOLID</h3><p>O princípio Encapsulate What Varies (EWV) está intimamente ligado à filosofia SOLID de design orientado a objetos, especialmente aos princípios SRP (Single Responsibility Principle) e OCP (Open/Closed Principle). De acordo com Robert C. Martin (Uncle Bob), o SRP estabelece que uma classe deve ter apenas uma razão para mudar. Nesse contexto, encapsular comportamentos variáveis é uma maneira eficaz de isolar essas razões, promovendo alta coesão e facilitando a manutenção do código. Separar responsabilidades em unidades menores e específicas reduz o acoplamento e torna o sistema mais previsível diante de alterações.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-Ii0cnNmqB3Pnw2V" /><figcaption>Imagem 2: ilustração do princípio do SOLID — SRP (Single Responsibility Principle)</figcaption></figure><p>Por outro lado, o OCP, proposto por *Bertrand Meyer, afirma que classes devem ser abertas para extensão e fechadas para modificação. Ao encapsular o que pode variar, é possível adicionar novos comportamentos ou funcionalidades por meio de composição ou implementação de interfaces, sem modificar o código existente. Essa prática reduz riscos ao evoluir o sistema.</p><blockquote><em>❝Entidades de software (classes, módulos, funções, etc.) devem ser abertas para extensão, mas fechadas para modificação❞ — Bertrand Meyer</em></blockquote><p>Em Agile Software Development: Principles, Patterns, and Practices (2002), Martin aprofunda essa abordagem, defendendo o uso intencional de abstrações, composição e herança como estratégias para desenvolver sistemas flexíveis, extensíveis e resistentes a mudanças.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6JdE61Fo28Y6W1bw" /><figcaption>Imagem 3: ilustração do princípio do SOLID — OCP (Open/Closed Principle)</figcaption></figure><h3>EWV sendo aplicado no Strategy</h3><p>Um dos exemplos mais emblemáticos da aplicação do princípio Encapsulate What Varies (EWV) no design orientado a objetos é o padrão de projeto Strategy, amplamente difundido pela já citada obra do Gang of Four (GoF). Este padrão fornece uma abordagem robusta para isolar comportamentos que podem variar, definindo-os como algoritmos encapsulados em classes independentes e intercambiáveis. Ao adotar Strategy, permite-se que diferentes comportamentos possam ser selecionados ou modificados em tempo de execução, sem que seja necessário alterar a estrutura dos objetos que os utilizam, promovendo extensibilidade e baixo acoplamento no sistema.</p><blockquote><em>❝Defina uma família de algoritmos, encapsule cada um e torne-os intercambiáveis. A estratégia permite que o algoritmo varie independentemente dos clientes que o usam.❞ (GoF, 2000, p. 292)</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/901/0*oQNW7GMjIW9jvJzK" /><figcaption>Imagem 4: Strategy Pattern simplified.</figcaption></figure><p>O Strategy Pattern permite trocar o comportamento de um objeto em tempo de execução, sem alterar sua estrutura. O comportamento é isolado numa abstração (interface) e implementado por diversas estratégias concretas.</p><h3>Aplicação em Paradigmas de Programação</h3><p>O princípio “Encapsule o que varia” é altamente adaptável e pode ser aplicado efetivamente em vários paradigmas de programação, cada um com estratégias exclusivas para encapsular mudanças.</p><ul><li><strong>Programação Orientada a Objetos (POO):</strong> Em POO, esse princípio frequentemente alavanca interfaces, polimorfismo e herança para isolar comportamento variável. Por meio do uso de classes abstratas e interações polimórficas, os sistemas podem encapsular comportamentos em classes dedicadas, facilitando a modificação da funcionalidade sem afetar o restante do aplicativo.</li><li><strong>Programação Funcional:</strong> Na programação funcional, a variabilidade é tipicamente gerenciada através do uso de funções puras e funções de ordem superior. Ao isolar efeitos colaterais e encapsular comportamentos variáveis dentro de funções específicas, as linguagens de programação funcional promovem modularidade e componibilidade, alinhando-se bem com o princípio “Encapsulate What Varies”.</li><li><strong>Programação Modular: </strong>O princípio também é bem adequado para programação modular, onde os sistemas são compostos de módulos discretos e autocontidos. Ao definir interfaces claras para comunicação entre módulos, os desenvolvedores podem isolar a funcionalidade e aprimorar a reutilização, facilitando a atualização ou substituição de componentes sem modificar o sistema inteiro.</li></ul><h3>Estratégias para implantação do EWV</h3><p>Aqui estão algumas maneiras de aplicar o princípio de encapsular o que varia:</p><ul><li><strong>Use abstração:</strong> Identifique as partes do sistema que estão sujeitas a mudanças e crie abstrações que as representem. Essas abstrações devem fornecer uma interface bem definida para o resto do sistema e encapsular os detalhes de sua implementação.</li><li><strong>Aplique o Princípio Aberto/Fechado: </strong>O Princípio Aberto/Fechado afirma que as entidades de software devem ser abertas para extensão, mas fechadas para modificação. Isso significa que devemos projetar nosso software de uma forma que nos permita adicionar novas funcionalidades sem ter que modificar o código existente. Uma maneira de conseguir isso é usando abstração e polimorfismo.</li><li><strong>Use Dependency Injection:</strong> Dependency Injection é um padrão de design que nos permite injetar dependências em uma classe em vez de deixar que a classe as crie ela mesma. Ao fazer isso, podemos facilmente trocar dependências com diferentes implementações sem ter que modificar a classe em si.</li><li><strong>Aplicar Separação de Preocupações:</strong> Separação de Preocupações é um princípio de design que afirma que o software deve ser dividido em partes distintas, cada uma das quais é responsável por um aspecto específico da funcionalidade. Ao fazer isso, podemos garantir que cada parte do sistema tenha uma única responsabilidade e não seja afetada por mudanças em outras partes do sistema.</li><li><strong>Configuração:</strong> Podemos usar arquivos de configuração para especificar qual implementação de uma abstração deve ser usada em tempo de execução. Ao fazer isso, podemos alternar entre diferentes implementações sem ter que recompilar o código.</li></ul><h3>Exemplo prático: encapsulando conexões de banco de dados em um aplicativo da Web</h3><p>Para ilustrar o princípio “Encapsulate What Varies”, considere um aplicativo web que interage com um banco de dados. Inicialmente, esse código pode incorporar diretamente a lógica de conexão do banco de dados em funções que manipulam a lógica do aplicativo, conforme mostrado abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/0*51vE9LctsQ1FOE8C" /></figure><p>Nesta versão, a conexão do banco de dados e a lógica de consulta são interligadas com a lógica do aplicativo. Se o tipo de banco de dados mudar, o código exigirá modificações extensas, arriscando erros e desafios de manutenção.</p><p>Aplicando o princípio “Encapsulate What Varies”, o código pode ser reestruturado para isolar as interações do banco de dados em uma classe dedicada, conforme mostrado abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wY4CmWokVc-xKJbr" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*12IhtvSrDQbcwl09" /></figure><p>Exemplo de uso:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rJW4mTYC1eC9JS2q" /></figure><p>Esta abordagem revisada encapsula a lógica do banco de dados dentro de uma classe SQLiteDatabaseConnection, que implementa a interface DatabaseConnection. O encapsulamento fornece uma arquitetura flexível: alternar para uma implementação de banco de dados diferente (como MySQL ou PostgreSQL) requer apenas a criação de uma nova classe que esteja em conformidade com a mesma interface, deixando o resto do aplicativo inalterado.</p><h3>Benefícios deste esforço</h3><p>Como vimos no exemplo acima, há várias razões pelas quais devemos aplicar o princípio de encapsular o que varia:</p><ul><li><strong>Flexibilidade:</strong> Ao encapsular as partes do sistema que estão sujeitas a mudanças, facilitamos a modificação ou substituição dessas partes sem afetar o restante do sistema. Isso torna o sistema mais flexível e mais fácil de se adaptar a requisitos de mudança.</li><li><strong>Reusabilidade:</strong> Ao criar abstrações que representam as partes do sistema que estão sujeitas a mudanças, tornamos possível reutilizar essas abstrações em diferentes contextos. Isso pode economizar tempo e esforço ao desenvolver novos recursos ou aplicativos.</li><li><strong>Mantenabilidade:</strong> Ao isolar o impacto das mudanças em uma parte específica do sistema, facilitamos a manutenção do sistema ao longo do tempo. Isso reduz o risco de introduzir efeitos colaterais não intencionais ou quebrar a funcionalidade existente.</li><li><strong>Testabilidade:</strong> Ao encapsular as partes do sistema que estão sujeitas a mudanças, facilitamos o teste dessas partes isoladamente. Isso nos permite identificar e corrigir problemas mais rapidamente e com maior confiança.</li><li><strong>Escalabilidade:</strong> Ao projetar o sistema com o encapsulamento em mente, podemos facilitar a escala do sistema horizontal ou verticalmente. Isso pode ajudar a garantir que o sistema permaneça com desempenho e confiável conforme o número de usuários ou a quantidade de dados cresce.</li></ul><h3>Conclusão</h3><p>O princípio “Encapsulate What Varies” é uma estratégia de design essencial para a construção de sistemas de software robustos, sustentáveis e extensíveis. Ao identificar e isolar aspectos variáveis de um aplicativo, esse princípio permite que os desenvolvedores gerenciem a complexidade, acomodem mudanças futuras e melhorem a qualidade geral do código. Sua aplicação em vários paradigmas e linguagens ressalta sua adaptabilidade e relevância no desenvolvimento de software moderno. Adotar esse princípio pode contribuir para a criação de soluções de software sustentáveis que podem evoluir em resposta a novos requisitos, tornando-o um ativo valioso no kit de ferramentas de todo designer e desenvolvedor de software.</p><p><strong>* Bertrand Meyer: </strong>criador da linguagem de programação Eiffel, muito conhecido por suas contribuições à engenharia de software, em especial na área de programação orientada a objetos e design de software robusto</p><h3>Referências</h3><p>GAMMA, Erich; HELM, Richard; JOHNSON, Ralph; VLISSIDES, John. Design patterns: elements of reusable object-oriented software. 1. ed. Boston: Addison-Wesley, 2000.</p><p>FREEMAN, Eric; ROBSON, Elisabeth. Head first design patterns. 1. ed. Beijing: O’Reilly Media, 2004.MARTIN, Robert C. Agile software development: principles, patterns, and practices. 1. ed. Upper Saddle River: Prentice Hall, 2002.</p><p>MASONCODING. Encapsulate what varies: a foundational principle in software design. Disponível em: <a href="https://medium.com/@Masoncoding/encapsulate-what-varies-a-foundational-principle-in-software-design-f0cca11131f2.">https://medium.com/@Masoncoding/encapsulate-what-varies-a-foundational-principle-in-software-design-f0cca11131f2.</a> Acesso em: 06 abr. 2025.</p><p>PANKAJ. Encapsulate what varies (EWV) — design principle. Disponível em: <a href="https://neatcode.org/encapsulate-what-varies/">https://neatcode.org/encapsulate-what-varies/.</a> Acesso em: 06 abr. 2025.</p><p>ROWE, Steve. Encapsulate what varies. Disponível em: <a href="https://learn.microsoft.com/en-gb/archive/blogs/steverowe/encapsulate-what-varies.">https://learn.microsoft.com/en-gb/archive/blogs/steverowe/encapsulate-what-varies.</a> Acesso em: 06 abr. 2025.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=221bb604f1dc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stock Options: Oportunidade ou Cilada? Tudo o Que Você Precisa Saber Antes de Aceitar]]></title>
            <link>https://elisandromello.medium.com/stock-options-oportunidade-ou-cilada-tudo-o-que-voc%C3%AA-precisa-saber-antes-de-aceitar-48af89ce3dbd?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/48af89ce3dbd</guid>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Wed, 05 Mar 2025 15:16:13 GMT</pubDate>
            <atom:updated>2025-03-05T15:16:13.350Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*59YlSqppTZTOiClvU-M5Nw.png" /></figure><p>Nos últimos anos, tem se tornado comum que startups ofereçam a desenvolvedores propostas que incluam participação em Stock Options ou Equity como parte da composição salarial. Embora esse modelo seja frequentemente associado a uma espécie de sociedade, essa caracterização nem sempre reflete a realidade. Como é um conceito relativamente novo para muitos profissionais, desenvolvedores costumam não compreender totalmente sua mecânica, o que pode dificultar a análise precisa dos benefícios e riscos envolvidos.</p><p>Para tomar decisões mais bem fundamentadas, é essencial e ntender esses modelos, evitando frustrações futuras. Este artigo tem como objetivo esclarecer essa temática e oferecer uma base para avaliar tais propostas com maior segurança.</p><h3>Por que StartUps têm proposto este tipo de modelo?</h3><p>Startups geralmente operam com recursos financeiros limitados e precisam ser estratégicas na gestão de seus investimentos, seja em um modelo bootstrapped ou financiado por investidores. Dentro desse cenário, a área de engenharia é uma das mais onerosas no cálculo de headcount, o que torna essencial buscar alternativas para mitigar custos operacionais. Uma estratégia comum é oferecer um salário menor combinado com cotas de participação, normalmente no modelo de Stock Options, o que permite que a empresa economize e ainda atraia talentos qualificados. Dessa forma, os custos fixos com salários são reduzidos, possibilitando maior investimento em crescimento, marketing e desenvolvimento do produto.</p><p>Além do aspecto econômico, outro fator relevante é a conexão entre o sucesso da empresa e o retorno financeiro do colaborador. A possibilidade de ganhos futuros com o crescimento da startup induz um maior senso de pertencimento e uma mentalidade de dono, o que tende a aumentar a motivação e o engajamento do profissional na busca pelo sucesso da empresa.</p><p>Esse vínculo de reciprocidade também funciona como um importante elemento de atração de talentos. Cada vez mais, engenheiros de software demonstram interesse em participar ativamente da construção de um produto, indo além da simples execução de tarefas. Startups, por sua vez, não conseguem competir com as gigantes da tecnologia em termos de salários e benefícios imediatos, mas podem se posicionar como oportunidades de alto potencial de retorno no futuro — algo que grandes empresas geralmente não oferecem com a mesma flexibilidade.</p><p>Profissionais que apreciam ambientes dinâmicos e de empreendedorismo podem se sentir atraídos pelo modelo de participação, que proporciona a chance de lucrar de forma significativa em caso de sucesso, semelhante à experiência de um investidor ou sócio. Ou seja, trata-se de um convite a empreender, trazendo consigo tanto suas oportunidades quanto seus riscos.</p><p>Por fim, um fator determinante nesse modelo é a retenção de talentos. As Stock Options costumam estar vinculadas a cláusulas de Vesting, que estipulam uma liberação gradual das opções conforme o profissional atinge períodos mínimos de permanência na empresa. Esse mecanismo reduz a rotatividade e evita a perda de capital intelectual, algo ainda mais crítico para startups em estágio inicial de desenvolvimento de produto.</p><h3>Modelos de participação mais utilizados</h3><p>Existem diferentes modelos de participação que podem compor a proposta oferecida ao profissional. Entre os mais comuns estão Stock Options e Equity. Neste artigo, vamos nos aprofundar no modelo de Stock Options, pois é o mais frequentemente adotado por startups e, além disso, ambos os modelos possuem características bastante semelhantes em termos de cláusulas e regras.</p><p>A diferença principal entre esses modelos é que, no caso das Stock Options, o profissional não recebe as ações automaticamente após o período de Vesting. Ele apenas ganha o direito de comprá-las por um valor fixo definido no contrato (chamado de Strike Price). Já no modelo de Equity, uma vez cumprido o período de Vesting e atendidas as cláusulas contratuais, o profissional passa a possuir efetivamente as cotas, sem a necessidade de um investimento adicional para comprá-las.</p><p>Além desses, existem modelos alternativos, como as Phantom Shares (ações fantasmas), que funcionam como um bônus financeiro atrelado ao crescimento da empresa, sem que o funcionário se torne acionista. Outro exemplo é o Profit Sharing (participação nos lucros), onde os ganhos variam conforme os resultados financeiros da empresa. Esses modelos são menos comuns em propostas de co-participação e, por isso, não serão abordados neste artigo.</p><h3>Características dos Modelos de Co-participação</h3><p>Cada modelo de co-participação possui características específicas, com vantagens e riscos distintos, adotados estrategicamente conforme o estágio da startup e o perfil do colaborador. Enquanto alguns modelos oferecem participação direta na empresa, outros condicionam a aquisição de cotas a determinados critérios e períodos de Vesting.</p><p>Os modelos de co-participação permitem que os profissionais compartilhem financeiramente dos resultados da empresa, incentivando maior engajamento e alinhamento entre seus interesses individuais e os objetivos organizacionais. Essa abordagem não apenas fortalece a cultura de pertencimento, mas também contribui para a retenção de talentos em um ambiente altamente competitivo.</p><h3>Conceitos e Cláusulas Fundamentais</h3><p>Antes de falarmos propriamente do modelo de opções de compra, é essencial compreender alguns conceitos e cláusulas fundamentais que regem essas estruturas. Esses princípios são a base para o funcionamento dos acordos de co-participação, garantindo clareza na relação entre empresa e colaborador, além de proporcionar uma análise mais precisa dos diversos contextos possíveis.</p><p>Entre os conceitos mais importantes, destacam-se Vesting, Cliff, Strike Price, e Liquidity Events, que influenciam diretamente a forma como os benefícios são concedidos e exercidos ao longo do tempo. Compreender esses elementos facilita a avaliação do modelo mais adequado às necessidades da empresa e dos profissionais envolvidos.</p><ul><li>Strike Price (Preço de Exercício): é o valor fixado pelo qual o colaborador pode comprar as ações no futuro. Esse preço geralmente é estabelecido no momento da concessão e permanece fixo. Também chamado de preço de exercício, é o valor pelo qual o colaborador tem o direito de adquirir as ações quando for exercer as opções de compra.</li><li>Cliff: Período inicial, normalmente de 1 ano, no qual o colaborador não recebe nenhuma opção. Após o cliff, ele adquire um percentual inicial e continua a receber as opções gradualmente conforme o Vesting. Neste período o beneficiário ainda não pode exercer a opção de compra das ações da empresa. Na prática, é como se fosse um prazo de experiência, no qual empresa e o profissional estão se conhecendo e avaliando a parceria futura.</li><li>Vesting: Passado o Cliff, temos o período de Vesting, que é quando o colaborador começa a adquirir gradualmente o direito de comprar as ações. Geralmente segue um cronograma de 3 a 5 anos, com parcelas liberadas ao longo do tempo. De forma geral, as empresas escalonam o Vesting (permitem que as ações sejam adquiridas em etapas). Assim, o profissional é incentivado a permanecer na empresa para obter totalmente o benefício das Stock Options</li><li>Lock up: período no qual o beneficiário não pode vender as ações que adquiriu por meio das opções de compra. A cláusula de Lock up é bastante comum em IPOs, e no caso das Stock Options o objetivo é manter o vínculo entre o profissional e a empresa pelo tempo contratual determinado.</li><li>Exercício das Opções: quando o colaborador decide comprar as ações pelo Strike Price, transformando-as efetivamente em propriedade sua. Isso pode ser feito após o período de Vesting ou em momentos específicos permitidos pelo contrato.</li><li>Liquidez (Liquidity Events): para que as Stock Options gerem lucro, a empresa precisa passar por um evento que permita a venda das ações, como uma oferta pública de ações (IPO) ou uma aquisição. Caso contrário, pode ser difícil transformar essas opções em dinheiro.</li></ul><h3>Stock Options Pool</h3><p>O Stock Option Pool é a parte do capital da empresa destinada a funcionários e executivos, usada para oferecer opções de compra de ações como incentivo. Em startups Early Stage, o pool geralmente varia entre 10% e 20% do capital total da empresa. Este percentual precisa ser suficiente para atrair talentos sem comprometer excessivamente os fundadores e investidores. De forma ilustrativa podemos imaginar uma startup, a qual teve um Valuation inicial de mercado de R$1.000.000,00 (Um milhão), que optou por uma emissão de 1 milhão de cotas. Esta startup definiu 15% do seu capital para construir o Options Pool, o que significa um montante de 150.000 ações reservadas para Stock Options, com um valor inicial total de R$150.000,00, a partir desta proporção teríamos um Strike Price de R$1,00 por cota.</p><h3>Stock Options</h3><p>Depois deste descritivo inicial sobre fundamentos do modelo de co-participação — importante enfatizar que não obrigatoriamente as propostas necessitam, ou mesmo possuem todas as cláusulas descritas — vamos analisar o modelo mais popular e amplamente adotado para composição de ofertas de participação em startups que é o de Stock Options.</p><p>Esse modelo se caracteriza pela concessão de opções de compra de ações da empresa a um preço pré-determinado, sem que o profissional tenha a propriedade imediata dessas ações. Mesmo após cumprir o período de Vesting — geralmente entre quatro e cinco anos, tempo mínimo de permanência exigido para ter direito à totalidade das cotas ofertadas — o colaborador ainda precisará adquiri-las para se tornar efetivamente um acionista.</p><p>Mas qual é, então, a vantagem desse modelo para o profissional? O benefício está no potencial de valorização da startup ao longo do tempo. Se a empresa alcançar um evento de liquidez, como um IPO ou uma aquisição, o colaborador poderá comprar as ações pelo preço pré-fixado (Strike Price) e revendê-las por um valor mais alto para obter lucro.</p><h3>Exemplo de uma proposta de co-participação</h3><p>Para tornar o conceito mais didático, consideremos o seguinte cenário:</p><p>Oferta de Contratação com Stock Options</p><ul><li>Salário Anual: R$180.000,00 (R$15.000,00 mensais)</li><li>Stock Options Oferecidas: Valor equivalente a 20% do salário anual (R$36.000,00)</li><li>Strike Price: R$1,00 por cota</li><li>Total de Cotas Ofertadas: 36.000 cotas (R$36.000,00 / R$1,00 por cota)</li><li>Vesting: 4 anos</li><li>Cliff: 12 meses</li></ul><h3>Como funciona na prática?</h3><p>A cláusula de Cliff de 12 meses estabelece que o colaborador precisa permanecer na empresa por pelo menos um ano antes de ter direito a qualquer cota. Caso saia antes desse período, perderá o direito às ações previstas na proposta. Já a cláusula de 4 anos de Vesting determina que, após o período de Cliff, as cotas serão adquiridas de forma linear ao longo de 48 meses. Assim, ao final do primeiro ano completo de Vesting, o colaborador terá direito à compra de 25% das cotas (9.000 cotas). Esse processo segue até a liberação total das ações ao final dos quatro anos.</p><h3>Exemplo de Aquisição das Stock Options:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EuEyZnKavZENJCDJ" /></figure><p>Se o colaborador permanecer por 4 anos completos, poderá comprar as 36.000 cotas pelo Strike Price de R$1,00 por cota (pagando um total de R$36.000). A possibilidade de ganho se define no quanto a empresa tenha se valorizado no período inicial até seu momento de liquidez.</p><h3>Então vale a pena as propostas que envolvam Stock Options?</h3><p>Pode parecer complexo, mas para avaliar se uma proposta que inclui participação acionária é realmente atrativa, é fundamental entender o potencial de crescimento da empresa, especialmente dentro do período estabelecido pelo Vesting. No entanto, não existe uma fórmula exata que permita prever com precisão se a startup terá sucesso nos próximos anos.</p><p>A taxa de valorização anual de uma startup em estágio inicial pode variar drasticamente conforme fatores como setor de atuação, modelo de negócio, adoção pelo mercado e sucesso na captação de investimentos. Por isso, projetar com precisão o retorno financeiro futuro de uma oferta de participação acionária é extremamente difícil.</p><p>Como já mencionado, aceitar uma proposta desse tipo é, em essência, um convite ao empreendedorismo — e, assim como qualquer investimento, envolve riscos. A startup pode não atingir o sucesso esperado, o que resultaria na perda do potencial ganho para o colaborador. Além disso, mesmo que a empresa se valorize, esse crescimento pode ser insuficiente para compensar um salário reduzido durante o período de Vesting.</p><p>Ainda assim, a incerteza não deve ser vista como um fator definitivo para descartar esse modelo de participação. Stock Options podem gerar retornos significativos a médio e longo prazo, especialmente no setor de tecnologia. O essencial é conduzir uma análise criteriosa, combinando métricas de mercado com informações específicas sobre a empresa, para tomar uma decisão bem fundamentada.</p><h3>Casos Reais</h3><p>No início dos anos 2000, o PayPal ofereceu um modelo de Stock Options aos seus primeiros funcionários. A empresa foi adquirida pelo eBay em 2002 por US$1,5 bilhão, tornando vários dos seus primeiros colaboradores milionários. Esse evento criou o que ficou conhecido como “PayPal Mafia” — um grupo de ex-funcionários que usou seus ganhos para fundar ou investir em empresas como Tesla, LinkedIn, YouTube e SpaceX.</p><p>Em outro exemplo prático de uso de co-participação temos a WeWork, empresa que valorizava Stock Options como grande parte da compensação de seus funcionários antes do IPO. Quando a empresa tentou abrir capital em 2019, seu valuation despencou de US$ 47 bilhões para menos de US$ 10 bilhões, tornando as opções de compras praticamente sem valor.</p><p>Casos famosos como o do PayPal demonstram como Stock Options podem transformar funcionários em milionários, desde que a empresa cresça e chegue a um evento de liquidez. No entanto, há riscos, como mostram os casos do WeWork, onde expectativas elevadas não se concretizaram. Por isso, ao considerar uma proposta com Stock Options, é essencial avaliar não apenas o potencial da startup, mas também as condições do contrato.</p><h3>Crescimento de uma Startup Early-Stage: Expectativas e Indicadores</h3><p>Embora não exista uma regra fixa, podemos recorrer a algumas métricas e benchmarks amplamente utilizados por investidores e aceleradoras para projetar o crescimento do valuation de startups em estágio inicial. Considerando esses parâmetros, podemos identificar três categorias principais de crescimento:</p><ol><li>Startups de baixo crescimento: Normalmente crescem de 20% a 50% ao ano.</li><li>Startups com crescimento mediano: Apresentam crescimento de 100% a 200% ao ano, dobrando ou triplicando seu valor anualmente.</li><li>Startups de alto crescimento: Atingem crescimento superior a 300% ao ano.</li></ol><p>Esses números servem como referência, mas outra métrica amplamente usada para avaliar a saúde financeira de startups de tecnologia é a Regra dos 40.</p><h3>Regra dos 40: O Indicador de Saúde Financeira</h3><p>A Regra dos 40 sugere que a soma da taxa de crescimento anual da receita (%) e da margem de lucro (%) deve ser, no mínimo, 40%. Essa fórmula é um método prático de avaliar a capacidade de uma startup de crescer e, ao mesmo tempo, manter a sustentabilidade financeira.</p><p>Fórmula da Regra dos 40:</p><ul><li>Taxa de Crescimento (%): Crescimento anual da receita recorrente (ARR — Annual Recurring Revenue).</li><li>Margem de Lucro (%): Lucro operacional ou EBITDA sobre a receita total.</li></ul><p>Se o resultado for superior a 40%, a startup é considerada financeiramente saudável. Embora não estabeleça um percentual fixo de crescimento anual, a Regra dos 40 sugere que uma startup SaaS early-stage saudável deve crescer, no mínimo, 100% ao ano em seus estágios iniciais.</p><h3>Justificativas para o Crescimento Acelerado</h3><p>Essa expectativa do mercado se justifica por vários fatores:</p><ul><li>Margens negativas e validação do modelo de negócio: Startups iniciais ainda não são lucrativas e operam com margens negativas elevadas, pois estão em fase de desenvolvimento do produto e aquisição acelerada de clientes. Embora déficits contábeis sejam normais, é essencial que o crescimento e os gastos se equilibrem de forma sustentável, justificando os investimentos na expectativa de rentabilidade futura.</li><li>Atração de investimentos e valorização: Crescimentos agressivos são essenciais para atrair investidores e sustentar um valuation crescente. Caso uma startup não apresente crescimento consistente, isso pode sinalizar dificuldades em escalar o negócio no futuro, diminuindo suas chances de atrair novos aportes de capital.</li><li>Sustentabilidade financeira e redução de dependência de aportes: Se uma startup não conseguir dobrar suas receitas a cada ano, precisará de mais rodadas de investimento para cobrir custos operacionais crescentes. Isso aumenta a dependência de capital externo e pode resultar em diluição significativa dos investidores iniciais. Crescer rapidamente ajuda a atingir o break-even point o quanto antes, minimizando a necessidade de novos aportes.</li><li>Pressão competitiva e consolidação no mercado: No setor SaaS, crescer rapidamente não é apenas um indicador de sucesso, mas também uma forma de garantir uma posição competitiva antes que empresas mais bem financiadas dominem o mercado. Startups que crescem devagar podem perder clientes e relevância.</li></ul><h3>Análise de Caso Prático</h3><p>Vamos analisar um exemplo prático para ilustrar a aplicação da Regra dos 40 e o impacto do crescimento acelerado. Imagine uma startup que cresceu 100% no primeiro ano, mas com uma margem de rentabilidade negativa de -60%. De acordo com a Regra dos 40, ela ainda é considerada financeiramente saudável, pois o crescimento é considerado sustentável.</p><p>Por outro lado, se a mesma startup crescesse 80% no ano, mantendo a margem negativa de -60%, o resultado seria 20% (80% — 60%). Isso indica um modelo insustentável de crescimento, já que a empresa não consegue manter um equilíbrio entre crescimento e rentabilidade.</p><p>Startups SaaS dependem de escalabilidade para se tornarem rentáveis. O modelo SaaS envolve custos fixos elevados, mas custos variáveis baixos, o que significa que é necessário crescer rapidamente para alcançar lucratividade. Portanto, um crescimento de 100% ao ano nos primeiros anos é fundamental para garantir a saúde financeira e permitir que a startup se torne financeiramente sustentável no futuro.</p><h3>Análise de Caso de Uso: Crescimento de 100% ao Ano e Valorização das Stock Options</h3><p>Para exemplificar o crescimento de uma startup que atinge 100% ao ano, vamos analisar uma situação em que a startup começa com um valuation de R$1.000.000,00. Considerando um crescimento anual de 100%, esse cenário é reconhecido no mercado como um crescimento moderado para startups early-stage. Utilizaremos a fórmula do crescimento composto para estimar a valorização da empresa ao longo de quatro anos:</p><p>Fórmula de Crescimento Composto:</p><p>Vt=V0×(1+r)t</p><p>Onde:</p><ul><li>Vt = Valuation futuro</li><li>V0 = R$1.000.000,00</li><li>r = 100% = 1.0</li><li>t = número de anos</li></ul><h3>Projeção de Valuation</h3><p>Aplicando a fórmula de crescimento composto, podemos calcular o valuation da startup ao longo de quatro anos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HVduc9Vq90L_xnpj" /></figure><p>Após a projeção de valorização da empresa, podemos estimar o valor das Stock Options concedidas ao colaborador no início de sua contratação.</p><h3>Exemplo de Stock Options</h3><p>Se a startup tiver 1 milhão de ações e crescer de forma consistente por 4 anos, cada ação poderá valer R$16,00. Se um colaborador recebeu 36.000 ações como parte de sua proposta de contratação, ele terá um patrimônio equivalente ao valor de R$576.000,00 em ações de mercado (36.000 cotas x R$16,00 cada), no final do período de Vesting.</p><h3>Exercício das Stock Options</h3><p>Portanto, o profissional tem o direito de exercer suas Stock Options, ou seja, adquirir as cotas pelo preço acordado inicialmente, que neste exemplo é de R$1,00 por cota. Assim, o valor a ser pago pelo colaborador para adquirir as 36.000 cotas seria de R$36.000,00 (36.000 x R$1,00).</p><p>O lucro bruto do colaborador seria calculado da seguinte forma:</p><p>Lucro Bruto = (16,00–1,00) * 36.000 = R$540.000,00</p><p>Ou seja, após exercer as Stock Options e pagar o valor acordado de R36.000,00, O colaborador teria um lucro bruto de R$540.000,00.</p><h3>Considerações Importantes</h3><ul><li>Forma de Pagamento: Em muitos casos, o colaborador não precisa desembolsar o valor total de aquisição das cotas (neste exemplo, R$36.000,00). Em vez disso, o valor é descontado diretamente do montante final recebido pelo colaborador, ou seja, ele recebe a diferença líquida após a venda ou liquidez da startup.</li><li>Exemplo Hipotético: Vale ressaltar que este é apenas um exemplo hipotético, utilizado para ilustrar a mecânica do modelo de Stock Options. Ele assume um cenário otimista, onde a startup cresce de forma constante e atinge seu potencial de valorização.</li><li>Participação no Pool de Opções: Neste caso, o colaborador recebeu 36.000 cotas de um total de 1 milhão de cotas emitidas, o que representa 3,6% do total. No entanto, é importante salientar que as Stock Options, se utilizam do pool de opções, que representam em torno de 15% do total de cotas (equivalente a 150.000 cotas). Um único profissional receber 24% — de um pool limitado a 150.000 cotas para todas as negociações — seria um valor impraticável no mercado real. Portanto, este cálculo é apenas para uma ilustração didática, não deve ser considerado como um cenário comum de rentabilidade para um profissional.</li><li>Riscos e Realidade do Mercado: Embora este exemplo considere um case de sucesso, é importante destacar que muitas startups não alcançam o sucesso esperado e não chegam a completar o período de vesting ou mesmo de operação. Segundo estudos, grande parte das startups não ultrapassa o segundo ano de funcionamento, o que torna a obtenção de lucros com Stock Options algo incerto e dependente de vários fatores.</li></ul><p>Este exemplo visa demonstrar a mecânica de Stock Options e como o crescimento acelerado de uma startup pode beneficiar os colaboradores no longo prazo. No entanto, é importante que tanto investidores quanto colaboradores estejam cientes dos riscos envolvidos e da incerteza quanto ao futuro da startup. O cenário otimista aqui apresentado não é a realidade da maioria das startups, mas oferece uma visão clara de como o modelo pode ser vantajoso, caso a empresa seja bem-sucedida em seu processo de escalabilidade e liquidez.</p><h3>Distribuição de Stock Options em Startups: Um Cenário Generalista</h3><p>A distribuição de Stock Options em startups é uma prática estratégica que pode variar de acordo com o perfil e o estágio da empresa, além de ser influenciada por decisões internas, muitas vezes tomadas em conjunto com fundos de investimento. O processo de alocação é geralmente estruturado com base em uma análise estratégica do negócio, levando em consideração fatores como a necessidade de atrair e reter talentos, o risco envolvido e a previsão de crescimento da empresa.</p><p>Embora cada startup defina suas próprias diretrizes para a distribuição de Stock Options, há um consenso de mercado sobre alguns parâmetros amplamente utilizados. Os fatores mais comuns que determinam o número de Stock Options atribuídas a cada colaborador incluem:</p><ol><li>Nível do Cargo: Executivos e líderes técnicos, que desempenham funções estratégicas e são cruciais para o desenvolvimento da startup, normalmente recebem um percentual maior de Stock Options do que desenvolvedores juniores, que estão em estágios mais iniciais e com responsabilidades mais limitadas.</li><li>Momento da Entrada: Quem ingressa na empresa mais cedo assume um risco maior, pois entra em um estágio de maior incerteza. Por essa razão, essas pessoas recebem uma quantidade maior de Stock Options em comparação com aquelas que entram em fases mais avançadas, quando o risco tende a ser menor.</li><li>Benchmark de Mercado: Startups costumam comparar suas práticas de Stock Options com empresas do mesmo setor ou estágio de desenvolvimento. Isso ajuda a garantir que as ofertas sejam competitivas e alinhadas com o que o mercado espera, o que é fundamental para atrair talentos de alto nível.</li></ol><h3>Modelo Comum de Distribuição de Equity (Stock Options)</h3><p>A distribuição de Stock Options segue, geralmente, o modelo abaixo, que foi estruturado de acordo com o cargo ocupado e a entrada do colaborador na empresa. Esses percentuais se referem ao total de equity da empresa (fully diluted equity) e não apenas ao Stock Option Pool, que é a reserva de cotas destinada a futuros colaboradores.</p><p>Geralmente, a distribuição segue um modelo parecido com este:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cvd5Zv8HCZZJjkG5" /></figure><p>* Esses percentuais médios referem-se ao</p><h3>Exemplo Prático de Distribuição de Equity</h3><p>Para ilustrar como a distribuição de Stock Options pode ser aplicada, considere o exemplo a seguir: uma startup tem um valuation inicial de R$10.000.000 e aloca 8% de equity para seu CEO, o que significa que, inicialmente, o CEO teria R$800.000 em valor de Stock Options. Este valor varia conforme o crescimento da empresa.</p><h3>Considerações sobre Diluição e Benchmark de Mercado</h3><p>Um aspecto fundamental a ser considerado na distribuição de Stock Options é o conceito de diluição. A diluição acontece quando a startup emite novas ações para captar investimentos. Isso reduz a porcentagem de participação dos investidores e funcionários que já possuem ações. Embora as Stock Options ofereçam aos colaboradores a oportunidade de obter um valor significativo em caso de sucesso da empresa, é importante lembrar que esse valor será impactado pela diluição, caso a startup emita mais ações no futuro.</p><p>Além disso, a startup pode comparar sua prática com benchmarks de outras startups do mesmo segmento ou estágio de desenvolvimento. Isso permite que a empresa se mantenha competitiva e atraente para os talentos, ajustando a quantidade de Stock Options para garantir que os colaboradores percebam um retorno significativo em caso de sucesso.</p><h3>Saída do Colaborador Antes de Completar o Período de Vesting</h3><p>Como em qualquer contrato, os programas de Stock Options possuem características específicas que devem ser acordadas entre a empresa e o colaborador. No entanto, ao contrário do que ocorre em alguns regimes jurídicos mais regulamentados, não existe uma legislação específica para regular as condições de Stock Options no Brasil. Por isso, todas as condições relacionadas ao programa de Stock Options são estabelecidas pela empresa no seu regulamento interno, e é fundamental que o colaborador tenha plena clareza sobre as cláusulas envolvidas, como a efetivação completa ou proporcional das opções adquiridas.</p><h3>Vesting e Cliff</h3><p>Imaginando que o profissional cumpriu o período inicial de Cliff (normalmente 12 meses) — caso este período inicial não tenha sido cumprido o colaborador não possui direito a nenhum percentual de cotas — mas, decidiu pela saída antes de completar o período de Vesting, ele perde as opções não adquiridas, proporcionalmente ao tempo que esteve na empresa. Abaixo está um exemplo de como isso funcionaria:</p><p>Exemplo:</p><ul><li>O colaborador tem direito a 36.000 opções de compra ao longo de 4 anos.</li><li>Após 36 meses (3 anos), o colaborador já cumpriu o período de Cliff e adquiriu, proporcionalmente, 27.000 opções.</li><li>As 9.000 opções restantes (25%) são perdidas, pois o colaborador não completou o período total de 48 meses de Vesting.</li></ul><p>Neste cenário, o colaborador poderia exercer suas 27.000 opções pelo preço de exercício (strike price) acordado, por exemplo, R$1,00 por opção, totalizando um investimento de R$27.000,00.</p><h3>Desconto nas Verbas Rescisórias ou Pagamento à Vista</h3><p>No momento da rescisão do contrato de trabalho, o valor das Stock Options adquiridas pode ser descontado das verbas rescisórias devidas ao colaborador, ou o colaborador pode ser solicitado a realizar o pagamento à vista para efetivar a compra das opções. Desde que o profissional tenha o interesse de exercer as opções de compra a que ele tem direito, caso contrário o percentual de cotas que ele detinha retornam ao Pool de Stock Options, para futuras distribuições.</p><h3>Liquidez das Stock Options Após a Saída</h3><p>Após a aquisição das opções, mesmo que o colaborador não esteja mais vinculado à empresa, ele pode lucrar com essas opções caso ocorra um evento de liquidez, como uma oferta pública inicial de ações (IPO) ou uma aquisição bem-sucedida da empresa no futuro. Nesse caso, o colaborador poderá vender as opções que comprou e obter lucro com a valorização da empresa, conforme o valor de mercado das ações.</p><h3>Considerações Importantes:</h3><ol><li>Proporcionalidade do Vesting: Caso o colaborador saia antes de completar o período total de Vesting, as opções adquiridas proporcionalmente ao tempo trabalhado são mantidas, mas as opções não adquiridas são perdidas.</li><li>Cláusulas Específicas: Como as condições de Stock Options variam entre as empresas, é importante que o colaborador leia e compreenda completamente as cláusulas relacionadas ao programa, especialmente as que tratam de condições de saída antes do período de Vesting.</li><li>Riscos e Oportunidades: Embora o programa de Stock Options seja uma excelente oportunidade para lucrar com o crescimento da empresa, o colaborador precisa estar ciente dos riscos envolvidos. Se a startup não se desenvolver como esperado ou o evento de liquidez não ocorrer, as opções podem não gerar retorno.</li></ol><h3>Possibilidade de Transferência de Stock Options</h3><p>Atualmente, não há uma legislação específica no Brasil que regulamente as Stock Options, o que significa que as regras sobre sua concessão e transferência são definidas individualmente por cada empresa em seu plano de opções de ações. Dessa forma, a possibilidade de transferência das Stock Options para outra pessoa depende exclusivamente das políticas internas estabelecidas pela empresa e dos acordos firmados no contrato do colaborador.</p><p>Em grande parte dos casos, os planos de Stock Options incluem restrições severas à transferência, permitindo-a apenas em situações excepcionais, como falecimento ou sucessão patrimonial, e sempre mediante aprovação dos gestores ou do conselho administrativo.</p><h3>Por que a Transferência Não é Comum?</h3><p>As Stock Options são um instrumento de incentivo e retenção de talentos, concedido a colaboradores estratégicos como forma de alinhar seus interesses aos da empresa e recompensar sua dedicação e desempenho. Assim, permitir a livre transferência para terceiros descaracterizaria esse propósito, tornando as opções um ativo especulativo, o que geralmente não é desejável para a empresa.</p><p>Além disso, a transferência pode envolver implicações legais e tributárias complexas, dependendo da jurisdição e da estrutura do plano de opções. Isso pode incluir a necessidade de pagar impostos antecipadamente, cumprir requisitos regulatórios ou até mesmo reavaliar o valor das opções transferidas.</p><h3>Conclusão [Minha Opinião sobre Stock Options]</h3><p>Na minha opinião, Stock Options não representam um benefício tão significativo em uma proposta de contratação. Encaro-as como um incentivo adicional, um plus, mas não um diferencial que justifique aceitar uma remuneração abaixo da expectativa do profissional ou do valor praticado pelo mercado para a posição ofertada. Além disso, não deveriam ser usadas como justificativa para longos períodos sem reajuste salarial, compensados apenas pelo aumento da quantidade de opções de compra.</p><p>Embora possam gerar lucros expressivos no futuro, trata-se essencialmente de um investimento — ou, dependendo da perspectiva, até uma aposta. Para que o retorno financeiro se concretize, diversas variáveis precisam estar alinhadas: a startup precisa crescer e se valorizar significativamente, e o profissional deve permanecer na empresa durante todo o período de vesting. Caso contrário, a quantidade de opções exercíveis será reduzida proporcionalmente.</p><p>Além disso, a simples valorização das cotas não garante rentabilidade. Para que haja um retorno real, a empresa precisa passar por um evento de liquidez, como uma aquisição ou um IPO – cenários que não são tão frequentes. No caso de uma saída antes do período de conclusão de Vesting (normalmente 4 anos), até existe a possibilidade de exercer a compra proporcional ao tempo de casa. Contudo, surge uma questão fundamental: vale a pena investir um valor significativo para adquirir cotas de uma empresa da qual o profissional já não faz mais parte?</p><p>Dessa forma, considero Stock Options um acréscimo interessante, desde que o salário e os demais benefícios propostos sejam compatíveis com o cargo e a responsabilidade assumida. No entanto, é importante destacar que, legalmente, Stock Options não tornam o colaborador um sócio da empresa. Elas concedem apenas o direito de compra futura de ações, e esse direito só se concretiza caso o profissional exerça a opção e adquira as cotas. Diferente do modelo de Equity, onde há efetiva propriedade das cotas, Stock Options oferecem apenas uma possibilidade futura de ganho, que depende de um alinhamento improvável de fatores para se concretizar.</p><h3><strong>Referências</strong></h3><p>BAKER, Alisa J.; CHERNOFF, Pam. **The Stock Options Book**. 16th ed. Palo Alto: NCEO, 2021.</p><p>CVM – Comissão de Valores Mobiliários. Normas sobre remuneração baseada em ações. Brasília: CVM, 2024. Disponível em: &lt;https://www.gov.br/cvm/&gt;. Acesso em: 5 jan. 2025.</p><p>MOYER, Mike. Slicing Pie: Fund Your Company Without Funds. 3rd ed. Chicago: Lake Shark Ventures, 2019.</p><p>MURPHY, Kevin J. Executive Compensation: Where We Are, and How We Got There. Handbook of the Economias of Finance*, v. 2, p. 211–356, 2013.</p><p>OYENIYI, Omotayo A. Stock Option Compensation and Managerial Incentives. Harvard Business Review*, v. 78, n. 2, p. 57–65, 2000.</p><p>RIES, Eric. The Lean Startup. New York: Crown Business, 2011.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=48af89ce3dbd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Notação Big O. Você se preocupa com isso?]]></title>
            <link>https://elisandromello.medium.com/nota%C3%A7%C3%A3o-big-o-voc%C3%AA-se-preocupa-com-isso-1af9d3533cce?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/1af9d3533cce</guid>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-quality-engineer]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Fri, 21 Feb 2025 15:02:21 GMT</pubDate>
            <atom:updated>2025-02-21T15:11:43.726Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZifYtbWuBEd_oBmAygEpeA.png" /></figure><p>A Engenharia de Software abrange diversos aspectos críticos, incluindo a notação Big O, que é frequentemente subestimada e, por vezes, considerada irrelevante por alguns desenvolvedores. No entanto, percebe-se que existem profissionais em posições de senioridade que possuem um conhecimento limitado dos conceitos fundamentais de Engenharia e Arquitetura de Software. A pandemia de 2020, que acelerou os requisitos de formação para engenheiros seniores, destacou a necessidade de redefinir e direcionar as expectativas relacionadas a esses profissionais. A opção por um perfil mais generalista pode ser uma estratégia de carreira individual, mas é vital ter consciência de que a profundidade do conhecimento técnico distingue um desenvolvedor competente de um excepcional. Além disso, a compreensão da notação Big O é altamente valorizada em entrevistas técnicas avançadas e tem um impacto significativo na redução de custos operacionais, ao evitar a implementação de soluções ineficazes que exigem mais recursos ou retrabalho.</p><p>De maneira objetiva, entender e dominar a notação Big O, também conhecida como complexidade assintótica, capacita o engenheiro de software a avaliar e projetar sistemas que são tanto eficientes quanto escaláveis. O índice Big O é uma ferramenta fundamental para analisar o desempenho dos algoritmos, facilitando a previsão de seu comportamento à medida que o volume de dados de entrada aumenta.</p><h3>Porque um Engenheiro deve ter o domínio sobre a notação?</h3><p>O domínio da notação Big O é essencial para engenheiros de software seniores, pois os capacita a resolver problemas complexos de maneira eficiente. Esta competência permite avaliar a eficácia de algoritmos e evitar soluções computacionalmente inviáveis em larga escala. Este tipo de conhecimento é essencial para o desenvolvimento de sistemas escaláveis que mantenham alto desempenho diante de um crescimento exponencial de usuários e dados.</p><p>Além disso, esse conhecimento promove uma comunicação clara e fundamentada com equipes e stakeholders, facilitando a orientação de desenvolvedores menos experientes e justificando decisões técnicas de forma robusta. Ao otimizar soluções, também contribuímos para a redução de custos operacionais ao minimizar a necessidade de recursos computacionais adicionais e evitar retrabalhos, assegurando a sustentabilidade e a eficácia dos sistemas que desenvolvemos.</p><p>Entenda o conceito: “Bons engenheiros desenvolvem códigos que solucionam problemas. Excelentes engenheiros desenvolvem códigos que se perpetuam.” A proficiência em Big O distingue um engenheiro de software sênior, demonstrando que ele não apenas resolve problemas, mas o faz de maneira estratégica e sustentável.</p><p>Adicionalmente, compreender Big O é uma habilidade altamente valorizada em entrevistas técnicas de alto nível, pois confere credibilidade aos profissionais que contribuem diretamente para a redução de custos operacionais. Em um ambiente em que eficiência e escalabilidade são imperativos, esse conhecimento é crucial para projetar e implementar soluções que suportem o crescimento e a complexidade do mundo real.</p><h3>Influências Notáveis na Análise de Complexidade Algorítmica e o Papel da Notação Big O</h3><p>Para fundamentar a importância deste tema para um profissional que busca realizar entregas acima da média, é essencial contar com referências de renomados engenheiros. Em seu livro “Refatoração: Aperfeiçoando o Design de Códigos Existentes”, Martin Fowler discute a relevância de entender como as alterações impactam o desempenho do software. Ele ressalta que “compreender a complexidade do algoritmo é crucial para assegurar a eficiência do software à medida que este evolui”. Outro autor proeminente, Eric Evans, na obra “Domain-Driven Design”, salienta a importância de considerar a complexidade dos algoritmos ao modelar sistemas. Ele aponta que “a complexidade algorítmica pode afetar diretamente o desempenho e a escalabilidade de um sistema”, destacando como uma arquitetura bem elaborada deve incorporar a análise dessa complexidade.</p><p>Adicionalmente, Andrew Hunt e David Thomas, autores do best-seller “O Programador Pragmático: De Aprendiz a Mestre”, enfatizam que “a escolha do algoritmo correto pode significar uma grande diferença no desempenho do software”. Essa observação realça a importância de análises de complexidade, como a notação Big O, para o desenvolvimento de códigos mais eficientes e sustentáveis ao longo do tempo. Para finalizar, as referências sobre o tema, Ian Sommerville em seu livro “Engenharia de Software”, menciona que “a complexidade algorítmica é uma das ferramentas mais utilizadas para descrever essa complexidade, especialmente em relação ao tempo de execução” .</p><h3>Mas o que é notação Big O?</h3><p>A notação Big O é uma representação matemática que descreve o comportamento assintótico de um algoritmo, ou seja, como o tempo de execução ou o uso de memória do algoritmo cresce à medida que o tamanho da entrada (𝑛) aumenta. Entenda, que mesmo um algoritmo mal implementado possui uma performance aceitável com baixa volumetria de entrada, devido a atual capacidade de processamento. Contudo, à medida que uma aplicação cresce o volume de entradas também cresce exponencialmente. Neste cenário, o cálculo de complexidade Big O, é uma ferramenta fundamental para avaliar a eficiência de algoritmos.</p><p>O cálculo de complexidade assintótica fornece uma maneira de descrever como o tempo de execução ou o espaço utilizado por um algoritmo cresce em relação ao tamanho da entrada. Ela é usada para classificar algoritmos com base em sua eficiência, destacando o pior caso ou o crescimento mais rápido.</p><p>A notação Big-O mede o pior caso do crescimento de um algoritmo, descartando constantes e termos de menor impacto à medida que o tamanho da entrada “n” cresce. Ela é expressa como: O(f(n))</p><p>Onde:</p><ul><li>f(n): Representa a função que descreve o número de operações executadas ou o espaço usado em termos do tamanho da entrada “n”.</li></ul><h3>Definição de Big O</h3><ul><li>Complexidade Algorítmica: A notação Big O é uma forma matemática que descreve como o desempenho de um algoritmo se comporta à medida que o tamanho da entrada aumenta. Ela se concentra no pior caso, fornecendo um limite superior para a taxa de crescimento de uma função.</li><li>Cenário de Pior Caso: A notação descreve o tempo máximo que um algoritmo levaria para executar em função do tamanho da entrada, permitindo a comparação entre diferentes algoritmos.</li></ul><p>A análise do comportamento assintótico ajuda a identificar a eficiência relativa dos algoritmos, permitindo que desenvolvedores escolham soluções mais adequadas para problemas específicos. Por exemplo, um algoritmo que opera em O(1) é considerado constante, pois seu tempo de execução não varia com o tamanho da entrada, enquanto um algoritmo em O(n) indica que o tempo de execução aumenta linearmente com o aumento da entrada.</p><h3>Métricas Comuns</h3><p>As métricas mais comuns na análise da complexidade incluem:</p><ul><li>O(1): Complexidade constante, onde o tempo de execução não depende do tamanho da entrada.</li><li>O(n): Complexidade linear, onde o tempo de execução cresce proporcionalmente ao tamanho da entrada.</li><li>O(n²): Complexidade quadrática, frequentemente encontrada em algoritmos que utilizam loops aninhados.</li><li>O(log n): Complexidade logarítmica, típica em algoritmos que dividem a entrada repetidamente, como a busca binária.</li></ul><h3>Complexidade Quadrática</h3><p>Algoritmos com complexidade quadrática frequentemente ocorrem quando dois loops aninhados iteram sobre o mesmo conjunto de dados. Para exemplificar uma implementação com complexidade de tempo O(n²), vamos analisar um algoritmo de ordenação por seleção. No exemplo proposto, o algoritmo interativamente seleciona o menor elemento de uma seção não ordenada e o troca com o elemento no início desta seção.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XM3kSGPiVnbXSpCT" /></figure><p>Explicação:</p><ul><li>Loop Externo: Itera sobre cada elemento do array, exceto o último, porque o último elemento automaticamente estará no lugar correto após as iterações anteriores.</li><li>Loop Interno: Começa do elemento seguinte ao atual índice do loop externo e procura o menor valor no resto do array.</li><li>Troca: Após cada passagem do loop interno, o menor elemento encontrado é trocado com o elemento no índice atual do loop externo.</li></ul><p>Este algoritmo tem a complexidade de tempo O(n²) porque realiza duas operações aninhadas sobre o array, ambas dependendo do tamanho (n) do array. É um exemplo típico de algoritmo de ordenação com complexidade quadrática, sendo útil para ensino e pequenos conjuntos de dados mas ineficiente para grandes volumes de dados em comparação a algoritmos de ordenação mais eficientes como “mergesort” ou “quicksort”.</p><h3>Complexidade Logarítmica</h3><p>Um exemplo clássico de algoritmo com complexidade logarítmica (O(log n)) é a busca binária. Este algoritmo funciona em listas ordenadas e busca um valor específico dividindo o espaço de busca pela metade a cada passo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WDS5xxrEFN37i0sO" /></figure><p>Explicação:</p><ul><li>Definição dos Limites: O “left” e “right” definem os limites dentro dos quais a busca é realizada. O valor inicial de “left” é 0 (primeiro índice), e o de “right” é o último índice do array.</li><li>Determinação do Centro: “mid” é calculado como o índice do meio entre “left” e “right”.</li><li>Condição de Busca: Se o valor no índice “mid” é igual ao target, o índice é retornado. Se o target é menor do que o valor no “mid”, a busca se restringe ao lado esquerdo (right = mid — 1). Caso contrário, ela continua no lado direito (left = mid + 1).</li></ul><p>A complexidade logarítmica surge porque o algoritmo divide o conjunto de busca pela metade a cada passo, significando que com cada iteração, o número de elementos restantes a serem verificados é reduzido pela metade.</p><p>Um algoritmo com complexidade logarítmica, notado como O(log n), é geralmente considerado eficiente para muitos problemas, principalmente quando comparado a complexidades mais altas como O(n), O(n²),</p><h3>Análise Caso de Uso</h3><p>Para que possamos descrever com melhor clareza como melhorar um código a partir de uma análise utilizando notação assintótica,vamos examinar o exemplo, descrito abaixo, onde temos uma função que encontra os pares únicos de números em um array que somam um valor-alvo. A solução usa dois loops aninhados, resultando em uma complexidade de O(n2):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3EGpyBHGOKf8duOt" /></figure><p>Problemas:</p><ol><li>O código tem complexidade O(n2) devido aos dois loops aninhados.</li><li>Em grandes entradas, o desempenho será muito ruim.</li><li>Não utiliza estruturas de dados otimizadas para resolver o problema.</li></ol><h3>Refatorando o Caso de Uso</h3><p>Podemos refatorar a solução para usar um hash set e reduzir a complexidade para O(n), iterando apenas uma vez sobre o array.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*16rGU0WwACouDaNe" /></figure><p>Melhorias:</p><ol><li>Complexidade reduzida para O(n): Cada número é processado apenas uma vez.</li><li>Uso eficiente de memória: O conjunto (Set) armazena os números já vistos, facilitando a busca em tempo constante.</li><li>Desempenho escalável: Essa abordagem é adequada para entradas maiores.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ADdd1CPm1KDr292v" /></figure><p>Refatorar para uma solução eficiente não apenas melhora o desempenho, mas também demonstra a habilidade de resolver problemas de maneira mais elegante e prática, característica esperada de engenheiros seniores.</p><h3>Conclusão</h3><p>O domínio de Big O diferencia um engenheiro de software sênior, mostrando que ele não apenas resolve problemas, mas o faz de maneira eficiente e sustentável. Em um ambiente onde eficiência e escalabilidade são requisitos fundamentais, esse conhecimento é essencial para projetar e implementar soluções que suportem o crescimento e a complexidade do mundo real.</p><p>O cálculo de complexidade Big O é essencial para garantir que os algoritmos sejam eficientes e escaláveis. Através da análise cuidadosa das operações e do crescimento em relação ao tamanho da entrada, os desenvolvedores podem otimizar seus códigos e escolher as melhores abordagens para resolver problemas computacionais.</p><h3>Referências</h3><p>EVANS, Eric. Domain-Driven Design: Atacando as Complexidades no Coração do Software. 3. ed. Alta Books, 2016.</p><p>FOWLER, Martin. Refatoração: Aperfeiçoando o Design de Códigos Existentes. 2. ed. Novatec Editora, 2020.</p><p>HUNT, Andrew Hunt. THOMAS, David. O Programador Pragmático: De Aprendiz a Mestre. 1. ed. Bookman, 2010.</p><p>MOREIRA, Ramires. Complexidade Ciclomática vs. Complexidade Assintótica: Uma Análise Comparativa. LinkedIn, 17/08/2024. Disponível em: <a href="https://www.linkedin.com/pulse/complexidade-ciclom%C3%A1tica-vs-assint%C3%B3tica-uma-an%C3%A1lise-ramires-moreira-a06gf/">https://www.linkedin.com/pulse/complexidade-ciclom%C3%A1tica-vs-assint%C3%B3tica-uma-an%C3%A1lise-ramires-moreira-a06gf/</a>. Acesso em: 24/12/2024.</p><p>SOMMERVILLE, Ian. Engenharia de Software. 10. ed. São Paulo: Pearson, 2019.</p><p>TERCEIRO, Antonio Soares de Azevedo. Caracterização da Complexidade Estrutural em Sistemas de Software Livre. 2009. Tese (Doutorado em Ciência da Computação) — Universidade Federal da Bahia, Salvador, 2009. Disponível em: <a href="https://repositorio.ufba.br/handle/ri/8149">https://repositorio.ufba.br/handle/ri/8149</a>. Acesso em: 26/12/2024.</p><p>VALENTE, Marco Tulio. Engenharia de Software Moderna. Editora Independente, 2022.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1af9d3533cce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Princípios que todo Engenheiro Sênior deveria conhecer. Você conhece]]></title>
            <link>https://elisandromello.medium.com/princ%C3%ADpios-que-todo-engenheiro-s%C3%AAnior-deveria-conhecer-voc%C3%AA-conhece-3a3b2849b9a0?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a3b2849b9a0</guid>
            <category><![CDATA[iamelisandromello]]></category>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Thu, 09 Jan 2025 14:40:12 GMT</pubDate>
            <atom:updated>2025-01-09T14:40:12.357Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iKUvl6zFeVMf7zFoymxZqQ.png" /></figure><p>Os princípios de design de software são fundamentais para orientar o desenvolvimento de sistemas que sejam de alta qualidade, sustentáveis e escaláveis. Esses princípios desempenham um papel essencial na promoção de códigos limpos, eficientes e fáceis de manter, destacando características vitais como manutenção, escalabilidade e desempenho. Eles formam a base do desenvolvimento de software e estão incorporados em ferramentas, linguagens, frameworks e padrões amplamente utilizados no ecossistema de desenvolvimento.</p><p>A capacidade de reconhecer e aplicar esses princípios é crucial para evitar um excesso de dependência de ferramentas específicas. Como Robert Martin destaca em sua obra “Clean Architecture”, qualquer recurso externo à aplicação deve ser visto como um detalhe e manter um desacoplamento completo das regras de negócio.</p><p>Conhecer e aplicar os princípios de design de software é o que distingue um desenvolvedor mediano de um engenheiro de software de alto desempenho. Enquanto um desenvolvedor pode ser capaz de escrever código que funcione, o engenheiro de software excepcional entende como organizar esse código para que ele seja funcional, sustentável e escalável ao longo do tempo. Esta compreensão habilita o engenheiro a antecipar problemas, desenvolver soluções elegantes e manter a integridade do sistema conforme novas funcionalidades são adicionadas. O domínio desses princípios não apenas melhora a qualidade do software produzido, mas também eleva a carreira do desenvolvedor, posicionando-o como um profissional valioso e respeitado no mercado. Conforme descreve Craig Larman disse em seu livro, “A parte crítica do desenvolvimento de software é ter uma mente bem educada para os princípios de Design, sem isso UML ou qualquer outra tecnologia torna-se irrelevante“.</p><p>A série de artigos que disponibilizarei não se propõe a ser um guia definitivo, mas sim uma tentativa de organizar uma lista de princípios básicos que devem ser revisados e atualizados periodicamente. Ao explorar esses conceitos, meu objetivo é fornecer uma visão de como eles contribuem para a criação de um código de qualidade, bom e legível.</p><p>Neste primeiro artigo, pretendo oferecer uma visão geral dos princípios de design de software mais utilizados, os quais descreverei com maior profundidade e exemplos práticos nos próximos artigos. Convido você, que almeja tornar-se um Engenheiro de Software verdadeiramente capacitado, a acompanhar esta série de artigos comigo.</p><h3>Encapsulate What Varies</h3><p>Este princípio sugere que as partes do código que podem mudar devem ser isoladas. Isso reduz o impacto de alterações, facilitando a manutenção e a evolução do software. Ao encapsular as variações, os desenvolvedores podem modificar uma parte do sistema sem afetar outras, resultando em um código mais robusto e flexível.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/978/0*sRoy4TDVNnH5Fx95" /></figure><p>A frase “Encapsulate the concept that varies (Encapsule o conceito que varia.). “ foi imortalizada no livro “Design Patterns: Elements of Reusable Object-Oriented Software”, de Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides. Essa expressão captura perfeitamente a essência deste padrão de design, que recomenda a encapsulação de comportamentos sujeitos a alterações futuras. Tal abordagem facilita modificações subsequentes sem impactar o restante do código, promovendo assim maior flexibilidade e robustez no desenvolvimento de software.</p><h3>Abstração</h3><p>É o processo analítico de eliminar do problema fatores irrelevantes para sua solução, ou seja, focar no que mais importa, bem como entender como essas soluções podem ser reutilizadas em múltiplos cenários. Lembrando que a escassez de informação é tão prejudicial quanto o seu excesso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*dyFih46lrRZ-t2rw" /></figure><p>A abstração envolve a simplificação de sistemas complexos, permitindo que os desenvolvedores se concentrem nos aspectos essenciais. Ao abstrair detalhes desnecessários, o código se torna mais legível e compreensível, o que facilita a colaboração entre equipes e a integração de novos membros.</p><p>“Abstraction is selective ignorance (Abstração é ignorância seletiva.).” — Andrew Koenig Esta citação realça o poder de abstração para ignorar os detalhes menos relevantes, focando no que é mais importante. A frase enfatiza a função da abstração como um mecanismo que permite ignorar detalhes irrelevantes, priorizando apenas as informações mais significativas para um determinado contexto.</p><h3>DRY (Don’t Repeat Yourself)</h3><p>O princípio DRY enfatiza a importância de evitar duplicação de código. Quando o código é repetido, aumenta-se o risco de erros e torna-se mais difícil realizar manutenções. Ao seguir esse princípio, os desenvolvedores criam um código mais limpo e eficiente, onde mudanças precisam ser feitas em apenas um lugar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*sAlhfcVe034N6MGa" /></figure><p>Uma citação notável sobre o conceito de DRY (Don’t Repeat Yourself) vem de Andrew Hunt e David Thomas em seu livro “The Pragmatic Programmer”, onde eles apresentam e detalham este princípio fundamental:</p><blockquote><em>“Every piece of knowledge must have a single, unambiguous, authoritative representation within a system. (Cada pedaço de conhecimento deve ter uma representação única, inequívoca e autoritativa dentro de um sistema.)”</em></blockquote><p>Esta frase sublinha a essência do DRY, que é evitar a duplicação de informações no código, assegurando que cada parte do conhecimento no sistema tenha uma única representação clara e autoritária, auxiliando na manutenção e na escalabilidade do software.</p><h3>KISS (Keep It Simple, Stupid)</h3><p>O princípio KISS defende que sistemas complexos devem ser evitados sempre que possível. A simplicidade no design do software não só facilita a compreensão e a manutenção do código, mas também reduz a probabilidade de introduzir erros. Um código simples é mais fácil de testar e menos propenso a falhas.</p><p>O princípio KISS (Keep It Simple, Stupid) enfatiza a importância de fazer um esforço consciente para simplificar sempre que possível, pois quanto menor a complexidade de um projeto, mais fácil é entendê-lo, depurá-lo e menos coisas podem dar errado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*j3FwjHh6GgxOXFwc" /></figure><p>Embora não seja um engenheiro de software, a frase de Leonardo da Vinci — “Simplicity is the ultimate sophistication. (A simplicidade é a sofisticação máxima.)” — encapsula a essência do KISS em busca da simplicidade no design.</p><h3>YAGNI (You Aren’t Gonna Need It)</h3><p>YAGNI é um princípio que aconselha os desenvolvedores a não adicionar funcionalidades até que sejam realmente necessárias. Isso ajuda a evitar a complexidade desnecessária e mantém o foco nas necessidades reais do projeto, resultando em um desenvolvimento mais ágil e eficiente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/719/0*FYRqArUQ-xVbkasV" /></figure><p>A afirmação de Ron Jeffries — “Always implement things when you actually need them, never when you just foresee that you need them.” (“Sempre implemente as coisas quando você realmente precisa delas, nunca quando você apenas prevê que precisa delas.”) ressoa profundamente no desenvolvimento ágil, notadamente no contexto do Extreme Programming, ressaltando a importância desse princípio. Como um dos pioneiros das metodologias ágeis, Jeffries sublinha o princípio de YAGNI. Este conceito enfatiza a necessidade de evitar a complexidade desnecessária até que seja absolutamente essencial, visando simplificar o processo de desenvolvimento, assegurar eficiência e prevenir esforços supérfluos.</p><h3>LoD (Law of Demeter)</h3><p>A Lei de Demeter sugere que um objeto deve interagir apenas com seus amigos diretos e não com amigos de amigos. Isso promove um baixo acoplamento entre componentes do sistema, tornando o software mais modular e fácil de entender. A aplicação desse princípio facilita as manutenções futuras ao limitar as dependências entre classes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*58lIskfW9kock8rf" /></figure><p>Ian Holland, desenvolvedor responsável pela formulação do conceito conhecido como “Lei do Menor Conhecimento”, descreve que “”Each unit should have only limited knowledge about other units: only units ‘closely’ related to the current unit.” (“Cada unidade deve ter apenas conhecimento limitado sobre outras unidades: apenas unidades ‘estreitamente’ relacionadas à unidade atual.”). Este princípio, também chamado Lei de Demeter, foi concebido na Northeastern University em 1987 por Holland e popularizado por seu colega Karl Lieberherr através de seminários e aulas sobre design orientado a objetos. A lei tem como objetivo principal a redução do acoplamento, enfatizando a importância de limitar as interações entre componentes a relações estritamente necessárias.</p><h3>SoC (Separation of Concerns)</h3><p>O termo “ Separation of Concerns “ (SoC) se origina do campo de engenharia e design de software, mas seu nome se inspira em princípios mais amplos encontrados na teoria de sistemas e metodologias de resolução de problemas. O termo “concern” se refere a qualquer aspecto ou responsabilidade distinta dentro de um sistema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nFRIA5ExMJa6I6XJ" /></figure><p>A Separação de Preocupações implica dividir um sistema em partes distintas, cada uma responsável por uma funcionalidade específica. Essa abordagem melhora a organização do código e permite que diferentes equipes trabalhem em paralelo sem interferir umas nas outras. Além disso, facilita testes unitários e manutenção.</p><p>“Treat different problems separately.” (“Trate problemas diferentes separadamente.”). Esta citação de Edsger W. Dijkstra, um pioneiro da ciência da computação, ressalta a importância de dividir um programa em componentes distintos que lidem com diferentes aspectos da funcionalidade. Esta abordagem reflete a filosofia central do princípio de “Separation of Concerns”.</p><h3>GRASP (General Responsibility Assignment Principles)</h3><p>Os princípios GRASP fornecem diretrizes sobre como atribuir responsabilidades dentro do design do software. Eles ajudam os desenvolvedores a criar sistemas mais coesos e com baixo acoplamento, promovendo uma melhor distribuição das responsabilidades entre as classes. Isso resulta em um código mais limpo e fácil de manter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*T1iTI_WiQwFJQndr" /></figure><p>“Responsibility-driven design is based on the idea that objects are responsible.” Esta citação de Craig Larman, extraída de seu livro “Applying UML and Patterns”, destaca o princípio de basear o design do software na distribuição de responsabilidades entre os objetos. Larman detalha essa abordagem ao discutir princípios de atribuição de responsabilidade em programação orientada a objetos, sublinhando a importância de definir claramente o papel de cada objeto dentro da arquitetura do software.</p><h3>Conclusão</h3><p>Ao explorar os benefícios gerais da aplicação dos princípios de design de software, fica evidente que seu uso é fundamental para o sucesso no mundo do desenvolvimento. A adoção desses princípios facilita a manutenção, melhora a colaboração entre desenvolvedores, reduz a ocorrência de erros, eleva a qualidade do software e aumenta a eficiência no processo de desenvolvimento. Para um engenheiro de software que busca excelência e capacitação, entender e implementar esses princípios não é apenas uma opção, mas uma necessidade.</p><p>Este artigo serve como introdução a uma série que irá explorar cada um dos principais princípios de design de software. Cada artigo da série proporcionará insights significativos e exemplos práticos que farão de você um engenheiro mais competente e preparado para enfrentar os desafios do desenvolvimento de software.</p><p>Para garantir que você não perca nenhuma parte desta série, convido-o a assinar nossa newsletter. Assim, você estará sempre atualizado e poderá continuar aprimorando suas habilidades de engenharia de software junto com profissionais que compartilham do seu objetivo de excelência.</p><h3>Referências</h3><p>ARAÚJO, I. &amp; LOUZADA, V. SOLID: o que é e quais os 5 princípios da Programação Orientada a Objetos (POO). Alura. Disponível em: <a href="https://www.alura.com.br/artigos/solid">https://www.alura.com.br/artigos/solid</a>. Acesso em: 12 de dezembro de 2024.</p><p>GAMMA, Erich., HELM, Richard., JOHNSON, Ralph., &amp; VLISSIDES, John. Padrões de Projetos: Soluções Reutilizáveis de Software Orientados a Objetos. Bookman, 2000.</p><p>HUNT, Andrew., &amp; THOMAS, David. O Programador Pragmático: De Aprendiz a Mestre. Bookman, 2010.</p><p>LARMAN, C. Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design. Prentice Hall, 1997.</p><p>VIEIRA, D. Conheça os 7 princípios do Clean Code. HostGator. Disponível em: <a href="https://www.hostgator.com.br/blog/clean-code-o-que-e/">https://www.hostgator.com.br/blog/clean-code-o-que-e/</a>. Acesso em: data de acesso: 13 de dezembro de 2024.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a3b2849b9a0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Você conhece o Design Pattern Retry? E quais as boas práticas de implementação deste modelo?]]></title>
            <link>https://elisandromello.medium.com/voc%C3%AA-conhece-o-design-pattern-retry-e-quais-as-boas-pr%C3%A1ticas-de-implementa%C3%A7%C3%A3o-deste-modelo-7428be19213b?source=rss-c15a1be5dee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/7428be19213b</guid>
            <dc:creator><![CDATA[Elisandro Mello Corrêa]]></dc:creator>
            <pubDate>Fri, 27 Dec 2024 17:23:53 GMT</pubDate>
            <atom:updated>2024-12-27T17:23:53.702Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lht2iEbnEkHzVxWDaBf7Vw.png" /></figure><p>A jornada de um engenheiro de software é marcada por aprendizado contínuo e desafios constantes, independentemente do nível de senioridade alcançado. Mesmo profissionais experientes podem se deparar com problemas técnicos aparentemente simples que resultam em atrasos significativos no tempo de resolução. Recentemente, deparei-me com essa situação ao desenvolver um projeto utilizando Arquitetura Orientada a Eventos. O problema manifestou-se na implementação de dois microservices operando de forma assíncrona e paralela, utilizando filas de mensageria do AWS SQS. O desenho arquitetural se mostrou robusto e os fluxos baseados em eventos eram consistentes. O que deveria resultar em uma orquestração fluida entre os microservices. Contudo, aconteciam erros acíclicos que impactavam a confiabilidade e a estabilidade da aplicação.</p><p>Após revisar, quase que inteiramente, o código desenvolvido e analisar diversas possibilidades, um colega me provocou um “insight” da origem do problema. O qual, encontrava-se evidente durante todo o tempo, e apenas dependia de uma análise mais sistêmica, a partir de compreender que estávamos trabalhando com fluxos assíncronos. A dificuldade residia na dependência de um microservice pela conclusão de uma tarefa do outro para acessar registros no banco de dados, resultando em um falso positivo acíclico. A imprevisibilidade em saber qual microservice concluiria primeiro, acabou por criar falhas no fluxo, comprometendo toda a solução. Esse problema, que consumiu cerca de três horas para ser solucionado, evidenciou a importância de nos mantermos atentos aos princípios arquiteturais de cada solução proposta, pois, muitas vezes imaginamos erros complexos como causadores da instabilidade enquanto o problema se encontra em conceitos básicos de implementação. Tendo este cenário como plano de fundo, quero descrever a solução que implementei e aproveito para descrever um design pattern pouco mencionado, mas bastante resiliente para atender casos de uso como o descrito.</p><h3>Estrutura dos microservices</h3><p>A orquestração que eu estava implementando envolvia um nível de complexidade significativo, devido à sua natureza totalmente assíncrona e baseada em eventos. O processo iniciava-se com o upload de um conteúdo de mídia para um repositório AWS S3 (Simple Storage Service), utilizando a abordagem de URL Pré-Assinada para o envio direto do vídeo do dispositivo do usuário. Um microservice específico era responsável por gerar essa “presigned URL” e retorná-la ao aplicativo móvel, que iniciava o fluxo de envio do arquivo.</p><p>Após o retorno das informações para o aplicativo, o microservice prosseguia com o fluxo de armazenamento de informações complementares no banco de dados para garantir que o arquivo fosse identificável e indexável posteriormente. Simultaneamente, um novo fluxo era desencadeado a partir do evento autônomo que indicava a conclusão do upload no storage S3. Este segundo microservice dedicava-se a buscar informações adicionais necessárias para compor os dados para um novo fluxo. Esses dados eram então publicados em uma fila na AWS SQS (Simple Queue Service), a partir de onde eram consumidos por outro microservice situado no Google Cloud Platform — configurando, portanto, uma estrutura multi-cloud. Esta interação desencadeia uma nova orquestração de microservices através do Google Gemini, completando o fluxo de processamento e proporcionando métricas de análise sobre o conteúdo do vídeo.</p><p>Sem dúvida, trata-se de um cenário complexo para ser detalhado em um único artigo. Talvez, em uma série futura de publicações, eu possa explorar cada uma das implementações e tecnologias envolvidas no fluxo completo da arquitetura proposta. Todavia, para ilustrar a solução, podemos considerar um caso de uso mais simples que simule o problema e demonstre a resolução proposta, bem como o padrão de design utilizado.</p><h3>Caso de Uso Simulado</h3><p>Vamos imaginar um cenário em que dois microservices são inicializados paralelamente em resposta a eventos específicos. O primeiro microservice é encarregado de realizar certos processamentos e de persistir essas informações em um banco de dados. O segundo, por sua vez, é responsável por processar um arquivo de mídia, realizando verificações de formato, tamanho, extensão e também a compressão desse arquivo. Além desses procedimentos, este microservice necessita acessar informações no banco de dados — informações essas que devem ser previamente armazenadas pelo primeiro microservice.</p><p>Dada a natureza assíncrona e orientada a eventos da arquitetura, não é possível prever exatamente quando os dados serão armazenados no banco de dados. Surge então a questão: seria possível disparar a inicialização do segundo microservice a partir do evento de persistência dos dados na base? É importante lembrar que ambos os microservices executam outros processos em paralelo, o que torna essa opção inviável.</p><p>Em algumas situações, o primeiro microservice completa o processamento antes, e o fluxo se conclui sem problemas. Entretanto, há ocasiões em que o segundo microservice tenta acessar o banco de dados antes que o primeiro tenha concluído a persistência das informações. Nestes casos, o fluxo é interrompido e a orquestração inteira é afetada. Este desafio destaca a complexidade de gerenciar dependências e sincronia em sistemas baseados em microservices e arquitetura orientada a eventos.</p><h3>Solução de Mitigação</h3><p>De forma generalista, e também para validar a consistência da análise do problema, podemos implementar um atraso (delay) antes do método de consulta do segundo microservice. Esse procedimento aumenta a probabilidade de que o primeiro microservice conclua a persistência dos dados. É importante salientar que um delay não garante que o processamento da dependência necessária tenha sido concluído, mas pode resolver esse fluxo específico, no qual não há erros de processamento ou falhas de comunicação.</p><p>No entanto, como lidar com outros tipos de erros, como indisponibilidade, falhas de processamento ou problemas em fluxos? Para esses cenários, é essencial que a arquitetura seja projetada para ser robusta e resiliente, capaz de suportar essas situações. Um exemplo prático é a implementação de recursos como a DLQ (Dead Letter Queue), uma fila de transbordo que direciona processos não executados conforme o esperado. Essa abordagem permite a realização de fluxos alternativos de processamento ou a emissão de alertas sobre falhas, assegurando que a arquitetura se adapte e responda adequadamente a problemas inesperados. Vale mencionar, no entanto, que este não é o foco deste artigo. Caso seja relevante, o tema pode ser explorado em detalhes ao longo da série proposta no início do texto.</p><p>Para que possamos evoluir na resolução, vamos analisar o código de exemplo descrito abaixo. Trata-se da classe VerifyService, que essencialmente simula o processo de consulta a um registro, neste caso, persistido pelo primeiro microservice e consultado pelo segundo. Além disso, a classe implementa níveis de abstração para tratamento de erros e manipulação de enums, garantindo um fluxo mais robusto e padronizado. Embora o foco deste artigo não seja explorar esses detalhes, apresento a seguir um breve resumo explicativo da classe.</p><h3>Funcionalidades da Classe</h3><p>1 — Dependências</p><p>a) userCheckEmail: Implementa a interface UserCheckEmailTreaty e é utilizada para verificar se o e-mail já está registrado.</p><p>b) treatment: Implementa a interface TreatmentErrorContract e fornece a capacidade de tratar e lançar erros de maneira padronizada.</p><p>2 — Método Principal: perform</p><p>O método recebe um objeto params com os seguintes dados:</p><p>a) email: E-mail que será verificado.</p><p>3 — Etapas da Execução</p><p>a) Aguardar 10 segundos: Antes de realizar a verificação, o método aguarda 10 segundos usando uma Promise. Ou seja, neste ponto que se insere o requisito de negócio (impor um atraso deliberado).</p><p>b) Verificar E-mail: A lógica de verificação é delegada ao método perform de userCheckEmail. Este método retorna uma instância de Error se houver algum problema ou se o e-mail já estiver registrado.</p><p>c) Tratar Erros: Caso a verificação retorne um Error, o método utiliza treatment.launchError para lançar um erro padronizado, indicando que o e-mail já foi registrado. A mensagem de erro inclui detalhes como o e-mail envolvido.</p><p>d) Retorno Bem-Sucedido: Se não houver erro, o método retorna true, indicando que a verificação foi bem-sucedida.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6s9Xl7kUN-7I670b" /></figure><p>Após a simples inclusão deste tratamento, incluindo um delay para o processamento, resolvemos integralmente o problema acíclico no fluxo, permitindo a conclusão bem-sucedida da orquestração dos serviços em todas as tentativas.</p><h3>Mas uma solução de mitigação não é uma resolução</h3><p>Evidentemente, o uso de setTimeout para implementar um atraso fixo, como 10 segundos, resulta em um tempo de espera pré-determinado, que pode ser inadequado. Esse intervalo pode ser excessivo, caso o recurso se torne disponível mais rapidamente, ou insuficiente, perpetuando o problema original que buscamos resolver.</p><p>Adotar uma abordagem simples com tentativas fixas após o término do timeout também apresenta desafios. Isso pode gerar uma alta frequência de chamadas, o que é particularmente problemático em sistemas onde múltiplos consumidores competem para acessar o mesmo recurso em paralelo. Quando muitos consumidores tentam acessar um recurso simultaneamente após um atraso fixo, ocorre o chamado “efeito de thundering herd”, em que todos bombardeiam o recurso ao mesmo tempo, potencialmente causando falhas adicionais.</p><p>Além disso, um tempo fixo não se adapta a condições variáveis, como recursos que exigem diferentes tempos de processamento ou sistemas sujeitos a flutuações de carga. Por essas razões, é essencial considerar soluções mais flexíveis e adaptáveis para gerenciar essas situações de maneira eficaz.</p><p>Em resumo, essa abordagem não é nem elegante nem eficiente. Embora, de forma simplista, possa resolver o problema identificado, ela introduz maior latência na comunicação e não se configura como uma solução performática.</p><h3>Retry Pattern com Exponential Backoff</h3><p>Neste contexto inserimos um Design Pattern pouco difundido, mas extremamente resiliente em sua abordagem no atendimento de cenários como o descrito no nosso caso de uso. O Retry Pattern com Exponential Backoff é uma abordagem mais robusta e eficiente porque introduz inteligência e adaptabilidade ao processo de “retry”, reduzindo a sobrecarga, melhorando a resiliência do sistema e evitando efeitos negativos como alta concorrência ou tentativas excessivas. Enquanto o setTimeout é uma solução simples, ele é estático e limitado, não adequado para cenários complexos ou dinâmicos.</p><p>O Retry Pattern com Exponential Backoff é uma abordagem usada para lidar com falhas transitórias ao realizar operações remotas, como chamadas de API ou acesso a bancos de dados. O padrão tenta realizar a operação repetidamente após falhas, aumentando o intervalo de espera entre as tentativas de maneira exponencial para evitar sobrecarregar o sistema remoto e melhorar as chances de sucesso, abaixo, na Figura 1, deixo um fluxograma para ilustrar a lógica de execução do padrão.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EbXgvYjzL3SITvFp" /></figure><p>Figura 1 — Fluxograma Retry Pattern</p><p>O Retry Pattern é uma abordagem eficaz para lidar com falhas temporárias em sistemas distribuídos ou operações críticas. Ele funciona iniciando uma operação e tentando executá-la. Após a tentativa, verifica-se se a operação foi bem-sucedida. Caso ocorra uma falha, o padrão aplica um mecanismo de Retry com Backoff, onde as tentativas subsequentes são espaçadas por intervalos de tempo que crescem exponencialmente, reduzindo a sobrecarga no sistema e aumentando as chances de sucesso. Para evitar loops infinitos ou comportamento indesejado, é estabelecido um limite máximo de tentativas ou um tempo limite total. Ao final, se todas as tentativas falharem, retorna-se uma falha definitiva; caso contrário, o resultado bem-sucedido da operação é entregue. Esse padrão é amplamente utilizado para aumentar a resiliência e a robustez de sistemas sujeitos a falhas transitórias.</p><p>O Retry Pattern é uma estratégia eficaz, amplamente utilizada para lidar com falhas temporárias em operações críticas, como a verificação de dados em sistemas distribuídos. No código apresentado, a seguir, o padrão é implementado na classe VerifyService, apresentada anteriormente, introduzindo tentativas sucessivas de busca do registro. Caso ocorra uma falha, o método “perform” aplica um mecanismo de Retry com Backoff incremental, onde o atraso entre as tentativas cresce exponencialmente, limitado a 16 segundos, para evitar sobrecarregar o sistema. O número máximo de tentativas é configurado como 5 por padrão, mas pode ser ajustado conforme a necessidade. Se todas as tentativas falharem, o sistema lança um erro descritivo, indicando a indisponibilidade do recurso. Essa abordagem garante maior resiliência à aplicação, reduzindo os impactos de falhas transitórias e melhorando a experiência do usuário ao evitar interrupções abruptas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1019/0*a7Q66VpDERKR6jRi" /></figure><h3>Cálculo do Delay</h3><p>A fórmula 1000 2 * (attempt — 1) calcula o tempo de espera (delay) em milissegundos, dobrando a cada tentativa.</p><p>O operador 2 ** (attempt — 1) eleva 2 ao número da tentativa menos 1:</p><ul><li>attempt = 1 → 2 ** 0 = 1 → Delay = 1000 * 1 = 1000 ms (1 segundo)</li><li>attempt = 2 → 2 ** 1 = 2 → Delay = 1000 * 2 = 2000 ms (2 segundos)</li><li>attempt = 3 → 2 ** 2 = 4 → Delay = 1000 * 4 = 4000 ms (4 segundos)</li><li>attempt = 4 → 2 ** 3 = 8 → Delay = 1000 * 8 = 8000 ms (8 segundos)</li><li>attempt = 5 → 2 ** 4 = 16 → Delay = 1000 * 16 = 16000 ms (16 segundos)</li></ul><p>E assim por diante.</p><h3>Limite Máximo</h3><p>A função Math.min() limita o valor máximo do delay a 16.000ms (16 segundos).</p><p>Mesmo que o cálculo do backoff resulte em valores maiores, o delay nunca ultrapassará 16 segundos.</p><h3>Conclusão</h3><p>O Retry Pattern, combinado com o mecanismo de Exponential Backoff, destaca-se como uma abordagem robusta para lidar com falhas transitórias em sistemas distribuídos. Sua implementação, além de reduzir sobrecargas desnecessárias no sistema, contribui significativamente para a resiliência e estabilidade da aplicação, ao adaptar-se às condições dinâmicas do ambiente. Como demonstrado no caso prático, esse padrão oferece uma solução elegante para gerenciar dependências em fluxos assíncronos e eventos imprevisíveis, minimizando os impactos de falhas temporárias. Para projetos complexos e arquiteturas modernas, adotar padrões como este não é apenas uma boa prática, mas uma necessidade estratégica para garantir a confiabilidade dos sistemas.</p><h3>Referências</h3><p>BHATTBHATT, Harish. Best practices for retry pattern. Disponível em: <a href="https://harish-bhattbhatt.medium.com/best-practices-for-retry-pattern-f29d47cd5117">https://harish-bhattbhatt.medium.com/best-practices-for-retry-pattern-f29d47cd5117</a>. Acesso em: data de acesso: 20 de dezembro de 2024.</p><p>NYGARD, Michael T. Release It!: Design and Deploy Production-Ready Software. 2. ed. Dallas: The Pragmatic Bookshelf, 2018.</p><p>RICHARDSON, Chris. Microservice Patterns: With examples in Java. Nova York: Manning Publications, 2018.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7428be19213b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>