<?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 Daniel Santos on Medium]]></title>
        <description><![CDATA[Stories by Daniel Santos on Medium]]></description>
        <link>https://medium.com/@daniel.dia?source=rss-3b2c3c45e2b1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*vMraYxP5Lbr2FRi_.</url>
            <title>Stories by Daniel Santos on Medium</title>
            <link>https://medium.com/@daniel.dia?source=rss-3b2c3c45e2b1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 12:07:11 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@daniel.dia/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[Claude Chat me fez perder tempo e eu tive que corrigir até a lista de erros dele]]></title>
            <link>https://medium.com/@daniel.dia/claude-chat-me-fez-perder-tempo-e-eu-tive-que-corrigir-at%C3%A9-a-lista-de-erros-dele-7edc4c7f6bee?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/7edc4c7f6bee</guid>
            <category><![CDATA[hallucinations]]></category>
            <category><![CDATA[claude-ai]]></category>
            <category><![CDATA[ai-research]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Sun, 07 Jun 2026 19:30:01 GMT</pubDate>
            <atom:updated>2026-06-07T19:31:25.189Z</atom:updated>
            <content:encoded><![CDATA[<p>Como uma sessão de pesquisa técnica virou um ciclo de correções, e por que confiança sem calibração é mais perigosa que ignorância assumida</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ON8bfZtx-2NrNBlUmqgWEg.png" /></figure><p>Sou Head de Arquitetura de Software, trabalho com IA todos os dias e vivo lendo documentação técnica. Mesmo assim, uma pesquisa simples no Claude virou um ciclo cansativo:<strong> eu perguntava, recebia uma resposta super confiante, encontrava erros, corrigia, e a próxima resposta ainda vinha carregando parte do erro anterior.</strong></p><h3>O que eu queria</h3><p>Simples: entender o ecossistema de ferramentas AI para TypeScript. Comparar Mastra, Vercel AI SDK, Vercel Workflow SDK e Temporal. Coisas que têm documentação pública, repositórios abertos, posts oficiais.</p><p>Não pedi nada obscuro.</p><h3>O que aconteceu</h3><p>A cada resposta, o Claude entregava tabelas bem formatadas, conclusões totalmente confiantes e assertivas, recomendações diretas. Parecia sólido.</p><p>Não era.</p><p>Fui identificando erros um a um. Corrigindo. Ele reconhecia, “ajustava” — e na resposta seguinte ainda carregava o viés da versão errada. Cheguei ao ponto de perguntar diretamente quantos erros ele tinha cometido na conversa. Ele me deu uma lista. Tive que corrigir a lista de erros também.</p><blockquote>Isso é desanimador. Era melhor ter ido direto na documentação oficial.</blockquote><h3>Os erros catalogados (7 confirmados)</h3><ol><li>AI SDK Afirmou que AI SDK não tem memória nativa. errado, tem documentação oficial e message persistence</li><li>Mesmo após notar o erro, continuou enquadrando o storage como “não nativo”, enviesando a comparação para favorecer o Mastra</li><li>Mesma tabela Afirmou que AI SDK não tem embed nativo. errado, tem embed, vector stores e seção dedicada na documentação</li><li>Tabela de alternativas workflow SDK e Temporal Classificou Temporal somente como SelfHost, ignorando serviço publico do temporal.</li><li>Classificou Vercel Workflow SDK como “não precisa de infra externa, só do seu código”, mas ele precisa da infra da IaaS da Vercel.</li><li>Conclusão/recomendação Descartou o Workflow SDK para ambientes GKE com base nos erros anteriores. recomendação inválida</li><li>E quando pedi a lista dos erros, ele esqueceu de incluir o erro relacionado ao Temporal. Tive que apontar isso também.</li></ol><h3>O padrão que incomoda</h3><p>Não parecia algo aleatório. Os erros seguiam sempre na mesma direção. Dava a impressão de que o Claude montava uma narrativa primeiro e só depois tentava encaixar os fatos. E tudo vinha com o mesmo nível de confiança: tabelas bem feitas, conclusões objetivas e recomendações que pareciam feitas sob medida para o meu contexto.</p><blockquote>Isso é perigoso. Já conhecia a ferramenta e sabia “por cima’” que cada uma entregava ou não. IMAGINA se não soubesse? iria confiar cegamente nas recomendações erradas da IA.</blockquote><p>Toda ferramenta tem limitações. O problema era a confiança excessiva. Um usuário menos experiente provavelmente teria aceitado tudo como verdade e seguido por um caminho técnico completamente errado.</p><h3>A comparação que não queria fazer, mas vou fazer</h3><p>Nunca precisei fazer esse nível de validação usando GPT ou Perplexity para pesquisas técnicas. O Claude parece funcionar muito bem para código, automação e tarefas com contexto bem definido, mas em comparações técnicas que dependem de precisão factual, minha experiência foi bem inconsistente. (mais de uma vez)</p><p>No fim, fiquei com a sensação de que é mais rápido ir direto à fonte. Documentação oficial, repositórios e changelogs costumam dar respostas mais confiáveis. as vezes fornecer link da documentação para AI ajudou também. Melhor que gastar tempo conferindo e corrigindo uma IA que responde com muita confiança, mesmo quando está errada.</p><p><em>Modelo usado: sonnet 4.6 thinking, high . busca na web ligada. Escrito após uma sessão real de pesquisa sobre AI tooling para TypeScript. Os erros listados foram identificados e confirmados durante a própria conversa.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7edc4c7f6bee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI me tirou uma parte da programação que eu gostava]]></title>
            <link>https://medium.com/@daniel.dia/ai-me-tirou-uma-parte-da-programa%C3%A7%C3%A3o-que-eu-gostava-616219d5eb1d?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/616219d5eb1d</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Wed, 03 Jun 2026 13:48:46 GMT</pubDate>
            <atom:updated>2026-06-03T14:21:57.838Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Não é um post contra IA. É um post sobre o que ficou para trás.</blockquote><p>Tenho percebido uma coisa estranha nos últimos meses. Eu sempre gostei de programar. Não só de resolver problemas ou entregar software, mas do ato de programar.</p><p>Sou um full stack sênior, mas o frontend, para mim, sempre teve um lado meio artístico. Gostava de testar frameworks novos, comparar experiências de desenvolvimento, discutir qual biblioteca era mais elegante. Ajustar fontes, espaçamentos, animações e detalhes visuais até tudo parecer certo.</p><p>Hoje, quando preciso criar uma interface, nunca faço isso manualmente. Não porque deixei de gostar, mas porque é muito mais rápido pedir para uma IA fazer. E ela faz rápido. Muito rápido. Entrego mais software do que nunca.</p><p>Mas a relação com o desenvolvimento mudou. Talvez eu nunca mais programe da mesma forma.</p><h4>Futuro dos frameworks.</h4><p>Outra coisa que tenho observado é que os frameworks também devem mudar.</p><p>Durante muitos anos falamos sobre DevXP (Developer Experience). Frameworks competiam para oferecer uma experiência melhor para quem escrevia código.</p><p>Agora parece que estamos entrando em uma fase diferente. Talvez os frameworks do futuro sejam otimizados não para desenvolvedores, mas para agentes de IA. Menos foco em DevXP e mais foco em AgentXP. Estruturas mais previsíveis. Convenções mais rígidas. APIs mais fáceis para agentes entenderem e modificarem.</p><p>Não sei se isso é bom ou ruim.</p><p>Só sei que sinto falta daquela programação mais contemplativa. Daquela tarde terapeutica ajustando detalhes de uma tela porque eu realmente gostava daquilo com perfeição.</p><p>Hoje a programação está ficando cada vez mais performática. Eu continuo construindo software. Estou mais produtivo do que nunca. Mas existe uma parte do processo que eu gostava bastante e que talvez não volte mais.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=616219d5eb1d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Qual modelo de IA usar para coding em 2026: benchmark real cruzado com preço do Copilot]]></title>
            <link>https://medium.com/@daniel.dia/qual-modelo-do-github-copilot-usar-no-seu-time-aa61adedf946?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa61adedf946</guid>
            <category><![CDATA[github]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Wed, 03 Jun 2026 02:15:19 GMT</pubDate>
            <atom:updated>2026-06-03T02:30:33.267Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Cruzei os dados do DeepSWE com os preços do GitHub Copilot. O resultado muda o que se assume sobre Claude Opus</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BYqVsQmZo2LxvqpCbCQtUA.png" /></figure><p>Em junho de 2026, o<a href="https://github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing/"> GitHub Copilot migrou a cobrança de “requests por mês” para tokens consumidos.</a> De repente, a escolha do modelo virou uma decisão, além de técnica, financeira real.</p><p>Então fiz o que qualquer engenheiro pragmático faria: cruzei os dados de performance do <a href="https://deepswe.datacurve.ai/"><strong>DeepSWE</strong> </a>— o benchmark de coding mais rigoroso disponível hoje — com a <a href="https://docs.github.com/pt/copilot/reference/copilot-billing/models-and-pricing#model-multipliers-for-annual-copilot-pro-and-copilot-pro-subscribers">nova tabela de preços do Copilot</a>. Para o cálculo de custo, usei os tokens de output do <a href="https://deepswe.datacurve.ai/"><strong>DeepSWE</strong></a><strong> </strong>e estimei os tokens de input de cada sessão agêntica, aplicando os <a href="https://docs.github.com/pt/copilot/reference/copilot-billing/models-and-pricing#model-multipliers-for-annual-copilot-pro-and-copilot-pro-subscribers">preços exatos do Copilot</a> para cada provedor — incluindo o custo de cache write da Anthropic, ausente nos custos de API reportados pelo benchmark.</p><h3>TL;DR: Cinco conclusões</h3><p>Se você tem dois minutos, estas são as descobertas que este artigo detalha com dados:</p><ul><li><strong>01 · Melhor custo-benefício no Copilot. GPT-5.5 </strong>[medium] — <strong>$4,88 por sucesso.</strong> Não é o modelo mais caro nem o de maior score. É o que resolve mais tarefas por real gasto — 48% de taxa de sucesso a $2,34 por tentativa.</li><li><strong>02 · Modo &gt; modelo. </strong>O esforço de raciocínio é a maior alavanca de custo. Para o mesmo modelo, trocar de [max] para [medium] pode <strong>reduzir o custo por sucesso em até 4×.</strong> Configurar o modo certo vale mais do que escolher o modelo certo.</li><li><strong>03 · Pior custo-benefício disponível </strong>Claude Opus 4.7 [max] — $36,15 por sucesso. 7× mais caro que GPT-5.5 [medium]por tarefa bem-sucedida. Score apenas 6 pontos percentuais maior. O modo [max] da Anthropic cobra caro por thinking tokens invisíveis.</li><li><strong>04 · O paradoxo do preço por token. </strong>GPT-5.5 paga mais por token, mas usa muito menos tokens. Output a $30/M vs $25/M do Opus 4.8, mas o GPT-5.5 usa menos da metade dos tokens por tarefa. A eficiência de tokens vence o preço por token.</li><li><strong>05 · Gemini não é a alternativa que parece. </strong>Gemini 3.5 Flash: $26,50/sucesso apesar de barato. O modelo gera 4x mais tokens por tarefa . O custo é alto mesmo com preço por token mais baixo.</li></ul><p>Abaixo detalhando como encontramos estes dados.</p><h3>Por que o SWE-bench não é suficiente</h3><p>O SWE-bench domina os leaderboards. O problema é que ele foi construído a partir de código já existente, o que cria um risco de contaminação: os modelos podem ter visto as soluções durante o treino.</p><p>O <a href="https://deepswe.datacurve.ai/"><strong>DeepSWE</strong> </a>resolve isso de um jeito elegante: <strong>todas as tasks são inéditas</strong>, escritas do zero por engenheiros humanos, e as soluções nunca são mergeadas de volta nos repositórios públicos. As tasks refletem trabalho real de engenharia: prompt médio de 2.158 caracteres, mas a solução de referência exige em média <strong>668 linhas de código em 7 arquivos diferentes</strong>.</p><p>O resultado é que o <a href="https://deepswe.datacurve.ai/">DeepSWE</a> <strong>separa os modelos com gaps muito maiores</strong> do que o SWE-bench. Por exemplo, Claude Sonnet 4.6 de 54% no SWE-bench para 32% no DeepSWE. Isso não é ruído, é o benchmark mostrando o que acontece quando a task é difícil de verdade.</p><h3>Custo por tarefa bemsucedida no Copilot:</h3><p>Com a cobrança por token, a pergunta certa não é “qual modelo é melhor?” mas <strong>“qual modelo entrega mais resultado por real gasto no Copilot?”</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/1*dEj_Izs_hBsHAb4G67PkEw.png" /><figcaption>Custo por sucesso = custo médio por tentativa ÷ taxa de sucesso</figcaption></figure><p>Para o cálculo de custo no Copilot: usei os tokens de output reportados pelo DeepSWE, estimei os tokens de input com base nos custos de API, e apliquei a tabela de preços do Copilot para cada provedor.</p><blockquote>Para modelos <strong>OpenAI e Google</strong>, os preços de API são idênticos aos do Copilot, verificado matematicamente. contudo Para <strong>Anthropic</strong>, o Copilot cobra adicionalmente pelo cache write. <strong>um aumento de 10 a 20% nos modelos Anthropic.</strong></blockquote><h3>O modo importa mais do que o modelo</h3><p>Esse é o dado mais importante da análise e o que mais vai mudar como você configura seu time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qWAxwAtqCxxcrCQ7L8AoEg.png" /></figure><p>Para o mesmo modelo, a diferença de custo/sucesso entre modos pode ser de <strong>4 a 7×</strong>. O exemplo mais dramático é o Claude Opus 4.7 no Copilot:</p><ul><li>[medium]: 32% de score a $2,69/trial → <strong>$8,41 por sucesso no Copilot</strong></li><li>[high]: 40% a $5,42 → $13,55 por sucesso</li><li>[xhigh]: 45% a $9,43 → $20,96 por sucesso</li><li>[max]: 54% a $19,52 → <strong>$36,15 por sucesso no Copilot</strong></li></ul><p>Do [medium] ao [max], o score sobe 22 pontos percentuais. O custo por sucesso no Copilot sobe <strong>4,3×</strong>.</p><p>O caso mais revelador é o Claude Opus 4.8: em [max] e [xhigh] o modelo entrega <em>o mesmo score</em> (58%), mas o [max] custa $14,23 contra $8,60 do [xhigh] no Copilot. Zero benefício adicional por 65% a mais de custo.</p><blockquote><strong>Resumindo:</strong> você pode rodar Claude Opus 4.7 em modo máximo uma vez no Copilot, ou rodar GPT-5.5 em modo médio <strong>8 vezes</strong> pelo mesmo preço — com score muito próximo por tentativa e resultado agregado muito melhor.</blockquote><p>O DeepSWE também documenta um comportamento recorrente do Claude Opus: ele tende a esquecer sub-requisitos em prompts com partes paralelas</p><h3>Ranking de eficiência. custo por tarefa bem-sucedida no Copilot</h3><p>Top 12 combinações disponíveis no Copilot, com preços reais. Menor = mais eficiente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/970/1*BjKhDQE-iURq2XZBtTmyLQ.png" /></figure><h3>Por que o GPT-5.5 sai mais barato apesar de custar mais por token</h3><p>Uma contradição aparente nos dados merece atenção direta: o GPT-5.5 cobra <strong>$30/M de output</strong> — 20% mais caro que os $25/M do Claude Opus 4.8. Como termina sendo mais barato por tarefa?</p><p>A resposta está na <strong>eficiência de tokens</strong>: quantos tokens o modelo precisa para resolver uma tarefa, independente do preço unitário. O GPT-5.5 termina a mesma tarefa usando menos da metade dos tokens do Opus 4.8.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7YhNA30M_7pfowiAx2LI_A.png" /></figure><ul><li><strong>Cache write</strong> ($6,25/M): o Copilot cobra para gravar o contexto no cache. Em [xhigh], isso adiciona $3,73 por sessão.</li><li><strong>Thinking tokens ocultos</strong>: o raciocínio interno do Claude é cobrado como output, mas não aparece no contador de tokens da resposta. Em [max], somam centenas de milhares de tokens adicionais por sessão.</li></ul><blockquote>A lição: <strong>preço por token e custo por tarefa são métricas diferentes</strong>. Um modelo pode cobrar mais por token e ainda assim ser mais barato por resultado — se for mais eficiente no uso de tokens. É isso que o DeepSWE mede que benchmarks simples não capturam.</blockquote><p><strong>Metodologia:</strong> Tokens de output e custos de API do <a href="https://deepswe.datacurve.ai/blog">DeepSWE</a> (Datacurve, Mai/2026). Tokens de input estimados por: <em>input = (custo_api − out×preço_out) / preço_in</em>. Custos Copilot calculados com preços da <a href="https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing">tabela oficial do GitHub Copilot</a> (Jun/2026), incluindo custo de cache write Anthropic (taxa efetiva de input: $6,05/M para Opus, $3,63/M para Sonnet, assumindo 60% de cache write e read por sessão agêntica). OpenAI e Google: verificados matematicamente — preço API = preço Copilot.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa61adedf946" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O Custo Invisível da IA no Desenvolvimento de Software]]></title>
            <link>https://medium.com/@daniel.dia/o-custo-invis%C3%ADvel-da-ia-no-desenvolvimento-de-software-e284d2e4c48e?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/e284d2e4c48e</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[metrics]]></category>
            <category><![CDATA[dora]]></category>
            <category><![CDATA[brain-fry]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Mon, 25 May 2026 20:32:23 GMT</pubDate>
            <atom:updated>2026-05-25T20:32:23.018Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Olye6hJpkvFj1dKsQqdAHQ.png" /></figure><h3><strong>TL;DR</strong></h3><p>IA aumenta output, mas transfere o esforço do autor para o validador. As métricas atuais não enxergam isso e mostram produtividade onde pode existir dívida técnica e humana acumulando silenciosamente.</p><p>O dado que resume tudo: 54% dos devs têm medo de questionar outputs ruins porque parece improdutivo nos dashboards.</p><p>O que muda: medir revisão, debugging e contexto-switching com o mesmo rigor que se mede geração de código.</p><h3>Introdução</h3><p>Um estudo lançado em maio de 2026 pela Harness — o State of Engineering Excellence — com mais de 700 profissionais do mundo todo, mostra que a IA está transformando a rotina dos desenvolvedores de forma positiva e negativa. Embora acelere a escrita de código, a IA introduziu uma carga de trabalho nova e totalmente invisível.</p><h3>Mudança da forma de trabalho</h3><p>Antes de entrar nos dados, deixa eu ser honesto sobre o que mudou no meu próprio dia a dia. Sou chefe arquiteto de software e até pouco tempo, meu trabalho era principalmente arquitetar soluções, escrever código, conversar com pessoas, discutir trade-offs, alinhar estratégia, desenhar sistemas.</p><p>Hoje gasto a maior parte do meu tempo revisando. Não há revisão no sentido de mentoria técnica, mas revisão de saída de máquina: entender o que aconteceu, por que aconteceu, e se aquilo cabe na estratégia de arquitetura e custo da empresa. Além de carga para gerenciar espectativas e pressões sobre uso de AI. Quando vi como os dados deste estudo se encaixam na minha realidade, resolvi falar sobre minha percepção.</p><p>Eu não sou um caso isolado. Este estudo, com engenheiros e líderes de engenharia em cinco países veio confirmar exatamente isso.</p><blockquote>“31% do dia de um desenvolvedor é consumido por trabalho invisível relacionado à IA que não aparece em nenhuma métrica.”<em> </em>.</blockquote><h3>De criador para revisor</h3><p>O relatório ainda mostra que <strong>81% dos líderes de engenharia</strong> reportaram aumento considerável no tempo de code review desde que começaram a usar IA.</p><p>Esse dado eu sinto na pele: Nosso fluxo de PR que antes fluía normalmente, virou gargalo e ponto de atenção. Passei a ter que monitorar para não travar a esteira, o que por si só já é um trabalho que não existia antes. <em>(Em outro artigo vou escrever como estou melhorando esse fluxo)</em></p><blockquote>“Os desenvolvedores não são mais os autores primários do código. Eles são agora os validadores do output gerado pela máquina.”</blockquote><p>Não é que seja errado usar IA dessa forma. O problema é que o custo dessa revisão<strong> não aparece em nenhum planejamento de capacidade.</strong> Simplesmente acontece, e vai se acumulando.</p><p>Em alguns casos, até revisar código de novos atores de áreas fora de engenharia. Vibe coding chega em diversas empresas permitindo outras áreas criarem software, e alguém precisa segurar se aquilo é sustentável, seguro, e se cabe na estratégia de arquitetura da empresa.</p><h3>O cansaço que ninguém mede</h3><p>Tem uma dimensão do problema que o relatório chama de <em>Brain Fry</em> — exaustão cognitiva.</p><p>A troca constante e profunda de contexto entre tarefas é exaustiva intelectualmente, penalizando o foco e a qualidade de execução de cada tarefa. A qualidade de engenharia fica prejudicada.</p><blockquote>“94% dos líderes dizem que dívida técnica e burnout de desenvolvedores estão faltando nas métricas atuais.”</blockquote><h3>Fora da rotina</h3><p>Além do trabalho operacional, tem o trabalho de <strong>se manter atualizado</strong>. Pessoalmente silenciei canais de notícia porque a enxurrada de conteúdo sobre IA é inacreditável. Todo dia alguém vendendo “como fazer seu trabalho ser 10x mais eficiente”, “como a IA vai substituir tudo”, “a nova ferramenta que muda tudo”…</p><p>Manter-se relevante e atualizado como arquiteto hoje significa filtrar o que realmente importa num volume crescente de informação e absorver o que importa. Isso também é carga coognitiva e consome energia. Outro item que não aparece em nenhuma métrica de produtividade.</p><h3>As métricas não evoluíram</h3><p>O relatório é direto sobre isso:</p><blockquote>“As organizações estão medindo output bruto. Elas não estão medindo onde os ganhos de produtividade estão sendo gastos.”</blockquote><p>DORA metrics, ciclo de PR, volume de código — todos continuam como eram antes da IA. O problema é que eles foram construídos para um mundo onde o desenvolvedor era o autor. Num mundo onde ele é o validador, esses números mentem.</p><p>Testemunhei pessoas se gabando de desenvolver o planejado um semestre em duas semanas usando vibe coding. As métricas explodiram de eficiência, mas na prática não se tornou uma entrega real.</p><p>Está semana, <strong>cancelei ferramentas que mediam esse tipo de métrica</strong>. O custo não se justificava para dashboards que não contavam a história que já era a nossa realidade.</p><p>E o dado mais preocupante do estudo: <strong>54% dos desenvolvedores temem que seus dados de produtividade com IA sejam usados negativamente em avaliações de desempenho.</strong> Isso cria um incentivo para aceitar outputs ruins sem questionar, porque questionar “parece” reativo e menos produtivo no dashboard.</p><p>É necessário <strong>criar espaço para que as pessoas digam que estão sobrecarregadas sem parecer que estão reclamando.</strong></p><h3>O que precisa mudar, segundo a Harness</h3><p>O relatório propõe:</p><ul><li><strong>Meça também o custo de validar</strong>: tempo de revisão, debugging e troca de contexto.</li><li><strong>Mais codigo não significam mais valor</strong>: acompanhe o que realmente foi entregue utilizado pelo cliente.</li><li><strong>Métricas incompletas é um alerta:</strong> revise se os indicadores capturam os impactos reais da IA.</li><li><strong>Prepare métricas para crescente complexidade</strong>: espere mais governança, segurança e necessidade de métricas avançadas.</li><li><strong>Crie confinaça da equipe nas suas métricas</strong>: defina regras e transparência antes de instrumentar medições.</li></ul><h3>Conclusão</h3><p>A IA veio pra ficar, mas tem seu preço, Fingir que esse preço não existe cria duas dívidas: a técnica, no código, e a humana, nas pessoas.</p><p>Depois de tudo que vivi nesses últimos meses, o que fica é simples. Se você lidera um time de engenharia e ainda não revisou suas métricas à luz de tudo isso, provavelmente seu time já está sentindo o peso de um trabalho que ninguém está medindo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e284d2e4c48e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como Criar Testes de um Servidor MCP em NodeJS: O Guia Definitivo]]></title>
            <link>https://medium.com/@daniel.dia/como-criar-testes-de-um-servidor-mcp-o-guia-definitivo-3f3c305ac267?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f3c305ac267</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[model-context-protocol]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Mon, 10 Nov 2025 18:58:31 GMT</pubDate>
            <atom:updated>2025-11-11T12:27:53.587Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DPWbdmwdpbzR3cYYnPu8ZA.png" /></figure><h3>TL;DR</h3><p><strong>O Problema</strong>: Como a biblioteca @modelcontextprotocol/sdk é nova e pouco documentada, as IAs sugerem métodos inexistentes ou abordagem ineficases para testar servidores MCP.</p><p><strong>A Solução</strong>: Use InMemoryTransport.createLinkedPair() que é nativo do SDK @modelcontextprotocol/sdk.</p><p><strong>Como Funciona</strong> (exemplo com calculadora):</p><pre>import { InMemoryTransport } from &#39;@modelcontextprotocol/sdk/inMemory.js&#39;;<br>import { Client } from &#39;@modelcontextprotocol/sdk/client&#39;;<br>import { McpServer } from &#39;@modelcontextprotocol/sdk/server/mcp.js&#39;;<br><br>// Criar um par ligado de transportes<br>const [serverTransport, clientTransport] = InMemoryTransport.createLinkedPair();<br><br>// Criar e conectar o servidor<br>const mcpServer = new McpServer({ name: &#39;calculator-server&#39;, version: &#39;1.0.0&#39; });<br>await mcpServer.connect(serverTransport);<br><br>// Criar e conectar o cliente<br>const mcpClient = new Client({ name: &#39;test-client&#39;, version: &#39;1.0.0&#39; });<br>await mcpClient.connect(clientTransport);<br><br>// Agora você pode testar!<br>const result = await client.callTool({ name: &#39;add&#39;, arguments: { a: 10, b: 5 } });<br><br>// e validar<br>assert.deepStrictEqual(result, { content: [{ type: &#39;text&#39;, text: &#39;15&#39; }] })</pre><p><strong>Estratégia de Mock</strong>: Mock as <strong>respostas</strong> dos métodos da camada de serviço, não as chamadas. Teste o que o servidor MCP retorna ao cliente. Jamais o comportamento interno do seu servidor MCP.</p><p><strong>Benefícios</strong>: Testes rápidos, isolados, determinísticos e que realmente validam a comunicação MCP.</p><h3>Índice</h3><ul><li><a href="#introdu%C3%A7%C3%A3o">Introdução</a></li><li><a href="#contexto-do-projeto">Contexto do Projeto</a></li><li><a href="#o-problema-ias-e-documenta%C3%A7%C3%A3o-desatualizada">O Problema: IAs e Documentação Desatualizada</a></li><li><a href="#a-solu%C3%A7%C3%A3o">A Solução</a> <a href="#setup-inicial">Setup Inicial</a></li><li><a href="#testando-diferentes-cen%C3%A1rios">Testando Diferentes Cenários</a></li><li><a href="#checklist">Checklist</a></li><li><a href="#conclus%C3%A3o">Conclusão</a></li><li><a href="#recursos-%C3%BAteis">Recursos Úteis</a></li></ul><h3>Introdução</h3><p>O <strong>Model Context Protocol (MCP)</strong>, desenvolvido pela Anthropic, permite criar servidores que expõem ferramentas (tools) para agentes de IA usando a biblioteca @modelcontextprotocol/sdk. Potencial revolucionário na interação entre LLMs e sistemas externos, porem a falta de documentação e exemplos práticos de testes torna seu uso desafiador.</p><p>Ao criar testes para meu servidor MCP, enfrentei o problema de assistentes de IA sugerirem código incorreto, com <strong>métodos inexistentes</strong> e <strong>APIs inventadas</strong>, resultando em horas perdidas debugando soluções inviáveis.</p><p>Decidi publicar uma <strong>boa solução</strong> que descobri. Este guia existe para que você não perca tempo com as mesmas armadilhas que encontrei. Aqui você aprenderá:</p><ul><li>✅ A forma correta de testar servidores MCP</li><li>O que <strong>não</strong> fazer (e por que IAs erram)</li><li>Estratégias de mock efetivas</li><li>Arquitetura e fluxos de comunicação</li><li>Código real e funcional</li></ul><h3>Contexto do Projeto</h3><p>Neste guia, usarei exemplos práticos com APIs conhecidas para facilitar o entendimento usando PokeAPI Esses exemplos são fáceis de entender, independente do seu domínio de negócio.</p><p>Quando um agente de IA pede “busque informações do Pikachu”, o servidor MCP deve retornar a resposta correta no formato esperado. É exatamente isso que vamos testar!</p><blockquote><em>💡 </em><strong><em>Nota</em></strong><em>: No meu projeto real, desenvolvi um servidor que expõe APIs do sistema em que trabalho, mas os princípios de teste são idênticos independente do domínio.</em></blockquote><h3>O Problema: IAs e Documentação Desatualizada</h3><p>Ao buscar ajuda de assistentes de IA para criar testes do meu servidor MCP, recebi diversas sugestões que simplesmente <strong>não funcionavam</strong>.</p><p>Isso acontece porque a biblioteca @modelcontextprotocol/sdk é recente e está em constante evolução, resultando em documentação escassa e IAs treinadas com informações desatualizadas ou incorretas.</p><p>Aqui estão alguns exemplos de código que IAs sugeriram, mas que não funcionam:</p><pre>// ❌ ERRADO - Este método não existe no SDK<br>import { createLocalPair } from &#39;@modelcontextprotocol/sdk&#39;;<br>const { clientTransport, serverTransport } = createLocalPair();</pre><pre>// ❌ ERRADO - McpServer não tem uma propriedade &#39;tools&#39;<br>const tool = server.tools.get(toolName);</pre><pre>// ❌ ERRADO - Este método não existe<br>const result = await server.handleToolRequest({<br>  name: &#39;calculate&#39;,<br>  arguments: { operation: &#39;add&#39;, a: 5, b: 3 },<br>});</pre><p><strong>Isso é um problema real</strong>: Desenvolvedores (incluíndo eu) perdem horas seguindo sugestões incorretas de IAs, tentando fazer funcionar algo que é impossível.</p><h3>A Solução.</h3><p>Testar seu servidor MCP emulando um cliente, sem precisar de sse ou http streaming: InMemoryTransport</p><p>Após investigar o código-fonte do SDK, entendi que a uma ótima forma correta servidores MCP é usando o InMemoryTransport, uma classe nativa mas pouco documentada.</p><h4>O Que É InMemoryTransport?</h4><p>InMemoryTransport é uma implementação de transporte que cria um <strong>par de canais de comunicação em memória</strong>, permitindo que um cliente e um servidor MCP se comuniquem sem necessidade de rede, stdio, ou outros mecanismos de IPC.</p><p>Ela apenas altera o tipo de transporte utilizado, mantendo todas as funcionalidades para testar o MCP de forma idêntica. Por exemplo:</p><p>Em vez de utilizar transporte baseado em HTTP streaming, Server-Sent Events (SSE) ou stdio:</p><pre>[MCP Server] &lt;----&gt; [ HTTP Streaming ] &lt;----&gt; [MCP Client]</pre><p>Você pode optar por um transporte em memória, simplificando a comunicação:</p><pre>[MCP Server] &lt;----&gt; [ In-Memory Transport ] &lt;----&gt; [MCP Client]</pre><p>então para testar o MCP Server precisamos criar um fake MCP client que se conecta via In-Memory Transport com o MCP Server.</p><h4>Código Real Que Funciona</h4><pre>import { InMemoryTransport } from &#39;@modelcontextprotocol/sdk/inMemory.js&#39;;<br>import { Client } from &#39;@modelcontextprotocol/sdk/client&#39;;<br>import { McpServer } from &#39;@modelcontextprotocol/sdk/server/mcp.js&#39;;<br><br>// Criar um par ligado de transportes (linked pair)<br>const [serverTransport, clientTransport] = InMemoryTransport.createLinkedPair();<br><br>// Criar e conectar o servidor<br>const mcpServer = new McpServer({ name: &#39;calculator-server&#39;, version: &#39;1.0.0&#39; });<br>await mcpServer.connect(serverTransport);<br><br>// Criar e conectar o cliente<br>const mcpClient = new Client({ name: &#39;test-client&#39;, version: &#39;1.0.0&#39; });<br>await mcpClient.connect(clientTransport);<br><br>// Agora você pode testar!<br>const result = await client.callTool({ name: &#39;add&#39;, arguments: { a: 10, b: 5 } });<br>assert.deepStrictEqual(result, { content: [{ type: &#39;text&#39;, text: &#39;15&#39; }] })</pre><h4>Por Que InMemoryTransport?</h4><ul><li><strong>Nativo do SDK</strong> — Parte oficial da biblioteca, não é gambiarra</li><li><strong>Isolado</strong> — Não depende de rede, filesystem ou ambiente externo</li><li><strong>Rápido</strong> — Comunicação em memória = latência ~0ms</li><li><strong>Determinístico</strong> — Sem race conditions, timeouts ou flakiness</li><li><strong>Simples</strong> — API direta: createLinkedPair() e pronto</li><li><strong>Confiável</strong> — Usado internamente pelo próprio SDK</li></ul><h4>Comparação: Outras Abordagens vs InMemoryTransport</h4><ul><li>❌ <strong>Tentar acessar server.tools diretamente</strong> — Não existe, propriedade privada</li><li>❌ <strong>Mock do transporte inteiro</strong> — Complexo, frágil, não testa comunicação real</li><li>❌ <strong>Servidor HTTP real + requests</strong> — Lento, depende de portas, não é unitário</li></ul><h4>A Filosofia: Mock Respostas, Não Chamadas</h4><p>Uma decisão arquitetural importante: <strong>o que mockar?</strong></p><p>Em vez de verificar <strong>se</strong> métodos foram chamados (assertion de chamadas), optei por mockar <strong>as respostas</strong> dos métodos. Esta abordagem testa o que realmente importa: <strong>o que o servidor MCP retorna ao cliente</strong>.</p><p>❌ <strong>Abordagem Ruim (Mock de Chamadas):</strong> Teste verifica: “O método X foi chamado?”. Problema: Não garante que a resposta está correta</p><p>✅ <strong>Abordagem Boa (Mock de Respostas)</strong>: Teste verifica: “O servidor MCP retornou o formato correto?”. Benefício: Valida o contrato entre servidor e cliente.</p><ul><li>❌ Não mockar o Servidor MCP</li><li>❌ Não mockar o Cliente MCP</li><li>❌ Não mockar o InMemoryTransport</li></ul><blockquote><strong><em>Por quê?</em></strong><em> Queremos testar a comunicação MCP REAL.</em></blockquote><ul><li>✅ Mockar a camada de serviço (PokeAPI)</li><li>✅ Mockar tanto sucesso quanto erros</li></ul><blockquote><strong><em>Por quê?</em></strong><em> Isolamos dependências externas, garantindo testes determinísticos e focados.</em></blockquote><h4>Criando Mocks</h4><p><strong>Exemplo: PokéAPI</strong>:</p><pre>import { mock } from &#39;node:test&#39;;<br><br>const mockPokeAPI = {<br>  getPokemon: mock.fn&lt;(name: string) =&gt; Promise&lt;Pokemon&gt;&gt;(),<br>  getAbility: mock.fn&lt;(id: number) =&gt; Promise&lt;Ability&gt;&gt;(),<br>};</pre><p>Cada teste segue este padrão consistente:</p><pre>it(&#39;should get pokemon data&#39;, async () =&gt; {<br>  // 1️⃣ ARRANGE<br>  const pikachuData = { name: &#39;pikachu&#39;, type: &#39;electric&#39;, hp: 35 };<br>  mockPokeAPI.getPokemon.mock.mockImplementationOnce(async name =&gt; pikachuData);<br><br>  // 2️⃣ ACT<br>  const result = await client.callTool({ name: &#39;get_pokemon&#39;, arguments: { name: &#39;pikachu&#39; } });<br><br>  // 3️⃣ ASSERT<br>  assert.deepStrictEqual(result, { content: [ { type: &#39;text&#39;, text: JSON.stringify(pikachuData) } ] });<br>});</pre><p>OBS mockImplementationOnce porquê, Cada teste é independente, Não vaza para outros testes e Fácil de debugar falhas</p><h4>Setup Inicial</h4><pre>import { Client } from &#39;@modelcontextprotocol/sdk/client&#39;;<br>import { InMemoryTransport } from &#39;@modelcontextprotocol/sdk/inMemory.js&#39;;<br>import { before, describe, it, mock } from &#39;node:test&#39;;<br><br>type ToolResponse = {<br>  content: { type: &#39;text&#39;; text: string }[];<br>  isError?: boolean;<br>};<br><br>describe(&#39;PokéAPI MCP Server&#39;, () =&gt; {<br>  // Mock do cliente da PokéAPI<br>  const mockPokeService = {<br>    getPokemon: mock.fn&lt;(name: string) =&gt; Promise&lt;Pokemon&gt;&gt;(),<br>    getAbility: mock.fn&lt;(id: number) =&gt; Promise&lt;Ability&gt;&gt;(),<br>    listTypes: mock.fn&lt;() =&gt; Promise&lt;string[]&gt;&gt;(),<br>  };<br><br>  // Servidor MCP com mock mockPokeService injetado<br>  const server = createPokeServer(mockPokeService);<br>  const client = new Client({ name: &#39;test-client&#39;, version: &#39;1.0.0&#39; });<br><br>  // Conectar via InMemoryTransport<br>  before(async () =&gt; {<br>    const [serverTransport, clientTransport] = InMemoryTransport.createLinkedPair();<br>    await server.connect(serverTransport);<br>    await client.connect(clientTransport);<br>  });<br> // ...<br>})</pre><h3>Testando Diferentes Cenários</h3><h4>1. Sucesso Básico</h4><pre>it(&#39;should get pokemon&#39;, async () =&gt; {<br>  const pikachu = { name: &#39;pikachu&#39;, type: &#39;electric&#39;, hp: 35 };<br>  mockPokeAPI.getPokemon.mock.mockImplementationOnce(async () =&gt; pikachu);<br><br>  const result = await client.callTool({ name: &#39;get_pokemon&#39;, arguments: { name: &#39;pikachu&#39; } });<br><br>  assert.deepStrictEqual(result, { content: [{ type: &#39;text&#39;, text: JSON.stringify(pikachu) }] });<br>});</pre><h4>2. Validação de Entrada</h4><pre>it(&#39;should validate required fields&#39;, async () =&gt; {<br>  const result = await client.callTool({ name: &#39;get_pokemon&#39;, arguments: {} });  // ❌ Falta arguments &#39;name&#39;<br><br>  assert.strictEqual(result.isError, true);<br>})</pre><h4>3. Dados Complexos</h4><pre>it(&#39;should handle complex pokemon data&#39;, async () =&gt; {<br>  const charizard = {<br>    name: &#39;charizard&#39;,<br>    types: [&#39;fire&#39;, &#39;flying&#39;],<br>    stats: { hp: 78, attack: 84, defense: 78 },<br>    moves: [&#39;flamethrower&#39;, &#39;fly&#39;, &#39;dragon-claw&#39;],<br>  };<br>  mockPokeAPI.getPokemon.mock.mockImplementationOnce(async () =&gt; charizard);<br><br>  const result = await client.callTool({ name: &#39;get_pokemon&#39;, arguments: { name: &#39;charizard&#39; } });<br><br>  assert.deepStrictEqual(result, { content: [{ type: &#39;text&#39;, text: JSON.stringify(charizard) }] });<br>});</pre><h4>4. Arrays Simples</h4><pre>it(&#39;should list pokemon types&#39;, async () =&gt; {<br>  const types = [&#39;fire&#39;, &#39;water&#39;, &#39;grass&#39;, &#39;electric&#39;];<br>  mockPokeAPI.listTypes.mock.mockImplementationOnce(async () =&gt; types);<br><br>  const result = await client.callTool({ name: &#39;list_types&#39;, arguments: {} });<br><br>  assert.deepStrictEqual(result, { content: [{ type: &#39;text&#39;, text: JSON.stringify(types) }] });<br>});</pre><h4>5. Contexto/Headers</h4><pre>it(&#39;should pass headers to API&#39;, async () =&gt; {<br>  const context = { requestInfo: { headers: { &#39;x-api-key&#39;: &#39;test-key&#39; } } };<br>  mockPokeAPI.getPokemon.mock.mockImplementationOnce(async () =&gt; ({ name: &#39;mew&#39; }));<br><br>  const result = await client.callTool({ name: &#39;get_pokemon&#39;, arguments: { name: &#39;mew&#39; }, _meta: { context }, });<br>  <br>  assert.strictEqual(result.isError, undefined);<br>});</pre><h4>6. Tratamento de Erros</h4><pre>it(&#39;should handle API errors&#39;, async () =&gt; {<br>  mockPokeAPI.getPokemon.mock.mockImplementationOnce(async () =&gt; { throw new Error(&#39;Pokemon not found&#39;); });<br><br>  const result = (await client.callTool({ name: &#39;get_pokemon&#39;,arguments: { name: &#39;invalid&#39; } })) ;<br><br>  assert.strictEqual(result.isError, true);<br>  assert.strictEqual(result.content[0].text, &#39;Pokemon not found&#39;);<br>});</pre><h3>Checklist</h3><ul><li>[ ] Usa InMemoryTransport.createLinkedPair()?</li><li>[ ] Mocks usam mockImplementationOnce?</li><li>[ ] Testa sucesso, validação e erros?</li><li>[ ] Usa assert.deepStrictEqual?</li><li>[ ] Setup no before() hook?</li><li>[ ] Tipos TypeScript corretos?</li></ul><h3>Conclusão</h3><p>Se você chegou até aqui, parabéns! Agora você sabe mais sobre testar servidores MCP do que 99% dos desenvolvedores. Use esse conhecimento com sabedoria, e <strong>não deixe IAs te enganarem com APIs inexistentes</strong>.</p><p>Testar servidores MCP não precisa ser um mistério ou uma jornada frustrante. Com o conhecimento certo — especificamente <strong>InMemoryTransport</strong> — você pode criar testes robustos, rápidos e confiáveis.</p><p>Para nós humanos: <strong>Sempre valide sugestões de IA com documentação oficial e código-fonte</strong>. IAs são ferramentas poderosas, mas não são infalíveis — especialmente com tecnologias novas.</p><h3>Recursos Úteis</h3><ul><li><a href="https://github.com/modelcontextprotocol/sdk"><strong>@modelcontextprotocol/sdk</strong></a>: Código-fonte oficial</li><li><a href="https://modelcontextprotocol.io/"><strong>MCP Documentation</strong></a>: Documentação oficial (limitada em testes)</li><li><a href="https://nodejs.org/api/test.html"><strong>Node.js Test Runner</strong></a>: API do node:test</li><li><a href="https://zod.dev/"><strong>Zod</strong></a>: Validação de schemas TypeScript-firs</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f3c305ac267" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[As Vantagens de Diretrizes de Estilo no Desenvolvimento de Software]]></title>
            <link>https://medium.com/@daniel.dia/as-vantagens-de-diretrizes-de-estilo-no-desenvolvimento-de-software-65cbe39f0dba?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/65cbe39f0dba</guid>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Wed, 22 Oct 2025 12:51:48 GMT</pubDate>
            <atom:updated>2025-10-22T12:51:48.103Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Dh1R-JTgt49Tsuz59fIlMw.png" /></figure><p>Trabalhando em uma equipe grande de desenvolvimento, me deparei com alguns desafios nas revisões de pull requests.</p><p>Era comum que cada desenvolvedor tivesse seu próprio estilo de código, o que tornava as revisões <strong>menos focadas na lógica e mais concentradas em discutir detalhes como formatação, nomes de variáveis e estrutura</strong>.</p><p>Além disso, convencer alguém de que “esse jeito é melhor” sem uma base sólida é um esforço desgastante. Tudo isso toma mais tempo do que o necessário e prejudicava a fluidez do trabalho.</p><p>Foi quando li o livro <a href="https://www.amazon.com/Software-Engineering-Google-Lessons-Programming/dp/1492082791">Software Engineering at Google: Lessons Learned from Programming Over Tim</a> e, especialmente o capítulo sobre guias de estilo <a href="https://abseil.io/resources/swe-book/html/ch08.html">(<em>Style Guides and Rules</em></a>), que tudo mudou.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4SVSr8WJAN_SSS6o" /></figure><blockquote>“Estilo” pode ser um termo um pouco inadequado aqui, pois sugere algo limitado a práticas de formatação. Nossos guias de estilo vão além disso; eles são o conjunto completo de convenções que regem nosso código.</blockquote><p>Aqui estão os problemas que eu enfrentava:</p><h4>Falta de Padrões Consistentes</h4><p>Cada membro da equipe tinha sua própria forma de nomear variáveis, funções e organizar o código. Isso tornava as revisões longas e subjetivas.</p><h4>Discussões Subjetivas Durante Revisões</h4><p>As revisões frequentemente se tornavam debates sobre preferências pessoais, em vez da lógica ou nos problemas reais do código.</p><h4>Código Difícil de Ler</h4><p>Muitas vezes, o código é escrito pensando no desenvolvedor que o criou, sem considerar quem iria revisá-lo ou mantê-lo no futuro.</p><h4>Revisões Ineficientes</h4><p>Muito tempo era gasto corrigindo detalhes triviais, como inconsistências de estilo, em vez de focar na qualidade da lógica ou na funcionalidade.</p><h4>Dificuldade em Argumentar Com Desenvolvedores</h4><p>Convencer alguém a mudar algo sem uma base concreta era difícil e, muitas vezes, levava a discussões improdutivas.</p><blockquote>A leitura desse capítulo me mostrou que guias de estilo são uma ferramenta poderosa para melhorar o trabalho em equipe e economizar tempo e se concentrar no que importa: a lógica.</blockquote><h3>Princípios de Regras de Estilo no Código</h3><p>Os Guia de Estilos do google tem as seguintes premissas:</p><ol><li><strong>Regras Relevantes:</strong> Crie apenas regras necessárias. Evite sobrecarregar engenheiros com normas óbvias ou redundantes.</li><li><strong>Priorize a Legibilidade:</strong> Código é lido mais vezes do que escrito. Prefira clareza, mesmo que isso torne a escrita mais trabalhosa.</li><li><strong>Consistência:</strong> Um código consistente facilita colaboração e manutenção. Priorize padrões globais, mas respeite convenções locais quando necessário.</li><li><strong>Evite Erros:</strong> Restrinja o uso de recursos complexos que possam introduzir bugs, como reflexão em Python ou construções obscuras em C++.</li><li><strong>Adapte-se:</strong> Às vezes, é necessário abrir mão de consistência ou legibilidade em favor de otimizações críticas de desempenho ou interopelabilidade,</li></ol><h3>Vantagens de ter um guia de estilo de código</h3><h4>Consistência Evita Discussões Desnecessárias</h4><p>Antes, as revisões de pull requests podem ser uma batalha de opiniões: “<em>Eu prefiro snake_case</em>”, “<em>Eu prefiro camelCase</em>”. A leitura me ajudou a entender que um guia de estilo resolve isso de forma objetiva: <strong>todo mundo segue a mesma regra, ponto final</strong>. Não gaste tempo sobre com coisas bobas vá direto para o que importa: a lógica.</p><h4>Otimização para o Leitor</h4><p>O livro bate muito na tecla de que <strong>o código é lido mais vezes do que escrito</strong>. Isso me fez perceber o quanto estruturas confusas e “atalhos” no código complicam o trabalho de quem está revisando ou dando manutenção. Isso facilita a revisão porque quem lê sabe imediatamente o que o código faz, sem precisar decifrar expressões complexas.</p><h4>Guias Previnem Erros Bobos</h4><p>Regras de estilo também ajudam a evitar práticas que causam bugs. Por exemplo, o guia do Google recomenda evitar valores “mágicos” (números ou strings soltos no código), o que é um problema comum que eu via direto nas revisões. por exemplo if(role === 1)O guia sugere o uso deconstantes nomeadas: if(role = ADMIN_ROLE)</p><h4>Revisões de Código Mais Rápidas e Focadas</h4><p>Antes, revisar código significava corrigir formatação, discutir tipagem ou apontar inconsistências. Adotar boas práticas de estilo mudou isso completamente. Agora, revisores podem se concentrar na lógica em vez de corrigir problemas básicos.</p><h4>Argumentos Mais Fortes com Desenvolvedores</h4><p>Um guia de estilo serve como referência objetiva para decisões, evitando conflitos baseados em preferências individuais, ao invés de argumentar Em vez de “eu prefiro assim”. Você pode argumentar com base no guia: <strong>“O guia do Google recomenda esta formatação porque melhora a legibilidade e é padrão na comunidade.”</strong></p><h3>Conclusão</h3><p>Ler o capítulo sobre guias de estilo e o guia de TypeScript do Google facilita não só as revisões de pull requests, mas também as conversas com a equipe.</p><p>Agora, temos uma base sólida para discutir e melhorar o código, e isso está economizando horas de trabalho e muita frustração.</p><p>Se você está enfrentando dificuldades parecidas, recomendo muito a leitura do livro e a aplicação dessas práticas. Vai transformar a maneira como você e sua equipe escrevem e revisam código.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65cbe39f0dba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Checklist de microserviços]]></title>
            <link>https://medium.com/@daniel.dia/checklist-de-microservi%C3%A7os-b85620c75540?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/b85620c75540</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[checklist]]></category>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Wed, 18 Sep 2024 20:31:00 GMT</pubDate>
            <atom:updated>2024-09-18T20:31:00.393Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7bo82tV32Pe1Rs81iHmCXw.png" /></figure><blockquote>O trecho abaixo é parte do livro <a href="https://www.amazon.com.br/Microsservi%C3%A7os-Prontos-Para-Produ%C3%A7%C3%A3o-Padronizados/dp/8575226215">Microsserviços prontos para a produção: Construindo sistemas padronizados em uma organização de engenharia de software</a>.</blockquote><p>As perguntas são organizadas por tópicos e correspondem às seções dentro de cada capítulo. Todas as perguntas de cada capítulo foram agrupadas aqui para uma fácil referência.</p><h3>1. Estabilidade e confiabilidade</h3><h4>Ciclo de desenvolvimento</h4><ul><li>O microsserviço tem um repositório central, no qual todo o código está armazenado?</li><li>Os desenvolvedores trabalham em um ambiente de desenvolvimento que reflete com precisão o estado da produção (por exemplo, que reflete com precisão o mundo real)?</li><li>Existem testes adequados do tipo lint, de unidade, de integração e fim a fim em operação para o microsserviço?</li><li>Existem procedimentos e políticas de revisão de código em vigor?</li><li>O processo de teste, empacotamento, construção e liberação é automatizado?</li></ul><h4>Pipeline de deployment</h4><ul><li>O ecossistema de microsserviços tem um pipeline de deployment padronizado?</li><li>Existe uma fase de staging total ou parcial no pipeline de deployment?</li><li>Qual o acesso que o ambiente de staging tem aos serviços de produção?</li><li>Existe uma fase canário no pipeline de deployment?</li><li>As implantações são executadas na fase de pré-release por um período de tempo longo o suficiente para detectar quaisquer falhas?</li><li>A fase de pré-release trata com precisão uma amostra aleatória do tráfego de produção?</li><li>As portas do microsserviço são as mesmas para o ambiente de pré-release e de produção?</li><li>As implantações no ambiente de produção são feitas todas ao mesmo tempo ou gradualmente?</li><li>Existe um procedimento em vigor para pular as fases de staging e pré-release em caso de emergência?</li></ul><h4>Dependências</h4><ul><li>Quais são as dependências deste microsserviço?</li><li>Quais são seus clientes?</li><li>Como este microsserviço mitiga as falhas de dependência?</li><li>Existem backups, alternativas, fallbacks ou cache defensivo para cada dependência?</li></ul><h4>Roteamento e descoberta</h4><ul><li>As verificações de saúde do microsserviço são confiáveis?</li><li>As verificações de saúde refletem com precisão a saúde do microsserviço?</li><li>As verificações de saúde são realizadas em um canal separado dentro da camada de comunicação?</li><li>Existem circuit breakers ativados para evitar que microsserviços não saudáveis façam solicitações?</li><li>Existem circuit breakers ativados para evitar que 0 tráfego de produção seja enviado para servidores e microsserviços não saudáveis?</li></ul><h4>Descontinuacão e desativacão</h4><ul><li>Existem procedimentos em funcionamento para desativar um microsserviço?</li><li>Existem procedimentos em funcionamento para descontinuar endpoints de API de um microsserviço?</li></ul><h3>2. Escalabilidade e desempenho</h3><h4>Conhecer a escala de crescimento</h4><ul><li>Qual a escala de crescimento qualitativo do microsserviço?</li><li>Qual a escala de crescimento quantitativo do microsserviço?</li></ul><h4>Uso eficiente de recursos</h4><ul><li>O microsserviço está sendo executado em hardware dedicado ou compartilhado?</li><li>Estão sendo usadas tecnologias de abstração e alocação de recursos?</li></ul><h4>Percepção de recursos</h4><ul><li>Quais os requisitos de recursos do microsserviço (CPU, RAM etc.)?</li><li>Quanto tráfego uma instância do micros serviço consegue tratar?</li><li>Quanta CPU uma instância do microsserviço exige?</li><li>Quanta memória uma instância do microsserviço exige?</li><li>Existem outros requisitos de recurso que são específicos deste microsserviço?</li><li>Quais os gargalos de recursos deste microsserviço?</li><li>Este microsserviço precisa ser escalado verticalmente, horizontalmente ou ambos?</li></ul><h4>Planejamento de capacidade</h4><ul><li>O planejamento de capacidade é executado de forma programada?</li><li>Qual o tempo de espera pelo novo hardware?</li></ul><h4>Qual a frequência das solicitações de hardware?</h4><ul><li>Alguns microsserviços têm prioridade quando as solicitações de hardware são feitas?</li><li>O planejamento de capacidade é automatizado ou manual?</li></ul><h4>Dimensionamento das dependências</h4><ul><li>Quais as dependências deste microsserviço?</li><li>As dependências são escaláveis e de alto desempenho?</li><li>As dependências escalarão com 0 crescimento esperado deste microsserviço?</li><li>Os donos das dependências estão preparados para o crescimento esperado deste microsserviço?</li></ul><h4>Gerenciamento de tráfego</h4><ul><li>Os padrões de tráfego do microsserviço são bem entendidos?</li><li>As mudanças no serviço são programadas de acordo com os padrões de tráfego?</li><li>As mudanças drásticas nos padrões de tráfego (especialmente picos de tráfego) são tratadas de forma cuidadosa e adequada?</li><li>O tráfego pode ser automaticamente roteado para outros datacenters em caso de falha?</li></ul><h4>Tratamento e processamento de tarefas</h4><ul><li>O microsserviço está escrito em uma linguagem de programação que permite que o serviço seja escalável e de alto desempenho?</li><li>Existem limitações de escalabilidade ou desempenho na forma como o microsserviço trata as solicitações?</li><li>Existem limitações de escalabilidade ou desempenho na forma como o microsserviço processa tarefas?</li><li>Os desenvolvedores na equipe do microsserviço entendem como seu serviço processa tarefas, o quão eficientemente ele processa essas tarefas e como o serviço irá se comportar à medida que o número de tarefas e solicitações aumentar?</li></ul><h4>Armazenamento escalável de dados</h4><ul><li>Este microsserviço trata dados de forma escalável e com alto desempenho?</li><li>Que tipos de dados este microsserviço precisa armazenar?</li><li>Qual o schema necessário para seus dados?</li></ul><h4>Quantas transações são necessárias e/ou feitas por segundo?</h4><ul><li>Este microsserviço precisa de um desempenho maior de escrita ou leitura?</li><li>Ele faz uso intensivo de operações de leitura, escrita ou ambos?</li><li>O database deste serviço é escalado horizontalmente ou verticalmente? Ele é replicado ou particionado?</li><li>Este microsserviço usa um database dedicado ou compartilhado?</li><li>Como o serviço trata e/ou armazena dados de teste?</li></ul><h3>Tolerância a falhas e preparação para catástrofes</h3><h4>Evitando pontos únicos de falha</h4><ul><li>O microsserviço tem um ponto único de falha?</li><li>Ele tem mais de um ponto de falha?</li><li>Os pontos de falha podem ser eliminados ou eles precisam ser mitigados?</li></ul><h4>Cenários de catástrofes e falhas</h4><ul><li>Todos os cenários de falha e possíveis catástrofes do microsserviço foram identificados?</li><li>Quais as falhas comuns no ecossistema de microsserviços?</li><li>Quais os cenários de falha da camada de hardware que podem afetar este microsserviço?</li><li>Quais falhas nas camadas de comunicação e aplicação podem afetar este microsserviço?</li><li>Quais falhas de dependência podem afetar este microsserviço?</li><li>Quais falhas internas podem derrubar este microsserviço?</li></ul><h4>Teste de resiliência</h4><ul><li>Este microsserviço tem testes adequados do tipo lint, de unidade, de integração e fim a fim?</li><li>Este microsserviço é submetido a testes de carga regulares e programados?</li><li>Todos os possíveis cenários de falha são implementados e testados usando o teste de caos?</li></ul><h4>Detecção e reparo de falhas</h4><ul><li>Existem processos padronizados na organização de engenharia de software para tratar incidentes e interrupções?</li><li>Como as falhas e interrupções deste microsserviço impactam o negócio?</li><li>Existem níveis claramente definidos de falha?</li><li>Existem estratégias de mitigação claramente definidas?</li><li>A equipe segue os cinco estágios de resposta a incidentes quando ocorrem incidentes e interrupções?</li></ul><h3>Monitoramento</h3><h4>Métricas principais</h4><ul><li>Quais são as métricas principais deste microsserviço?</li><li>Quais são as métricas de servidor e infraestrutura?</li><li>Quais são as métricas no âmbito de microsserviço?</li><li>Todas as métricas principais do microsserviço são monitoradas?</li></ul><h4>Logging</h4><ul><li>Quais informações este microsserviço precisa gravar em Iog?</li><li>Este microsserviço grava em log todas as solicitações importantes?</li><li>O logging reflete o estado do microsserviço em qualquer momento?</li><li>Este logging é escalável e eficaz em termos de custo?</li></ul><h4>Dashboards</h4><ul><li>Este microsserviço tem um dashboard?</li><li>O dashboard é fácil de interpretar? Todas as métricas principais são exibidas no dashboard?</li><li>Posso determinar se este microsserviço está funcionando corretamente ou não apenas olhando o dashboard?</li></ul><h4>Alertas</h4><ul><li>Existe um alerta para todas as métricas principais?</li><li>Todos os alertas são definidos por adequados limites sinalizadores?</li><li>Os limites de alerta são configurados adequadamente de modo a disparar um alerta antes que ocorra uma interrupção?</li><li>Todos os alertas são acionáveis?</li><li>Existem instruções passo a passo para triagem, mitigação e resolução para cada alerta no roteiro de plantão?</li></ul><h4>Turnos de plantão</h4><ul><li>Existe um turno de plantão dedicado e responsável por monitorar este microsserviço?</li><li>Cada turno de plantão contém pelo menos dois desenvolvedores?</li><li>Existem procedimentos padronizados de plantão em toda a organização de engenharia de software?</li></ul><h3>Documentação e compreensão</h3><h4>Documentacão do microsserviço</h4><ul><li>A documentação de todos os microsserviços está armazenada em um local centralizado, compartilhado e de fácil acesso?</li><li>É fácil pesquisar a documentação?</li><li>As mudanças significativas no microsserviço são acompanhadas por atualizações da documentação do microsserviço?</li><li>A documentação do microsserviço contém uma descrição do microsserviço?</li><li>A documentação do microsserviço contém um diagrama da arquitetura?</li><li>A documentação do microsserviço contém informações de contato e plantão?</li><li>A documentação do microsserviço contém links para informações importantes?</li><li>A documentação do microsserviço contém um guia de bordo e desenvolvimento?</li><li>A documentação do microsserviço contém informações sobre o fluxo de solicitações, os endpoints e as dependências do microsserviço?</li><li>A documentação do microsserviço contém um roteiro de plantão?</li><li>A documentação do microsserviço contém uma seção FAQ?</li></ul><h4>Compreensão do microsserviço</h4><ul><li>Todo desenvolvedor da equipe é capaz de responder perguntas sobre a disponibilidade de produção do microsserviço?</li><li>Existe um conjunto de princípios e padrões que todos os microsserviços devem seguir?</li><li>Existe um processo RFC para cada novo microsserviço?</li><li>Os microsserviços existentes são revisados e auditados com frequência?</li><li>São feitas revisões de arquitetura para cada equipe de microsserviço?</li><li>Há um processo de auditoria de disponibilidade de produção?</li><li>São usados planos estratégicos de disponibilidade de produção para levar o microsserviço a um estado de pronto para produção?</li><li>Padrões de disponibilidade de produção orientam os OKRs da organização?</li><li>O processo de disponibilidade de produção é automatizado?</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b85620c75540" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Uma breve introdução técnica ao Elasticsearch]]></title>
            <link>https://medium.com/@daniel.dia/uma-breve-introdu%C3%A7%C3%A3o-ao-elasticsearch-32057ed3484c?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/32057ed3484c</guid>
            <category><![CDATA[lucene]]></category>
            <category><![CDATA[elasticsearch]]></category>
            <category><![CDATA[elk]]></category>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Thu, 01 Aug 2024 20:25:56 GMT</pubDate>
            <atom:updated>2024-08-01T20:40:51.414Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*niM9OkxdIUzP-t3GkrT_mw.png" /></figure><p>Elasticsearch é uma poderosa ferramenta de busca e análise de dados que tem ganhado popularidade devido à sua eficiência e escalabilidade.</p><p>Elasticsearch é um mecanismo de busca e análise distribuído, de código aberto, baseado no Apache Lucene. Ele permite realizar buscas de texto completo, análise de dados e visualização de forma rápida e eficiente.</p><p>Utilizado amplamente em diversas indústrias, o Elasticsearch é conhecido por sua capacidade de lidar com grandes volumes de dados em tempo real.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jlVzAxK0avdEEkHq.png" /></figure><p>O Elasticsearch tem sido amplamente adotado por empresas de todos os tamanhos devido à sua flexibilidade e desempenho. Grandes nomes como Netflix, Uber, e Stack Overflow utilizam Elasticsearch para monitoramento de logs, análise de dados e busca de texto completo.</p><p>A comunidade ativa e o suporte contínuo pela Elastic contribuem para sua crescente popularidade.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4_cDMNEKpSijI1oCHF2Ucw.png" /></figure><h3>Unde the hood — Lucene: O Motor por Trás do Elasticsearch</h3><p>Apache Lucene é uma biblioteca de busca de texto completo que fornece a base para o Elasticsearch.</p><p>Lucene lida com a indexação e a pesquisa de documentos, oferecendo uma API robusta para criar índices e realizar consultas. O Elasticsearch usa Lucene para oferecer uma interface RESTful simplificada, tornando a busca e a análise mais acessíveis.</p><p><a href="https://www.parse.ly/lucene/">https://www.parse.ly/lucene/</a>, <a href="https://lucene.apache.org/">https://lucene.apache.org</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qmMqN5Wnal7dQhX2.png" /></figure><h3>Índice Invertido</h3><p>O coração do Elasticsearch é o índice invertido do lucene, uma estrutura de dados que mapeia termos de texto para seus locais em um conjunto de documentos. Isso permite buscas rápidas e eficientes.</p><p>Quando um documento é indexado, cada palavra é armazenada em uma lista que referencia todos os documentos que contêm essa palavra.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2I1pnsmCioiUM4DA.png" /></figure><p>Ah, então não é um índice de documentos para termos, é um índice de termos para documentos. Se organizarmos os dados dessa maneira, podemos encontrar documentos por valor mais rapidamente.</p><p>Esta é basicamente a estrutura de dados principal no Lucene e na pesquisa em geral.</p><blockquote>Não, o índice invertido não é uma estrutura de dados colunar. Dado colunar armazena dados em colunas em vez de linhas, o que é comum em bancos de dados analíticos para otimizar consultas de leitura intensiva.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/0*Efnw2N_nBS5h0VcE.png" /></figure><h3>Estrutura do Índice</h3><p>Um índice no Elasticsearch é composto por <strong>shards</strong>, que são divisões lógicas dos dados. Cada shard é uma instância do Lucene e pode ter réplicas para redundância e escalabilidade.</p><p>A divisão em shards permite que o Elasticsearch gerencie grandes volumes de dados distribuídos em múltiplos nós.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/0*Ek8QzkGUTABAekGp.png" /></figure><h3>Tipos de Queries</h3><p>Elasticsearch oferece uma variedade de tipos de consultas para atender a diferentes necessidades de busca:</p><ul><li><strong>Match Query:</strong> Busca por documentos que correspondem a um texto.</li><li><strong>Term Query:</strong> Busca por documentos que contêm termos específicos.</li><li><strong>Range Query:</strong> Busca por documentos dentro de um intervalo de valores.</li><li><strong>Bool Query:</strong> Combinação lógica de múltiplas consultas.</li></ul><p>E agregações no Elasticsearch permitem a análise de dados em tempo real. Existem diferentes tipos de agregações, como:</p><ul><li><strong>Metric Aggregations:</strong> Calculam métricas, como médias e somas.</li><li><strong>Bucket Aggregations:</strong> Agrupam documentos em buckets com base em critérios.</li><li><strong>Pipeline Aggregations:</strong> Processam os resultados de outras agregações.</li></ul><p><a href="https://coralogix.com/blog/42-elasticsearch-query-examples-hands-on-tutorial/">42 Elasticsearch Query Examples - Tutorial - Coralogix</a></p><h3>ELK Stack?</h3><p>ELK Stack é um acrônimo que se refere à combinação de três ferramentas de código aberto: Elasticsearch, Logstash e Kibana. Essa stack é amplamente utilizada para monitoramento, busca e análise de dados em tempo real.</p><ul><li><strong>Elasticsearch:</strong> Motor de busca e análise.</li><li><strong>Logstash:</strong> Ferramenta de ingestão de dados que coleta, processa e envia dados para o Elasticsearch.</li><li><strong>Kibana:</strong> Interface de visualização que permite criar dashboards interativos e visualizações dos dados armazenados no Elasticsearch.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/893/0*FmIQhjEpt62FatnR.jpeg" /></figure><h3>Monitoramento e Visualização com Kibana</h3><p>Kibana é a interface gráfica para o Elasticsearch, permitindo a visualização e análise de dados através de gráficos, dashboards e mapas. É uma ferramenta essencial para explorar os dados indexados e criar visualizações interativas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*x0HN6R1DzhC3v8Lf.jpg" /></figure><h3>Ingestão de Dados com Beats e Logstash</h3><p>Beats e Logstash são ferramentas que complementam o Elasticsearch, facilitando a ingestão de dados de diversas fontes.</p><p>Beats são agentes leves para coletar e enviar dados, enquanto Logstash é uma ferramenta de processamento de dados que permite transformar e enviar dados para o Elasticsearch.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/927/0*8rs-6fjse5t2W51-.png" /></figure><h3>Alguns casos de Uso do Elasticsearch</h3><p>O Elasticsearch é usado em diversos casos de uso, como monitoramento de logs, busca em e-commerce, análise de redes sociais, e mais. Sua flexibilidade e escalabilidade o tornam uma escolha ideal para qualquer aplicação que exija busca e análise de dados eficientes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DhdV-fMod8XRyNRU.png" /></figure><p><a href="https://www.elastic.co/pt/enterprise-search/search-applications">https://www.elastic.co/pt/enterprise-search/search-applications</a></p><h3>Conclusão</h3><p>Elasticsearch é uma ferramenta poderosa e versátil que pode transformar a maneira como você busca e analisa dados. Com uma comunidade ativa e um ecossistema robusto de ferramentas, ele continua a ser uma escolha popular para empresas de todos os tamanhos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=32057ed3484c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lições aprendidas com PubSub]]></title>
            <link>https://medium.com/@daniel.dia/estrat%C3%A9gias-eficazes-para-o-gerenciamento-de-subscriptions-garantindo-sucesso-e-efici%C3%AAncia-b50e5a92c5bb?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/b50e5a92c5bb</guid>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Thu, 15 Feb 2024 21:37:16 GMT</pubDate>
            <atom:updated>2025-06-01T18:18:16.015Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ruFeCL6chg1gERtc1xV_Fw.png" /></figure><p>No desenvolvimento de sistemas e aplicações, o gerenciamento eficiente de <em>subscriptions</em> é crucial para assegurar a entrega confiável e tempestiva de mensagens, bem como para otimizar recursos e custos. Implementar uma abordagem estruturada e bem pensada pode significar a diferença entre um sistema robusto e um propenso a falhas e ineficiências.</p><p>Neste artigo, exploramos passos fundamentais para o sucesso na gestão de <em>subscriptions</em>, garantindo que sua aplicação se mantenha resiliente, escalável e eficiente.</p><p>Os items descritos aqui refletem minha experiencia REAL utilizando mensageria, especificamente Google PubSub</p><h3>TLDR.</h3><p>Para garantir o sucesso e a eficiência no gerenciamento de subscriptions, siga estes passos:</p><ol><li>Estabeleça timeouts de processamento baseados em 10x a 20x o tempo médio esperado para evitar reprocessar falsas falhas.</li><li>Implemente backoff exponencial nas retentativas de envio para otimizar o uso de recursos.</li><li>Defina um limite de retentativas para evitar esforços ineficazes e utilizar dead letter queues para gerenciar falhas.</li><li>Estabeleça cotas para recursos que geram custos, evitando uso excessivo e despesas inesperadas.</li><li>Crie mecanismos em software para prevenir o re-processamento de mensagens.</li><li>Monitore latência e principalmente o número de retentativas para identifcar problemas o quanto atntes.</li><li>Evite qualquer erros de input 4xx como resposta de push. Os erros 4xx vão ser retentados infinitamente com a mesma entrada inválida</li></ol><h3>Detalhamento</h3><h4>1. Identificação do Tempo Médio de Processamento</h4><p>Imagine um sistema de notificações que, sem um <em>timeout</em> apropriado, frequentemente aborta o envio de e-mails importantes devido a picos temporários de latência. O resultado? Mensagens importantes não chegam aos destinatários, comprometendo a comunicação eficaz, ou pior. As mensagens são enviadas mas depois do timeout, nesse caso cada usuário recebe vários emails devido à retentativas.</p><p>O primeiro passo é identificar o tempo médio de processamento das mensagens. Uma vez estabelecido, definir um <em>timeout</em> significativamente maior, cerca de 10x a 20x o tempo médio, assegura que as mensagens em processamento tenham tempo suficiente para serem concluídas. Essa prática previne interrupções prematuras e garante que as operações em curso atinjam a finalização adequada.</p><p>Importante destacar que ao utilizar a estratégia ‘pull’, esse valor precisa ser configurado no cliente assinante. Configurações de deadline da subscription serão desconsideradas <a href="https://cloud.google.com/pubsub/docs/lease-management?_gl=1*1vwz1rs*_ga*MjA3OTY4NTgyMi4xNzEzNzg4Nzg3*_ga_WH2QY8WWF5*MTcyMzU2ODk1Ny4zMjEuMS4xNzIzNTcxNzkyLjE1LjAuMA..#lease_management_configuration">fonte</a>.</p><h4>2. Implementação de Backoff Exponencial</h4><p>Uma aplicação tenta reenviar uma mensagem falha imediatamente após o primeiro erro. Com múltiplas instâncias fazendo o mesmo, o sistema rapidamente se sobrecarrega, agravando o problema inicial.</p><p>O <em>backoff</em> exponencial é uma estratégia para gerenciar retentativas de entrega de mensagens. Retentar imediatamente após uma falha tende a ser contraproducente, especialmente em aplicações assíncronas, resultando em desperdício de recursos e reprocessamento desnecessário. O <em>backoff</em> exponencial aumenta progressivamente o intervalo entre as retentativas, otimizando o uso de recursos e dando tempo ao sistema para recuperar-se de eventuais falhas.</p><h4>3. Definição de Limite de Retentativas</h4><p>Uma tarefa de sincronização de dados persiste em falhar e tentar novamente infinitamente, consumindo recursos valiosos e nunca alcançando sucesso, deixando dados em um estado de limbo.</p><p>Estabelecer um limite para o número de retentativas é essencial para prevenir tentativas de entrega indefinidas. Uma política eficaz pode incluir, por exemplo, um máximo de 20 retentativas ao longo de 24 horas. Esse limite, aliado ao <em>backoff</em> exponencial, equilibra a persistência e a prudência, evitando esforços exaustivos e ineficazes. Implementar uma <em>dead letter queue</em> (fila de mensagens não entregues) permite o tratamento e reenvio adequado de mensagens que excederam o limite de tentativas.</p><h4>4. Definição de Cotas para Recursos Pagos</h4><p>Um bug no sistema como dito no item 1, dispara milhares de e-mails em poucos minutos, gerando uma fatura inesperadamente alta para a empresa.</p><p>Recursos que geram custos, como endpoints que disparam e-mails, ou AI, devem ser cuidadosamente monitorados e controlados. Definir cotas previne o uso excessivo e inesperado desses recursos, ajudando a manter os custos sob controle. Uma gestão eficiente assegura que os recursos pagos sejam utilizados de forma inteligente e econômica.</p><h4>5. Prevenção de Re-Processamento</h4><p>Mesmo com as medidas anteriores, sistemas distribuídos estão sujeitos ao risco de processamento duplicado de mensagens. Implementar mecanismos que evitem o re-processamento é importante. Tais mecanismos garantem que cada mensagem seja processada uma única vez, aumentando a eficiência e prevenindo inconsistências nos dados.</p><h4>6. Observabilidade e Métricas, Focando no Número de Retentativas</h4><p>Sem visibilidade sobre as retentativas de envio de mensagens, uma equipe de operações luta para diagnosticar problemas de entrega, resultando em atrasos críticos e satisfação reduzida do cliente.</p><p>A observabilidade e o monitoramento de métricas, especialmente o <strong>número de retentativas</strong>, são cruciais para entender a saúde e o desempenho do sistema de <em>subscriptions</em>. Monitorar essas métricas permite identificar padrões de falhas, otimizar processos e intervir proativamente antes que pequenos problemas se transformem em interrupções desastrosas. Implementar dashboards de monitoramento e alertas para altas taxas de retentativas ajuda a manter a equipe informada e pronta para agir, garantindo a entrega eficiente de mensagens e a continuidade dos serviços.</p><h4>7. Erros de entrada do tipo 4xx são infinitos</h4><p>A gestão eficiente de erros do tipo 4xx, relacionados a falhas na entrada, destaca a necessidade de uma validação robusta.</p><p>Quando ocorrem esses erros, indica-se um problema na entrada fornecida, levando tentativas repetidas de reenvio sem modificar a entrada inicial.</p><p>Tais ações transformam qualquer status fora do espectro 2xx em não-acknowledged (NACK), perpetuando um ciclo de retentativas que podem levar à saturação da fila de mensagens.</p><p>Para mitigar esse ciclo vicioso, é importante que as respostas resultantes de entradas inválidas sejam apenas ‘logadas’ para registro e análise e aceitas com um reconhecimento positivo (ACK). Esse procedimento permite a continuidade do fluxo de trabalho sem interrupções, ao mesmo tempo que proporciona insights para a correção e aprimoramento do sistema.</p><h3>Conslusão</h3><p>A gestão eficiente de <em>subscriptions</em> é um pilar fundamental para o desenvolvimento de sistemas confiáveis e eficientes em event driven. Seguindo os passos delineados — desde a identificação adequada do tempo de processamento até a implementação de estratégias para evitar o re-processamento — é possível construir arquiteturas robustas e resilientes. A adoção dessas práticas não apenas otimiza o desempenho e a escalabilidade dos sistemas, mas também contribui para a redução de custos e a melhoria da experiência do usuário final. Implementar essas estratégias é um investimento no sucesso e na sustentabilidade de suas operações digitais.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b50e5a92c5bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding MySQL uuid_short. A Case Study.]]></title>
            <link>https://medium.com/@daniel.dia/understanding-mysql-uuid-short-a-case-study-1c0e5508ce9?source=rss-3b2c3c45e2b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c0e5508ce9</guid>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[uuid]]></category>
            <dc:creator><![CDATA[Daniel Santos]]></dc:creator>
            <pubDate>Thu, 20 Apr 2023 15:06:10 GMT</pubDate>
            <atom:updated>2023-04-20T18:52:37.904Z</atom:updated>
            <content:encoded><![CDATA[<p>The uuid_short() function in MySQL generates a 64-bit integer value that can be used as a unique identifier and to be stored as <a href="https://dev.mysql.com/doc/refman/8.0/en/integer-types.html">BIGINT NSIGNED</a>.</p><p>Here are some of the advantages of using any UUID as a database key:</p><ol><li><strong>Universality: </strong>A UUID is inter-server unique and can be generated anywhere, not just within the MySQL server, which means the probability of two UUID keys colliding is extremely low.</li><li><strong>Environment independence:</strong> UUID does not depend on any numeric sequence system or other ID generation mechanism, making it environment-independent.</li><li><strong>Distribution:</strong> A UUID can be generated anywhere, making it ideal for distributed systems where multiple nodes need to generate unique IDs.</li><li><strong>Security</strong>: UUID is hard to predict, making it more secure than sequential keys that can be easily guessed.</li><li><strong>Scalability</strong>: With the use of UUID, it is possible to scale the database to a large number of records without worrying about key conflicts.</li><li><strong>Avoid key collisions</strong>: The use of UUID as a database key virtually eliminates the possibility of key collisions.</li></ol><p>Why not use the standard 36 char uuid-4 as key? Here are some advantages of using a 64-bit (16-byte) number instead of a 36-character UUID as a key in MySQL:</p><ol><li><strong>Improved Performance:</strong> Using a 64-bit number for a key improves the performance of indexing and relational lookup operations. The smaller size of the key means that less data needs to be processed, which results in faster query response times. (main reason)</li><li><strong>Reduced Storage Requirements:</strong> Using a 64-bit number, it can be stored as <a href="https://dev.mysql.com/doc/refman/8.0/en/integer-types.html">BIGINT NSIGNED</a>instead of a 36-character UUID reduces storage requirements. The smaller key size means that less space is required to store the key in the database, which can be particularly beneficial when working with large data sets.</li><li><strong>Simplified Code:</strong> Working with a number as a key can simplify code, as it removes the need to convert between UUID strings and binary representations. This can make code more readable and easier to maintain.</li></ol><h3>How the MySQL uuid_short are generated?</h3><p>According to the <a href="https://dev.mysql.com/doc/refman/8.0/en/miscellaneous-functions.html#function_uuid-short">official MySQL documentation</a>, the algorithm for generating uuid_short values is as follows:</p><pre>(server_id &amp; 255) &lt;&lt; 56<br>+ (server_startup_time_in_seconds &lt;&lt; 24)<br>+ incremented_variable++;</pre><p>The bit organization of the generated value can be broken down as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yDjeY2vHjWgDnuklOux7qQ.png" /><figcaption>bits oganization for MySQL uuid_short() generated value</figcaption></figure><ul><li>Bits 0 to 23 (3 bytes) represent an incremented variable, which is incremented every time a new uuid_short() value is generated. This ensures that each value is unique, even if it is generated on the same server with the same server ID and startup time.</li><li>Bits 24 to 55 (4 bytes) to represent the number of seconds of the server startup time. This means that the server startup time in seconds can be up to 2³² seconds (approximately 136 years), which is more than enough for most use cases.</li><li>Bits 56 to 65 (1 byte) represent the server ID. This ensures that only the last 8 bits of the server ID are used, since they are the least significant bits and are less likely to cause collisions.</li></ul><h3>Does the UUID_SHORT really avoid colisions?</h3><p>According to the <a href="https://dev.mysql.com/doc/refman/8.0/en/miscellaneous-functions.html#function_uuid-short">MySQL documentation</a>, uuid_short avoids collision if:</p><ul><li>The current server’s server_id value is unique among your set of source and replica servers and ranges between 0 and 255.</li><li>You should not set the system time back for your server host between mysqld restarts.</li><li>On average, you should invoke UUID_SHORT() fewer than 16 million times per second between mysqld restarts.</li></ul><h3>Testing the UUID_SHORT Generation</h3><p>To confirm my understanding of how UUIDs are generated, I conducted some tests.</p><p>Initially, I referred to the official documentation, which outlines the algorithm for generating UUIDs and explains the measures taken to prevent collisions.</p><p>Afterwards, I set up a test table for experimentation.</p><pre>CREATE TABLE uuids_shorts (<br>  uuid_short BIGINT UNSIGNED NOT NULL, -- to populate uuid_short<br>  server_id TINYINT UNSIGNED NOT NULL DEFAULT 0, -- to extract value and study<br>  server_startup_time_in_seconds INT UNSIGNED NOT NULL DEFAULT 0, -- to extract value and study<br>  incremented_variable MEDIUMINT UNSIGNED NOT NULL DEFAULT 0, -- to extract value and study<br>  PRIMARY KEY (uuid_short)<br>)</pre><p>Next, populate the column ‘uuid_short’ with 20 million values.</p><pre>INSERT INTO uuids_shorts (uuid_short) VALUES<br>(UUID_SHORT()), (UUID_SHORT()), ... (UUID_SHORT()));<br></pre><p>All the UUID shorts were successfully generated.</p><pre>uuid_short            server_id  server_startup_time  incremented_variable<br>...                   ...        ...                  ...<br>16673521041825333362  0          0                    0<br>16673521041825333363  0          0                    0  <br>16673521041825333364  0          0                    0  <br>16673521041825333365  0          0                    0  <br>16673521041825333366  0          0                    0<br>16673521041825333367  0          0                    0<br>16673521041825333368  0          0                    0<br>...                   ...        ...                  ...</pre><p>After populating the first row, I proceeded to populate the last three rows.</p><p>Before checking the consistency of the last three columns I need to some reference values to check integrity with populated values.</p><p>To obtain the server ID.</p><pre>SHOW VARIABLES LIKE &#39;server_id&#39;; -- returns 3158640103<br>select 3158640103 &amp; 255; <br>-- which returns &#39;231&#39; &lt; this value must match</pre><p>To obtain the server’s startup time in seconds, I need to subtract the server’s uptime from the current time.</p><pre>SELECT (UNIX_TIMESTAMP(now()) - u.Uptime) &amp; 4294967295<br>FROM (<br>  SELECT VARIABLE_VALUE AS Uptime <br>  FROM performance_schema.global_status <br>  WHERE VARIABLE_NAME = &#39;Uptime&#39;<br>) AS u;<br>-- which returns &#39;1681853477&#39; &lt;&lt; this value musth match</pre><p>After putting in a lot of effort, I managed to come up with the following update query:</p><pre>update uuids_shorts set <br>server_id = (uuid_short &gt;&gt; 56) &amp; (POW(2,8 ) -1) ,<br>server_startup_time_in_seconds = (uuid_short &gt;&gt; 24) &amp; (POW(2,32) -1),<br>incremented_variable = (uuid_short &gt;&gt; 0 ) &amp; (POW(2,24) -1);</pre><p>then i got:</p><pre>uuid_short            server_id  server_startup_time  incremented_variable<br>...                   ...        ...                  ...<br>16673521041825333362  231        1681853477           114<br>16673521041825333363  231        1681853477           115<br>16673521041825333364  231        1681853477           116<br>16673521041825333365  231        1681853477           117<br>16673521041825333366  231        1681853477           118<br>16673521041825333367  231        1681853477           119<br>16673521041825333368  231        1681853477           120<br>...                   ...        ...                  ...<br></pre><p>The server ID and startup time match, and the auto-increment value increases by one each time. When the increment variable overflows, it returns to zero, and the server’s startup time increments as follows:</p><pre>uuid_short            server_id  server_startup_time  incremented_variable<br>...                   ...        ...                  ...<br>16673521041842110461  231        1681853477           16777213<br>16673521041842110462  231        1681853477           16777214<br>16673521041842110463  231        1681853477           16777215 -3byte limit<br>16673521041842110464  231        1681853478 -changed  0<br>16673521041842110465  231        1681853478           1<br>16673521041842110466  231        1681853478           2<br>...                   ...        ...                  ...</pre><p>This implies that the UUID increment relies on the server’s startup time, allowing it to store more than three bytes for an incremental part.</p><h3>In conclusion</h3><p>understanding the advantages of using UUID and 64-bit numbers as keys in MySQL can have a significant impact on database performance, storage requirements, and code complexity.</p><p>With this knowledge, developers can make informed decisions when designing and implementing database systems, and can even utilize services that provide UUID generation such as uuid_short outside MySQL server like <a href="https://medium.com/@daniel.dia/implementing-the-mysql-uuid-short-generation-as-a-nodejs-service-8792b32a2b5c?postPublishedType=repub">this node implementation of uuid_short</a>.</p><p>By leveraging these techniques, it is possible to improve the scalability, security, and efficiency of database systems, ultimately leading to better performance and more reliable data storage.</p><p><a href="https://medium.com/@daniel.dia/implementing-the-mysql-uuid-short-generation-as-a-nodejs-service-8792b32a2b5c?postPublishedType=repub">&gt; My next step is creating a uuid_short generation in js as described here</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c0e5508ce9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>