<?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 Cesar Augusto Alcancio de Souza on Medium]]></title>
        <description><![CDATA[Stories by Cesar Augusto Alcancio de Souza on Medium]]></description>
        <link>https://medium.com/@cesar-alcancio?source=rss-bc27ed464630------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*itbj6-8s3XSs4EI8e8ZT7g.jpeg</url>
            <title>Stories by Cesar Augusto Alcancio de Souza on Medium</title>
            <link>https://medium.com/@cesar-alcancio?source=rss-bc27ed464630------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 00:22:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@cesar-alcancio/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[Como o Claude Code me ajudou a terminar uma tarefa que eu adiava há meses (e onde ele errou)]]></title>
            <link>https://cesar-alcancio.medium.com/como-o-claude-code-me-ajudou-a-terminar-uma-tarefa-que-eu-adiava-h%C3%A1-meses-e-onde-ele-errou-d77420149a9c?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/d77420149a9c</guid>
            <category><![CDATA[anthropic-claude-code]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[genio-desk]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Mon, 25 May 2026 13:44:48 GMT</pubDate>
            <atom:updated>2026-05-25T13:44:48.154Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oP93TpTjbvZn_Epi85DyVQ.png" /><figcaption>Claude Code e Opus 4.7</figcaption></figure><p>Já fazia algumas semanas que minha mesa da Genio Desk , aquelas com regulagem de altura que permitem trabalhar em pé, tinha parado de funcionar. Foi depois de um dia em que meu filho descobriu que apertar o botão era a coisa mais divertida do mundo, e a mesa acabou apresentando um código de erro.</p><p>A tarefa de resolver isso era daquelas que eu vinha procrastinando. Eu sabia que precisaria:</p><ul><li>encontrar o canal de contato da Genio,</li><li>escrever uma mensagem com todas as informações importantes,</li><li>localizar a nota fiscal e extrair os dados certos,</li><li>talvez fazer um passo a passo de troubleshooting pra mostrar que tentei resolver em casa antes (olhando o manual),</li><li>checar a garantia,</li><li>entender o que poderia estar falhando.</li></ul><p>Feito com tranquilidade, eu estimaria de 1h a 2h. Coisa de &quot;vou separar uma tarde&quot;, e a tarde nunca vinha.</p><p>No sábado, eu estava testando o Claude Code pra automatizar algumas tarefas repetitivas do dia a dia e pensei: por que não usar pra isso também?</p><p>Comecei com um prompt simples:</p><blockquote><em>&quot;minha Genio Desk fica com código E22, como arrumar?&quot;</em></blockquote><p>Ele me passou os problemas mais comuns associados a esse erro e me explicou como fazer um reset, que seria o procedimento padrão.</p><p>Tentei. Nada.</p><p>Então pedi pra ele me ajudar a redigir o e-mail pro suporte. Ele me passou o canal de contato, sugeriu título, corpo da mensagem e sugeriu mais coisas (como sempre): pediu que eu anexasse a nota fiscal, uma foto de certos componentes da mesa e um vídeo de eu fazendo o reset , disse que o suporte provavelmente ia pedir isso de qualquer jeito, então melhor já enviar de uma vez e adiantar tempo.</p><p>Colei a nota fiscal e as fotos no prompt, e ele gerou o e-mail completo, com todos os dados preenchidos. Essa parte, caçar informação na NF, conferir CPF, número de pedido, data de compra, costuma ser onde eu mais demoro e sempre acabo esquecendo alguma coisa.</p><p>Tudo isso levou 10 a 15 minutos. Saí do fim de semana com aquele alívio gostoso de tirar do colo uma tarefa que estava me incomodando há tempos.</p><p>Hoje, segunda-feira de manhã, abri o e-mail e vi a resposta do suporte. Várias informações que o Claude Code tinha me passado estavam erradas. Duas em particular eram importantes:</p><p>1. <strong>O procedimento de reset que ele me ensinou não era o correto pro meu modelo.</strong> A atendente me passou o procedimento certo, apliquei, e funcionou perfeitamente.</p><p>2. <strong>O tempo de garantia também estava errado. </strong>Eram 4 anos, não 5 como ele havia afirmado.</p><p>No fim das contas, resolvi em 10–15 minutos algo que demoraria 1h-2h caçando informação online. Mas precisou de um humano, com contexto real, manual do produto atualizado e experiência atendendo esse tipo de problema, pra corrigir pontos importantes que a IA assumiu como verdade. E eu, por confiar, também acreditei.</p><p><strong>Fica a experiência:</strong> a IA reduz drasticamente o atrito de começar e de organizar a parte burocrática. Mas em pontos específicos e técnicos, o humano com contexto continua sendo a peça que fecha o problema.</p><p>Resolvi rapidíssimo, com bem menos peso na consciência, e ainda aprendi uma coisa nova sobre minha mesa no processo. Não tem como reclamar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d77420149a9c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como criar bibliotecas em Clojure e publicar no Clojars]]></title>
            <link>https://cesar-alcancio.medium.com/como-criar-bibliotecas-em-clojure-e-publicar-no-clojars-b7a78bf9ba40?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/b7a78bf9ba40</guid>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[clojure]]></category>
            <category><![CDATA[clojars]]></category>
            <category><![CDATA[programacao-funcional]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Mon, 06 Dec 2021 18:33:36 GMT</pubDate>
            <atom:updated>2021-12-06T18:49:36.793Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/528/0*lJs_FDi9KlrIHBhM" /><figcaption>Biblioteca José Vasconcelos, Cidade do Mexico</figcaption></figure><p>Recentemente eu estava preparando um projeto para uma introdução à Clojure e precisava escrever um código que era um pouco mais complexo e que não tinha muito relação com meu contexto.</p><p>Esse código era basicamente uma função que recebia um número de 1 a 13 para desenhar na tela uma carta de baralho em caracteres <em>ascii</em>.</p><p>Para evitar adicionar esse código no projeto, eu resolvi abstrair o código e colocar em uma biblioteca separada. Dessa forma, a pessoa que estivesse estudando o projeto simples, apenas importaria a biblioteca e chamaria a função. A biblioteca pode ser encontrado no <a href="https://github.com/cesaralcancio/card-ascii-art">Github</a>.</p><p>Nesse artigo vou mostrar como criar uma biblioteca em Clojure e publicar no repositório <a href="https://clojars.org/">Clojars</a> caso você tenha a mesma necessidade.</p><h3>O que é Clojars?</h3><p>É um repositório Maven, mantido pela comunidade, para publicar bibliotecas Clojure de código aberto. É possível acessar o <a href="https://repo.clojars.org/">repositório do Clojars no Maven</a>.</p><h4>Registrar e gerar um token</h4><p>Para utilizar o Clojars, basta se registrar uma c<a href="https://clojars.org/register">onta aqui</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fbisQ4qtLM8-3LldSkciWw.png" /></figure><p>Guarde o seu <strong>Username</strong>, pois ele vai fazer parte do seu <strong>groupId</strong> e você vai precisar dele na definição do seu projeto.</p><p>Depois de se registrar, essa é a página inicial.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t3uz5IyTiFrDiSYeTsF2jg.png" /></figure><p>No canto superior direito você vai clicar no menu <strong>Deploy Tokens</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-j6IiK4gugfXmQGU3fGH6w.png" /></figure><p>Agora basta criar o seu token e guardar. Pode colocar qualquer nome pra identificar o token. O escopo é para dizer em que <em>groupId</em> você vai permitir criar pacotes dentro do Clojars, nesse caso pode deixar para todos como está na imagem.</p><p>Agora com o <strong>username</strong> e o <strong>token</strong> guardados<strong>,</strong> vamos criar o projeto.</p><h3>Criando projeto com Leiningen</h3><p>O <a href="https://leiningen.org/">Leiningen</a> é uma ferramenta que ajuda a criar projetos em Clojure e também a gerenciar as dependências do projeto.</p><p>Primeiro vamos executar o comando lein new app minha-biblioteca e teremos criado o nosso projeto chamado minha-biblioteca.</p><p>Agora precisamos adicionar o groupId no nome do nosso projeto, para que o Clojars saiba qual groupId esse projeto vai pertencer.</p><p>Execute um cd minha-bibliteca para entrar na pasta do projeto. Dentro da pasta tem um arquivo chamado project.clj com as definições do projeto.</p><p>Vamos substituir o nome passado para a função defproject de minha-biblioteca para groupId/minha-biblioteca.</p><p>No meu caso org.clojars.cesaralcancio/minha-biblioteca, no seu caso você vai substituir o cesaralcancio pelo <strong>username</strong> que você criou anteriormente.</p><p>Seu project.clj vai ficar mais ou menos assim.</p><pre>(defproject com.github.cesaralcancio/minha-biblioteca &quot;0.1.0-SNAPSHOT&quot;<br>  :description &quot;FIXME: write description&quot;<br>  :url &quot;<a href="http://example.com/FIXME">http://example.com/FIXME</a>&quot;<br>  :license {:name &quot;EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0&quot;<br>            :url &quot;<a href="https://www.eclipse.org/legal/epl-2.0/">https://www.eclipse.org/legal/epl-2.0/</a>&quot;}<br>  :dependencies [[org.clojure/clojure &quot;1.10.1&quot;]]<br>  :main ^:skip-aot minha-biblioteca.core<br>  :target-path &quot;target/%s&quot;<br>  :profiles {:uberjar {:aot :all<br>                       :jvm-opts [&quot;-Dclojure.compiler.direct-linking=true&quot;]}})</pre><p>Antes de publicar o projeto, vamos adicionar uma função simples no arquivo src/minha_biblioteca/core.clj, para que possamos utilizá-la em outro projeto.</p><p>O seu core.clj deverá ser mais ou menos isso.</p><pre>(ns my-library.core<br>  (:gen-class))</pre><pre>(defn -main<br>  &quot;I don&#39;t do a whole lot ... yet.&quot;<br>  [&amp; args]<br>  (println &quot;Hello, World!&quot;))</pre><pre>(defn hello-world<br>  &quot;Minha primeira biblioteca&quot;<br>  []<br>  (println &quot;Ola, biblioteca!&quot;))</pre><h3>Publicando o projeto</h3><p>Dentro da pasta do projeto, você vai executar o comando lein deploy clojars para publicar o seu jar no repositório do Clojars.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NRbbn48qEfHBcUoXMaSMWQ.png" /></figure><p>Ele vai pedir o username e o token que geramos anteriormente, e vai publicar o serviço no seu Clojars.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iWolM0xkNMD937NhkE2qew.png" /></figure><p>Inclusive no lado direito inferior, com o nome <strong>Version Badge</strong>, você pode copiar um código para colocar no <em>readme</em> do seu projeto e fazer referencia ao repositório do Clojars.</p><h3>Como usar a biblioteca</h3><p>Vamos criar um projeto com o comando lein new app meu-cliente para consumir a biblioteca que está hospedada no Clojars.</p><p>Vamos atualizar as dependências no project.clj e, dentro da chave tal :dependencies, adicionar[org.clojars.cesaralcancio1/minha-biblioteca &quot;0.1.0-SNAPSHOT&quot;] . O código completo seria.</p><pre>(defproject meu-cliente &quot;0.1.0-SNAPSHOT&quot;<br>  :description &quot;FIXME: write description&quot;<br>  :url &quot;<a href="http://example.com/FIXME">http://example.com/FIXME</a>&quot;<br>  :license {:name &quot;EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0&quot;<br>            :url &quot;<a href="https://www.eclipse.org/legal/epl-2.0/">https://www.eclipse.org/legal/epl-2.0/</a>&quot;}<br>  :dependencies [[org.clojure/clojure &quot;1.10.1&quot;]<br>                 [org.clojars.cesaralcancio1/minha-biblioteca &quot;0.1.0-SNAPSHOT&quot;]]<br>  :main ^:skip-aot meu-cliente.core<br>  :target-path &quot;target/%s&quot;<br>  :profiles {:uberjar {:aot :all<br>                       :jvm-opts [&quot;-Dclojure.compiler.direct-linking=true&quot;]}})</pre><p>Depois disso, vamos executar o comando lein repl, que permite executar códigos Clojure de maneira interativa, utilizando os recursos do projeto, no nosso caso, o projeto meu-cliente.</p><p>E uma vez que estamos no namespace do projeto meu-cliente podemos utilizar a função (use &#39;[minha-biblioteca core]) para importar o namespace core da minha-biblioteca e executar a função (hello-world) .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0YJCgnvo331ZQwd3XlvVSQ.png" /></figure><p>Na imagem podemos ver que depois de executar o lein repl a biblioteca foi baixada do repositório Maven, e o comando (hello-world) escreveu na tela a mensagem Ola, biblioteca!.</p><h3>Conclusão</h3><p>Utilizando apenas Clojure, Leiningen e Clojars é possível criar uma biblioteca e hospedá-la publicamente. Essa é a maneira mais simples que eu encontrei de criar uma biblioteca de maneira open source e disponibilizar para que outras pessoas possam utilizar. Espero que tenha ajudado! 🙂</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b7a78bf9ba40" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Concorrência em microserviços com Clojure e Datomic]]></title>
            <link>https://cesar-alcancio.medium.com/concorr%C3%AAncia-em-microservi%C3%A7os-com-clojure-e-datomic-2fafe20e0759?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/2fafe20e0759</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[clojure]]></category>
            <category><![CDATA[microsserviços]]></category>
            <category><![CDATA[race-condition]]></category>
            <category><![CDATA[datomic]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Wed, 03 Nov 2021 04:16:12 GMT</pubDate>
            <atom:updated>2021-11-03T04:16:12.314Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n42hoipF49t2CuJc.jpg" /><figcaption>Concorrência em microserviços utilizando Clojure e Datomic</figcaption></figure><p>Há alguns anos atrás eu estava em uma equipe que precisava criar um produto novo para oferecer <strong>empréstimos</strong>, começamos a validar o produto com alguns serviços em <strong>Java</strong> e <strong>MySQL</strong>.</p><p>A proposta era ter uma API onde alguns <strong>parceiros pudessem integrar</strong> e criar ofertas para os nossos clientes. Posteriormente os clientes poderiam escolher a melhor oferta, submeter seus dados pessoais, passar por um processo de aprovação e receber seu empréstimo.</p><p>Só era permitido que cada parceiro criasse até <strong>três ofertas para cada cliente</strong>, toda a <em>User Interface</em> estava desenhada para atender apenas três ofertas. As ofertas tinham tempo de expiração e portanto era possível criar mais três ofertas apenas depois que as atuais fossem expiradas.</p><p>De forma resumida queríamos ter uma API que recebesse a oferta, e antes de inserir a oferta na base de dados, <strong>era necessário validar se já não existiam três ofertas com status disponível.</strong> Caso não existisse, a oferta seria criada, caso já existisse, seria retornado um <em>bad request</em> informando que já existiam ofertas disponíveis para este cliente.</p><p>A tabela de ofertas era basicamente composta por <em>id</em>, <em>partner_id</em>, <em>customer_id</em>, <em>status</em> e <em>amount</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/151/1*luY5CaEDjtSXxnUilhLYBg.png" /><figcaption>Exemplo de tabela de ofertas</figcaption></figure><p>Em um arquitetura de <strong>microserviços</strong> é muito comum que tarefas sejam <strong>executadas de maneira paralela</strong>, esse tipo de execução já acontecia com aplicações monolíticas que trabalhavam com <strong>várias threads em um mesmo servidor,</strong> porém em uma <strong>arquitetura distribuída</strong> como a de microserviços, é bastante comum que existam várias instâncias do mesmo serviço que executam a <strong>mesma tarefa ao mesmo tempo</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*ONzys58YF0FFXHx3MRIiTg.png" /><figcaption>Várias instâncias do mesmo serviço validando e criando ofertas</figcaption></figure><p>Caso as três instancias façam a validação ao mesmo tempo e depois cadastrem as três ofertas cada uma, <strong>o total de ofertas será nove</strong>. Como podemos assegurar que vamos ter <strong>apenas três ofertas</strong>?</p><p>Com o Datomic podemos ver <strong>duas formas de evitar este tipo de problema</strong>. Até o final do texto você vai entender a <strong>arquitetura básica do Datomic</strong>, como <strong>preparar o seu ambiente</strong> para executar a aplicação com o Datomic, uma <strong>visão geral do projeto</strong>, <strong>simular o erro de ter mais de três ofertas</strong> e conhecer <strong>duas possibilidades de solução</strong>. Se você já conhece algum desses temas, pode pular para o seguinte. Vamos lá!</p><h3>Arquitetura do Datomic</h3><p><a href="https://cesar-alcancio.medium.com/primeiros-passos-utilizando-datomic-b9c5252731d">Eu escrevi uma introdução ao Datomic que explica um pouco como ele armazena os dados</a> como <strong><em>datoms</em></strong>, se você ainda não viu, da uma olhada nele antes de continuar.</p><p>Agora que você já sabe que o Datomic armazena os dados como <strong><em>datoms</em></strong>, é importante entender um pouco como funciona a <a href="https://docs.datomic.com/on-prem/overview/architecture.html">arquitetura do Datomic</a>.</p><p>O <strong>Datomic é uma base de dados distribuída</strong>, isso significa que você pode executar os componentes de <strong>maneira independente.</strong> São basicamente três componentes.</p><ul><li><em>Storage service:</em> responsável por <strong>armazenar os dados</strong>, no ambiente local é utilizado o próprio <em>file system</em>, mas pode ser utilizado ferramentas como DynamoDB ou um banco SQL como PostgreSQL</li><li><em>Transactor:</em> responsável por receber as transações, <strong>executá-las de maneira sequencial</strong> e armazenar no storage.</li><li><em>Peer Server:</em> É um intermediário <em>opcional</em> entre a aplicação e o transactor. Aqui é onde o processamento de consultas é realizado e também pode ser adicionado camadas de cache.</li></ul><p>No nosso exemplo, <strong>não</strong> vamos usar o <em>Peer Server,</em> porque <strong>existe uma forma de executar a aplicação como um “Peer Server”</strong>.</p><p>Existe basicamente duas maneiras que você pode executar sua aplicação que vai acessar o Datomic.</p><ul><li>Executar a aplicação com o <a href="https://docs.datomic.com/on-prem/overview/project-setup.html"><strong><em>client library</em></strong></a>, que foi como executamos no texto de <a href="https://cesar-alcancio.medium.com/primeiros-passos-utilizando-datomic-b9c5252731d">Introdução ao Datomic</a>. Existem duas <em>client libraries</em>: a <strong>dev-local</strong> para provas locais (usada no Introdução ao Datomic) e a <strong>client-pro</strong> que é para o ambiente produtivo. Com a <strong>client-pro</strong> é necessário um <em>Peer Server</em>, porque toda a consulta será executada no <em>Peer Server</em>. Algumas desvantagens desse modelo <em>client library,</em> é que no momento que eu escrevo esse texto, a biblioteca é um pouco limitada em funções, e caso o <em>Peer Server</em> fique sobrecarregado todas as instancias da aplicação serão afetadas. A vantagem é a facilidade de testar o Datomic utilizando a <strong>dev-local</strong>.</li><li>Executar a aplicação com a <a href="https://docs.datomic.com/on-prem/peer/integrating-peer-lib.html"><strong><em>peer library</em></strong></a>, nesse modelo cada aplicação é uma especie de <em>Peer Server, </em>por isso não é necessário criar um <em>Peer Server </em>aparte. O processamento das queries é realizados na aplicação. Caso alguma query tenha um alto consumo, impactará apenas a instância que está executando a consulta. Consequentemente a aplicação precisará de mais recursos de memória e CPU.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/226/1*FMfbg6qrox-LWiJLBeC03g.png" /><figcaption>Peer library config</figcaption></figure><p>Vamos utilizar a <strong><em>peer library</em></strong> para o nosso exemplo.</p><h3>Preparando o ambiente Datomic com Peer Library</h3><p>Para utilizar a <a href="https://docs.datomic.com/on-prem/peer/integrating-peer-lib.html">Peer Library</a> é necessário fazer um cadastro no <a href="https://my.datomic.com/login">site do Datomic</a>. Uma vez cadastro e autenticado, você pode acessar a página inicial e fazer o download do Datomic. Eu vou usar a versão <strong>1.0.6316</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NPm8MLb3BA4T_EOQJQUnwA.png" /><figcaption>Página para download do Datomic</figcaption></figure><p>O comando já vai vim com o seu password, basta trocar o $VERSION para a versão desejada e executar, por exemplo.</p><pre>wget --http-user=cesar.alcancio@gmail.com --http-password=&lt;seu-password-aqui&gt; https://my.datomic.com/repo/com/datomic/datomic-pro/$VERSION/datomic-pro-<strong>1.0.6316</strong>.zip -O datomic-pro-$VERSION.zip</pre><p>Depois de executar o download você deve instalar a biblioteca no seu Maven local com o seguindo comando.</p><pre>bin/maven-install</pre><p>Ou no Windows.</p><pre>mvn install:install-file -DgroupId=com.datomic -DartifactId=datomic-pro -Dfile=datomic-pro-<strong>1.0.6316</strong>.jar -DpomFile=pom.xml</pre><p>Agora basta criar o seu projeto Clojure utilizando Leiningen e adicionar a biblioteca. Mas antes vamos executar o <em>Datomic Transactor</em>.</p><h4>Executando o Datomic Transactor</h4><p>Depois de tudo configurado você precisa executar o <em>transactor</em> do Datomic para que sua aplicação possa executar as queries e adicionar e retrair <em>datoms</em> do Datomic.</p><p>Para isso você precisa entrar na sua <a href="https://my.datomic.com/account">página do Datomic</a> e clicar no botão de enviar a licença para o seu e-mail.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tLvhsAYOQzU6PUdpZOXkTA.png" /><figcaption>Enviar código da licença do Datomic</figcaption></figure><p>Você vai receber um e-mail com a licença para executar o Datomic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/777/1*UofNzVnJo9uzAg39K3NqvQ.png" /><figcaption>Datomic License</figcaption></figure><p>Dentro da pasta onde você baixou o Datomic, você vai editar um arquivo chamado <strong>datomic-pro-1.0.6316/config/samples/dev-transactor-template.properties. </strong>Nesse arquivo você<strong> </strong>vai adicionar a <strong>license-key</strong> no lugar pré estabelecido, depois do <strong>“license-key=”</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*NQtsGCPk0TFFoWZYXW-Nmg.png" /><figcaption>Arquivo dev-transactor-template.properties</figcaption></figure><p>Depois você pode executar o Datomic <em>Transactor</em> passando o caminho completo do arquivo de configuração:</p><pre>bin/transactor /caminho/completo/datomic-pro-1.0.6316/config/dev-transactor-template.properties</pre><p>E agora seu Datomic <em>Transactor</em> deve estar sendo executado no endereço <strong>datomic:dev://localhost:4334</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YmFfAtrLQWXHy8zUCNz_Wg.png" /><figcaption>Datomic transactor executando</figcaption></figure><p>Pronto! Agora você já tem a <em>peer library</em> instalada localmente com Maven para ser utilizada, e já tem o Datomic <em>Transactor</em> executando para ser usado. Vamos criar o projeto.</p><h3>Criando o projeto Clojure para criar ofertas</h3><p>Vamos criar o projeto utilizando <a href="https://leiningen.org/">Leiningen</a> e o processo será o mesmo que foi utilizado no artigo sobre <a href="https://cesar-alcancio.medium.com/primeiros-passos-utilizando-datomic-b9c5252731d">Introdução ao Datomic</a>. O código completo pode ser encontrado no <a href="https://github.com/cesaralcancio/service-clojure-offers">Github</a>.</p><p>A única diferença é que o projeto vai usar a <em>peer library </em>instalada anteriormente, que pode ser importada no <em>project.clj</em> da seguinte maneira.</p><pre>[com.datomic/datomic-pro &quot;1.0.6316&quot;]</pre><h3>Visão geral do projeto</h3><p>O projeto foi dividido em basicamente 4 camadas: <em>business, common, controllers</em> e <em>datomic</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/508/1*aGoqMMD3LcO1S2KD1Ypcrw.png" /><figcaption>Estrutura do projeto</figcaption></figure><p>Vamos começar pela camada do Datomic.</p><h4>Datomic</h4><p>Essa é a camada responsável por conectar com o datomic e realizar as operações de listar, inserir e retrair <strong><em>datoms</em></strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/429/1*dzFANHKVWagYymD4hPDdPg.png" /><figcaption>Datomic</figcaption></figure><p>O <strong><em>config.clj</em></strong> vai expor as funções para conectar com o datomic, criar base de dados, função para criar o schema e etc.</p><p>O <strong><em>offers.clj</em></strong> é uma especie de <a href="https://pt.wikipedia.org/wiki/Objeto_de_acesso_a_dados">Data Access Object</a>, possui funções para listar, inserir e retrair datoms.</p><p>O <strong><em>schema.clj</em></strong> é onde fica declaro o schema da base de dados. Composto por offer/id, offer/customer-id, offer/status, offer/amount e offer/created-at.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/479/1*6T1DFrosEFBWilT3f4uKEg.png" /><figcaption>Schema da base de dados</figcaption></figure><h4>Business</h4><p>A camada de <em>business</em> é onde fica a lógica de negócio. Nesse pacote vamos ter a função responsável por receber as ofertas e validar se existem mais de 3 ofertas com o status de available.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/946/1*Pd_WfIn_AFUryraRBR5tuQ.png" /><figcaption>Função validar se existe mais de 3 ofertas disponíveis</figcaption></figure><p>A ideia é que essa <strong>função seja pura</strong>, dessa forma fica mais fácil realizar os testes unitários.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*MBdtHTwJnVueg1VceUgtsA.png" /><figcaption>Testes unitarios</figcaption></figure><h4>Common</h4><p>Essa seção possui apenas algumas funções que vão ajudar na construção do projeto, por exemplo: retornar data e hora, gerar uuids, executar um bloco de código em várias <em>threads</em> e<em> </em>criar uma oferta <em>fake</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/564/1*wFSIxziyC-tC1OKyddad1g.png" /><figcaption>Funções comuns</figcaption></figure><p>A macro <strong><em>run-threads</em></strong> é bastante importante pois vai permitir que possamos executar os <strong><em>controllers</em></strong> de forma paralela permitindo que seja simulado o erro de concorrência. Se você não sabe muito bem como criar macros, pode consultar esse artigo que explica <a href="https://cesar-alcancio.medium.com/como-funcionam-as-macros-em-clojure-71e919359807">como funcionam as macros em Clojure</a>.</p><h4>Controllers</h4><p>Por fim o controlador, que é o responsável por conectar todos os outros pacotes. As funções no controlador vão chamar as outras funções de commons, business e datomic, executando o que chamamos de <a href="https://en.wikipedia.org/wiki/Function_composition_(computer_science)">composição de funções</a>.</p><p>O projeto possui basicamente três funções no controlador:</p><ul><li><strong><em>create-offer-v1!</em></strong> responsável por reproduzir o <strong>erro de concorrência</strong></li><li><strong><em>create-offer-v2!</em></strong> responsável por aplicar uma solução usando o <strong><em>transactor</em></strong> do datomic</li><li><strong><em>create-offer-v3!</em></strong> responsável por aplicar uma solução usando o <strong><em>db-after</em></strong> do <em>datomic</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/756/1*NZhZ_pzcRnsvVShivry1Hw.png" /><figcaption>Três função de composição</figcaption></figure><p>Vamos ver cada função com mais detalhes.</p><h3><strong>Simulando o erro de concorrência</strong></h3><p>A função <strong><em>create-offer-v1!</em></strong> faz o processo básico, ela recebe como parâmetros o datomic (que possui o db e a conexão) e a offer. A primeira coisa que essa função faz é consultar todos as ofertas do customer id, acrescentar a oferta nova e chamar a função para checar se vai ultrapassar o limite de 3 ofertas <em>available</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*sDrZ1irYSTpZngmORV1POA.png" /></figure><p>Por último, caso não ultrapasse o limite, vai registrar a nova oferta. Essa é uma função que funciona caso não exista muitas chamadas executadas de maneira paralela como explicamos no começo do texto.</p><p>Vamos executar uma prova onde 100 threads diferentes vão realizar a chamada para esta função. No final a prova vai validar se foram inseridas apenas 3 ofertas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/959/1*1orH-7_ExVxjCkMj2NpT_A.png" /><figcaption>Validando crate-offer-v1!</figcaption></figure><p>Nesse caso estamos validando que no final da execução (após 1 segundo), foram inseridas <strong>mais que três ofertas, ou seja, quando chamamos a create-offer-v1! 100 vezes em paralelo mais de 3 ofertas são registradas, </strong>fazendo com que a regra não seja cumprida.</p><h3>Solução utilizando o Datomic Transactor</h3><p>A primeira abordagem que podemos utilizar para corrigir este problema é executar a validação <strong>dentro do transactor do Datomic</strong>. Na seção que explica a arquitetura do Datomic, vimos que o transactor é único e executa as transações de maneira sequencial, dessa forma mesmo que criarmos 100 <em>threads</em> em paralelo, as <strong>validações seriam executadas de maneira sequencial</strong>.</p><p>Para isso precisamos instalar a função que vai validar e inserir os <em>datoms</em>. Essa função é instalada no Datomic assim como o schema é instalado, portanto ela deve ser instalada como “dado” (Existe outras formas de instalar essa função, por exemplo, <a href="https://docs.datomic.com/on-prem/reference/database-functions.html#classpath-functions">adicionado a função no <em>classpath</em></a>, porém vamos focar na versão mais simples no nosso código).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_gSzZoXsPXj-MT-5CjAFnw.png" /><figcaption>Função :add-offer</figcaption></figure><p>Na visão geral do projeto vimos o <em>schema</em> das ofertas, nesse caso estamos adicionando mais um “campo” que será identificado com o <strong><em>“:db/ident”</em></strong> como<strong>“:add-offer”.</strong> No <strong><em>“:db/fn” </em></strong>será definido um mapa com a linguagem, os parâmetros e o código.</p><ul><li>A linguagem é Clojure, sinalizando que o que vai em “code” deve ser escrito em Clojure.</li><li>Como parâmetros é sempre o db em primeiro e o restante são os dados que serão enviados quando essa função será executada, no nosso caso a offer.</li><li>O código deve ser enviado em um único bloco, pois ele será executado no transactor. Caso seja adicionado alguma referencia a uma função que só existe no serviço mas não existe no transactor, não irá funcionar. É possível utilizar o <strong>datomic.api</strong> porque o transactor também possui essa biblioteca.</li></ul><p>Basicamente a função vai consultar na base de dados todas as ofertas com status <strong><em>available</em></strong>, adicionar a nova oferta na lista e validar se já excedeu o limite de ofertas. Caso não exceda o limite a função deve retornar o <em>datom</em> que será inserido, se não vai retornar uma exceção produzida pela função <strong><em>cancel</em></strong> do datomic api. Nesse caso não foi possível reaproveitar a função de validar o limite, toda a lógica ficou acoplada a base de dados.</p><p>Para executar a função basta chamar o <strong><em>transact</em> e enviar o :add-offer com a offer </strong>em vez de enviar o <em>datom</em> diretamente<strong>. </strong>Dessa forma a função irá receber o db e a offer enviada, irá realizar a validação e retornar o datom para ser inserido. Ou a exceção.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/704/1*LESUn3_5U8zKWfAfbsUw6g.png" /><figcaption>Executando o :add-offer</figcaption></figure><p>Finalmente podemos executar o mesmo teste, porém, nesse caso, <strong>a quantidade de ofertas criadas sempre será três</strong>. Funcionando corretamente!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*2OvtoOwmJpfq_mXXiQiMhQ.png" /><figcaption>Testando a solução com o transactor</figcaption></figure><p>Essa é uma possível solução, mas vale a pena considerar que é dependente do <em>transactor</em>, o que pode deixar as coisas um pouco menos performática por executar de forma sequencial com consulta e validação em um único ponto. Outra coisa a se considerar é a organização do código, que não fica tão bem separado entre base de dados e regras de negócio. Vamos ver a próxima alternativa.</p><h3>Solução utilizando consulta em em um ponto especifico do tempo</h3><p>Essa solução não utiliza o <em>transactor function</em>, porém utiliza o fato do <em>transactor</em> executar as transações em sequencias. A ideia é que cada <em>thread</em> registre os dados da oferta primeiro e posteriormente valide se alguma outra <em>thread</em> inseriu uma oferta antes. Se outra <em>thread</em> inseriu uma oferta antes e excedeu o limite então a <em>thread</em> atual deve remover sua própria oferta, caso contrário deve manter a oferta registrada.</p><p>São duas coisas que permite que essa solução funcione (1) é o fato do datomic realizar as transações em sequencia e (2) permitir consultar a base de dados como exatamente no ponto após a inserção da nova oferta. Vamos ver dois exemplos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tVAMCB6Z85_PJdv6FGipDw.png" /><figcaption>Consulta no momento da validação com consulta normal</figcaption></figure><p>Vamos avaliar como funcionaria caso fosse realizado uma <strong>consulta normal</strong>. A imagem representa no eixo <strong><em>x</em></strong> o <strong>tempo</strong> e no eixo <strong><em>y</em></strong> as <strong><em>threads</em></strong>. O <strong>azul</strong> é quando a oferta foi inserida. O <strong>amarelo</strong> é quando a <em>thread</em> realizou a operação de validação. Considerando que a validação amarela recebe os dados no mesmo momento em que é executada, ou seja, todos os dados antes da linha tracejada, as 4 threads vão resultar em apenas <strong>2 ofertas e não 3 ofertas</strong>, porque a <em>t1</em> e a <em>t2</em> estão considerando a oferta da <em>t4</em> e estão retraindo suas respectivas ofertas (o <strong>vermelho</strong> representa o <em>delete</em>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xXqkKJpuyBKqZCbXBe-wWQ.png" /><figcaption>Consulta uma “foto” do momento após a inserção dos dados</figcaption></figure><p>Agora vamos ver o mesmo exemplo, com os mesmos tempos, porém realizando uma consulta de um ponto especifico no tempo, esse tempo seria o <strong>momento exato após a inserção dos dados</strong>, como se fosse uma foto daquele momento da base de dados. Nesse caso, mesmo que a validação, em amarelo, seja realizado depois, a consulta só vai retornar os dados que foram inseridos em um ponto especifico do tempo, permitindo que no final seja inserido 3 ofertas e não apenas 2 como no exemplo anterior. Vamos ver como fica o código.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*z4CTwpkLJjVGK4qparqLtA.png" /><figcaption>Usando o db-after</figcaption></figure><p>O código é muito parecido com a primeira versão, utiliza o <strong><em>business</em></strong> para validar se existem mais de três ofertas após inserir a oferta. E a parte interessante é que após inserir a oferta o datomic retorna o <strong><em>:db-after</em></strong> que pode ser extraído para realizar uma consulta de uma foto do momento exato após a inserção da oferta, funcionando como no exemplo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/963/1*yloqeb-Tg11ayhWijtELvg.png" /><figcaption>Teste unitário</figcaption></figure><p>Realizando a mesma prova anterior, porém, com o <strong><em>create-offer-v3!</em></strong> é possível assegurar que enviando 100 requests apenas 3 ofertas permaneceram na base de dados. Obviamente em algum momento mais de 3 ofertas existiram, porém foram removidas posteriormente.</p><h3>Conclusão</h3><p>A ideia foi apresentar como eu poderia ter resolvido um problema que existia em um micro serviço com Java e MySQL, porém, utilizando Clojure e Datomic. Como vocês podem perceber, <strong>não existe bala de prata</strong>. Apesar do Datomic permitir que seja executadas funções no <em>transactor</em>, isso pode deixar os inserts mais lentos já que para inserir uma oferta é preciso fazer uma consulta e realizar uma validação dentro do <em>transactor</em>, que não foi escalado horizontalmente como os microserviços. Já na solução usando o <strong><em>db-after</em></strong>, caso algum serviço realize a consulta antes da <em>thread</em> remover o <em>datom</em> duplicado vai acabar vendo mais de três ofertas. Esse é um desafio bastante comum quando queremos <strong>garantir integridade e consistência em sistemas distribuídos</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2fafe20e0759" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sua empresa não precisa de um time de Arquitetura de Software, e você não precisa ser um Arquiteto…]]></title>
            <link>https://cesar-alcancio.medium.com/sua-empresa-n%C3%A3o-precisa-de-um-time-de-arquitetura-de-software-e-voc%C3%AA-n%C3%A3o-precisa-de-ser-um-fbb503b155ad?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/fbb503b155ad</guid>
            <category><![CDATA[squad]]></category>
            <category><![CDATA[time]]></category>
            <category><![CDATA[desenvolvimento]]></category>
            <category><![CDATA[engenharia]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Wed, 06 Oct 2021 19:25:03 GMT</pubDate>
            <atom:updated>2021-10-13T17:29:36.182Z</atom:updated>
            <content:encoded><![CDATA[<h3>Sua empresa não precisa de um time de Arquitetura de Software, e você não precisa ser um Arquiteto de Software</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/910/1*PMs9VgoVHSBmiBWUIOKnRQ.jpeg" /></figure><p>Se você é responsável pela área de tecnologia, você <strong>não precisa de um time de arquitetura de software.</strong> E e se você é um engenheiro de software, você também <strong>não precisa ser um arquiteto de software</strong> no futuro.</p><p>Calma! Eu sei que se você é o responsável pela area de tecnologia, só quer <strong>garantir que as coisa sejam feitas do jeito certo</strong>. E se você é um engenheiro, só quer ser <strong>um melhor programador. </strong>E tudo bem. Porém, um time de arquitetura de software, ou ser um arquiteto de software, não é o caminho ideal. Prometo que até o final do texto você vai saber os motivos e as alternativas. Vamos lá!</p><p>Existe um tema bastante polêmico entre as empresas de tecnologia referente ao cargo de arquiteto de software. Ter ou não ter arquitetos de software? Quando ter?</p><p>O título de arquiteto de software tem um certo <em>glamour</em> e é muito desejado pelos desenvolvedores. Eu me lembro de quando eu comecei a trabalhar como programador e muitos amigos tinham como ambição ser um arquiteto de software no futuro. O desejo de ser arquiteto de software normalmente significava:</p><ul><li>projetar e construir uma solução de software considerada de qualidade e robusta;</li><li>de qualidade porque seria de fácil extensão e manutenção;</li><li>robusta porque suportaria grande volume de requisições e dados;</li><li>que fosse confiável e segura;</li><li>e que fosse legível e elegante. Quem não gosta de um código bonito?</li></ul><p>O senso comum era de que a <strong>função principal do arquiteto era garantir uma boa implementação dos requisitos não funcionais</strong>, mais conhecidos como: performance, escalabilidade, disponibilidade, segurança, manutenibilidade, gerenciabilidade, confiabilidade e extensibilidade.</p><p>Acredito que foi com esse propósito que os times de arquitetura surgiram e se dividiu as responsabilidades dos desenvolvedores, ou <strong>engenheiros de software</strong>, e os <strong>arquitetos de software</strong>. Os engenheiros de software ficaram com a responsabilidade de criar as funcionalidades de negócio, ou também como eram conhecidos, <strong>requisitos funcionais</strong>.</p><p>Assim chegamos em algumas organizações que vemos hoje: um time de <strong>Engenharia de Software</strong>, com engenheiros de software, gerente de engenharia, diretores de engenharia e VP de engenharia. E outro time de <strong>Arquitetura de Software</strong> com arquitetos de softwares respondendo para um Chief Architecture Officer.</p><h3>Como funcionam os times de Arquitetura de Software</h3><p>O fator que vai determinar como os times de engenharia e arquitetura funcionam é a <strong>quantidade de engenheiros necessários para entregar os produtos e funcionalidades</strong> que o negócio exige.</p><p>Normalmente uma empresa pequena, de algumas dezenas de engenheiros, não vai ter um time de arquitetura, porém uma empresa com algumas centenas de engenheiros vai sentir falta de <strong>criar padrões para que todos os outros engenheiros possam seguir</strong>. Além de criar e manter esses padrões o time de arquitetura também vai <strong>garantir que os engenheiros estão seguindo os padrões</strong>.</p><p>E foi assim que eu tive minha primeira experiência com um time de arquitetos. Depois de alguns anos eu decidi <strong>sair de uma empresa com dezenas de desenvolvedores</strong> onde nós éramos responsáveis por todo o processo de desenvolvimento de um software, desde a análise até a manutenção em produção e entrega de novas funcionalidades, e <strong>entrei em uma empresa com centenas de desenvolvedores</strong>, onde minha responsabilidade era primeiro criar um <a href="https://www.ibm.com/docs/pt-br/elm/6.0.5?topic=requirements-vision-document">documento de visão</a> com toda especificação do software, casos de usos, modelos de dados e requisitos não funcionais antes de <strong>implementar qualquer solução</strong>.</p><p>Esses documentos eram aprovados pelos times de negócios e arquitetura. Eu tinha uma reunião com o arquiteto de software durante 30 minutos, ele fazia uma leitura dinâmica do documento que eu fiz, esse documento projetava a quantidade de <strong>requisições e volume</strong> de dados que minha aplicação teria, <strong>ele assinava o documento e com a sua assinatura eu estava livre para implementar a minha solução</strong>.</p><p>Nesse caso a empresa estava passando por uma migração de uma arquitetura distribuída com Java EE e EJB para uma arquitetura SOA. A regra era que tudo novo precisaria ser escrito em SOA, o problema é que faltavam peças escritas em SOA. O arquiteto de software não tinha tempo a perder com esses detalhes, tinha que ser escrito no SOA e pronto. <strong>Essa era a nova regra do time de arquitetura</strong>.</p><p>Depois de um ano eu troquei de empresa novamente e agora para uma empresa com dezenas de engenheiros e bastante trabalho terceirizado para fábricas de software, com outras dezenas de engenheiros. <strong>Essa empresa também tinha um time de arquitetos que decidiu todas as ferramentas que seriam usadas para o desenvolvimento nos primeiros meses da empresa.</strong> Os arquitetos decidiram tudo de melhor segundo o que dizia o <a href="https://www.gartner.com/smarterwithgartner/gartner-top-strategic-technology-trends-for-2021">Gartner</a>.</p><p>O time de arquitetura raramente, ou nunca, fazia entregas de funcionalidades e consequentemente não usava os padrões criados para entregar código em produção. Acredito que a maioria deles nem escreviam códigos. Inclusive a proposta de uma das ferramentas era escrever soluções arrastando caixinhas. Quem conheceu o <a href="https://www.oracle.com/middleware/technologies/bpm.html#:~:text=Oracle%20Business%20Process%20Management%2C%20a,automate%20and%20optimize%20business%20processes.">Oracle BPM</a>?</p><p>A arquitetura utilizada foi SOA, com Oracle Service Bus, Oracle API Gateway, Oracle BPEL e muitos serviços em Java que se comunicavam através do Service Bus utilizando o protocolo SOAP. O banco de dados também era Oracle. Para o front-end também era utilizado uma ferramenta da Oracle chamada Oracle WebCenter Sites.</p><p>O mais interessante das ferramentas era o <a href="https://subversion.apache.org/">SVN</a>. Porém, na época o Git já era tão superior que a fábrica de software resolveu usar o Git e automatizar a entrega para o SVN para cumprir a regra do SVN. Acredito que essa regra existia mais pela falta de comunicação do que pela preferência pelo SVN. <strong>É uma consequência de trabalhar em silos.</strong></p><p>Independente da arquitetura, o resultado foi que o produto não teve aderência e a empresa demitiu grande parte dos funcionários e teve que <em>pivotar</em> o negócio. <strong>Nessa mudança o time de arquitetura acabou desaparecendo e as decisões de arquitetura foram absorvidas e executadas por uma equipe de engenheiros que participavam ativamente nas entregas dos produtos.</strong> Na prática é difícil afirmar que as decisões foram melhores, porém o time que tomava as decisões era o mesmo time que colhia os resultados, <strong>isso foi uma mudança importante</strong>. Trabalhei um bom tempo em alguns time de produtos nessa empresa, sem equipes de arquitetura.</p><p>Depois de um bom tempo acostumado a não trabalhar com um time de arquitetura de novo, eu fui para uma empresa que também era orientada a produtos e tinha um time de arquitetos. Em uma empresa orientado a projetos, como a que eu tinha que escrever documentos de visão e casos de uso, <strong>o papel do arquiteto é só mais uma papel em toda a cadeia burocrática</strong>, porém em uma<strong> empresa orientada a produto, a equipe de arquitetura se torna o verdadeiro empecilho para entregas de funcionalidades e inovação</strong>.</p><p>Normalmente um time organizado em volta de produtos é composto por <em>Product Manager, Product Designer e alguns Software Engineers</em>. A ideia é que esse time tenha <strong>autonomia para entregar todas as funcionalidades do produto fim a fim</strong>. Conhece o conceito de <a href="https://docs.aws.amazon.com/whitepapers/latest/introduction-devops-aws/two-pizza-teams.html"><em>two pizza team</em></a>?</p><p>O P<em>roduct Manager</em> é basicamente responsável por gerar <em>hipóteses</em> que serão validadas com o <strong>mínimo de esforço dos engenheiros</strong>. Várias hipóteses serão descartadas e as que sobreviverem a aprovação do cliente serão então evoluídas para serem estendidas, escaladas, rescritas com mais qualidade e etc. Famosas dívidas técnicas.</p><p>Nesse tipo de desenvolvimento o time precisa ter <strong>completa autonomia</strong> para decidir o que construir, quando construir e o mais importante <strong>como construir</strong>.</p><p>Por outro lado o time de arquitetura tem o objetivo de <strong>criar padrões e garantir que os times de engenharias sigam estes padrões</strong>. O problema é que esses padrões são feitos para garantir que a <strong>solução final seja robusta e a maior parte das entregas do time de engenharia não precisará ser robusta</strong> e será descartada o mais rápido possível. Na verdade, quanto menos código para testar uma hipótese melhor para o time de engenharia e <strong>terrível para o time de arquitetura</strong>. Perceberam o dilema?</p><blockquote>Baseado nessa experiência eu tenho alguns motivos pelos quais eu acredito que <strong>toda empresa orientada a produtos não deveria ter um time de arquitetura.</strong></blockquote><ul><li>Um time de arquitetura representa um departamento diferente do time de engenharia. Departamentos diferentes, gestores diferentes e no fim, objetivos diferentes. Essa é causa de constante discussões onde ambos estão certos porém com objetivos que apontam para direções contrarias. <strong>É um trabalho em silos</strong>.</li><li>Eu costumo dizer que na <a href="https://pt.wikipedia.org/wiki/A_Galinha_e_o_Porco">fabula do porco e a galinha</a>, o <strong>engenheiro é o porco e o arquiteto é a galinha</strong>. Isso porque todos os padrões gerados pelos arquitetos serão usados diariamente pelos engenheiros sob a supervisão dos arquitetos. Enquanto um decide qual é a arquitetura apropriada e como os sistemas devem se comunicar, o outro é responsável por implementar. O engenheiro vai lidar com os problemas da arquitetura no dia a dia enquanto o arquiteto só vai ver a beleza das caixas e linhas que se conectam no<em> </em>diagrama. O dia que acontecer um problema em produção quem vai resolver? <strong>O porco está comprometido e a galinha está apenas envolvida</strong>.</li><li>Muitos times de arquitetura fazem <strong>programas de intercambio</strong>, onde os arquitetos devem ativamente participar de <em>sprints</em> desenvolvendo novas funcionalidades junto com os times de engenharia de produto. Nesse período ele coleta feedbacks da arquitetura e volta para o seu departamento para implementar as melhorias. Isso acontece uma ou duas vezes a cada semestre. Na minha opinião esse tipo de <strong>programa só reforça o quanto esses dois times trabalham em silos</strong> e pessoalmente eu nunca vi grandes mudanças serem implementadas com esse tipo de feedback.</li><li>O time de arquitetura normalmente tem a palavra final sobre as decisões técnicas e por isso elas são tomadas de maneira unilateral, não considerando as necessidades do negócio ou as necessidades de engenharia. Isso também gera uma sensação de que o engenheiro é um <em>second class citizen</em> ou cidadão de segunda classe. Ele deve receber a aprovação de alguém que não tem os mesmos incentivos que ele: <strong>testar o máximo de hipóteses possível com o mínimo de esforço necessário</strong>.</li><li>Em algumas empresas a supervisão do time de arquitetura é tão forte que nenhum <em>pull request</em> é integrado ao código principal sem a aprovação de um arquiteto. Nenhum <em>deploy</em> é realizado em <em>staging</em> ou produção sem uma aprovação de um arquiteto. <strong>Isso é exterminar com a autonomia de qualquer time</strong>.</li></ul><p>Acredito que o problema principal pode <strong>ser atacado com o alinhamento dos objetivos</strong> entre as areas de arquitetura e engenharia. Infelizmente o título de arquiteto de software está tão <strong>enraizado nesse modelo de desenvolvimento em silos</strong> que apenas removendo esse departamento e título será possível realizar alguma mudança significativa.</p><h3>Mas sem arquiteto de software como ficam os requisitos não funcionais?</h3><p>Se você chegou até aqui provavelmente deve estar perguntando: E a solução? Quem vai garantir os padrões de qualidade?</p><p>Se o time é pequeno, os próprios engenheiros mais seniores vão decidir a arquitetura. Se o time é maior você vai precisar criar uma <strong>guild, comitê, ou o nome que você desejar para o grupo</strong>, que vai participar ativamente dessas decisões, porém esse grupo ainda deve trabalhar em um time de produto e ainda têm suas responsabilidades com relação as <strong>funcionalidades do produto</strong>.</p><p>Você pode ter um comitê para cada situação especifica, qualidade de código, pipeline de deliver, linguagens de programação, banco de dados e etc. E o ideal é que qualquer desenvolvedor possa participar desse grupo, pelo menos passivamente, e que as <strong>decisões sejam tomadas sempre mediante algum racional</strong>.</p><p>Idealmente, deve ser definido a <strong>estratégia de engenharia</strong> que o time de engenharia vai seguir, isso vai criar os <strong>princípios que guiará as decisões de tecnologia</strong>.</p><p>A estratégia do time de engenharia é ter poucas ferramentas para acelerar o desenvolvimento e integrar os serviços de maneira mais fácil? Tudo bem. A estratégia vai ser ter mais liberdade e flexibilidade para utilizar a ferramenta apropriada com o custo de ter um desenvolvimento mais longo em algumas ocasiões? Tudo bem também. <strong>Não existe bala de prata</strong>.</p><p>Esses princípios vão guiar as decisões técnicas que vão ser <strong>definidas de maneira colaborativa pelas pessoas que mais vão sofrer o resultado positivo e negativo dessas decisões</strong>. O livro Staff Engineering apresenta uma opção para se criar a <a href="https://staffeng.com/guides/engineering-strategy">estratégia de engenharia</a>.</p><p>O fato é que alguns engenheiros vão trabalhar na arquitetura enquanto também trabalham no time de engenharia. Eles respondem para o mesmo gestor e têm o mesmo objetivo: <strong>testar o máximo de hipóteses possível com o mínimo esforço e depois criar soluções robustas que foram foram já foram validadas.</strong></p><p>Esses engenheiros normalmente são conhecidos como <strong>staff plus engineers</strong> e podem ter títulos como <strong>senior software engineer, technical lead, staff engineer, distinguished engineer</strong> entre outros. Eles também podem ter outras responsabilidades como <strong>ajudar a definir a estratégia de engenharia, ajudar o time de contratação, influenciar outros engenheiros em soluções técnicas e implementações, dar mentoria a outros engenheiros, patrocinar outros engenheiros que querem progredir na carreira e etc</strong>. Dessa forma os engenheiros mais juniores também podem vislumbrar um caminho mais claro para crescer em vez de querer apenas ser o arquiteto de software, que normalmente envolveria trocar de departamento.</p><p><strong>O trabalho de arquitetura de software continua sendo executado</strong> porém com outras prioridades. Vou apresentar uma lista resumida da diferença desse modelo para o modelo tradicional de arquitetura de software:</p><ul><li>Existe apenas <strong>um objetivo e os requisitos não funcionais são tratados como parte do produto</strong>. Afinal de contas, ter uma funcionalidade robusta também deve ser uma prioridade para o time produto.</li><li><strong>Menos decisões unilaterais e top-down</strong>. O staff+ engineer é responsável por entender o problema que o time quer resolver e influenciar na solução junto com outros engenheiros.</li><li><strong>Autonomia</strong> para o time de produtos decidir o <strong>que, quando e como</strong> implementar uma solução e arcar com as consequências dessa solução.</li><li>Menos controle sobre as pessoas e mais <strong>qualidade de código</strong>. Eu acredito que uma <strong>arquitetura incremental e evolutiva</strong>, evitando <strong>otimização precoce do código</strong> tem um resultado final com mais qualidade.</li><li>Consequentemente mais <strong>inovação</strong>, mais <strong>erros</strong> e <strong>aprendizados</strong> e mais engenheiros de software motivados a fazer um bom trabalho.</li></ul><h3>Mas nada é tão simples como parece</h3><p>Outro problema comum é definir quem serão os engenheiros que vão focar no desenvolvimento de novas bibliotecas, do <em>pipeline</em> de integração e <em>deliver</em>, de serviços que serão utilizados por toda empresa, por exemplo, uma API de disparo de e-mails, ou até de decidir entre construir um software novo ou comprar um software pronto.</p><p><strong>Uma das maiores dificuldades em tecnologia é conciliar o desenvolvimento de coisas que não vão trazer valor diretamente para o negócio mas que vão acelerar o desenvolvimento de novas funcionalidades.</strong> Isso é um constante cabo de guerra.</p><p>Eu acredito que isso possa evoluir naturalmente. Primeiro os times de produto podem assumir essas responsabilidades já pensando que outros times poderão usar a ferramenta no futuro. Os novos times que usarão essa ferramenta podem participar de forma colaborativa com melhorias e correções.</p><p>Conforme o time for crescendo, uma alternativa é criar times de produto que sejam responsáveis pelo desenvolvimento dessas ferramentas internas para os desenvolvedores. Existem vários nomes para esses times: Developer Experience, Times de Produtos Interno ou <a href="https://martinfowler.com/articles/platform-prerequisites.html">Times de Plataforma</a>. <strong>Dependendo da quantidade de desenvolvedores será necessário um ou mais times de plataformas.</strong></p><p>Por exemplo, pode existir um time de Developer Experience que vai criar soluções para um novo desenvolvedor fazer o setup do ambiente, aprender as tecnologias e começar a ser produtivo o mais rápido possível. E o time de plataformas pode criar ferramentas para facilitar todo o processo de integração e entrega de código em produção.</p><p>Não importa muito como você vai chamar esse time, o mais importante é <strong>garantir que a responsabilidade seja bem definida e que isso não tire a autonomia dos times de engenharia.</strong> Alguns pontos importantes.</p><ul><li>O time de engenharia não deve ser obrigado a utilizar as ferramentas desenvolvidas pelo time de plataforma. As ferramentas devem <strong>ser tão boas que o time de engenharia prefira utilizar elas porque serão mais produtivos</strong>.</li><li>O time de plataforma precisa entender as necessidades do time de engenharia e da estratégia da empresa. <strong>Os engenheiros são os clientes principais do time de plataforma</strong>.</li><li>O time de produtos precisa poder participar ativamente das decisões e das coisas que estão sendo construídas pelos times de plataforma. As prioridades devem ser de acordo com as dores da empresa e dos engenheiros. E por fim os próprios engenheiros podem entregar códigos para serviços comuns e bibliotecas comuns.</li></ul><p>Acredito que mais detalhes pode ser encontrado nesses artigo sobre <a href="https://martinfowler.com/articles/talk-about-platforms.html">times de plataforma</a>.</p><p>Se você chegou até aqui deve ter percebido que eu não tenho nada contra o trabalho de <strong>arquitetura de software</strong>, na verdade acredito que ele seja muito importante, principalmente quando alinhado com os objetivos de negócio e produto.</p><p>O verdadeiro problema não está no título <strong>arquiteto de software</strong>, e sim no modelo de trabalho que foi construindo nas empresas. Apesar de eu pessoalmente não gostar do título arquiteto de software, se pra você esse título não representa o modelo que eu descrevi, acredito que não exista grandes problemas.</p><p>E espero que com minha opinião você possa buscar empresas que valorizam o trabalho colaborativo em vez do<strong> modelo de arquitetura de software</strong> em silos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fbb503b155ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Primeiros passos utilizando Datomic]]></title>
            <link>https://cesar-alcancio.medium.com/primeiros-passos-utilizando-datomic-b9c5252731d?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/b9c5252731d</guid>
            <category><![CDATA[programacao-funcional]]></category>
            <category><![CDATA[immutability]]></category>
            <category><![CDATA[datomic]]></category>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[clojure]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Sun, 12 Sep 2021 17:35:53 GMT</pubDate>
            <atom:updated>2021-09-12T23:02:45.767Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VZaGbd3LfD9oCIRt" /></figure><p>O <a href="https://www.datomic.com/on-prem.html">Datomic</a> é um banco de dados transacional, distribuído e um pouco diferente dos bancos de dados relacionais e não relacionais tradicionais, por exemplo: MySQL e MongoDB.</p><p>A ideia desse artigo é introduzir alguns <strong>conceitos básicos</strong> do Datomic e um exemplo de como funciona as <strong>operações simples</strong> de escrita e leitura. O exemplo completo <a href="https://github.com/cesaralcancio/movies-datomic">está disponível no meu Github</a>.</p><p>Adicionalmente também apresenta um passo a passo para <strong>preparar o seu ambiente</strong> para testar os primeiros códigos usando Datomic.</p><p>O primeiro passo para entender melhor as diferenças entre Datomic e os outros banco de dados é entender como o Datomic armazena os dados.</p><h3>Como o Datomic armazena os dados?</h3><p>O <a href="https://docs.datomic.com/cloud/whatis/data-model.html">Datomic armazena</a> os dados como um grande <strong>conjunto de fatos</strong>, como se fosse uma <strong>única e enorme tabela</strong> no banco de dados. Esses fatos são chamados de <strong>datoms</strong>.</p><p>Os <strong>datoms</strong> são dados <strong>imutáveis</strong> e <strong>atômicos</strong> que representam as informações <strong>adicionadas</strong> e <strong>retraídas</strong> <em>(removidas)</em><strong> </strong>em uma <strong>entidade</strong> na base de dados. Imutável porque uma vez inserida na base de dados <strong>não é possível modificar</strong> seu valor; e atômico porque <strong>não se pode adicionar parcialmente </strong>a informação de um datom.</p><p>Um <strong>datom</strong> é composto por: id da entidade, atributo, valor, id da transação e um indicador se o <strong>datom</strong> foi adicionado ou retraído.</p><p>Vamos analisar um exemplo, vamos supor que temos um banco de dados que armazena um <strong>conjunto de filmes</strong>, esse banco de dados se chama <strong><em>movies</em></strong>.</p><p>Nesse banco de dados queremos armazenar o <strong>título</strong> do filme, <strong>gênero</strong>, <strong>ano de lançamento</strong>. Também é interessante armazenar um <strong>identificador único</strong> para o filme e <strong>quando o registro foi criado</strong>.</p><p>Após registrar o filme <em>Shutter Island</em> na nossa base de dados, seus datoms podem ser visualizados na seguinte forma.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c20fa09a023972ec9de4b572c665d7e8/href">https://medium.com/media/c20fa09a023972ec9de4b572c665d7e8/href</a></iframe><p>Um grande vetor, onde cada posição é um novo vetor que representa o <strong>datom</strong> com: id da entidade, atributo, valor, id da transação e um booleano para representar se o dato foi adicionado ou retraído.</p><p>Essa informação também pode ser visualizada em formato de tabela, que é mais familiar para quem trabalha com banco de dados relacionais.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a409cdfac8c037dbb02130580b88e68c/href">https://medium.com/media/a409cdfac8c037dbb02130580b88e68c/href</a></iframe><p>Agora que sabemos como uma entidade e seus datoms são armazenados no Datomic vamos ver como definir um <em>schema</em>.</p><h3>Definir o schema do banco de dados</h3><p>O <em>schema</em> basicamente informa ao datomic a estrutura dos dados: quais serão os atributos armazenados e seus respectivos tipos de dado. Esse processo é parecido com a criação de tabelas e suas colunas em um banco de dados relacional. No nosso exemplo os atributos do filme são: <em>movie/id como uuid, movie/title como string, movie/genre como string, movie/release-year como long e movie/created-at como instant</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f959f8623fc72a47c62632615d0f337f/href">https://medium.com/media/f959f8623fc72a47c62632615d0f337f/href</a></iframe><p>Esse código está criando um cliente client para se comunicar com o Datomic dev-local que é uma biblioteca do Datomic para ser usada para testes. Os dados serão armazenados no <em>file system</em> indicado com o atributo :storage-dir .</p><p>Com o cliente é criado um base de dados chamada movies e posteriormente é gerada uma <strong>conexão com essa base de dados</strong>.</p><p>Por fim é realizado a transação que vai adicionar o <em>schema</em> na base de dados para que seja possível adicionar os <strong>datoms</strong> posteriormente. Os dados necessários para definir o schema são:</p><ul><li><strong>db/ident</strong> que representa o nome do atributo</li><li><strong>db/unique</strong> (opcional) apenas caso o valor seja único para a entidade, a entidade é representada pelo namespace movie , por exemplo, movie/id</li><li><strong>db/valueType</strong> que representa o tipo: string, uuid, long and etc</li><li><strong>db/cardinality</strong> que representa se a relação da entidade para este valor é de um ou vários, para este nosso exemplo vamos utilizar sempre um</li><li><strong>db/doc</strong> (opcional) para adicionar alguma documentação ao nosso atributo</li></ul><p>Depois de definir e transacionar o schema podemos fazer algumas operações básicas para ler e registrar um filme.</p><h3>Adicionar, consultar e retrair datoms</h3><p>Para adicionar os datoms que representam o filme vamos importar o namespace <strong>datomic.client.api </strong>e utilizar a função <strong>transact</strong> enviando a <strong>conexão</strong> com o datomic e um <strong>mapa com os dados da transação</strong>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e69a6dfcf915870d637234d8587e6d2d/href">https://medium.com/media/e69a6dfcf915870d637234d8587e6d2d/href</a></iframe><p>Os datoms são enviados em um vector:</p><ul><li>A primeira posição representa a operação, nesse caso<strong> :db/add </strong>para adicionar o datom</li><li>A segunda posição é o <strong>id temporário da entidade</strong>. Nesse caso colocamos todos iguais para que o datomic saiba que todos esses atributos fazem referencia a apenas uma entidade, ou seja, <strong>o mesmo filme</strong></li><li>A terceira posição é o atributo, por exemplo, <strong>:movie/title</strong></li><li>A quarta posição é o <strong>valor do atributo</strong></li></ul><p>Após inserir os datom que representam um filme podemos executar uma consulta no Datomic para trazer todos os datoms que representam os filmes.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/86913e7978068f18e087977553eabc70/href">https://medium.com/media/86913e7978068f18e087977553eabc70/href</a></iframe><p>Para a consulta, o Datomic vai <strong>percorrer todos os datoms adicionados </strong>e vai aplicar as cláusulas <em>where</em> para <strong>cada datom</strong>, no nosso caso são cinco cláusulas where.</p><p>Vamos entender o primeiro vetor <strong><em>[?e :movie/id ?id].</em></strong> Essa clausula indica que o Datomic vai trazer todos os datoms onde a primeira posição seja <em>qualquer coisa</em>, a segunda posição seja <em>:movie/id</em> e a terceira posição <em>seja qualquer coisa</em>. Os valores que começam com <em>?</em> indicam que o Datomic vai trazer qualquer valor e atribuir este valor ao símbolo para que ele seja usado posteriormente, tanto no <em>:find</em> quanto nas seguintes clausulas <em>:where</em>.</p><p>Por exemplo, após inserir o filme Harry Potter, os datoms armazenados no Datomic serão:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1a66cfa0443889b0e1ff875bde1646a8/href">https://medium.com/media/1a66cfa0443889b0e1ff875bde1646a8/href</a></iframe><p>Esses datoms são percorridos com a clausula <em>[?e :movie/id ?id]</em>, o único datom que atende a essa clausula é o primeiro, consequentemente o valor <strong>92358976733262</strong> será atribuído ao <strong>?e</strong> e o valor <strong><em>#uuid”3dea1d1d-9fc7–4ba8-a6fd-f5e1284e3084&quot;</em></strong> será atribuído ao <strong>?id</strong>.</p><p>O <strong>?e</strong> vai ser utilizado no próximo where [?e :movie/title ?title] para que seja consumido o título da mesma entidade do movie/id e assim por diante para as próximas clausulas <em>where</em>. O <strong>?id</strong> vai ser utilizado na clausula <strong>:find</strong>, que indica os campos que serão retornados pela consulta.</p><p>A clausula <strong>:key</strong> permite que seja especificado qual é o nome de cada campo que será retornado, para que os dados possam ser retornados em um formato de mapa em vez do formato tradicional dos datoms, nesse o valor retornado será.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c0010b7729568b86b1c29394ecd4013b/href">https://medium.com/media/c0010b7729568b86b1c29394ecd4013b/href</a></iframe><p>Finalmente podemos retrair os datoms para <em>“eliminar”</em> o filme. Lembrando que o Datomic é imutável portanto o filme sempre estará armazenado, entretanto os datoms estarão indicados como <strong>false</strong>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/23644923b358be6fadeac711c47dae76/href">https://medium.com/media/23644923b358be6fadeac711c47dae76/href</a></iframe><p>Retrair os <strong>datoms</strong> é muito parecido com adicionar os <strong>datoms</strong>, a diferença está no<strong> :db/retract</strong> em vez de <strong>:db/add</strong> e no lugar do <strong>id temporário da entidade</strong> temos que passar realmente o <strong>id da entidade</strong>. Como não temos o id da entidade mas temos o identificador único do filme, nesse caso podemos passar o vetor <strong>[:movie/id id]</strong> para que o Datomic internamente busque o id da entidade com base no id do filme e retraia os datoms.</p><p>Depois que os datoms são retraídos e executamos a consulta, os datoms <strong>não</strong> serão retornados pois a consulta retorna apenas os datoms que estão com valores <strong>true</strong>. Isso não significa que os dados foram removidos do <em>file system</em>, existem outras consultas mais avançadas no Datomic que possibilitam que dados retraídos possam ser consultados, ou até mesmo fazer consulta em outro ponto específico do tempo.</p><p>E como podemos atualizar um filme? Nesse caso o que fazemos é adicionar os novos datoms e automaticamente o Datomic vai identificar se a entidade que estamos inserindo é um id já existente (isso de acordo com o :movie/id que quando criamos o schema colocamos como único), e para este caso vai <strong>retrair o datom antigo e adicionar o datom novo</strong>, mantendo o histórico dos dados.</p><h3>Conclusão</h3><p>O Datomic é uma base de dados um pouco diferente das base de dados tradicionais, sua principal vantagem é manter todo o histórico da base de dados já que os dados uma vez inseridos nunca são removidos.</p><p>Acredito que conhecer como é exatamente um datom e como esses datoms são armazenados no Datomic é a parte mais importante para que seja possível entender as queries e como adicionar e retrair datoms.</p><p>Esse artigo foi apenas uma breve introdução ao Datomic, existe muito mais features que podem ser encontradas na <a href="https://docs.datomic.com/cloud/index.html">documentação oficial</a>.</p><h3>Preparando o ambiente</h3><p>Para preparar o ambiente é preciso instalar as seguintes ferramentas:</p><ul><li><strong>Maven</strong>: <a href="https://maven.apache.org/">https://maven.apache.org/</a></li><li><strong>Clojure</strong>: <a href="https://clojure.org/guides/getting_started">https://clojure.org/guides/getting_started</a></li><li><strong>Leiningen</strong>: <a href="https://leiningen.org/">https://leiningen.org/</a></li><li><strong>IDEA</strong> que vou utilizar é <strong>IntelliJ Community</strong>: <a href="https://www.jetbrains.com/idea/download/">https://www.jetbrains.com/idea/download/</a></li><li>Plugin do IntelliJ <strong>Cursive</strong>: <a href="https://plugins.jetbrains.com/plugin/8090-cursive">https://plugins.jetbrains.com/plugin/8090-cursive</a> ou você pode ir em “Preferencias” / “Plugins” e encontrar este plugin direto noIntelliJ</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/970/1*ThVsoa-gSypNnORcBVcq6A.png" /><figcaption>Plugin do Cursive no IntelliJ</figcaption></figure><p>O <a href="https://www.datomic.com/">Datomic</a> possui uma versão lightweight chamada <a href="https://docs.datomic.com/cloud/dev-local.html">dev-local</a> que é muito boa para <em>continuous integration</em> e também para testes locais. Nesse nosso pequeno exemplo vamos utilizar esta versão. Você vai precisar preencher <a href="https://cognitect.com/dev-tools">este formulário</a> com o teu email para receber <strong>duas instruções</strong> por e-mail:</p><ul><li>Um zip com um executável chamado <strong>install</strong> que vai instalar a dependência no seu maven local</li><li>Um link para configurar o seu maven settings xml</li></ul><p>Você só precisa fazer <strong>um dos dois</strong>, no meu caso eu fiz o primeiro que considerei mais fácil, apenas instalei a dependência no meu maven local.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/1*F2gcuHAXuJ4zqfpXheyFZw.png" /><figcaption>Formulário para receber o dev-tools</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/1*7YAi_geSGVSB7rVqR94JNA.png" /><figcaption>E-mail com o dev-tools</figcaption></figure><p>Depois de clicar no link para baixar o <strong>dev-tools</strong>, basta executar o arquivo “<strong>install</strong>” para poder utilizar o dev-local como dependência do seu projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/295/1*oiewYd4PD3azzMbyUSX2dA.png" /><figcaption>Install maven</figcaption></figure><h4>Criando o projeto</h4><p>Utilizamos o leiningen para criar o projeto, podemos utilizar ele por linha de comando: <em>$ lein new app project-name</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/956/1*3m1ag53Zp0URw9n4R-jDyA.png" /><figcaption>Criando o primeiro projeto Leiningen</figcaption></figure><p>Ou podemos utilizar o IntelliJ em “File” -&gt; “New Project” e selecionar “Clojure” -&gt; “Leiningen”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/879/1*aVwBeflDsYgkQyXJDNhwwg.png" /></figure><h4>Adicionando dependência</h4><p>Uma vez que o projeto foi criado, basta adicionar a dependência <strong>dev-local</strong> ao project.clj. No meu caso foi adicionado como <strong>[com.datomic/dev-local “0.9.235”]</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*yAeA98AvAoDuOMz0PgheNQ.png" /><figcaption>Adicionado a dependência do dev-local</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9c5252731d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como funcionam as macros em Clojure]]></title>
            <link>https://cesar-alcancio.medium.com/como-funcionam-as-macros-em-clojure-71e919359807?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/71e919359807</guid>
            <category><![CDATA[linguagem-funcional]]></category>
            <category><![CDATA[macro]]></category>
            <category><![CDATA[clojure]]></category>
            <category><![CDATA[caracteres-estranhos]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Mon, 23 Aug 2021 00:30:54 GMT</pubDate>
            <atom:updated>2021-09-02T17:13:14.662Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9ScfVvm9uNOlVYtwqe9cPw.png" /></figure><p>Se você já escreveu algum código em Clojure provavelmente você já se deparou com as famosas <em>macros</em>, que é definida utilizando a função <em>defmacro</em> e muitas vezes possui caracteres diferentes como <strong>apóstrofos (‘), acento grave (`), til (~), sinal tironiano ou <em>e</em> comercial (&amp;), arroba (@) e cerquilha (#)</strong>. Nesse texto você vai entender, de forma bem <strong>simples e direta</strong>, o que é uma <strong>macro</strong> e o que significa esses <strong>caracteres estranhos</strong>.</p><p>Segundo o site oficial do Clojure, uma <a href="https://clojure.org/reference/macros">macro</a> é um sistema que permite <strong>estender o compilador com código Clojure</strong>, e cita o exemplo do <em>when</em>, que é uma macro composta pelas <a href="https://clojure.org/reference/special_forms#if">formas especiais</a> <em>if</em> e <em>do</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*bkljT9qsCOG7bGa2FVHiWg.png" /><figcaption>No final do texto vamos entender cada código dessa macro.</figcaption></figure><h3><strong>Por que não uma função em vez de uma macro?</strong></h3><p>Mas o que é estender o compilador exatamente e porque o <em>when</em> é uma macro e não uma função? Vamos tentar criar uma função que faça o mesmo que o <em>when</em>. Essa função vai se chamar <em>when-fn</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/292/1*SSUi5rpchlc8Umu_2eDqTQ.png" /><figcaption>Função when-fn</figcaption></figure><p>Quando executamos a macro <em>when</em> e a função <em>when-fn</em>, validando se um número é positivo, vamos ter o mesmo comportamento:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/452/1*Cn7Fz8npSjixMbem3t4_9g.png" /><figcaption>A função funciona como a macro!</figcaption></figure><p>Reparem que a macro e a função têm o mesmo retorno para os dois cenários, positivo e negativo, mas o que acontece se enviamos um bloco de código que deve ser executado <strong>apenas</strong> se o número é positivo ou <strong>apenas</strong> se o número é negativo?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/592/1*T2Hz0RidUQn8AMAryzndQA.png" /><figcaption>A função não funciona como a macro!</figcaption></figure><p>Diferente da macro <em>when</em>, na função <em>when-fn</em> o <em>println</em> <strong>é sempre executado independente</strong> se o número é positivo ou negativo! Ou seja, não é possível estender o código criando a função <em>when-fn</em>, precisamos da <em>defmacro</em>. Isso porque as funções recebem o <strong>resultado de outras funções executadas</strong> enquanto a macro é capaz de receber os argumentos como <strong>lista</strong>, <strong>manipulá-los</strong> e <strong>executá-los</strong> ou <strong>deixar de executá-los</strong> (<em>você vai entender mais adiante)</em><strong> </strong>além disso, as macros não retornam diretamente o resultado da operação, elas retornam listas (<em>ou </em><strong><em>expandem</em></strong><em> para listas) </em>porque a lista é como o Clojure reconhece suas funções, que vão ser posteriormente executadas.</p><h3><strong>Como funcionam as macros?</strong></h3><blockquote>Macros recebem argumentos como lista e permitem que essa lista seja manipulada</blockquote><blockquote>Macros retornam listas manipuladas, esse é o processo de expansão, e posteriormente as listas serão executadas como uma função</blockquote><p>Por exemplo, vamos supor que queremos criar nosso próprio <em>when-print</em> que escreve <em>“Hello”</em> antes de executar o <em>bloco de código</em> desejado. Nossa macro deve retornar uma lista parecida com o código abaixo que será posteriormente executado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/0*VrwkTJqbaFG1nHUO" /></figure><p>No lugar de <em>&lt;condicao&gt;</em> e <em>&lt;bloco-de-codigo&gt;</em> deve ser o código que foi enviado no momento em que macro foi invocada. Para isso podemos construir a macro <em>when-print </em>da seguinte maneira<em>.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/779/0*w1HyHKuXi7Pu_pt_" /></figure><p>Utilizando essa macro com a mesma condicional do número positivo é possível ver o <em>“Hello!”</em> escrito na tela antes de retornar a string <em>“positivo”</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/457/1*wjGUjJTnLpJO37LuOb2JZA.png" /></figure><p>Antes de nos aprofundarmos no código da <em>macro</em>, utilizando a função <em>macroexpand</em> é possível analisar a lista que será retornada pela nossa macro antes da sua execução.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/0*kx4YWDg6hukEfl_5" /></figure><p>A macro retorna uma lista como planejamos, onde a primeira posição é um if, a segunda posição é uma lista com a condicional que foi enviada, a terceira posição é uma nova lista que contém: <em>do</em>, uma lista com o <em>println</em> e uma <em>string</em> “<em>positive”</em>.</p><p>Para entender melhor como a macro retornou esse resultado, precisamos entender o que significa o <em>apóstrofo</em> (‘) antes dos símbolos <em>if, do </em>e <em>println</em> na declaração da macro.</p><h3>Símbolo, valores e quote</h3><p>O <em>apóstrofo</em> (‘) também conhecido como <a href="https://clojure.org/guides/weird_characters#_quote">quote</a> é a mesma coisa que utilizar a própria função <em>quote</em> em Clojure, ou seja, essa função permite que quando o símbolo seja executado retorne o próprio símbolo em vez de retornar seu valor, por exemplo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/269/0*j0fXEaAIECUC6oBj" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/205/0*HnXgBiE_4xE2MM9k" /></figure><p>Aqui definimos um símbolo com o valor de uma <strong><em>string</em></strong> <em>“Cesar”</em>, esse símbolo quando executado retorna o valor <em>“Cesar”</em>, porém se queremos retornar o próprio símbolo <strong><em>nome</em></strong> podemos utilizar a função <strong><em>quote</em></strong> ou simplesmente adicionar um apóstrofo antes da palavra para deixar o código menos verboso.</p><p>Dessa forma fica mais fácil entender como o código a seguir.</p><blockquote>​​(list ‘if test (list ‘do (list ‘println “Hello!”) body))</blockquote><p>Se transforma neste código.</p><blockquote>(if (pos? 1) (do (println “Hello!”) “positive”))</blockquote><p>Como isso funciona? A função <em>list</em> permite que os parênteses não sejam executado como uma função, e que em vez disso seja retornada uma lista.</p><p>Os símbolos <em>if</em>, <em>do</em> e <em>println</em> <strong>não</strong> são “avaliados” no momento em que a macro é expandida, os símbolos <em>test</em> e <em>body</em> <strong>são</strong> “avaliados” de acordo com seu valor, se transformando em <em>(pos? 1)</em> e <em>“positive”</em> respectivamente.</p><p>Também podemos notar que a função list retorna apenas os parênteses, ou seja, aparentemente é o mesmo que utilizar a função <em>quote</em> ou simplesmente o um <em>apóstrofo</em>, por exemplo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/240/0*MEkr-B0MRahzaE2K" /></figure><p>Porque não utilizamos <em>apóstrofo</em> em vez da função <em>list</em>? A resposta é porque o <em>quote</em> mantém <strong>todos</strong> os valores da lista como <strong>símbolo</strong> e não é possível acessar o seu <strong>valor</strong> como fazemos para o <em>test</em> e <em>body</em> no exemplo, veja:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*teH5kWuf7HJHRdR2" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/635/0*BTHVVDhHTTNzUlHQ" /></figure><p>Nesse caso <em>test</em> e <em>body</em> não se transformaram em <em>(pos? 1)</em> e <em>“positive”</em>. E é aí que entra o acento <em>grave</em> (`) e o <em>til</em> (~).</p><h4>Acento grave e til</h4><p>Se utilizamos o acento grave no lugar do apóstrofo e combinamos ele com o til antes dos símbolos que queremos extrair o respectivo valor, pode ser escrita dessa forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/0*eKozoQqilsjf89Lb" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/881/0*fxcsRIMfN5oUxJIT" /></figure><p>Além de permitir esse comportamento o acento grave também utiliza o <em>namespace</em> completo das funções enquanto o apóstrofo apenas o nome da função:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/340/0*nzKdYyVK7MLBSMu8" /></figure><h4>Arroba e sinal tironiano ou e comercial</h4><p>Mas onde entra o o <em>arroba</em> (@) nesse monte de caracteres? Para isso vamos utilizar o sinal tironiano (&amp;) que, usado no vetor de argumentos, agrupa todos os últimos argumentos em uma lista, por exemplo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/406/1*s_CR8qpJEK3a5QqNMpO65A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/478/1*VnRXFP65exS_8lVF00VJ0Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/0*9-oF6ejiqp00S3BL" /></figure><p>Se aplicamos esse conceito para a nossa macro, ela ficaria dessa forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/619/1*Ww8Zcb2wbisroctmRXWuUw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ESLj3WSOrXgIii6kqAVITA.png" /></figure><p>Repare que a macro expandida retorna uma lista de <em>println</em> dentro da função <em>do</em>, isso vai falhar porque o <strong>((println “it’s”) (println “positive”))</strong> vai ser transformado em <strong>(nil nil)</strong>, que quando for executado irá gerar o famoso <em>NullPointerException</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lR85bfyi5J3du1vLusRJew.png" /></figure><p>O correto seria extrair os dois <em>println</em> da lista e deixá-los diretamente dentro da função <em>do, </em>transformando <strong>((println “it’s”) (println “positive”)) em (println “it’s) (println “positive”)</strong>.</p><p>Para isso podemos utilizar o arroba antes do símbolo <em>body</em>, ficando <strong><em>~@body</em></strong>, o <em>til</em> para extrair o valor e o <em>arroba</em> para removê-los de dentro da lista.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/0*XzpHbPl4XxQVzIFd" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WvsaX_JU2AV3aljl" /></figure><h4>Cerquilha</h4><p>Agora o comando que precisamos entender dentro de uma <em>macro</em> é o cerquilha (#). Vamos supor que queremos mudar um pouco nossa <em>macro</em> para usar um <em>let</em> para armazenar a <em>string</em> <em>“Hello”</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/0*ESCqzFVJPdLXD2W0" /></figure><p>Se tentamos executar a macro ou expandir a macro vamos receber um erro:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xn82w91Pohdx-jyakBABrA.png" /></figure><p>Isso acontece porque a macro tenta prevenir que o desenvolvedor utilize símbolos que já foram definidos antes e força o desenvolvedor a definir símbolos aleatórios com a função <em>gensym</em>, vamos testar ela.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/288/0*F4h9b4coFNng91v6" /></figure><p>Apenas com essa função a <em>macro</em> pode assegurar que o símbolo que está sendo criado na <em>macro</em> é aleatório e não foi definido antes. Atualizando a nossa macro com o <em>gensym</em> ficaria:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/830/0*pDoj9cyRtVxRX7Lm" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*z6jFUIuNLxvTjyY9" /></figure><p>Nesse caso, tivemos que adicionar um <em>let</em> fora da nossa lista de retorno (fora do acento grave), que vai ser executado no momento que a macro for expandida. Vai criar o nosso símbolo <em>“hello-str20026”</em> e utilizá-lo posteriormente. E é aí que a cerquilha ajuda, podemos evitar a utilização da função <em>gensym</em> dentro da macro e substituir pela cerquilha nos símbolos em que queremos que sejam gerados aleatoriamente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/776/0*avqRRObJhzMFCbnS" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HBzjnpKHlg27QEB8" /></figure><p>Dessa forma o símbolo <em>generated-symbol</em> é gerado automaticamente e podemos aproveitá-lo posteriormente na macro.</p><h3><strong>Conclusão</strong></h3><ul><li>Os retornos das funções não são enviadas a macro como em uma função normal, em vez disso são enviados como listas</li><li>As macros podem manipular essa lista e retornar uma nova lista que será executada como uma função posteriormente</li><li>A expansão da macro é o processo que transforma o código da macro em uma lista para ser executada posteriormente</li><li>O apóstrofo (‘) é o mesmo que a função quote, que permite retornar o símbolo em vez do seu valor ou permite a criação de listas se usado antes dos parênteses</li><li>O acento grave (`) funciona como o apóstrofo porém permite ser utilizado em combinação com o til (~) para os casos que queremos retornar o valor e não o símbolo</li><li>O sinal tironiano (&amp;) permite que uma função ou macro receba todos os últimos argumentos dentro de uma lista</li><li>O arroba (@) dentro de uma macro permite extrair o conteúdo de uma lista, por exemplo, transformar (:a :b :c) em :a :b :c</li><li>O cerquilha (#) dentro de uma macro permite criar símbolos aleatoriamente</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71e919359807" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to avoid Big Bang Deployment]]></title>
            <link>https://cesar-alcancio.medium.com/how-to-avoid-big-bang-deployment-4dc901f2c1ca?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/4dc901f2c1ca</guid>
            <category><![CDATA[software-engineer]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[step-wise-deployment]]></category>
            <category><![CDATA[big-bang-deployment]]></category>
            <category><![CDATA[incremental-deployment]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Mon, 04 Jan 2021 18:17:50 GMT</pubDate>
            <atom:updated>2021-01-14T23:28:08.046Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/839/0*G-CqumMA4WPMPUGB.jpg" /></figure><p>Have you ever forgotten a DDL script to be applied in the production environment before your service deployment and the service deployment failed?</p><p>Have you ever done a deployment that didn’t work and you had to rollback and it was easier to fix the problem than to rollback the deployment?</p><p>Have you ever be afraid of deploying a list of new services into the production environment because it was too much change?</p><p>If any of the answers is <strong><em>yes</em></strong>, you probably did a <strong>Big Bang Deployment</strong>.</p><h4>Facing the problem</h4><p>When I was in one of my first companies, we usually deploy new features at night to decrease the risk of unavailability to our customers. One day, after a new feature deployment, everything suddenly stopped working.</p><p>Thereafter, we started to troubleshoot the problem but we couldn’t figure out what was happening, it was just like everything was not working correctly, even services that we didn’t touch. A few minutes went by and we decided to rollback that feature. After the rollback everything still didn’t work.</p><p>Finally, we restarted the Application Server and everything came back to normal. We didn’t understand what happened. We ended up that night without our feature, stressed, and with a considerable unavailability time.</p><p>On the next day, we figured out that the order that we deployed the services was incorrect, it crashed a critical service and it cascades the problem to the others. That night we tried to deliver a couple of services such as backend, frontend, database, enterprise service bus &amp; orchestration. If it was not deployed in the right order it will not work.</p><p>Why did we let it go to that point?</p><h4>The natural behavior</h4><p>The big bang deployment is the natural process of developing a new feature, it is something like:</p><ul><li>We discuss a new feature to be developed with the product manager, business people, and other software engineers</li><li>We identify the services and/or applications we need to change</li><li>We identify the tests we need to do to make sure everything will work fine</li><li>We implement all the components and services we need to change</li><li>We do end to end tests to make sure everything is good</li><li>We deploy it as it is needed</li></ul><p>It looks simple and it usually works for some of the features that we need to implement. The problem only happens when the feature is not <strong>isolated and it needs several changes</strong> like frontend, backend, database, and other services or components.</p><p>Now stop and think about the last features you just did last week and how many were isolated?</p><p>Almost every feature needs more than one component to change and this natural process brings a lot of problems to those features and their deployment process.</p><h4>The big bang deployment problems</h4><p>There are some problems with the previous simple workflow.</p><ul><li><strong>It assumes all bugs will be caught in the development and test step</strong>. Have you ever delivered any tested feature and when you validated it in the production environment you found a new bug? I hope you usually validate your features and I’m sure you found a new bug someday in your career.</li><li><strong>It increases the complexity and coordinator effort.</strong> Changes are dependent on each other. Most of the developers that I know don’t like to coordinate things with other people, therefore this coordination effort is neglected, causing problems like we just saw related to the order of the deployment.</li><li><strong>It takes a long time to test and a long time to receive feedback from peers.</strong> If we code the whole feature before sending the PR or testing it, there will be some issues that we could have fixed early and it will probably generate bugs and rework. Inefficiency.</li><li><strong>Normally they are large pull requests.</strong> Again, if we code the whole feature how many lines do you think your team member will need to review and how long is it gonna take? Don’t be the guy that sends a <em>pull request</em> with hundreds of lines and asks it to be done as fast as possible.</li><li><strong>It has unavailability due to steps deployments and incompatibility of the previous version.</strong> Here is the main point, incompatibility is what causes the issues, if we do everything at once we usually neglect the compatibility of the <strong>individual parts</strong> what causes the necessity to deploy everything at once.</li></ul><p>Most of the engineers like to focus on coding and they are not trained to avoid risks, that’s why the natural process is the big bang deployment.</p><blockquote>After all, avoiding big bang deployment is all about avoiding risks.</blockquote><p>Depending on the criticality of your system, if it is not critical, there is a high chance that you do big bang deployment over and over again and everything works fine. So why do you would rather avoid big bang deployment?</p><p>If you want to avoid the risk of being unavailable or you want to remove the coordinator effort to deploy new features I would recommend you to avoid big-bang deployment. Otherwise, you can continue to work that way.</p><h4>Stepwise deployment or incremental deployment</h4><p>I will call stepwise deployment the opposite of the big bang deployment and I will describe some techniques that can help those who would rather apply the stepwise deployment.</p><h4><strong>Have a vision of the whole feature before start any code.</strong></h4><p>To remove the temptation to start coding after discussing and identifying the services and components to change, separate a time to imagine the whole feature, think about the communication between the services, and ask yourself some questions.</p><ul><li>What if some component became unavailable what will happen to other components?</li><li>Is there another service or component that relies on one of those components that we will change?</li><li>Is it possible to versioning those changes to deliver them independently?</li></ul><p>It will help you plan the changes before starting it.</p><h4><strong>Slice it into small pieces</strong></h4><p>Sometimes an individual component will have more than a function, method or API to change, try to separate those tasks to think about them independently. Check if you can make those changes independently of the whole feature.</p><p>For example, recently in one of our payment products, we are considering creating a feature that will allow customers to pay more than one time per day. For some reason, it wasn&#39;t allowed before. This is a huge change and it covers several components and services.</p><p>To enable it we had to change the database table to support more than one payment record per day, we isolated that task and did it independently. We had to create new fields that will be temporarily <strong><em>null</em></strong> and when the whole feature is done we will change it to <strong><em>not null</em></strong>.</p><blockquote>Sometimes we will have an “inconsistent” state for our service or component and it will look weird, but it is better than assuming the risk of making changes tied to each other.</blockquote><h4><strong>Your deployment is not your release</strong></h4><p>Slightly different but a very important one.</p><p>The <strong>deployment</strong> is the acting of delivering new code, it can sometimes be unavailable to the costumers or to the components that will use it in the future, like the new column we added in the last example.</p><p>The <strong>release</strong> is the acting of let new features available to costumers. Sometimes it doesn’t include deployments.</p><p>That’s why I don’t like product managers or engineer managers approvals for the deployment of new code, sometimes it is still not a completely new feature, it is just code that will enable new features.</p><p>Use feature flags like <a href="https://launchdarkly.com/">Launch Darkly</a> to toggle on/off new features to the customers. Or just use properties or databases to enable features to customers. Separate deployment of releases.</p><h4>Use parallel change to do incremental code</h4><p>Parallel change works for every size of the code you are changing. If you are going to change an API to have a new required field, do the following steps.</p><ul><li>Add this new field as an optional one</li><li>Change the client components that use this API</li><li>Change the field to required in the API</li></ul><p>Each step should be done independently and it should be delivered to the production environment independently, you <strong>can do it even if you have just one client component using this API</strong>. Why not? We usually change the client component and the API together and it brings us all the problems we mentioned before.</p><p>If the API is public and you don’t have the control you can create another version of the API and ask your clients to switch to this new version with a pre-defined deadline.</p><p>I know most of the engineers know that, but I’ve seen a lot of engineers just changing both client component and services anyway, as I said sometimes you think it isn’t worth avoiding the risks. That’s ok, I personally prefer to avoid those risks.</p><h4><strong>Smaller changes</strong></h4><p>Type of logic can be applied also to smaller changes, for example, if you need to change a method to add a new required field you can just overload that method, a lot of languages support it. Given that example in Java.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_iOqGAHNawieYRZa" /></figure><p>If we want to change the parameters of the method <strong>sendMessage</strong> from the <em>author</em>, <em>message,</em> and <em>datetime</em> to a better object we can just add a new method instead of changing this one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5vDa3v1v9roGOlmU0GIDyA.png" /></figure><p>After deploying it in the production environment we can change all the clients of this method, and finally, we can remove the old one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zmZl7Z7hHejrWEjr69nBQg.png" /></figure><p>If you are in a more <em>agile</em> company, I strongly recommend you to do it. It will help you to think more about incremental changes.</p><h4>Conclusion</h4><p>Those techniques are not everything you need to know about stepwise or incremental deployment. But I hope you can start to think about how to deliver code independently and what risks are you taking when you decide to move on with big bang deployment.</p><p>The key point is creating code that can go to the production environment whenever you want.</p><p>When you are coding your next feature, before commit and push your changes to the main branch, ask yourself if that change can go directly to prod without side effects. If the answer is yes, there is a high chance that this commit is independent and you are in the right direction.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4dc901f2c1ca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Product and technology books to read 2021]]></title>
            <link>https://cesar-alcancio.medium.com/product-and-technology-books-to-read-2021-102758807f45?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/102758807f45</guid>
            <category><![CDATA[technology-and-design]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[manager]]></category>
            <category><![CDATA[books]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Sun, 20 Dec 2020 12:25:13 GMT</pubDate>
            <atom:updated>2020-12-20T14:49:12.474Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*e2I4V_7FqcbUbZEL.jpg" /><figcaption>Books</figcaption></figure><p>For the last few years, I’ve been challenging myself to improve my reading habit, the only rule that I follow is to read my little books every single day, it has been working and I’m really enjoying spending my free time watching movies, walking my dogs and also reading.</p><p>I’ve been through some books this year, some of them are about Product &amp; Technology and they helped me a lot in terms of understanding new areas, how some important people mindset works, technologies, strategies, and businesses.</p><p>I would like to recommend those books and share my opinions and my perceptions of each of them.</p><h4>Blitzscaling: The Lightning-Fast Path to Building Massively Valuable Companies</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*HQoHBk6t584_FI1js4btwg.png" /><figcaption>Blitzcalling Kindle Book</figcaption></figure><p>The first book of this series is maybe the most controversial one, the book Blitzcalling by Chris Yeh and Reid Hoffman is all about <strong>prioritizing speed over efficiency</strong>, of course, this mindset applies to startups companies that need to grow fast but it also applies to a new product or new vertical area in a well-established company.</p><p>The authors talk about several examples in AirBnB, Amazon, Facebook, Zara, and other innovative companies that sometimes led to manual work or inefficient processes in order to increase the market share and establish themselves as the first company to offer their product and services. It is about taking risks to grow or simply die.</p><p>It is controversial because many times the authors say about hiring people that are not prepared yet, launching products that still suck, scale the product until the operation didn’t support it anymore only then to start to organize operations to tackle it. It is to do <em>everything</em> in the name of <strong>speed</strong>.</p><p>Besides the controversial side, it has a lot of relevant facts about the world economy, business, culture, and companies gain &amp; loss money. It is worth reading.</p><p>By the way, we can say this book is the opposite of the third on this list: <em>Think Like Amazon.</em></p><h4>The Manager’s Path: A Guide for Tech Leaders Navigating Growth and Change</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*uhh1rem6257kIXDILUDtFw.png" /><figcaption>The Manager’s Path Kindle Book</figcaption></figure><p>This book by Camille Fournier, as the name suggests, is a guide to help technical leaders, engineers, or engineer managers to understand how the coder’s career ladder works and what is expected from them as managed or manager.</p><p>The book is divided into two parts: <strong>how to be managed </strong>and<strong> how to manage.</strong></p><p>It was exciting because at the first time I saw the book I was down to learn about “how to manage” but in the first few chapters about “how to be managed” I came to notice that it is valuable and it might help engineers that sometimes doesn’t take along with their boss or even them who don’t understand what their boss stands for.</p><p>It has a lot of tips to establish and improve the 101 meetings and the process of mentoring inexperienced developers. I liked the tip about trying to keep an alive “agenda” so we can add or remove topics that we want to discuss in further 101 meetings. And the idea for managers who manage other managers to “skip level” and talk directly to engineers, it sounds very good to be heard by a top-level manager periodically.</p><p>There is a chapter only about the challenges to be a tech lead, how to have time to take part in meetings, and plus have time to code and participate in business decisions.</p><p>I recommend this book to every engineer who wants to improve their soft skills, and especially who is willing to be (or understand) a manager, manager’s manager, director, vice president of engineering, and chief technology officer.</p><h4>Think Like Amazon: 50 1/2 Ideas to Become a Digital Leader</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*pIVwpaqSy9Uo4fhkhZMvCA.png" /><figcaption>Think like Amazon Kindle Book</figcaption></figure><p>This book by John Rossman talks about 50 and a half ideas to be Digital Leader, he is an ex-Amazon Executive telling about what a company should do to be digital and how it should be done.</p><p>The book is divided into <strong>Culture, Strategy, Business &amp; Technology and Approach and Execution</strong>, I will separate some ideas that I usually try to apply.</p><p><strong>Get back to day one:</strong> Jeff Bezos says it a lot, there is two types of company, those that are still in day one and the companies that are going to die. Day one means that we are constantly innovating. If your business has become stagnant, admit the situation, and do something.</p><p><strong>Don’t go along to get along:</strong> It is directly related to Amazon Principle 13 “Disagree and Commit”. I love that one because we all have seen so many people doing politics in a corporate environment and we all know how it can destruct a company and its culture.</p><p><strong>Ownership for everyone:</strong> The best part here is that we are responsible for things that are out of our control. We used to say that “our partner is terrible” or something like that, but in the end, it is our responsibility to deal with that problem.</p><p>These and other ideas worth reading this book even if you are not a big decision-maker at your company.</p><h4>INSPIRED: How to Create Tech Products Customers Love (Silicon Valley Product Group)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*_0gDsmwUjmcFDLvDx8Qp_A.png" /><figcaption>Inspired Kindle Book</figcaption></figure><p>First of all, I must be honest that sometimes I hated this book, especially when the author says we can do several discovery processes within a single week (<em>I am struggling to do much fewer tasks haha</em>) and other parts when the author says a lot of discovery techniques without too many details and often so similar to other technique, for me it is a little confusing.</p><p>I’d rather organize things inside “well-defined boxes” therefore it is hard to talk about “creativity” and qualitative measurement. It is stuff like this that is why I do recommend developers and engineers to read and reflect on this book. It is very important to understand the product manager role and activities because we also need to understand the <strong>value</strong> we are delivering, validate <strong>feasibility</strong>, <strong>business</strong> <strong>viability,</strong> and <strong>usability</strong>.</p><p>It is also very important to understand the differences in discovering and execution processes, learn some discover techniques, the why and when to apply each of them, and understand how product team and engineers team are organized in successful companies.</p><p>Just to let you curious I will share two main points I keep with me from this book.</p><p>The <strong>first</strong> one is about finding an alternative to the current way that we do product road maps. The author says that the executive manager wants to make sure of two things while doing traditional roadmaps:</p><ul><li>If we are working on top priorities</li><li>If the business will support the features we are working on</li></ul><p>What new strategy can we have to replace the current product roadmap? The proposal is to use <em>Objective and Key Results</em> (OKR) and <em>high-integrity commitment. </em>Of course, it is not that easy but the book do a lot of recommendations based on the style of the company you are working on.</p><p>The <strong>second</strong> is about the <em>Opportunity Assessment Technique</em> that helps share the key points about something that a team is planning to work on. The idea is to have the following answer and share it across the whole team:</p><ul><li>What business objective is this work intended to address?</li><li>How will you know if you have succeeded?</li><li>What problem will this solve for our customers?</li><li>What type of customer?</li></ul><p>I think those are very good questions before starting any task. I do recommend reading this book especially if you only read books about code.</p><h4>No Rules Rules: Netflix and the Culture of Reinvention</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*ytzmLwCXwzdbfxAeIewzqA.png" /><figcaption>No Rules Rules Kindle Book</figcaption></figure><p>This book was written by Reed Hasting the Netflix CEO is about a completely new way to build Culture in a tech company. The worst thing about reading this book is that probably you will notice that you have been behaving in the opposite direction.</p><p>Most of us, in our company, when something fails we have the tendency to review the failure to create a process in order to minimize the risk to other employees do the same therefore each failure we do is limited by <strong>control</strong>. Of course, it creates a limited environment where innovation will probably not raise.</p><p>How to balance efficiency and innovation? Netflix tries to answer that question prioritizing the innovation, regardless of being necessary to have a large profit and a business where the mistake is acceptable (where the damage is not like killing people) there are innovative ideas to create a better innovation based on <strong>no rules.</strong></p><p>Some of the ideas are:</p><ul><li><strong>Talent density</strong>: If you will not fight for an employee to stay in your team, you probably are decreasing the talent density. <strong>Keep only the best. </strong>It sounds cruel, I think it probably is.</li><li>You need to say what you <strong>really think</strong>, if necessary in front of all others. Sometimes it is the right time to be candid. Always with good intent. Don’t be the Brilliant Jerk.</li><li>Remove policies like vacations, travel, and expense approvals. You don’t control the hours of the day why control days of the year?</li><li>Pay top the market. The interesting here is the incentive for people to know how much the market is paying for their jobs and share with the company so Netflix will adjust the compensation. It really needs a beautiful profit.</li><li>Share everything with everyone on Netflix, people make better decisions with all the information available, including P&amp;L statement.</li><li>Lead with Context, Not Control</li></ul><p>Of course, it is not like a dream, and the culture is based mainly on <strong>Freedom and Responsibility (F&amp;R),</strong> it also shares some bad aspects of having this culture, the employee is gonna try to rip you off sometimes, and you need to deal with that person and avoid applying new control process for others. I have no idea how hard it should be, however treating people like an adult sounds logical and honest.</p><p>I really recommend this book and I am still fascinated.</p><p>I hope you like and share the books you’ve been reading that you loved.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=102758807f45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Principais problemas utilizando Scrum como framework]]></title>
            <link>https://cesar-alcancio.medium.com/principais-problemas-utilizando-scrum-como-framework-1eb6429105aa?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/1eb6429105aa</guid>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[problems]]></category>
            <category><![CDATA[scrum-team]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Wed, 25 Nov 2020 13:43:43 GMT</pubDate>
            <atom:updated>2020-11-26T01:56:32.207Z</atom:updated>
            <content:encoded><![CDATA[<h3>Principais desafios utilizando Scrum como framework</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/0*twUcJyfuNN8rNjjF.jpg" /></figure><p>A maioria das empresas já aceitou o fato de que o modelo em cascata não funciona bem para desenvolvimento de software e na verdade já fizeram bastante esforço para ser mais <strong><em>agile</em></strong>, a maioria delas utiliza o Scrum como principal framework de trabalho.</p><p>O Scrum se popularizou resolvendo os desafios do modelo em cascata, mas agora já estamos trabalhando com Scrum tempo suficiente para saber que ele também possui muitos problemas.</p><p>Este artigo tem objetivo de compartilhar alguns desafios que encontrei aplicando o Scrum, <strong>isso não significa que o Scrum não funciona e nem que não devemos utilizá-lo ou nos basear em sua metodologia.</strong></p><p>A ideia é compartilhar desafios e situações que o Scrum não ajuda e às vezes realmente nem tem a intenção de ajudar.</p><h4><strong>Balanço entre <em>Production Quality</em> e <em>Sprint Timebox</em></strong></h4><p>Normalmente uma equipe Scrum trabalha com sprints pequenas, <strong>de 1 a 2 semanas</strong>, a justificativa é que quanto maior a sprint mais esforço de coordenação e planejamento é exigido, com uma sprint de 3 semanas começa a ficar difícil planejar e manter as coisas <strong>sem mudanças</strong> dentro da sprint.</p><p>Também sabemos que cada <strong><em>user story</em></strong> deve ter um <strong><em>business value</em></strong>, ou seja, um valor para o usuario final, criar um serviço backend <em>normalmente</em> não pode ser considerado uma <strong><em>user story</em></strong> já que essa atividade sozinha não traz valor para o negocio.</p><p>A maioria das <em>user stories</em> são compostas por mudanças no backend, frontend, base de dados, mudanças no código de infraestrutura, as vezes precisa de testes E2E, <em>load tests</em>, as vezes depende de um serviço externo (um parceiro ou um serviço de outra equipe interna), às vezes o desenvolvimento é em um serviço que a equipe não é <em>owner</em>. Podemos dizer que grande parte das <strong><em>user stories</em></strong> tem alguma complexidade técnica.</p><p>Quando falamos de <strong>production-quality</strong> queremos garantir que a funcionalidade tenha: <strong>validação de código estatica, provas unitarias, provas integradas e que seja escalável, tolerante a falhas, de confiança (execute o que ela foi desenhada para executar), de alta performance, segura, deploy com CI/CD e monitoração.</strong></p><p>Além disso, não queremos entregar somente <strong>uma user story por sprint</strong>, queremos entregar <em>algumas</em> e queremos que as <em>user stories</em> sejam entregues em produção, aceitas e com métricas coletadas dentro da sprint. Queremos ver nosso <strong>burndown chart</strong> baixando a cada dia com <em>user stories</em> sendo terminadas a cada 3~4 dias.</p><blockquote>É possível entregar software realmente de qualidade e com real valor de negócio em uma semana?</blockquote><p>Quantas iterações de <strong>micro valores de negócio</strong> realmente precisamos para ter um produto de valor? Como ter uma visão de longo prazo com essa dinâmica?</p><h4><strong>Lidar com as mudanças dentro da sprint</strong></h4><p>Tenho certeza que muitos engenheiros e managers já trabalharam em uma empresa ou time onde a prioridade muda toda semana, todo dia e às vezes mais de uma vez por dia.</p><p>O pior é que às vezes realmente são mudanças simples que deveriam demorar pouco, por exemplo, uma cor de um botão ou um texto. Porém, quando essa mudança vem no meio da sprint ela exige um esforço extra de várias pessoas envolvidas:</p><ul><li>O product manager precisa garantir com os engenheiros que podemos realizar essa alteração fácil dentro da sprint.</li><li>Os engenheiros que estão trabalhando na <em>user story</em> precisam se organizar.</li><li>O product designer UX precisa atualizar a versão de mockups e validar com outros stakeholders.</li><li>O QA precisa saber para quando for validar não se confundir.</li><li>O product manager precisa comunicar áreas de negocio envolvidas: marketing, sales ou finanças etc.</li></ul><p>O trabalho de coordenação <strong>tira o foco</strong> do time na sprint e tira o foco do product manager e product designer que provavelmente estão refinando user stories do próximo sprint.</p><blockquote>A recomendação nesse caso é não permitir mudanças dentro da sprint, mas isso realmente ajuda?</blockquote><p>Saber que estamos construindo algo que já não deveria ser assim desmotiva temporariamente o time, por isso muitos product managers e engenheiros têm a tendência de aceitar essas “pequenas mudanças” e subestimá-las.</p><p>Quando subestimamos é muito provável que vão existir outras atividades que não vão ser terminadas dentro da sprint, os famosos <strong><em>carry-over</em></strong>. Mas como justificar um <em>carry-over</em> com “apenas uma mudança de texto?” E o que acontece com o “welcome changes” no Scrum?</p><h4><strong>Estimar atividades com Story Points</strong></h4><p>Story Points é a metodologia utilizada para estimar atividades dentro da Sprint, seu principal objetivo é <strong>ajudar o time a conhecer sua capacidade e servir como base para futuras sprints. </strong>Essa metodologia <strong>não faz parte oficial do Scrum</strong> mas é frequentemente utilizado.</p><p>Apesar de ter um objetivo super claro muitas equipes ainda imaginam que os story points vão ser utilizado como um critério de avaliação de equipes, comparação de equipes ou avaliação de performance (a verdade também é que alguns managers fazem isso).</p><p>É muito difícil como manager remover essa ideia, ainda mais quando algumas perguntas são feitas, por exemplo:</p><ul><li>Porque não conseguimos entregar todos os story points que prometemos no começo da sprint?</li><li>Essa sprint vamos fazer apenas 2 stories de 8 pontos?</li></ul><p>Existem também algumas perguntas que começam a surgir por parte dos desenvolvedores:</p><ul><li>Vamos estimar bugs e tasks também?</li><li>Se existe um carry over dentro da sprint vou estimar de novo para o próximo sprint? O que acontece com os pontos que a nós já desenvolvemos?</li><li>Como backend eu preciso estimar as user stories do frontend?</li><li>O QA e UX precisam estimar também?</li></ul><p>Existe muitas dúvidas e receios com o <strong>story points</strong> e essas dúvidas acabam ganhando mais atenção do que o objetivo principal que é <strong>ajudar o time a conhecer sua capacidade.</strong></p><p>Vejo muitos times abandonando o story points ou simplesmente estimando por estimar e no final eles já sabem informalmente quantas atividades podem executar durante 2 semanas.</p><h4><strong>Dar visibilidade do trabalho completo</strong></h4><p>Existe um enorme trabalho antes do desenvolvimento, teste e deploy:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lezR-k5gKAQk3cr8" /><figcaption>Cagan, Marty. INSPIRED (Silicon Valley Product Group)</figcaption></figure><p>Esse trabalho envolve muitas vezes iterações com os engenheiros ou com alguns deles (as vezes chamados de tech leads) e esse trabalho deveria ser o mais importante, pois é ele que define <strong>o que</strong> vai ser construído.</p><p>Em um modelo scrum <em>normalmente</em> terminamos uma sprint e logo começamos outra de acordo com o backlog mantido pelo product manager, mas não existe muitos momentos dedicados pelo scrum onde o time participa desse backlog.</p><p>Muitos times fazem uma sessão de uma hora chamada <strong>refinamento</strong> onde discutem as tarefas que estão no backlog, mas normalmente essas tarefas já estão lá definidas. Não existe muita visibilidade do trabalho realizado para deixar as user stories <strong>ready to start e como os engenheiros podem ajudar nisso.</strong></p><p>Onde podemos acompanhar o progresso das pendências para as atividades estarem definidas? Onde podemos discutir outras soluções? Como conciliar isso com a sprint que está sendo executada?</p><h4>Definir o escopo da sprint</h4><p>O escopo da sprint é definido no sprint planning de acordo com a prioridade do product manager e a capacidade do time, porém as vezes as atividades priorizadas são apenas de backend ou são apenas de frontend, nesse caso o que fazemos?</p><p>Precisamos atacar essas atividades porque são as mais prioritárias porém o time não tem o skill necessário para atacar esse conjunto de uma vez.</p><p>Isso também acontece quando algum engenheiro termina uma atividade e deseja começar a próxima priorizada, o engenheiro percebe que não tem skill suficiente para atacar essa atividade e o resto dos companheiros estão ocupados. Esse engenheiro também não é aconselhado a pegar atividade fora da sprint com risco de <strong>carry-over.</strong></p><p>O Scrum pede para evitar adicionar atividades durante a sprint e atacar as mais prioritárias. O que podemos fazer nesse caso?</p><p>Podemos pensar que o time não tem o skill suficiente e devemos contratar novas pessoas ou formar novos skills, porém isso é muito comum hoje em dia com arquiteturas de microserviços, as vezes utilizando até 4 linguagens diferentes e inumeras tecnologias e ferramentas. Além disso o produto tem exigências diferente todo o tempo, hoje precisamos entregar mais features que exigem frontend porém amanhã precisamos atacar features que precisam de mais backend.</p><p>E isso também entra no <strong>problema de como contratar engenheiros mais juniors</strong> em time multidisciplinares com todas essas exigencias.</p><h4>Conclusão</h4><p>O Scrum é um framework que tem muitas vantagens comparado ao modelo de cascata porém também existem alguns problemas que geram tempo de discussão e as vezes não se chega a nenhuma conclusão satisfatória.</p><p>A ideia é refletir sobre esses desafios e pensar como podemos diminuir eles ou simplesmente lidar melhor com eles.</p><p>Será que nessa fase devemos abandonar a ideia do Scrum, testar outro framework, ou simplesmente <strong>adaptar</strong> algumas das “regras” impostas pelo framework?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1eb6429105aa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coesão, Acoplamento e Lei de Demeter]]></title>
            <link>https://cesar-alcancio.medium.com/coes%C3%A3o-acoplamento-e-lei-de-demeter-45f5ca8470f6?source=rss-bc27ed464630------2</link>
            <guid isPermaLink="false">https://medium.com/p/45f5ca8470f6</guid>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Cesar Augusto Alcancio de Souza]]></dc:creator>
            <pubDate>Sun, 19 Jul 2020 22:58:27 GMT</pubDate>
            <atom:updated>2020-07-20T15:51:48.217Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RvHmC5patliUaWnj.png" /></figure><p>No ambiente de desenvolvimento Orientado a Objetos, é muito comum a gente escutar desenvolvedores falarem que temos que escrever códigos <strong>coeso</strong> e com <strong>baixo acoplamento</strong> (ou acoplamento fraco).</p><p>É importante saber que esses são conceitos que surgiram quando começamos a dar mais importância a <strong>legibilidade do código</strong> e <strong>manutenibilidade</strong> em detrimento de aspectos da engenharia de software como <strong>performance</strong>. Alias, esse é <strong>um</strong> dos motivo do surgimento e popularização de linguagens cada vez mais fáceis de usar (alto nível) referente a linguagens mais performática (baixo nível), por exemplo, <em>Java</em> <em>e Node</em> no lugar da linguagem <em>C (</em><strong>Obs</strong>: há controversas e hoje em dia as linguagens de alto nível chegam a ser mais rápidas em determinadas tarefas).</p><p>Mas o que <strong>Coesão</strong> e <strong>Acoplamento</strong> quer dizer na prática?</p><h3>Coesão</h3><p>A palavra coesão no contexto de software, significa algo que é <strong>claro</strong> e <strong>compreensível</strong>, isso significa que o código, assim como um texto ou história, deve ser fácil de compreender.</p><p>Se fizemos uma analogia com os textos que lemos (historias ou notícias) vemos que eles estão organizados em <strong>blocos</strong> e cada bloco com <strong>objetivo único</strong>, diminuindo a complexidade de um assunto e adicionando essa complexidade aos poucos, por exemplo, uma redação possui <em>introdução</em>, <em>desenvolvimento</em> e <em>conclusão</em>. Além disso o <em>desenvolvimento</em> é normalmente dividido em várias etapas para que os temas complexos sejam adicionados sem causar confusão ou ruído.</p><p>Caso a redação fosse escrita em outra ordem ou faltando alguma parte seria muito dificil a compreensão. O mesmo acontece com o código, ele precisa ser divididos em <strong>partes</strong> (classes) que tenham <strong>objetivos</strong> muito bem <strong>definidos. </strong>Esse também é um princípio conhecido como <strong><em>Single Responsibility Principle</em></strong><em>.</em></p><p>Por exemplo, o código abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0596QYW8-BcuyYxXFGhbmw.png" /></figure><p>É muito comum ver códigos que recebam parâmetros que vão decidir todo o seu comportamento e esse é um exemplo que eu encontrei recentemente em produção.</p><p>Não é pouco comum que descobrimos que também temos que registrar essa informação de uma forma diferente caso ela seja de um <em>resultado</em> de erro ou sucesso. Nesse caso o desenvolvedor poderia agregar outro parâmetro para atender essa necessidade, por exemplo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_TT230D1dsT_5GkglzgMvA.png" /></figure><p>Com tantos cenários possíveis para esta classe, como fazemos para ter certeza que tudo funciona bem? Qual é a nossa confiança de mudar uma classe com tantas bifurcações? Como são os testes automatizados? Tudo isso é complexidade para a leitura e manutenção do código.</p><p>Quanto mais tipos eu precisar persistir (JSON, XML, YAML etc…) mais linhas de códigos eu precisaria agregar a essa classe, fazendo com que a classe tenha que ser constantemente modificada.</p><p>Existe outro principio chamado <strong><em>Open Closed Principle</em></strong> que diz que uma classe deve ser aberta para extensão e fechada para modificação, nesse caso, cada vez que eu precise acrescentar uma nova forma de persistir a informação eu precisaria acrescentar mais linhas de códigos a essa classe, o que não está de acordo com o <strong><em>Open Closed Principle</em></strong>. Eu preciso adicionar funcionalidades a essa classe sem precisar alterar ela, como podemos resolver isso?</p><p>Existem muitas formas que podemos resolver estes problemas, para este exemplo eu resolveria basicamente com 2 coisas:</p><ol><li><strong>Dividindo o método em dois</strong>: um para persistir em caso de sucesso e outro para persistir em caso de erro.</li><li>Criando uma <strong>interface</strong> para os diferentes tipos de implementaçōes de persistência: JSON, XML, YAML e etc.</li></ol><p>Então veja como ficaria o nosso código. Primeiro a interface:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lgPbo6-bopURtHgMAHv4aw.png" /></figure><p>Depois como ficaria a nossa classe principal:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bo8Z0ihRbzJFrYqLSQUdEA.png" /></figure><p>E por último como ficariam as nossas classes que fazem a implementação de persistir o dado no formato necessário, por exemplo a de XML:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MFmszkTI38A5FsAH8ohvtQ.png" /></figure><p>As principais vantagens dessa abordagem é:</p><ul><li>A classe <strong><em>SingleResponsibilityExample</em></strong> não precisaria ser modificada caso existisse um novo formato necessário a ser persistido.</li><li>Caso fosse necessário adicionar uma nova funcionalidade (forma de persistir) bastaria criar uma nova classe e implementar a interface <strong><em>PersistableData</em></strong><em>.</em></li><li>Os métodos de <em>sucesso</em> e <em>erro</em> estão separados, deixando claro seu comportamento para quem vai invocar ele.</li></ul><p>Como tudo em tecnologia, não existe apenas vantagens, algumas desvantagens podem ser:</p><ul><li>A princípio (e depois também) pode parecer mais complexo ter várias classes onde antes só existia uma classe, principalmente para quem não está familiarizado com OOP (<em>Objected Oriented Programming</em>) e está acostumado com linguagem procedural.</li><li>Podem existir códigos repetidos caso a forma de persistir os dados em JSON e XML seja muito parecidas.</li></ul><p>O desenvolvedor precisa avaliar bem quando é necessário desmembrar o código em mais classes ou quando isso apenas vai trazer complexidade desnecessária.</p><h3>Acoplamento</h3><p>O acoplamento é o quanto uma classe, código, método ou até mesmo aplicação <strong>depende</strong> de outra.</p><p>O acoplamento é sempre mencionado como se fosse o pior dos violões da orientação a objetos, mas é possível fazer código sem se acoplar? Eu desconheço.</p><p>O mais importante aqui é tentar acoplar o seu código a outras classes mais <strong>sólidas</strong>, ou seja que provavelmente não vão mudar, em vez de acoplar a classes menos sólidos que possuem uma maior tendência a mudar e a propagar essa mudança para todos que a estão utilizando.</p><p>Por exemplo, a classe <em>Acoplamento</em> tem o <strong>metodoA</strong> e o <strong>metodoB</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SCOtvj1WGbt3SWKOwyhzcw.png" /></figure><p>O <strong>metodoA</strong> tem menos chances de mudar. Caso não seja mais necessário implementar a persistência em XML e sim em JSON o método não precisaria fazer nada. Enquanto o <strong>metodoB</strong> precisaria ser atualizado (quebraria).</p><p>É importante notar que sempre estamos acoplados, inclusive ambos os métodos estão acoplados a classe <strong>String</strong>, mas nesse caso nem notamos pois sabemos que a classe <strong>String</strong> é sólida e dificilmente mudaria.</p><p>O <strong><em>Dependency Inversion Principle</em></strong> é um princípio que trata exatamente este tema, ele propõe que uma classe deve ser acoplada sempre a outras clases mais sólidas que ela, por exemplo, a classe String não pode ser acoplada a classe PersistXML, mas a classe PersistXML pode ser acoplada a classe String e isso serve também para as nossas classes pessoais dos nossos projetos.</p><p>É importante ressaltar que essas decisões devem ser tomadas com cuidado, é muito comum projetos onde <strong>TODAS</strong> classes (sim, todas) possuem uma Interface, por exemplo, IPessoaDao.java para especificar os métodos CRUD da classe PessoaDaoImpl.java, isso é uma aplicação pura do conceito de interface e baixo acoplamento, mas na realidade não traz muitas vantagens já que essa relação de um para um (<em>classe -&gt; interface</em>) NÃO tende a crescer (possuir mais implentações) e quando precisa ser alterada normalmente se altera ambos classe e interface. É preciso avaliar caso a caso e não correr o risco de quebrar o principio <a href="https://www.martinfowler.com/bliki/Yagni.html"><em>You Won’t Need It Principle</em></a>.</p><h3>Lei de Demeter</h3><p>Agora que já sabemos o que é acoplamento e como gerenciá-lo a nosso favor, podemos conhecer outro princípio que também tem o objetivo de diminuir o acoplamento entre as classes e evitar a propagação de erros em caso de mudanças.</p><p>Apesar do nome a Lei de Demeter é muito simples e diz o seguinte:</p><blockquote>Deve haver conhecimento limitados entre as classe e elas devem apenas conversar com suas dependências diretas.</blockquote><p>É muito comum a gente ver o seguinte código:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OoQxbV2AyRihdHC7QgnqTg.png" /></figure><p>Não parece existir um problema muito grande com este código, porém a classe que procesa o Cliente está com acceso diretamente a lista de itens, ou seja, pode até modificá-la (caso não seja usado nenhuma função que impeça isso, por exemplo, <em>Collections.unmodifiablelist</em>).</p><p>A Lei de Demeter diz que a classe que processa o cliente não poderia ter acesso a Compra e Itens, apenas poderia acessar a classe Cliente. Assim caso ocorra alguma mudança na classe Compra ou Item a classe que processa o Cliente não seria afetada.</p><p>E como isso poderia ser resolvido?</p><p><strong>Classe Principal</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sz1ZowkiEX4Hid3RPEi1bQ.png" /></figure><p><strong>Classe Cliente</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7SF2l4mXYk_5QQsFC9qh1Q.png" /></figure><p><strong>Classe Compra</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cm69xPsx2Ongc0hZBMAvhg.png" /></figure><p>Agora em vez da classe Compra expor os itens diretamente, ela apenas expõe o tamanho da lista. A classe Cliente por sua vez repassa esse método para a classe Principal.</p><p>Agora a classe Principal não tem conhecimento da Compra e do Item, caso aconteça alguma mudança nessa classe não afetaria a classe principal.</p><p>Além da Coesão e Acoplamento foi apresentado alguns dos conceitos <strong>SOLID</strong> (<em>Single Responsibility, Open Closed, Liskov Substitution, Interface Segregation e Dependency Inversion</em>), espero que esse artigo possa ter ajudado a entender alguns desses princípios de desenvolvimento orienado a objetos. Sempre reforçando que a <strong>simplicidade</strong> está diretamente ligado a capacidade de legibilidade de um código e esses (e qualquer) princípio deve ser utilizado com bom senso.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45f5ca8470f6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>