<?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 Eduardo Spagiari on Medium]]></title>
        <description><![CDATA[Stories by Eduardo Spagiari on Medium]]></description>
        <link>https://medium.com/@e-spagiari?source=rss-efffa6e0bf98------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*neukSRHqPxiNCvcdPbAPbA.jpeg</url>
            <title>Stories by Eduardo Spagiari on Medium</title>
            <link>https://medium.com/@e-spagiari?source=rss-efffa6e0bf98------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 01:47:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@e-spagiari/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[S.O.L.I.D. Parte II]]></title>
            <link>https://e-spagiari.medium.com/s-o-l-i-d-parte-ii-ce50d974900f?source=rss-efffa6e0bf98------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce50d974900f</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[solid-principles]]></category>
            <dc:creator><![CDATA[Eduardo Spagiari]]></dc:creator>
            <pubDate>Sun, 01 Nov 2020 21:23:21 GMT</pubDate>
            <atom:updated>2020-11-03T13:13:54.036Z</atom:updated>
            <content:encoded><![CDATA[<p>Nessa série eu comento o artigo <a href="https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898">The S.O.L.I.D. Principles in Pictures da Ugonna Thelma</a> [1]. Na <a href="https://medium.com/@e.spagiari/s-o-l-i-d-parte-i-37b43a65167f">parte I</a> [2] eu falei sobre o SRP — Single-responsibility principle e como alguns detalhes pouco intuitivos podem fazer com que nosso design viole o SRP. Agora é hora de avançar para o segundo princípio o open-closed principle.</p><h3>OCP — Open-closed principle</h3><p>O OCP foi definido pela primeira vez por Bertrand Meyer em seu livro Object Oriented Software Construction de 1988. A Definição criada por Bertrand em tradução livre é:</p><blockquote>Um artefato de software deve ser aberto para extensão, mas fechado para modificação.</blockquote><p>O OCP é um dos principais guias para o design de classes e módulos. Nessa simples frase está condensado um conceito muito poderoso. Uma outra forma menos abrangente de definir esse principio é:</p><blockquote>Um artefato de código deve ser extensível alterando-se a menor quantidade de código já existente possível. O ideal é que não seja alterada nenhuma linha.</blockquote><p>O termo estender significa adicionar nova funcionalidade sem interferir nas já existentes. Um código que respeita esse princípio é mais fácil de ampliar, manter e testar. Além de ser mais difícil uma nova funcionalidade quebrar algo que já funcionava, pois que não houve alteração no que já existia. Quebrar algo durante a extensão de um código é algo frustrante. Quem nunca passou por esse problema?</p><p>Se pensarmos no nosso código como uma ferramenta, ele pode ser usado de diversas formas. Formas corretas e também formas erradas. É nossa responsabilidade fazer o possível para que só exista uma forma de utilização e que essa única forma seja a forma certa. Correções, extensões e a própria leitura do código também são formas de utilização e temos que cuidar para que tudo aconteça da maneira correta. A figura 1 ilustra uma forma que acho adequada de como encarar o desafio de viabilizar o uso correto de nossos artefatos de código. Nela temos duas facas, uma com guarda e outra sem. Usar a faca sem guarda nem de longe significa que vamos nos cortar, mas normalmente estamos mais seguros usando a faca com guarda. Nosso código tem que impor limites para que seja usado de maneira segura. Como a faca com guarda que impõe um limite: Se sua mão passar desse ponto você vai se cortar! Com isso em mente fica mais fácil entender o OCP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*E9KaRMdjhJQVpaCZg_6sLw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bn-xz0HlR7McR4MEvOW-hA.jpeg" /><figcaption>Fig 1: Esquerda — Faca classica. Direita — faca classica com guarda.</figcaption></figure><p>Como nosso código pode ser aberto para extensão e fechado para modificação? O seu design deve apresentar um caminho para isso. Devemos identificar e projetar as partes certas para permitir extensões de maneira clara e objetiva. De forma que qualquer desenvolvedor que vá estender nosso código seja naturalmente guiado a seguir o caminho que deixamos.</p><h3>Um exemplo</h3><p>O artigo <a href="https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898">The S.O.L.I.D. Principles in Pictures</a> [1] mostra dois exemplos de como o OCP funciona, que geraram muitas dúvidas. Vamos avançar com um exemplo parecido. Logo mais revisitaremos os exemplo do <a href="https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898">The S.O.L.I.D. Principles in Pictures</a> para entender seus problemas.</p><p>Vamos imaginar que temos que criar um robô para ser usado em uma linha de montagem. Nosso robô quando acionado precisa fazer um furo a 90 graus na peça que está na linha de montagem. A linha de montagem será responsável por acionar o robô. Para simplificar vamos assumir que a linha de montagem execute o comando <em>&quot;faça&quot; </em>do nosso robô que iniciará imediatamente o trabalho para qual foi construído. Vamos definir nosso robô como uma classe e o comando faça é um metodo público. Após entender os requisitos projetamos nosso robô como mostra a Fig. 2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/161/1*4UJ2jpqF6MjW0QvTC0UeXg.png" /><figcaption>Fig. 2: Classe que representa robô que sabe furar a 90 graus.</figcaption></figure><p>Nosso robô está pronto e foi construído conforme a Fig. 2. Ele vai para produção e tudo vai bem. Algum tempo depois, recebemos a solicitação de que nosso robô precisa também executar furos a 45 graus, dependendo da configuração da linha de montagem. Nossos problemas começam a partir daqui. Não existe um caminho de como adicionar essa funcionalidade ao nosso robô, pois o design não prevê extensões. Porém a demanda chegou e temos que atender. Imagine que o desenvolvedor responsável pelo trabalho acha conveniente adicionar a funcionalidade conforme a Fig. 3.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/161/1*TiOhMnLz7yH0SzE7oMYGaQ.png" /><figcaption>Fig. 3: Classe que representa robô que sabe furar a 90 e a 45 graus.</figcaption></figure><p>Nosso robô agora é capaz de executar as duas furações, porem o código existente, a classe robô, foi alterado varias vezes. O construtor da classe foi alterado para receber o tipo de furo que ele vai executar. A função <em>“faça”</em> agora precisa verificar o tipo do furo e então invocar o metodo correto. Além da alteração do código que invoca o construtor do robô o que pode ser um problema em particular, pois esse código pode ser de outro projeto, por exemplo. Podemos dizer que o nosso código está fechado para extensão e aberto para a alteração. Em outras palavras nosso design convidou o desenvolvedor a alterar o código criando um tipo de extensão baseado em alteração. Esse tipo de extensão pode eventualmente criar bugs em funcionalidades que já estavam validadas e em plena utilização. Outro ponto que devemos notar é que após a inclusão da nova funcionalidade, nosso código aponta um caminho para extensão, mas um caminho errado.</p><p>Imagine agora que nosso robô de linha de montagem precisa também disparar uma pistola de pintura dependendo da configuração da linha de montagem. Quando nosso desenvolvedor olhar para o nosso robô da Fig. 3 ele vai se sentir compelido a estender nosso robô como mostra a Fig. 4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/161/1*axiJmJukBUC_hvjIfTu6Xw.png" /><figcaption>Fig. 4: Classe que representa robô que sabe pintar e furar a 90 e a 45 graus.</figcaption></figure><p>Nosso robô agora está com a habilidade de furar e pintar, mas novamente o processo alterou o código existente. Além disso a inclusão da nova funcionalidade violou o SRP (Single-responsibility principle), pois agora nosso código carrega a funcionalidade de furar e pintar. Pela falta de limitações nosso código cresceu de maneira desordenada.</p><p>Agora entendemos melhor os problemas envolvidos no OCP e podemos falar um pouco nos exemplos citados pelo artigo <a href="https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898">The S.O.L.I.D. Principles in Pictures</a> [1]. No primeiro exemplo existe um robô com a habilidade de cortar. O robô passa por uma manutenção e depois disso ele perde a capacidade de cortar e passa a apenas pintar. Esse caso é classificado como uma violação do OCP. Não vejo esse exemplo como uma violação do OCP. Substituir uma funcionalidade por outra nova é algo que acontece no mundo real com mais frequência do que o saudável. Porém o fato de remover o código da funcionalidade anterior é algo até que benéfico, não devemos deixar código não utilizado em nossos projetos.</p><p>Indo para o segundo exemplo de SRP do <a href="https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898">The S.O.L.I.D. Principles in Pictures</a> [1] temos o mesmo robô cortador, porém depois da manutenção ele passa a cortar e pintar. Um braço corta e outro pinta. Esse exemplo é classificado como alinhado ao OCP. A primeira polemica desse exemplo é que essa extensão teria violado o SRP ao manter duas funcionalidades tão distintas no mesmo robô. A segunda polêmica é que esse exemplo, pelo que foi mostrado, pode violar o OCP. Assumindo que o Robô é uma representação direta de uma classe e sem mais detalhes de como essa extensão foi feita acredito que esse exemplo não representa um design alinhado com o que vimos sobre o OCP.</p><h3>Uma Solução</h3><p>Como resolver o problema do nosso robô de linha de montagem? Como podemos desenhar nosso design para mostrar um caminho claro de como estender nosso robô? A Fig. 5 mostra o desenho de uma solução simplificada para o problema inicial de um robô que sabe furar a 90 graus.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/631/1*7bI3T0ULSSPJFO2g1Uv4oA.png" /><figcaption>Fig. 5: Uma nova versão do robô que sabe furar a 90 graus.</figcaption></figure><p>Nessa proposta a ação que o robô executa (funcionalidade) deixa de ser algo fixo dentro robô e passa ser algo mais parecido como um modulo. O robô passa a encapsular um modulo ou diversos módulos dependendo da necessidade. Seguindo nosso exemplo, agora temos um caminho mais claro para adicionar a funcionalidade de furar a 45 graus. A Fig. 6 Mostra nosso robô com a funcionalidade de furo 45 graus implementada. Podemos ver que nesse design a nova funcionalidade foi totalmente desenvolvida em uma classe separada gerando menos alterações em códigos existentes. A alteração de código existente pode chegar a zero, veremos isso em outra oportunidade.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/631/1*bQhxnzjBsAQN551LoDzTFw.png" /><figcaption>Fig. 6: A nova versão do robô que sabe furar a 90 e 45 graus.</figcaption></figure><p>A Fig. 7 mostra nosso robô com a funcionalidade de pintar. Notem que a inclusão da funcionalidade não viola o SRP, pois tudo referente a pintura está encapsulado na classe pintar. Nosso robô agora tem um caminho claro para extensão e mesmo com funcionalidades tão distintas não viola o SRP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/631/1*dVIQRiDgJs4jMFpYprQizA.png" /><figcaption>Fig. 7 A nova versão do robô que sabe pintar e furar a 90 e a 45 graus.</figcaption></figure><h3>Conclusão</h3><p>O OCP é um grande guia para modelagem de classes e módulos. Vimos como a violação desse princípio pode levar a uma desorganização sistemática no código. Entendemos como em um cenário respeitando o OCP, a extensão do código fica mais simples. Espero ter desfeitos alguns possíveis enganos e deixado mais clara as idéias centrais do principio.</p><p>Os conceitos do OCP podem ser a diferença entre um código simples e intuitivo de se sustentar e de se entender e um código difícil e caro de estender. Essa diferença está diretamente ligada ao sucesso ou ao fracasso de um projeto ou empresa.</p><p>Algo muito importante para ressaltar sobre o S.O.L.I.D. é que eles não são princípios isolados, eles são complementares e não se conflitam. Seguir um um princípio nunca violará outro. Caso algo parecido aconteça pare, respire fundo e reavalie.</p><p>[1] <a href="https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898">The S.O.L.I.D. Principles in Pictures da Ugonna Thelma</a></p><p><a href="https://medium.com/@e.spagiari/s-o-l-i-d-parte-i-37b43a65167f">[2] S.O.L.I.D. Parte I</a></p><p>[3] <a href="https://books.google.com.br/books/about/Clean_Architecture.html?id=8ngAkAEACAAJ&amp;redir_esc=y">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce50d974900f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[S.O.L.I.D. Parte I]]></title>
            <link>https://e-spagiari.medium.com/s-o-l-i-d-parte-i-37b43a65167f?source=rss-efffa6e0bf98------2</link>
            <guid isPermaLink="false">https://medium.com/p/37b43a65167f</guid>
            <category><![CDATA[solid-principles]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[patterns]]></category>
            <dc:creator><![CDATA[Eduardo Spagiari]]></dc:creator>
            <pubDate>Sat, 17 Oct 2020 15:12:15 GMT</pubDate>
            <atom:updated>2020-10-18T23:27:47.024Z</atom:updated>
            <content:encoded><![CDATA[<p>Recentemente li um artigo nesta plataforma que teve grande repercussão: o <a href="https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898">The S.O.L.I.D. Principles in Pictures da Ugonna Thelma</a> [1]. Realmente é um artigo muito bom que aborda os conceitos gerais dos princípios S.O.L.I.D. de uma forma bem divertida. Gostaria de ler mais artigos assim.</p><p>Aqui quero comentar alguns pontos do artigo da Ugonna e aproveitar para me aprofundar um pouco mais no tema, pois como alerta o provérbio alemão “o diabo mora nos detalhes”.</p><p>Um ponto que eu acho muito interessante e relevante nos princípios S.O.L.I.D. é que ele foi resultado de anos de reflexões e debates entre grandes nomes da comunidade de desenvolvimento de software. Eles observaram as características em comum nos principais softwares e padrões de código bem-sucedidos e traduziram essas características em cinco princípios: Single-responsibility principle, open-closed principle, Liskov substitution principle<strong>, </strong>Interface segregation principle e Dependency inversion principle. Esses princípios surgiram de uma seleção natural que escolheu alguns softwares para extinção. Os softwares sobreviventes possuíam esses princípios em comum que ajudam e muito na organização, manutenção e extensão do nosso código, trazendo muitos outros benefícios. Outro ponto que vale reforçar é que o S.O.L.I.D. não é de aplicação exclusiva do paradigma de orientação a objetos. Ele pode ser aplicado a qualquer conjunto de dados e funções que se relacionam (módulos, microsserviços e por aí vai). Então vamos ao que interessa!</p><h4>SRP — Single-responsibility principle</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*OpiYcPoOw8lLADRRejGsqw.jpeg" /><figcaption>Um canivete suíço com uma única responsabilidade</figcaption></figure><p>O SRP ou single-responsibility principle é normalmente definido como: Uma classe deve ter uma única responsabilidade. No artigo [1] existe um exemplo bem interessante quando inicialmente um robô faz de tudo: cozinha, cuida do jardim, pinta e dirige. Depois de refatorar o robô surgem quatro novos robôs, cada um especialista em uma atividade. Sem dúvida isso é uma característica muito desejável em um software. Vamos explorar esse princípio.</p><p>Em seu livro Clean Architecture [2] Robert Martin expande o conceito:</p><blockquote>Uma classe deve ter uma única responsabilidade</blockquote><blockquote>Uma classe deve ter apenas um motivo para mudar</blockquote><blockquote><strong>Uma classe deve ter apenas um dono</strong></blockquote><p>O uncle Bob poderia tê-lo nomeado como single-owner principle, o que economizaria algumas explicações. Certo, mas o que ele quer dizer na prática é que times diferentes pedindo mudanças no mesmo bloco de código e pensando apenas em sua parte do problema podem levar a interações muito ruins e bugs inesperados.</p><h3>Uma história, dois donos e um problema</h3><p>Agora vamos pensar em um dos robôs refatorados, o robô pintor. Imagine que ele pinte apenas paredes e que o processo de pintura tem duas etapas, a preparação da parede (aplicar um fundo, massa corrida ou impermeabilização) para depois aplicar a tinta. O que nos deixaria com uma classe com a seguinte interface:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*jsWnRZLoGDZMFeVKCEuJEg.png" /><figcaption>Classe Pintor</figcaption></figure><p>O método <em>pintar</em> invoca o <em>preparar</em> que em seguida invoca o <em>aplicarTinta</em>. Tanto o método <em>preparar</em> quanto o <em>aplicarTinta</em> usam os métodos e atributos privados da classe, como por exemplo <em>areaUtil</em> (método que calcula área útil da parede para provisionar recursos para execução do trabalho). Ótimo, problema resolvido. Estendendo o exemplo, é razoável pensar que a preparação da parede siga as diretrizes de um engenheiro e que a aplicação da tinta siga as orientações de um arquiteto.</p><p>O engenheiro analisou nosso cenário e pediu para que o time de desenvolvimento faça com que o método de preparação da parede execute um processo de impermeabilização. O arquiteto analisou a fachada do nosso empreendimento e decidiu as cores e o padrão da pintura. Tudo está funcionando perfeitamente, os habitantes livres de umidade e orgulhosos de duas casas bem pintadas.</p><p>Algum tempo depois o engenheiro responsável, pressionado por redução de custos, decide que a aplicação da impermeabilização pode ser feita só na metade inferior da parede. Isso economizará uma grande quantidade de impermeabilizante. Então o engenheiro solicita para o time de desenvolvimento a alteração.</p><p>O desenvolvedor então vai até nossa classe de responsabilidade única e faz todas as alterações necessárias, no decorrer do processo ele acha conveniente alterar diretamente o método de área útil diminuindo a área da parede pela metade para que nosso robô provisione a quantidade certa de impermeabilizante. Nosso engenheiro acompanha a impermeabilização da primeira casa, tudo certo! Nosso robô pintor continua seu trabalho.</p><p>Conforme nosso robô pintor vai terminando as casas, percebemos que algo está errado. As paredes estão mal pintadas e com péssimo acabamento. O que aconteceu!? O bug foi percebido tarde demais. Faltou tinta para que nosso robô pintasse adequadamente as paredes. Tudo está mal pintado, porem livres de humidade.</p><p>Neste exemplo, nosso robô pintor tem dois motivadores de mudança: o engenheiro e o arquiteto. O código desses dois proprietários compartilha as mesmas bases, portanto uma mudança necessária para um processo pode ser catastrófica para outro. Como vimos no exemplo anterior.</p><h3>Uma possível solução</h3><p>Uma solução para o problema é separar o robô pintor em 2 robôs. O preparador de parede e o aplicador de tinta. Dessa forma o engenheiro e o arquiteto não teriam acoplamento entre si e qualquer mudança solicitada por um não afetaria o outro. Essa abordagem vai contra uma ideia comum, de que em um software bem escrito não existe código duplicado, pois nessa solução proposta surgem trechos de códigos muito parecidos ou as vezes iguais em cada robô. O código igual parece inclusive representar o mesmo conceito, mas não representam. Por exemplo a área da parede para preparação e a área da parede para aplicação de tinta são conceitos diferentes. Outro ponto contra intuitivo tem paralelo com as abstrações do mundo real utilizadas. A atividade de pintura e a preparação da parede na vida real são executadas pelo mesmo profissional, por que em uma abordagem de orientação a objetos isso seria diferente?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/686/1*woUE2mPof-o1bv3t2jGySQ.png" /><figcaption>Um exemplo de solução</figcaption></figure><p>Esse exemplo hipotético e ingênuo tem semelhanças com a realidade. Vi situações como essas acontecerem em vários projetos. Um exemplo clássico é organizar cálculo de impostos junto com regras comerciais em uma mesma classe. Esse é um caso claro de dois donos, ou dois motivos de mudanças na mesma classe. A classe pode mudar por uma determinação do negócio ou por uma mudança na legislação tributária. Claramente parte da classe é de propriedade da área comercial e outra parte é de propriedade do governo. Outro exemplo é uma classe ser responsável pelas regras de negócio de cadastro de produto e pela persistência das informações no banco de dados. Como persistir os dados, tecnologias e frameworks são de competência exclusiva da área técnica, uma mudança de tecnologia de banco de dados definida pelo CIO da companhia não deve gerar impacto em regras de negócio, novamente é uma classe com dois donos.</p><h3>Conclusão</h3><p>Nosso robô pintor inicialmente parecia respeitar o princípio do SRP com as características de implementação que definimos, o que faz muito sentido quando definimos SRP sendo uma classe de responsabilidade única. Ele é um pintor e isso é uma responsabilidade única, normalmente não existe um pintor preparador e um pintor aplicador de tinta nas obras mundo a fora. Logo, a abstração usada se encaixa perfeitamente ao SRP. Quando a solução é analisada de perto e estressada, percebemos seus problemas de design. Aplicar o SRP com maestria requer atenção, conhecimento sólido, uma visão ampla do motivo de existir até a forma como nosso artefato de código será utilizado, além de muita prática é claro.</p><p>[1] <a href="https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898">The S.O.L.I.D. Principles in Pictures da Ugonna Thelma</a></p><p>[2] <a href="https://books.google.com.br/books/about/Clean_Architecture.html?id=8ngAkAEACAAJ&amp;redir_esc=y">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37b43a65167f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>