<?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[Fora de assunto - Medium]]></title>
        <description><![CDATA[Espaço para discutir sobre os assuntos que mais gosto: programação, jogos, filmes e quadrinhos. - Medium]]></description>
        <link>https://medium.com/fora-de-assunto?source=rss----4ffd537c83df---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Fora de assunto - Medium</title>
            <link>https://medium.com/fora-de-assunto?source=rss----4ffd537c83df---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 16:11:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/fora-de-assunto" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Os design patterns Abstract Server e Adapter nas palavras de Uncle Bob]]></title>
            <link>https://medium.com/fora-de-assunto/os-design-patterns-abstract-server-e-adapter-nas-palavras-de-uncle-bob-e2cc66849198?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/e2cc66849198</guid>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[abstract-server]]></category>
            <category><![CDATA[uncle-bob]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[adapter-pattern]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Thu, 26 Jan 2023 11:50:07 GMT</pubDate>
            <atom:updated>2023-01-26T11:50:07.368Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>No segundo semestre de 2022, o <strong>Fora de Assunto</strong> deu o pontapé inicial na série inédita voltada para o aprendizado dos padrões de projeto. O design pattern apresentado na postagem anterior foi o <em>Observer</em>, que se sobressaiu por suas diferentes formas de implementação entre os modelos push e pull.</p><p><a href="https://medium.com/fora-de-assunto/o-design-pattern-observer-nas-palavras-de-uncle-bob-c39b0c86c1c2">O design pattern Observer nas palavras de Uncle Bob</a></p><p>O artigo de hoje traz os detalhes e características dos padrões <strong>Abstract Server</strong> e <strong>Adapter</strong>, que resolvem o mesmo conjunto de problemas, cada um do seu jeito. Como de costume, as informações presentes nesta publicação foram consultadas diretamente dos materiais de Robert C. Martin em <em>Princípios, Padrões e Práticas Ágeis em C#</em>.</p><h3>O problema da luminária</h3><p>Assim como em outros padrões de projeto, Robert C. Martin introduz em sua obra um exemplo simples, com o objetivo de assimilarmos o funcionamento de <em>Abstract Server </em>e <em>Adapter.</em></p><p>Neste caso, o autor relembra um problema discutido na década de 1990 no fórum <strong>comp.object</strong>. A ideia básica era projetar um software para uma luminária de mesa.</p><p>O utensílio hipotético possuía apenas um interruptor e uma lâmpada. As funcionalidades <em>core </em>consistiam de perguntar ao interruptor se ele estava ligado/desligado e enviar um comando para acender/apagar a lâmpada.</p><p>Uncle Bob conta que inúmeras soluções foram apresentadas ao longo dos meses de debate, sendo que algumas delas chamaram mais a sua atenção, como por exemplo:</p><ul><li>Um programa somente com os objetos interruptor e lâmpada;</li><li>Um programa com o objeto luminária, que continha os objetos interruptor e lâmpada;</li><li>Outros programas inusitados sugeriam ainda o uso de objetos eletricidade e cabo elétrico.</li></ul><p>O primeiro conceito de projeto, envolvendo os objetos interruptor e lâmpada, aparentava ser o com maior consistência para Robert. De modo sucinto, o objeto interruptor poderia consultar o estado do interruptor real, e encaminhar as mensagens necessárias para o objeto lâmpada.</p><p>Entretanto, Martin identificou que a proposta em questão feria dois princípios do <strong>SOLID</strong>: a <strong>Inversão de Dependência </strong>e o <strong>Aberto/Fechado</strong>.</p><p>O primeiro deles era violado porque o objeto interruptor dependia diretamente do objeto concreto lâmpada. Isso ignora a diretiva que recomenda a dependência exclusiva em relação à objetos abstratos.</p><p>Por sua vez, o segundo princípio não estava aderente por uma razão clara: o objeto lâmpada possuía um acoplamento elevado com o objeto interruptor. Logo, esse último não poderia ser estendido visando o controle de outros objetos.</p><h3>Solucionando o problema com Abstract Server</h3><p>Robert comenta que algumas pessoas pensam em resolver este problema criando uma subclasse para o objeto interruptor, de tal forma que a derivada pudesse controlar objetos diferentes de lâmpada.</p><p>Contudo, essa estratégia não seria o suficiente, tendo em vista que a superclasse interruptor continuaria a depender de lâmpada, e consequentemente as suas subclasses também possuíram tal vínculo.</p><p>Felizmente, esta confusão de dependências pode ser solucionada com <em>Abstract Server</em>, classificado por Bob como um dos padrões de projetos mais simples que existem.</p><figure><img alt="Diagrama de classes do problema da luminária com o uso do padrão Abstract Server" src="https://cdn-images-1.medium.com/max/1024/1*XxJ7vQ8bAXyjgbpn58D4fQ.jpeg" /><figcaption>Diagrama de classes do problema da luminária com o uso do padrão Abstract Server</figcaption></figure><p>Conforme retratado no diagrama, a novidade incorporada pelo padrão é a interface <em>Switchable</em>. Com ela, a classe <em>Switch </em>consegue manipular qualquer tipo que implemente a definição desse contrato. De imediato, os princípios da Inversão de Dependência e do Aberto/Fechado são obedecidos.</p><p>Martin realiza uma observação importante quanto ao nome de <em>Switchable</em>. Ele destaca que a interface segue a nomenclatura de seu cliente, que é a classe <em>Switch</em>, ao invés de se basear em <em>Light</em>. O autor pondera que as interfaces sempre estão relacionadas com o seu consumidor, e não com as classes derivadas.</p><p>A justificativa para a alegação anterior está no fato de que o <strong>vínculo lógico</strong> detém tamanha relevância, que não há nexo em implantar a classe <em>Switch </em>sem <em>Switchable</em>. Por outro lado, implantar <em>Light </em>sem <em>Switchable </em>é completamente plausível.</p><h3>Solucionando o problema com Adapter</h3><p>O padrão <em>Abstract Server</em> sana as necessidades iniciais do desafio proposto. Porém, a sua simplicidade provoca uma outra dor de cabeça em potencial. Se notarmos bem, o princípio da <strong>Responsabilidade Única</strong> é violado de maneira sútil.</p><p><em>Light </em>e <em>Switchable </em>foram conectados para contornar as violações da Inversão de Dependência e do Aberto/Fechado, mas ambos os tipos podem <strong>mudar por razões distintas</strong>. Além disso, mais duas questões pertinentes podem surgir a partir da solução apresentada com <em>Abstract Server</em>:</p><ul><li>E se <em>Light </em>fosse uma classe disponibilizada por um fornecedor terceiro, que não compartilhasse o código-fonte?</li><li>E se <em>Switch </em>precisasse controlar uma dependência não relacionada com <em>Switchable</em>?</li></ul><p>As respostas para essas dúvidas estão diretamente ligadas ao design pattern <em>Adapter</em>, reproduzido em detalhes no diagrama de classes a seguir.</p><figure><img alt="Diagrama de classes do problema da luminária com o uso do padrão Adapter" src="https://cdn-images-1.medium.com/max/1024/1*clfpf51PvYUGJg-7fzDhHQ.jpeg" /><figcaption>Diagrama de classes do problema da luminária com o uso do padrão Adapter</figcaption></figure><p>A classe adaptadora herda da interface <em>Switchable </em>e repassa os comandos para <em>Light</em>. Com isso, qualquer objeto consegue ser ligado ou desligado, permanecendo sob o controle de <em>Switch</em>. O único requisito para o feito em questão advém da criação de um adaptador adequado.</p><h3>Abstrair ou adaptar?</h3><p>Provavelmente, ficou nítido que os padrões <em>Abstract Server</em> e <em>Adapter </em>foram criados para resolver o mesmo tipo de problemas. Assim sendo, uma das dúvidas mais recorrentes é sobre qual desses design patterns deve ser escolhido no momento da implementação — caso faça sentido aplicá-los, obviamente.</p><p>Em seu livro, Robert Martin escreveu a resposta para este questionamento comum que surge nas reflexões dos programadores novatos no mundo dos padrões de projeto.</p><blockquote>Os adaptadores custam caro. Você precisa escrever a nova classe, instanciar o adaptador e vincular o objeto adaptado a ele. Então, sempre que chama o adaptador, você precisa pagar pelo tempo e espaço exigidos para a delegação. Portanto, claramente você não quer usar adaptadores o tempo todo. A solução Abstract Server é bastante apropriada para a maioria das situações.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2cc66849198" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/os-design-patterns-abstract-server-e-adapter-nas-palavras-de-uncle-bob-e2cc66849198">Os design patterns Abstract Server e Adapter nas palavras de Uncle Bob</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O design pattern Observer nas palavras de Uncle Bob]]></title>
            <link>https://medium.com/fora-de-assunto/o-design-pattern-observer-nas-palavras-de-uncle-bob-c39b0c86c1c2?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/c39b0c86c1c2</guid>
            <category><![CDATA[observer-pattern]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[observer]]></category>
            <category><![CDATA[uncle-bob]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Wed, 28 Dec 2022 19:44:24 GMT</pubDate>
            <atom:updated>2022-12-28T19:44:24.059Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>Na publicação mais recente do <strong>Fora de Assunto</strong>, demos um passo adiante na série sobre os padrões de projeto. O último design pattern destrinchado foi o <em>Null Object</em>, que elimina a necessidade de verificações condicionais no que tange objetos nulos.</p><p><a href="https://medium.com/fora-de-assunto/o-design-pattern-null-object-nas-palavras-de-uncle-bob-1525dd7ff55e">O design pattern Null Object nas palavras de Uncle Bob</a></p><p>Hoje desbravaremos de cabo a rabo o padrão <strong>Observer</strong>, que pode ser implementado de duas formas completamente distintas. Seguindo a linha dos demais artigos, busquei as informações aqui presentes dos materiais de Robert C. Martin em P<em>rincípios, Padrões e Práticas Ágeis em C#</em>.</p><h3>O problema do relógio digital</h3><p>Com o intuito de atingirmos uma compreensão total do design pattern <em>Observer</em>, introduzirei o problema do <strong>relógio digital</strong>, que foi elaborado por Robert C. Martin em sua obra.</p><p>Neste desafio, a proposta é desenvolver um relógio digital que obtém interrupções em milissegundos a partir do sistema operacional e converte o <em>input </em>em questão para um horário do dia.</p><p>Uma solução simples seria escrever o seguinte código-fonte para exibir qualquer horário atualizado na área de trabalho do usuário.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/63775c75130d7ef45794242a73bc7bc1/href">https://medium.com/media/63775c75130d7ef45794242a73bc7bc1/href</a></iframe><p>Ainda que resolva o desafio, o código acima consome muitos recursos da <em>CPU</em>, tendo em vista que executa um loop <em>while </em>contínuo. Além disso, boa parte das exibições será desperdiçada, já que a hora não é alterada com frequência.</p><p>Dessa maneira, pode-se concluir que uma solução simples não é o melhor caminho para este problema. Na verdade, o principal quebra-cabeça a ser resolvido consiste de migrar os dados do objeto <strong>Clock</strong>, que extrai<strong> </strong>as interrupções do sistema operacional,<strong> </strong>para o objeto <strong>DigitalClock</strong>, que mostra o horário vigente em qualquer área de trabalho.</p><p>A priori, a conexão que deve existir entre os dois objetos mencionados pode ser testada por um programador. Ou seja, uma vez que os dados de <em>Clock </em>sejam idênticos aos de <em>DigitalClock</em>, será possível afirmar que o problema central do relógio digital foi atendido.</p><p>E para validar a interação dos objetos, duas interfaces devem ser criadas para simular <em>Clock</em>, bem como <em>DigitalClock</em>. Isso viabiliza o desenvolvimento das implementações de teste que herdem dessas interfaces, de modo a garantir a conexão dos dados originados no sistema operacional e dos dados exibidos constantemente ao usuário.</p><figure><img alt="Diagrama de classes elaborado por Robert C. Martin para testar as classes do problema do relógio digital" src="https://cdn-images-1.medium.com/max/1024/1*BSdr6SFR-OYy2WcZrHH-mQ.jpeg" /><figcaption>Estrutura das classes para testar o problema do relógio digital</figcaption></figure><p>Conforme ilustrado no diagrama de classes, <strong>ClockDriverTest </strong>instancia o objeto <strong>ClockDriver</strong>, que por sua vez consome as interfaces <strong>TimeSource </strong>e <strong>TimeSink</strong>, responsáveis por fornecer uma abstração aos objetos <em>Clock </em>e <em>DigitalClock</em>. Logo, <em>ClockDriver </em>faz o meio de campo para as instâncias de <em>TimeSource </em>e <em>TimeSink</em>, enquanto <em>ClockDriverTest </em>valida se a conexão pretendida foi de fato realizada.</p><p>Entretanto, com o objetivo de que <em>ClockDriver </em>saiba quando o horário mudou, é necessário fazer uma modificação na estrutura. Uma eventual saída se baseia em passar uma instância de <em>ClockDriver </em>por meio de <em>TimeSource</em>. Assim sendo, <em>Clock</em>/<strong>MockTimeSource</strong> podem notificar <em>ClockDriver</em>, que na sequência configura a nova hora em <em>DigitalClock</em>/<strong>MockTimeSink</strong>.</p><p>O código resultante da mudança supracitada está disponível a seguir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2ece6766bca4d41379ea1995748a8d32/href">https://medium.com/media/2ece6766bca4d41379ea1995748a8d32/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2729f826d7b1a4c0357748b4e26f2b44/href">https://medium.com/media/2729f826d7b1a4c0357748b4e26f2b44/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/955696e7e250cc2d56c1fa95bf296705/href">https://medium.com/media/955696e7e250cc2d56c1fa95bf296705/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/20b015fcef835b1795a05aeeca492ecf/href">https://medium.com/media/20b015fcef835b1795a05aeeca492ecf/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b9d04b10ec9e4cd67f4e324f7196d857/href">https://medium.com/media/b9d04b10ec9e4cd67f4e324f7196d857/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1dd8e917256ef29cc7d275551e6c44fe/href">https://medium.com/media/1dd8e917256ef29cc7d275551e6c44fe/href</a></iframe><h3>Caminhando em direção ao padrão Observer</h3><p>A última solução apresentada é muito mais elegante e eficiente do que a primeira introduzida nos parágrafos iniciais do artigo. Contudo, há uma imperfeição no design. <em>TimeSource </em>depende diretamente de <em>ClockDriver</em>, estabelecendo um acoplamento elevado.</p><p>A ineficiência em discussão pode ser corrigida com a definição de uma outra interface, chamada <strong>ClockObserver</strong>, que será usada por <em>TimeSource </em>e implementada por <em>ClockDriver</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/33e3d2524914cb1c6d5e7b019b5443fd/href">https://medium.com/media/33e3d2524914cb1c6d5e7b019b5443fd/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d6acb7aad55032f4264734c7095ec51b/href">https://medium.com/media/d6acb7aad55032f4264734c7095ec51b/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bf1d5f506e6af8eb7ca05ffd0b483b5c/href">https://medium.com/media/bf1d5f506e6af8eb7ca05ffd0b483b5c/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/918a989672aa7edbaa2945a9f1db3cc5/href">https://medium.com/media/918a989672aa7edbaa2945a9f1db3cc5/href</a></iframe><p>Todavia, caso fosse preciso que mais de um objeto <em>TimeSink </em>extraísse o horário atual, de qual forma todo o código-fonte mostrado até então deveria ser adaptado?</p><p>Se prestarmos atenção, <em>ClockObserver </em>e <em>TimeSink </em>compartilham o método <strong>SetTime</strong>, embora <em>TimeSink </em>não implemente <em>ClockObserver</em>. Sendo assim, fazendo com que <em>MockTimeSink </em>herde diretamente de <em>ClockObserver</em>, tanto <em>ClockDriver</em>, quanto <em>TimeSink</em>, poderiam ser removidos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f91254fc9ba7b6dd58b00f5412361ee8/href">https://medium.com/media/f91254fc9ba7b6dd58b00f5412361ee8/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9dd937f52287de3cf2c53cebcfbe1da8/href">https://medium.com/media/9dd937f52287de3cf2c53cebcfbe1da8/href</a></iframe><p>Agora, com a supressão de <em>ClockDriver</em> e <em>TimeSink</em>, a função <em>SetObserver</em> de <em>TimeSource </em>pode ser alterada para <strong>RegisterObserver</strong>, habilitando a manipulação de vários objetos <em>ClockObserver</em>. Tal ajuste provoca os seguintes impactos nas classes da solução.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ec8c0b155dd97310a1f03b95a3a0c1e8/href">https://medium.com/media/ec8c0b155dd97310a1f03b95a3a0c1e8/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ad363943c5d6765761e43ae17afdea3d/href">https://medium.com/media/ad363943c5d6765761e43ae17afdea3d/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2fab33401517186a7a52d082c4a7728f/href">https://medium.com/media/2fab33401517186a7a52d082c4a7728f/href</a></iframe><p>Porém, ainda há uma oportunidade de melhoria. Como <em>TimeSource </em>é uma interface, todo o código de registro e atualização precisa ser duplicado ao criar implementações que sigam o seu contrato, a exemplo de <em>MockTimeSource </em>e <em>Clock</em>.</p><p>Desse jeito, uma ideia inteligente decorre da transformação de <em>TimeSource </em>em um <strong>tipo abstrato</strong>, movendo os métodos comuns para a sua definição.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/490564d3784c2b50f2801951d32a5d18/href">https://medium.com/media/490564d3784c2b50f2801951d32a5d18/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/081b9a1f0d898ec1fc0edc2dc6e1dd70/href">https://medium.com/media/081b9a1f0d898ec1fc0edc2dc6e1dd70/href</a></iframe><h3>Abraçando o padrão Observer</h3><p>Depois de inúmeras mudanças no código-fonte, a estrutura das classes do problema do relógio digital está muito próxima ao design pattern <em>Observer</em>. No entanto, restam algumas formalidades para afirmarmos que o padrão foi implementado na prática.</p><p>Primeiramente, os textos originais de <em>Observer </em>apelidam uma classe como <em>TimeSource</em>, que registra e atualiza dados, de <strong>Subject</strong>. Mas, para que <em>TimeSource </em>se torne uma <strong>classe genérica</strong> e possa ser identificada pelo nome <em>Subject</em>, outra alteração deve ser realizada — trocar o funcionamento das classes do <strong>modelo push</strong> para o <strong>modelo pull</strong>.</p><p>Na literatura do pattern, os observadores “modelo push” se encarregam de transferir os dados do <em>Subject </em>para o observador, a partir das funções <strong>Notify </strong>e <strong>Update</strong>. Já os observadores “modelo pull” dependem exclusivamente do objeto observador para consultar o objeto observado.</p><p>Portanto, <em>MockTimeSink </em>pode perguntar a hora para <em>MockTimeSource</em>. Basta criar uma interface que <em>MockTimeSink </em>possa depender e descubra o horário atual — <strong>TimeSource</strong>, desacoplando-a de <em>MockTimeSource</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/21ef1a838a16a3ceb599a611ae1784d5/href">https://medium.com/media/21ef1a838a16a3ceb599a611ae1784d5/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ac1d1bd671acb2130f64c36c13b2dc3f/href">https://medium.com/media/ac1d1bd671acb2130f64c36c13b2dc3f/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/331568957f9116c3276077b07770dc3b/href">https://medium.com/media/331568957f9116c3276077b07770dc3b/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/212398fba7d9f58cdffe9cc1fd25fb60/href">https://medium.com/media/212398fba7d9f58cdffe9cc1fd25fb60/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/76f50e52101a26cb371cc70bbaa05c00/href">https://medium.com/media/76f50e52101a26cb371cc70bbaa05c00/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/336db304d4c8b09361d8a43b899ec281/href">https://medium.com/media/336db304d4c8b09361d8a43b899ec281/href</a></iframe><p>Com isso, finalmente o projeto apresentado atingiu o modelo canônico de <em>Observer</em>. <em>Clock</em>/<em>MockTimeSource </em>é observado por <em>DigitalClock</em>/<em>MockTimeSink</em>, que se registra na interface de <em>Subject</em>. Em qualquer mudança de horário, <em>Clock</em>/<em>MockTimeSource </em>invoca a função Notify, que por sua vez chama o método Update de cada implementação de <em>Observer</em>. Consequentemente, <em>DigitalClock</em>/<em>MockTimeSink</em> recebe uma atualização de horário de Update, obtendo os novos valores de <em>Clock</em>/<em>MockTimeSource</em>.</p><h3>Push versus Pull</h3><p>A resolução definitiva do problema do relógio digital de Uncle Bob nos mostrou que o padrão <em>Observer </em>pode possuir dois modelos: <strong>push </strong>e <strong>pull</strong>.</p><p>A última versão do código-fonte utilizou a abordagem pull, na qual <em>DigitalClock</em>/<em>MockTimeSink </em>extrai as informações de hora do objeto <em>Clock</em>/<em>MockTimeSource</em>.</p><p>Visualizando os seus pontos fortes, o modelo pull dispõe de uma fácil implementação, além de viabilizar uma reutilização das classes <em>Subject </em>e <em>Observer </em>para <em>n</em> cenários.</p><p>Ainda assim, algumas situações não são bem gerenciadas pelo modelo pull. Por exemplo, suponhamos que registros de objetos que representem um funcionário estejam sendo observados, e estes possuam centenas de propriedades. Quando uma mensagem for enviada por Update, como descobrir quais campos foram alterados?</p><p>Em circunstâncias semelhantes, o modelo push se destaca e possui uma melhor serventia. Nesse caso, os métodos Notify e Update recebem um argumento, que indica qual propriedade de Employee passou por mudanças.</p><figure><img alt="Diagrama de classes elaborado por Robert C. Martin para mostrar o padrão Observer no modelo push" src="https://cdn-images-1.medium.com/max/1024/1*VVccWdWJA2KCD-IdsX_zwQ.jpeg" /><figcaption>Diagrama de classes do padrão Observer no modelo push</figcaption></figure><p>A escolha entre pull e push irá depender da <strong>complexidade do objeto em observação</strong>. De acordo com o que acabou de ser retratado, objetos complexos se adaptam de modo superior ao paradigma push. Por outro lado, objetos simples se relacionam bem com o paradigma pull.</p><h3>Uma observação final</h3><p>Pessoalmente, acredito que o padrão de projetos <em>Observer </em>é um dos mais interessantes que já estudei. Ele pode solucionar diversos problemas, oferecendo ao desenvolvedor a capacidade de decidir entre dois modelos de implementação.</p><p>Entretanto, julgo ser importante finalizar a publicação com uma observação de Robert C. Martin, que nos alerta sobre a aplicabilidade deste design pattern.</p><blockquote>Depois que você entende o padrão Observer, vê usos para ele por toda parte. Com a indireção, é possível registrar observadores em todos os tipos de objetos, em vez de escrever esses objetos explicitamente para chamar você. Embora a indireção seja uma maneira interessante de gerenciar dependências, ela pode ser levada a extremos facilmente. O abuso de Observer tende a tornar os sistemas difíceis de entender e rastrear.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c39b0c86c1c2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/o-design-pattern-observer-nas-palavras-de-uncle-bob-c39b0c86c1c2">O design pattern Observer nas palavras de Uncle Bob</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O design pattern Null Object nas palavras de Uncle Bob]]></title>
            <link>https://medium.com/fora-de-assunto/o-design-pattern-null-object-nas-palavras-de-uncle-bob-1525dd7ff55e?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/1525dd7ff55e</guid>
            <category><![CDATA[uncle-bob]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[null]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[null-object]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Wed, 07 Dec 2022 17:44:32 GMT</pubDate>
            <atom:updated>2022-12-07T17:44:32.492Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>No último post do <strong>Fora de Assunto</strong>, continuamos a nossa longa trajetória de aprendizado envolvendo os padrões de projeto. Os design patterns apresentados anteriormente foram o <em>Singleton </em>e <em>Monostate</em>, que se sobressaíram por sua capacidade de manter a singularidade de objetos instanciados em um programa.</p><p><a href="https://medium.com/fora-de-assunto/os-design-patterns-template-method-e-strategy-nas-palavras-de-uncle-bob-2a3cd3147600">Os design patterns Template Method e Strategy nas palavras de Uncle Bob</a></p><p>Prosseguindo com a série, hoje entenderemos as particularidades do padrão <strong>Null Object</strong>. Assim como nas demais postagens, consultei informações dos textos de Robert C. Martin em P<em>rincípios, Padrões e Práticas Ágeis em C#</em>.</p><h3>Buscando a simplificação</h3><p>A principal proposta do design pattern <em>Null Object</em> pode ser compreendida a partir de um breve trecho de código desenvolvido por Robert C. Martin. Vamos conferir.</p><figure><img alt="Trecho de código desenvolvido com a linguagem de programação C# para apresentar o padrão de projeto Null Object." src="https://cdn-images-1.medium.com/max/926/1*TqUjKr2vGF-Xk0EScnring.png" /><figcaption>Recuperando o funcionário de nome ‘Bob’ do banco de dados</figcaption></figure><p>A primeira linha de código do exemplo anterior busca a instância de um objeto do tipo <em>Employee </em>do banco de dados. Neste caso, se não houver um funcionário registrado com o nome ‘Bob’, o método <em>GetEmployee </em>retornará <em>null</em>. Para que a função <em>Pay</em> seja chamada, o funcionário deve existir e estar apto a receber um pagamento.</p><p>Qualquer programador que trabalhe com Java, C# e outras linguagens orientadas a objeto, provavelmente escreveu um código parecido com este que acabou de ser demonstrado. Digo isso porque é comum verificarmos se uma instância está nula antes de utilizá-la, de modo a evitar o lançamento de exceções.</p><p>Contudo, mesmo com a evolução das <em>features </em>disponibilizadas pelas novas versões das linguagens de programação que auxiliam na checagem de valores nulos, muitos desenvolvedores ainda sofrem com os famosos erros advindos da <em>NullReferenceException</em>. Além disso, a própria verificação se um objeto está nulo polui o código-fonte, dificultando a sua legibilidade.</p><p>Há programadores que julguem ser uma opção melhor lançar exceções explicitamente no lugar de retornar objetos nulos. Todavia, esse tipo de solução não costuma ter um impacto positivo, pois os blocos <em>try/catch</em> também são deselegantes, e podem diminuir a eficiência do código.</p><p>O padrão de projetos <em>Null Object</em> desponta como uma das melhores saídas para o cenário abordado até então. Esse pattern acaba com a obrigatoriedade de checar se um objeto está nulo, além de não exigir o tratamento defensivo de exceções. Logo, ele <strong>simplifica o código</strong> elaborado pelos desenvolvedores, tornando-o mais limpo.</p><h3>Implementando o padrão</h3><p>Da mesma forma que o padrão <em>Null Object</em> proporciona a simplificação do código, a sua implementação não deixa a desejar, sendo portanto bastante descomplicada. Para comprovar isso, mostro a seguir o diagrama de classes criado por Martin, que explica o funcionamento do design pattern.</p><figure><img alt="Diagrama de classes ilustrando os mecanismos do padrão de projetos Null Object" src="https://cdn-images-1.medium.com/max/1024/1*hn_EcZgxiCRdpzVzXRXMNQ.jpeg" /><figcaption>Diagrama de classes ilustrando os mecanismos do padrão Null Object</figcaption></figure><p>Conforme pode ser observado, <em>Employee </em>é adaptada para uma interface, que possui duas implementações. A classe <em>EmployeeTransaction</em> é a implementação padrão do objeto. Assim sendo, quando a classe <em>DB </em>localizar um funcionário no banco de dados, retornará uma instância desse tipo.</p><p>Por outro lado, se DB não encontrar o funcionário pesquisado, agora com a nova estrutura do padrão <em>Null Object</em>, o método <em>GetEmployee </em>retornará uma instância de <em>NullEmployee</em>. Esse tipo implementa os mesmos métodos de <em>EmployeeTransaction</em>, com a diferença que eles não fazem absolutamente nada.</p><p>Com as mudanças aplicadas por <em>Null Object</em>, o primeiro trecho de código incluído no artigo pode ficar da seguinte maneira:</p><figure><img alt="Nova forma de consumir o método GetEmployee com o suporte do padrão Null Object" src="https://cdn-images-1.medium.com/max/926/1*4kvrd27G6ImcNBveK4PG7w.png" /><figcaption>Nova forma de consumir o método GetEmployee com o suporte do padrão Null Object</figcaption></figure><p>Diferente da alternativa de lançar exceções para funcionários não localizados, esta abordagem é visualmente agradável e sem propensão a erros inesperados. O método <em>GetEmployee </em>sempre irá retornar uma instância de <em>Employee</em>, que por sua vez se comportará corretamente, independente de ter sido buscada com sucesso do banco de dados.</p><figure><img alt="Implementação do design pattern Null Object com a linguagem de programação C#" src="https://cdn-images-1.medium.com/max/1024/1*G6_myy0BBjWaW_q7mTbOwg.png" /><figcaption>Implementação do design pattern Null Object</figcaption></figure><p>O código da classe abstrata <em>Employee </em>está exposto na imagem acima. Ela possui uma variável estática chamada <em>NULL</em>, que armazena a única instância da classe aninhada <em>NullEmployee</em>.</p><p>A estratégia de definir <em>NullEmployee </em>como um tipo privado aninhado é interessante. Isso garante que apenas uma instância dela irá existir por todo o sistema, remetendo ao padrão <strong>Singleton</strong>.</p><p>A variável estática <em>NULL </em>serve como uma referência para os consumidores de <em>Employee </em>que precisarem saber se um funcionário foi encontrado pelo método <em>GetEmployee.</em></p><figure><img alt="Verificação de objetos nulos com o padrão de projetos Null Object" src="https://cdn-images-1.medium.com/max/1024/1*CsbVkhYP2kyAh-ZTgHGovA.png" /><figcaption>Verificação se o funcionário ‘Bob’ foi localizado</figcaption></figure><h3>O poder de Null Object</h3><p>Mantendo a tradição das outras publicações sobre os padrões de projeto, finalizo este artigo com uma citação do Uncle Bob, que destaca as vantagens oportunizadas pelo <em>Null Object</em>.</p><blockquote>Aqueles que têm usado linguagens baseadas em C há muito tempo se acostumaram com funções que retornam null ou 0 em caso de alguma falha. Presumimos que o valor de retorno de tais funções precisa ser testado. O padrão Null Object muda isso. Usando esse padrão, podemos garantir que as funções sempre retornem objetos válidos, mesmo quando falham.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1525dd7ff55e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/o-design-pattern-null-object-nas-palavras-de-uncle-bob-1525dd7ff55e">O design pattern Null Object nas palavras de Uncle Bob</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Os design patterns Singleton e Monostate nas palavras de Uncle Bob]]></title>
            <link>https://medium.com/fora-de-assunto/os-design-patterns-singleton-e-monostate-nas-palavras-de-uncle-bob-f2d1bec6a02c?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/f2d1bec6a02c</guid>
            <category><![CDATA[singleton]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[uncle-bob]]></category>
            <category><![CDATA[monostate]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Wed, 30 Nov 2022 18:02:39 GMT</pubDate>
            <atom:updated>2022-11-30T18:02:39.780Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>Hoje darei continuidade à nova série de artigos do <strong>Fora de Assunto</strong>, focada nos design patterns das linguagens orientadas a objetos. Os últimos padrões abordados foram o Façade e Mediator, encarregados de impor diretivas para os seus clientes.</p><p><a href="https://medium.com/fora-de-assunto/os-design-patterns-fa%C3%A7ade-e-mediator-nas-palavras-de-uncle-bob-26cb3d09c76d">Os design patterns Façade e Mediator nas palavras de Uncle Bob</a></p><p>Esta postagem apresentará mais dois padrões — Singleton e Monostate, que possuem características em comum. Do mesmo modo que em outros artigos, trarei o conteúdo obtido dos capítulos escritos por Robert C. Martin em <strong>Princípios, Padrões e Práticas Ágeis em C#</strong>.</p><h3>Buscando a singularidade</h3><p>Em grande parte dos programas que escrevemos, muitas instâncias das nossas classes são criadas, e posteriormente descartadas quando cumprem o seu propósito dentro de uma funcionalidade.</p><p>Contudo, dependendo da situação, pode ser que a instanciação de múltiplos objetos não seja o ideal, ou até mesmo permitida dentro do contexto de um novo desenvolvimento. Nesses casos, devemos limitar que determinadas classes possuam somente uma instância, desde o início até o fim da execução da aplicação.</p><p>Geralmente, objetos que exigem essa premissa são <strong>fábricas</strong>, utilizadas para criar outros objetos do sistema. Em outros momentos, os objetos em questão são <strong>gerenciadores</strong>, que monitoram e orquestram uma quantidade considerável de dependências.</p><p>Existe um mecanismo chamado <strong>Just Create One</strong>, que simplifica a necessidade de instanciar um único objeto de uma classe. Nesse padrão, o desenvolvedor, de fato, cria apenas uma instância do objeto no seu programa e se da por satisfeito. Essa abordagem, porém, transmite pouca expressividade no código, e não deixa claro para os demais programadores que outros objetos não devem ser construídos.</p><p>Para resolver esse problema, dois design patterns foram elaborados para impor a <strong>singularidade de objetos</strong>: <em>Singleton </em>e <em>Monostate</em>. Embora possuam o mesmo objetivo, as suas implementações são completamente distintas, e trazem vantagens e desvantagens particulares.</p><h3>Singleton</h3><p>O padrão de projeto <em>Singleton </em>é um dos mais fáceis de se implementar. Para comprovar isso, podemos observar um dos exemplos programados por Robert C. Martin.</p><figure><img alt="Definição básica do padrão de projeto Singleton na linguagem de programação C#" src="https://cdn-images-1.medium.com/max/1024/1*_Fggq9FzDJ4V5PGRFF0HRQ.png" /><figcaption>Definição básica do design pattern Singleton</figcaption></figure><p>A instância da classe <em>Singleton </em>pode ser acessada com a propriedade pública <em>Instance</em>. Se <em>Instance </em>for chamada várias vezes, uma referência para a mesma instância será retornada, sem exceções. A classe não possui construtores públicos, logo não há como criar um objeto sem usar a propriedade já mencionada.</p><p>Uncle Bob destaca as seguintes vantagens de usar o padrão <em>Singleton</em>:</p><ul><li><strong>Suporte a Lazy Loading</strong>: caso a classe <em>Singleton </em>não seja invocada, a instância jamais será criada;</li><li><strong>Suporte a derivação</strong>: dada qualquer classe, é possível implementar uma subclasse <em>Singleton</em>;</li><li><strong>Suporte a qualquer classe</strong>: se for preciso, qualquer classe pode ser transformada em um <em>Singleton</em>, bastando tornar os construtores privados e incluir os métodos/propriedades estáticas requeridas.</li></ul><p>Assim como qualquer pattern, <em>Singleton </em>também possui os seus custos:</p><ul><li><strong>Eficiência</strong>: sempre que a propriedade <em>Instance </em>é chamada, a instrução <em>if</em> acaba sendo verificada. Isso caracteriza um gasto desnecessário de processamento (mesmo que baixo), pois para a maioria dos cenários, a checagem não terá mais utilidade;</li><li><strong>Falta de transparência</strong>: necessariamente, todos os usuários de uma classe <em>Singleton </em>sabem que estão consumindo este padrão, dado que a propriedade <em>Instance </em>deve ser usada;</li><li><strong>Destruição indefinida</strong>: objetos <em>Singleton </em>são difíceis de serem destruídos, ou seja, liberados da memória. Por exemplo, se o programador incluir um método que anula o campo <em>theInstance</em>, outras classes ainda podem referenciar o <em>Singleton</em>. Logo, outras invocações para <em>Instance </em>criarão mais uma instância, duplicando-a.</li></ul><h3>Monostate</h3><p>O design pattern <em>Monostate </em>atua de forma diferente do <em>Singleton </em>para alcançar a singularidade de objetos. A seguir temos um trecho de código criado por Martin para ilustrar o mecanismo do padrão.</p><figure><img alt="Definição básica do padrão de projeto Monostate na linguagem de programação C#" src="https://cdn-images-1.medium.com/max/812/1*1auN5nortQWKYIOqSqnugA.png" /><figcaption>Definição básica do design pattern Monostate</figcaption></figure><p>Conforme a definição da classe <em>Monostate</em>, percebe-se que os objetos instanciados compartilharão a variável <em>itsX</em>. Isso porque ela foi declarada internamente como estática.</p><p>A distinção em relação à <em>Singleton </em>está no <strong>comportamento x estrutura</strong>. Enquanto <em>Singleton </em>força a estrutura da singularidade, impedindo que mais instâncias sejam criadas, <em>Monostate </em>impõe o comportamento da singularidade, permitindo a instanciação de vários objetos.</p><p>Robert Martin ressalta os benefícios de usar <em>Monostate</em>:</p><ul><li><strong>Transparência</strong>: os clientes da classe <em>Monostate </em>se comportam do mesmo jeito que os clientes de classes que não utilizam o padrão;</li><li><strong>Derivação</strong>: as subclasses de um <em>Monostate </em>também são <em>Monostate</em>. Todas compartilham as mesmas variáveis estáticas;</li><li><strong>Polimorfismo</strong>: os métodos de um <em>Monostate </em>não são estáticos, habilitando a sobrescrita de funções;</li><li><strong>Destruição definida</strong>: opondo-se ao <em>Singleton</em>, as variáveis de um <em>Monostate </em>possuem o seu ciclo de vida (criação e destruição) bem definido.</li></ul><p>As desvantagens da aplicabilidade do padrão estão listadas abaixo:</p><ul><li><strong>Ausência de conversão</strong>: classes que não são <em>Monostate</em> não podem ser convertidas em <em>Monostate </em>a partir de derivação;</li><li><strong>Eficiência</strong>: tendo em vista que <em>Monostate </em>habilita a criação e destruição de múltiplas instâncias, isto pode ter um custo considerável durante a execução do sistema;</li><li><strong>Memória</strong>: independente da utilização de um <em>Monostate</em>, as suas variáveis irão ocupar espaço.</li></ul><h3>Escolhendo entre Singleton e Monostate</h3><p>De acordo com o funcionamento dos padrões <em>Singleton </em>e <em>Monostate</em>, qual dos dois escolher quando for preciso impor a singularidade de objetos?</p><p>Robert C. Martin deu a resposta para esta pergunta na sua obra:</p><blockquote>O melhor uso do padrão Singleton se dá quando você tem uma classe que deseja restringir por meio de derivação e não se importa que todo mundo tenha que chamar a propriedade Instance. O melhor uso do padrão Monostate se dá quando você quer que a natureza singular da classe seja transparente para os usuários ou quando quer usar derivadas polimórficas do único objeto.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f2d1bec6a02c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/os-design-patterns-singleton-e-monostate-nas-palavras-de-uncle-bob-f2d1bec6a02c">Os design patterns Singleton e Monostate nas palavras de Uncle Bob</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Os design patterns Façade e Mediator nas palavras de Uncle Bob]]></title>
            <link>https://medium.com/fora-de-assunto/os-design-patterns-fa%C3%A7ade-e-mediator-nas-palavras-de-uncle-bob-26cb3d09c76d?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/26cb3d09c76d</guid>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[uncle-bob]]></category>
            <category><![CDATA[facade]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[mediator-pattern]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Wed, 16 Nov 2022 14:25:47 GMT</pubDate>
            <atom:updated>2022-11-16T14:28:26.945Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>Há algumas semanas, o <strong>Fora de Assunto</strong> introduziu uma nova série de artigos, concentrada nos padrões de projeto. Os últimos design patterns apresentados foram o Template Method e Strategy, que se destacaram por sua capacidade de separar os detalhes de implementação de algoritmos genéricos.</p><p><a href="https://medium.com/fora-de-assunto/os-design-patterns-template-method-e-strategy-nas-palavras-de-uncle-bob-2a3cd3147600">Os design patterns Template Method e Strategy nas palavras de Uncle Bob</a></p><p>Hoje veremos mais dois padrões —Façade e Mediator, que compartilham várias semelhanças. Assim como nas outras publicações, trarei informações retiradas dos textos de Robert C. Martin em <strong>Princípios, Padrões e Práticas Ágeis em C#</strong>.</p><h3>Façade</h3><p>A proposta do padrão <strong>Façade </strong>é estabelecer uma interface simplificada e específica para os seus clientes, a partir de um grupo de objetos que sejam mais complexos. Podemos notar isso observando a classe <em>Db</em>, implementada por Robert Martin. Ela publica uma <em>API </em>extremamente fácil de se entender e utilizar, direcionada apenas para o tipo <em>ProductData</em>, que por de baixo dos panos consome as dependências da biblioteca <em>System.Data</em>.</p><figure><img alt="Implementação em C# da classe Db com o uso do padrão Façade" src="https://cdn-images-1.medium.com/max/1024/1*3hk5K8YXH7OZ3Ei3NOaf8g.png" /><figcaption>Implementação da classe Db com o uso do padrão Façade</figcaption></figure><p>A beleza do pattern está em ocultar toda a dificuldade imposta pelo namespace <em>System.Data</em>, de modo que quem chama os métodos públicos da classe <em>Db </em>não tem qualquer conhecimento de como a conexão com o banco de dados está sendo feita.</p><blockquote>Uma fachada como Db impõe muitas diretivas em relação ao uso de System.Data, sabendo como inicializar e fechar a conexão com o banco de dados, transformar os membros de ProductData em campos de banco de dados e desfazer essa transformação.</blockquote><p>Ao escolher este padrão para desenvolver a classe <em>Db</em>, o autor do código conscientemente definiu um contrato para se conectar com o banco de dados da aplicação. Caso algum trecho faça a conexão com <em>System.Data</em> sem intermediários, violará a convenção estipulada. Assim sendo, é possível afirmar que o design pattern Façade institui as suas <strong>diretivas </strong>no programa em questão.</p><h3>Mediator</h3><p>Do mesmo jeito que o padrão <em>Façade</em>, o <strong>Mediator </strong>impõe diretivas que devem ser seguidas pelo código cliente. Entretanto, há duas diferenças claras entre esses patterns.</p><p>A primeira delas é que o Mediator define as suas regras de forma oculta, enquanto o Façade faz isto explicitamente. Já a segunda distinção está relacionada com as restrições causadas pelos padrões. O Mediator não restringe o consumidor que utilizá-lo como dependência, embora o Façade funcione de maneira oposta, trazendo restrições.</p><figure><img alt="Implementação em C# da classe QuickEntryMediator com o uso do padrão Mediator" src="https://cdn-images-1.medium.com/max/1024/1*j96lpI_cQ_zxWnhjwWEwog.png" /><figcaption>Implementação da classe QuickEntryMediator com o uso do padrão Mediator</figcaption></figure><p>Para compreendermos com maior precisão o mecanismo do padrão Mediator, podemos utilizar como base o exemplo acima, também elaborado por Robert Martin.</p><p>A classe <em>QuickEntryMediator </em>recebe em seu construtor dois componentes da biblioteca <strong>Windows Forms</strong>: <em>TextBox </em>e <em>ListBox</em>. No ato de sua instanciação, um <strong>EventHandler </strong>é registrado na variável <em>TextBox</em>. Quando uma alteração no texto desse componente acontecer, o método <em>TextFieldChanged</em> será invocado. Essa função se responsabiliza por encontrar e selecionar um item do <em>ListBox </em>que tenha em seu prefixo o texto digitado no <em>TextBox</em>.</p><p>Percebam que os clientes de <em>ListBox </em>e <em>TextBox </em>não possuem conhecimento deste objeto Mediator. Ele é criado no início do programa, e a partir deste momento monitora quaisquer mudanças realizadas no <em>TextBox</em>, impondo portanto as suas diretivas silenciosamente.</p><h3>Escolhendo entre Façade e Mediator</h3><p>Tenho quase certeza que uma das principais dúvidas de quem está conhecendo estes design patterns é qual dos dois escolher quando for necessário criar diretivas em uma aplicação. Para solucionar esse questionamento, nada melhor do que recorrer às sugestões de Uncle Bob em seu livro:</p><blockquote>A imposição de diretivas pode ser feita a partir de cima usando o padrão Façade, caso esta diretiva precise ser grande e visível. Por outro lado, se são necessárias sutileza e discrição, o padrão Mediator pode ser a escolha mais adequada. As fachadas são o ponto focal de uma convenção. Todos concordam em utilizá-la. O padrão Mediator fica oculto dos usuários. Sua diretiva é um fato consumado, em vez de uma questão de convenção.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26cb3d09c76d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/os-design-patterns-fa%C3%A7ade-e-mediator-nas-palavras-de-uncle-bob-26cb3d09c76d">Os design patterns Façade e Mediator nas palavras de Uncle Bob</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Os design patterns Template Method e Strategy nas palavras de Uncle Bob]]></title>
            <link>https://medium.com/fora-de-assunto/os-design-patterns-template-method-e-strategy-nas-palavras-de-uncle-bob-2a3cd3147600?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/2a3cd3147600</guid>
            <category><![CDATA[strategy]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[template-method]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[design-patterns]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Wed, 19 Oct 2022 11:49:29 GMT</pubDate>
            <atom:updated>2022-10-19T11:49:29.189Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>No último artigo publicado no <strong>Fora de Assunto</strong>, iniciamos uma jornada pelo universo dos padrões de projeto. O primeiro design pattern apresentado foi o <em>Command</em>, que se destacou por sua versatilidade.</p><p><a href="https://medium.com/fora-de-assunto/o-design-pattern-command-nas-palavras-de-uncle-bob-757bcc08d874">O design pattern Command nas palavras de Uncle Bob</a></p><p>Dando continuidade a esta série, hoje veremos dois padrões de uma só vez — <strong>Template Method </strong>e <strong>Strategy</strong>. Assim como na publicação sobre o Command, trarei informações no que tange a esses patterns tendo como base os textos de Robert C. Martin em <em>Princípios, Padrões e Práticas Ágeis em C#</em>.</p><h3>Herança x Delegação</h3><p>Segundo os relatos de Martin, durante a década de 1990, quando a orientação a objetos estava dando os seus primeiros passos, o conceito de <strong>herança </strong>se popularizou entre os programadores. Isso porque este pilar da <em>POO </em>permitia que os desenvolvedores reaproveitassem boa parte do seu código, modificando apenas operações específicas nas subclasses.</p><p>Entretanto, não demorou muito tempo para que algumas pessoas notassem os impactos de se utilizar a herança de modo desgovernado. Uncle Bob conta que foi a partir de 1995, na época em que Gamma, Helm, Johnson e Vlissides lançaram o seu famoso livro de <em>design patterns</em>, que os efeitos colaterais da herança foram expostos de fato. Inclusive, os autores destacaram o seguinte:</p><blockquote>Favoreça a composição de objetos (delegação) em detrimento da herança de classe.</blockquote><p>A dicotomia entre herança e delegação pode ser bem retratada pelos padrões de projeto <strong>Template Method</strong> e <strong>Strategy</strong>.<strong> </strong>Os dois patterns resolvem o mesmo problema, que basicamente se resume a <strong>separar um algoritmo genérico de um contexto detalhado</strong>.</p><h3>Template Method</h3><p>Com o objetivo de assimilarmos o funcionamento do padrão <em>Template Method</em>, mostrarei a seguir vários trechos de código elaborados por Robert Martin em sua obra.</p><p>Para os programadores de C#, gostaria apenas de fazer uma observação. Os exemplos foram feitos em uma época que ainda não tínhamos o recurso de <strong>Generics </strong>na linguagem, e por conta disto a solução exigiu uma abordagem diferente.</p><p>Sem mais delongas, considerem uma classe responsável por ordenar um array de inteiros usando o algoritmo <strong>Bubble Sort</strong>.</p><figure><img alt="Código da classe chamada BubbleSorter implementada com a linguagem de programação C#" src="https://cdn-images-1.medium.com/max/1024/1*13BA2sXRg21FmrsDVOK4Ug.png" /><figcaption>Classe BubbleSorter sem a utilização do Template Method</figcaption></figure><p>Reparem que o método <em>Sort </em>encapsula a lógica de ordenação. Ele consome os outros dois métodos da classe, <em>Swap </em>e <em>CompareAndSwap</em>, que manipulam o array e se responsabilizam pelos detalhes do algoritmo.</p><p>A estrutura de <em>BubbleSorter</em> pode ser melhorada com a implementação do pattern Template Method. Aplicando essa refatoração, a classe não terá mais a preocupação de saber qual é o tipo do vetor sendo ordenado, e irá transferir ainda a responsabilidade de comparar e trocar elementos fora de ordem para as suas subclasses.</p><figure><img alt="Código refatorado para o padrão Template Method da classe chamada BubbleSorter implementada com a linguagem de programação C#" src="https://cdn-images-1.medium.com/max/1024/1*KBvz5NMHTwzdvomX_cn9wQ.png" /><figcaption>Classe BubbleSorter com a utilização do Template Method</figcaption></figure><p>Agora que <em>BubbleSorter</em> é uma classe abstrata e está aberta para ser herdada, várias classes derivadas podem ser criadas com o intuito de ordenar não apenas arrays de inteiros, mas de qualquer tipo desejado.</p><figure><img alt="Código da classe derivada de BubbleSorter chamada IntBubbleSorter na linguagem de programação C#" src="https://cdn-images-1.medium.com/max/1024/1*lGLAlskcB8vjNYRnEBxHzg.png" /><figcaption>Classe derivada IntBubbleSorter</figcaption></figure><figure><img alt="Código da classe derivada de BubbleSorter chamada DoubleBubbleSorter na linguagem de programação C#" src="https://cdn-images-1.medium.com/max/1024/1*WELceiG4mA6ZRyHmgquAZA.png" /><figcaption>Classe derivada DoubleBubbleSorter</figcaption></figure><p>Contudo, o uso do Template Method traz algumas desvantagens. Por se basear na herança, as classes derivadas acabam ficando muito acopladas em relação às superclasses. Os métodos <em>OutOfOrder</em> e <em>Swap </em>seguem o mesmo princípio em outros algoritmos de ordenação, mas não podem ser reaproveitados desta forma.</p><h3>Strategy</h3><p>O design pattern <em>Strategy </em>se propõe a resolver os mesmos problemas do Template Method, porém de uma maneira totalmente distinta. Para compreendermos isso, vamos observar o exemplo da classe <em>BubbleSorter</em>, desta vez construída sob o prisma do padrão Strategy.</p><figure><img alt="Código refatorado para o padrão Strategy da classe chamada BubbleSorter implementada com a linguagem de programação C#" src="https://cdn-images-1.medium.com/max/1024/1*jITmuU3DawHI163CCxv8AA.png" /><figcaption>Classe BubbleSorter com a utilização do Strategy</figcaption></figure><figure><img alt="Interface ISortHandler utilizada na solução com o uso do design pattern Strategy na linguagem de programação C#" src="https://cdn-images-1.medium.com/max/850/1*FFLPFYXoxCjV9G-7CjTL1Q.png" /><figcaption>Interface ISortHandler</figcaption></figure><figure><img alt="Implementação IntSortHandler da interface ISortHandler utilizada na solução com o uso do design pattern Strategy na linguagem de programação C#" src="https://cdn-images-1.medium.com/max/1024/1*1GiYvGri7OZrdw0GgeOG-g.png" /><figcaption>Implementação IntSortHandler</figcaption></figure><p>Em oposição ao que foi retratado com o Template Method, <em>IntSortHandler </em>não tem qualquer conhecimento de <em>BubbleSorter</em>, e portanto não depende do algoritmo em questão.</p><p>A estrutura do pattern Template Method desobedece parcialmente o princípio da <strong>Inversão de Dependência</strong>, pois <em>Swap </em>e <em>OutOfOrder </em>dependem da ordenação por bolhas. Por outro lado, a partir da aplicabilidade de Strategy, <em>IntSortHandler </em>pode ser consumido por outros algoritmos de ordenação.</p><p>A afirmação do último parágrafo pode ser comprovada através de mais um exemplo. Imagine que um programa necessite de um algoritmo de ordenação por bolhas otimizado. Ao implementar essa classe, é possível reaproveitarmos a instância de <em>IntSortHandler </em>no novo algoritmo proposto.</p><figure><img alt="Implementação QuickBubbleSorter utilizada na solução com o uso do design pattern Strategy na linguagem de programação C#" src="https://cdn-images-1.medium.com/max/1024/1*SoQuW6RU7ZhIyyLn_n1hMw.png" /><figcaption>Classe QuickBubbleSorter com a utilização do Strategy</figcaption></figure><h3>Template Method ou Strategy?</h3><p>É natural que depois de conhecer cada um dos padrões, vocês estejam se perguntando qual dos dois utilizar em uma solução do dia a dia. Para responder a essa última pergunta, deixo logo a seguir a conclusão de Uncle Bob a respeito do dilema entre Template Method e Strategy.</p><blockquote>O padrão Template Method é simples de escrever e utilizar, mas também é rígido. O padrão Strategy é flexível, mas você precisa criar uma classe extra, instanciar um objeto extra e ligar o objeto extra ao sistema. Portanto, a escolha entre os dois depende de você precisar da flexibilidade de Strategy ou poder conviver com a simplicidade de Template Method.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2a3cd3147600" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/os-design-patterns-template-method-e-strategy-nas-palavras-de-uncle-bob-2a3cd3147600">Os design patterns Template Method e Strategy nas palavras de Uncle Bob</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O design pattern Command nas palavras de Uncle Bob]]></title>
            <link>https://medium.com/fora-de-assunto/o-design-pattern-command-nas-palavras-de-uncle-bob-757bcc08d874?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/757bcc08d874</guid>
            <category><![CDATA[uncle-bob]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[commands]]></category>
            <category><![CDATA[object-oriented]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Wed, 14 Sep 2022 12:47:43 GMT</pubDate>
            <atom:updated>2022-09-14T12:47:43.582Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>O mundo da programação orientada a objetos está repleto de <strong>padrões de projeto</strong>, também conhecidos como <em>design patterns</em>. Muitos deles foram elaborados e condensados pela <em>Gang Of Four</em>, que trouxe uma gigantesca contribuição para a comunidade de desenvolvimento de software.</p><p>No artigo de hoje, abordarei o pattern Command. Ele figura na lista dos padrões apresentados originalmente por Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides. Porém, a minha introdução do padrão será feita sob a óptica do ilustríssimo Uncle Bob.</p><h3>Command e a simplicidade</h3><p>Na sua obra <strong>Princípios, Padrões e Práticas Ágeis em C#</strong>, Robert Martin coloca o padrão de projeto Command na lista dos mais simples e elegantes. Entretanto, o autor faz um aviso importante: ainda que seja um <em>pattern</em> descomplicado, Command possui uma aplicabilidade praticamente infinita, característica que o torna útil para diversas ocasiões.</p><p>Conforme podemos visualizar logo a seguir, Command é composto apenas por uma interface contendo o método void <strong>Execute</strong>. Assim sendo, entende-se a razão de Uncle Bob descrevê-lo como um padrão simples.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fcarbon.now.sh%2Fembed%3Fbg%3Drgba%2528225%252C226%252C228%252C1%2529%26t%3Dvscode%26wt%3Dnone%26l%3Dtext%252Fx-csharp%26width%3D680%26ds%3Dtrue%26dsyoff%3D20px%26dsblur%3D68px%26wc%3Dtrue%26wa%3Dtrue%26pv%3D56px%26ph%3D56px%26ln%3Dfalse%26fl%3D1%26fm%3DHack%26fs%3D14px%26lh%3D133%2525%26si%3Dfalse%26es%3D2x%26wm%3Dfalse%26code%3Dpublic%252520interface%252520Command%25250A%25257B%25250A%252520%252520void%252520Execute%2528%2529%25253B%25250A%25257D&amp;display_name=Carbon&amp;url=https%3A%2F%2Fcarbon.now.sh%2F%3Fbg%3Drgba%252528225%25252C226%25252C228%25252C1%252529%26t%3Dvscode%26wt%3Dnone%26l%3Dtext%25252Fx-csharp%26width%3D680%26ds%3Dtrue%26dsyoff%3D20px%26dsblur%3D68px%26wc%3Dtrue%26wa%3Dtrue%26pv%3D56px%26ph%3D56px%26ln%3Dfalse%26fl%3D1%26fm%3DHack%26fs%3D14px%26lh%3D133%252525%26si%3Dfalse%26es%3D2x%26wm%3Dfalse%26code%3Dpublic%25252520interface%25252520Command%2525250A%2525257B%2525250A%25252520%25252520void%25252520Execute%252528%252529%2525253B%2525250A%2525257D&amp;image=https%3A%2F%2Fcarbon.now.sh%2Fstatic%2Fbrand%2Fbanner.png&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;scroll=auto&amp;schema=carbon" width="1024" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/5c938a53d497d7044adc3825849b0f9f/href">https://medium.com/media/5c938a53d497d7044adc3825849b0f9f/href</a></iframe><p>Martin destaca que diferente da maioria das classes que associam um conjunto de métodos a um conjunto de variáveis, Command acaba seguindo uma rota totalmente oposta: o padrão encapsula um método que não interage com variáveis na sua assinatura, trazendo algumas particularidades do paradigma funcional ao universo da orientação a objetos.</p><h3>Utilizando Command na “vida real”</h3><p>Ainda em seu livro, Robert conta que há muitos anos prestou consultoria a uma empresa que fabricava fotocopiadoras. Ele tinha a missão de auxiliar a equipe de programadores a estruturar um software embarcado que controlava o funcionamento interno de uma nova copiadora.</p><p>Durante o período de desenvolvimento, Uncle Bob e os demais membros do projeto tiveram a ideia de implementar o padrão Command para resolver uma grande parte dos desafios impostos pelo contexto do programa. O design da solução está retratado no diagrama abaixo, retirado do próprio capítulo escrito por Bob.</p><figure><img alt="Diagrama de classes do projeto da copiadora desenvolvido por Uncle Bob" src="https://cdn-images-1.medium.com/max/1024/1*MMS0RmEDVNNJsQH3QwhIWA.jpeg" /><figcaption>Diagrama de classes do projeto da copiadora</figcaption></figure><p>Disponível em todas as classes expostas no diagrama, o método Execute obteve uma responsabilidade em cada comando. Ao chamar a função em <em>RelayOnCommand</em>, um relé era ativado na máquina. A mesma ação em <em>MotorOffCommand</em> desligava o seu motor, e assim por diante. A identificação dos componentes da copiadora, como o relé ou o motor, era passada nos parâmetros do construtor das classes Command.</p><p>Além do pattern Command, o sistema funcionava através de eventos, que por sua vez eram captados por <strong>sensores</strong>. Para deixar essa arquitetura mais compreensível, Robert explica em seu livro um cenário concreto da aplicação:</p><blockquote>Quando um sensor óptico determinava que uma folha de papel tinha atingido certo ponto na trajetória do papel, precisávamos acionar certo engate. Pudemos implementar isso simplesmente vinculando o <strong>ClutchOnCommand</strong> apropriado ao objeto que controlava o sensor.</blockquote><p>A partir deste relacionamento entre as classes que representavam os sensores e a interface Command, o objeto do tipo <em>Sensor</em> ficava desinformado sobre o seu comportamento. Isso porque um sensor não conhecia qual implementação de Command estava sendo utilizada em tempo de compilação, simplificando portanto todo o seu funcionamento.</p><p>Martin resume a beleza do padrão ao comentar a respeito do desacoplamento obtido com o seu uso:</p><blockquote>Em algum ponto durante a inicialização do sistema, cada objeto Sensor é vinculado a um objeto Command apropriado. Isso coloca todas as interligações lógicas entre os sensores e comandos em um único lugar, e as retira do corpo principal do programa.</blockquote><h3>Command e transações</h3><p>Uncle Bob especifica ainda outro papel recorrente desempenhado pelo pattern — a criação e execução de <strong>transações</strong>. De modo a ilustrar essa interessante finalidade, Robert conjectura um software que administra um banco de dados de funcionários. Nele, os usuários estão aptos a adicionar, excluir ou alterar os dados desses empregados.</p><p>A fim de incluir um novo funcionário, o sistema deve necessariamente verificar se as informações cadastrais estão corretas antes de persistir o registro na base. É nesse ponto que o padrão Command pode ser inserido, segundo o autor:</p><blockquote>O objeto comando atua como um repositório dos dados não validados, implementa os métodos de validação e implementa os métodos que finalmente executam a transação.</blockquote><figure><img alt="Diagrama de classes do exemplo do banco de dados de funcionários" src="https://cdn-images-1.medium.com/max/1024/1*msvA71yXxMHvIdxpqh0Aag.jpeg" /><figcaption>Diagrama de classes do exemplo do banco de dados de funcionários</figcaption></figure><p>No diagrama de classes elaborado para o exemplo, a interface <em>Transaction</em> corresponde a interface <em>Command</em>. O método <strong>Validate</strong> assegura que os dados enviados pelo usuário estão aderentes às regras impostas pelo sistema, podendo até realizar uma verificação com o intuito de garantir a coerência entre o estado atual do objeto e o banco de dados. Ou seja, se certificar que o funcionário ainda não foi cadastrado na base.</p><p>Isto posto, um novo objeto do tipo <em>Employee</em> é criado com os campos do objeto <em>AddEmployeeTransaction</em>, ao passo que <em>PayClassification</em> também acaba sendo copiado para Employee. Com a instanciação do objeto que representa o funcionário, a função <strong>Execute</strong> consome os dados validados para atualizar o banco de dados.</p><p>Para encerrar, Bob ressalta um dos principais benefícios conquistados pelo encapsulamento de transações com o padrão Command:</p><blockquote>A vantagem que isso nos proporciona é o excepcional desacoplamento do código que obtém os dados do usuário, do código que valida e opera nesses dados e dos próprios objetos de negócio. Separando o código de validação e execução na classe AddEmployeeTransaction, desacoplamos fisicamente esse código da interface de obtenção.</blockquote><h3>O método Undo</h3><p>De acordo com o que foi detalhado na seção anterior, Command pode possuir uma variação <strong>transacional</strong> em sua implementação. Todavia, há ainda outra possibilidade oferecida pelo padrão, que pode ser extremamente eficiente e vantajosa em inúmeras ocasiões: a <strong>funcionalidade Undo</strong> (Desfazer).</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fcarbon.now.sh%2Fembed%3Fbg%3Drgba%2528225%252C226%252C228%252C1%2529%26t%3Dvscode%26wt%3Dnone%26l%3Dtext%252Fx-csharp%26width%3D680%26ds%3Dtrue%26dsyoff%3D20px%26dsblur%3D68px%26wc%3Dtrue%26wa%3Dtrue%26pv%3D56px%26ph%3D56px%26ln%3Dfalse%26fl%3D1%26fm%3DHack%26fs%3D14px%26lh%3D133%2525%26si%3Dfalse%26es%3D2x%26wm%3Dfalse%26code%3Dpublic%252520interface%252520Command%25250A%25257B%25250A%252520%252520void%252520Execute%2528%2529%25253B%25250A%252520%252520void%252520Undo%2528%2529%25253B%25250A%25257D&amp;display_name=Carbon&amp;url=https%3A%2F%2Fcarbon.now.sh%2F%3Fbg%3Drgba%252528225%25252C226%25252C228%25252C1%252529%26t%3Dvscode%26wt%3Dnone%26l%3Dtext%25252Fx-csharp%26width%3D680%26ds%3Dtrue%26dsyoff%3D20px%26dsblur%3D68px%26wc%3Dtrue%26wa%3Dtrue%26pv%3D56px%26ph%3D56px%26ln%3Dfalse%26fl%3D1%26fm%3DHack%26fs%3D14px%26lh%3D133%252525%26si%3Dfalse%26es%3D2x%26wm%3Dfalse%26code%3Dpublic%25252520interface%25252520Command%2525250A%2525257B%2525250A%25252520%25252520void%25252520Execute%252528%252529%2525253B%2525250A%25252520%25252520void%25252520Undo%252528%252529%2525253B%2525250A%2525257D&amp;image=https%3A%2F%2Fcarbon.now.sh%2Fstatic%2Fbrand%2Fbanner.png&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;scroll=auto&amp;schema=carbon" width="1024" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/f48519a908bfd33df0f0cea2634f6b3b/href">https://medium.com/media/f48519a908bfd33df0f0cea2634f6b3b/href</a></iframe><p>Com o objetivo de entender como este método se encaixa no design pattern, irei recorrer a mais um exemplo criado por Robert Martin. Suponha que um grupo de usuários acesse um aplicativo capaz de desenhar formas geométricas na tela. Uma das ações requisitadas frequentemente no sistema é o desenho de círculos.</p><p>Imaginando o hipotético código do programa, a solicitação para imprimir um círculo no monitor cria um objeto <strong>DrawCircleCommand</strong>, que possui o método <em>Execute</em>. Quando o usuário confirma com o mouse que deseja inserir o círculo na tela, o objeto inclui esta forma geométrica na lista de desenhos exibidos e armazena o seu identificador único de modo privado. Na sequência, o sistema coloca <em>DrawCircleCommand</em> na pilha dos comandos concluídos.</p><p>Caso o usuário não tivesse gostado do círculo desenhado e quisesse removê-lo, ele clicaria na <strong>operação de desfazer </strong>na barra de ferramentas. O aplicativo então leria todos os comandos armazenados na pilha de concluídos, e por consequência chamaria o <strong>método Undo</strong> no objeto Command procurado. Por fim, a figura geométrica seria apagada da tela, simples assim!</p><blockquote>Com essa técnica, você pode implementar Undo de maneira fácil em praticamente qualquer aplicativo. O código que sabe como desfazer um comando está sempre próximo ao código que sabe como executar o comando.</blockquote><h3>1001 utilidades</h3><p>Acredito que tenha sido possível notar que o padrão de projeto Command se adequa muito bem em múltiplas situações. Sem dúvida alguma essa é a maior beleza do pattern, que demonstra ser flexível e simples de implementar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=757bcc08d874" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/o-design-pattern-command-nas-palavras-de-uncle-bob-757bcc08d874">O design pattern Command nas palavras de Uncle Bob</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Conhecendo os diagramas de classe da UML]]></title>
            <link>https://medium.com/fora-de-assunto/conhecendo-os-diagramas-de-classe-da-uml-6f237f53cb45?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/6f237f53cb45</guid>
            <category><![CDATA[uml]]></category>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[uncle-bob]]></category>
            <category><![CDATA[diagrama-de-classe]]></category>
            <category><![CDATA[uml-diagrams]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Wed, 27 Jul 2022 11:56:21 GMT</pubDate>
            <atom:updated>2022-07-27T11:56:21.005Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>Os diagramas de classes nos permitem modelar o <strong>conteúdo estático </strong>e os <strong>relacionamentos</strong> entre as classes. Em um diagrama de classes podemos mostrar as variáveis membro e as funções de uma classe específica. Ademais, há a possibilidade de mostrar se uma classe herda de outra ou se contém uma referência para outra.</p><figure><img alt="Diagrama de classes com as classes Shape, Circle, Triangle e Rectangle" src="https://cdn-images-1.medium.com/max/588/1*Op5h9LzUWudHsn85gDiSxg.png" /><figcaption>Uma representação do diagrama de classes. Retirado de: <a href="https://dhtmlx.com/blog/">https://dhtmlx.com/blog/</a></figcaption></figure><p>Conforme veremos nas próximas seções do artigo, a <em>Unified Modeling Language</em> oferece ao analista inúmeras notações e particularidades com o intuito de que este represente da forma mais rica os módulos do seu projeto. Assim como na publicação sobre as máquinas de estado, abordarei apenas as características de maior valor dos diagramas de classe, de modo a simplificar o seu uso e entendimento.</p><h3>As classes</h3><p>O símbolo da classe no diagrama pode ser subdividido em <strong>compartimentos</strong>. O nível superior contém o <em>nome da classe</em>, enquanto o segundo possui as suas <em>variáveis</em> e o terceiro apresenta os seus <em>métodos</em>.</p><figure><img alt="Diagrama de classes mostrando os atributos e métodos de um tipo identificado como Item." src="https://cdn-images-1.medium.com/max/610/1*uslzN0iJ_jZdwHDAP-WTBQ.png" /><figcaption>Diagrama de classes mostrando os atributos e métodos de um tipo identificado como Item</figcaption></figure><p>Os atributos e funções costumam ter caracteres na frente de seus nomes. Um traço denota acesso <strong>privado</strong>, ou seja, somente integrantes dentro da própria classe estão autorizados a consultar o membro em questão. Por outro lado, o jogo da velha corresponde ao acesso <strong>protegido</strong>, que é bastante similar ao privado, com a diferença de que as subclasses também podem utilizar as variáveis e métodos correspondentes. Enfim, o sinal de adição significa que o campo ou método são <strong>públicos</strong>, expostos para qualquer cliente consumir.</p><p>Esse tipo de detalhe às vezes é útil, mas alguns autores como <strong>Robert C. Martin</strong> (Uncle Bob) aconselham a não usá-lo com muita frequência. As declarações de variáveis e funções devem ser aplicadas apenas quando elas forem essenciais para o propósito do diagrama.</p><h3>Associação</h3><p>As associações entre classes reproduzem <strong>variáveis de instância que contêm referências para outros objetos</strong>. A direção da seta indica que uma classe possui uma referência para outra classe. O nome próximo à seta é a identificação da variável de instância, e o número revela quantas referências são armazenadas.</p><figure><img alt="Diagrama de classes no qual a classe Item se associa com a classe Dimension" src="https://cdn-images-1.medium.com/max/601/1*v9EcBx7l9t9-NCHVGGivIg.png" /><figcaption>A classe Item possui uma associação direta com a classe Dimension</figcaption></figure><h3>Herança</h3><p>As setas de herança apontam diretamente para a <strong>classe base</strong>, de acordo com as especificações da UML. No caso de <strong>interfaces</strong>, as setas são desenhadas com um tracejado, embora esta especificidade não seja tão relevante de ser seguida pelo desenvolvedor.</p><figure><img alt="Diagrama de classes no qual a classe ItemRepositoryDatabase implementa (herda) da interface ItemRepository" src="https://cdn-images-1.medium.com/max/436/1*aHCXfux6PHp3q21j36kyIw.png" /><figcaption>A classe ItemRepositoryDatabase implementa (herda) da interface ItemRepository</figcaption></figure><h3>Estereótipos de classe</h3><p>Os estereótipos de classe aparecem entre dois caracteres semelhantes aos sinais de menor e maior, normalmente acima do nome da classe.</p><figure><img alt="Diagrama de classes representando a classe estática RandomCodeGenerator, decorada com o estereótipo utility" src="https://cdn-images-1.medium.com/max/416/1*h5fdEpoDapgcmzOp8lzw2g.png" /><figcaption>Classe RandomCodeGenerator com o estereótipo utility</figcaption></figure><p>O estereótipo <strong>interface</strong> indica que todos os métodos de uma classe são abstratos. Já o estereótipo <strong>utility</strong> indica que todos os métodos e variáveis são estáticos.</p><h3>Classes abstratas</h3><figure><img alt="Diagrama de classes em que a classe concreta HolidayCoupon está herdando da classe abstrata Coupon" src="https://cdn-images-1.medium.com/max/407/1*ePxJIW_pGYnfWUZqh1HsXw.png" /><figcaption>Classe concreta HolidayCoupon herdando da classe abstrata Coupon</figcaption></figure><p>Existem duas maneiras de retratar que uma classe ou método é abstrato na UML. Há a possibilidade de escrever o nome em itálico ou usar a propriedade <strong>abstract</strong>, representada entre chaves.</p><h3>Agregação</h3><figure><img alt="Diagrama de classes em que a classe OrderItem é um agregado da classe Order" src="https://cdn-images-1.medium.com/max/574/1*difWr98CoY7DAdIFMc5IWg.png" /><figcaption>A classe OrderItem é um agregado da classe Order</figcaption></figure><p>A agregação é uma<strong> forma especial de associação</strong> que significa um relacionamento todo/parte. A única regra que a UML fornece com relação às agregações é que um todo não pode ser sua própria parte. Logo, um objeto não pode ser agregado de si mesmo.</p><h3>Composição</h3><figure><img alt="Diagrama de classes em que a classe OrderCode compõem de maneira exclusiva a classe Order" src="https://cdn-images-1.medium.com/max/670/1*I9b1ltK_Hs2i1_c898aC4w.png" /><figcaption>A classe OrderCode compõem de maneira exclusiva a classe Order</figcaption></figure><p>A composição, do mesmo modo que a agregação, compartilha das características propostas pela associação. A regra aplicada à agregação também está presente na composição: não pode haver ciclos de instâncias. Entretanto, a UML expõe muito mais detalhes para este outro tipo de associação.</p><ul><li>Uma instância de objeto não pode pertencer simultaneamente a mais de um objeto do mesmo tipo;</li><li>O objeto contêiner é responsável pela duração do objeto de composição. Se o objeto contêiner é destruído, o objeto de composição deve ser destruído com ele.</li></ul><h3>Multiplicidade</h3><figure><img alt="Diagrama de classes em que a multiplicidade da associação entre Order e OrderItem é de zero para muitos" src="https://cdn-images-1.medium.com/max/601/1*EM4nnKkvdOo1aWcwg62FLA.png" /><figcaption>A multiplicidade da associação entre Order e OrderItem é de zero para muitos</figcaption></figure><p>Os objetos podem conter <em>arrays</em> ou coleções de outros objetos, ou podem conter muitos objetos do mesmo tipo em variáveis de instância distintas. Na UML, isso pode ser mostrado colocando-se uma expressão de multiplicidade na extremidade da associação.</p><p>As formas de multiplicidade permitidas são as seguintes:</p><ul><li><strong>Dígito</strong>: o número exato de elementos;</li><li><strong>* ou 0..*</strong>: de zero para muitos;</li><li><strong>0..1</strong>: zero ou um;</li><li><strong>1..*</strong>: de um para muitos;</li><li><strong>3..5</strong>: de três a cinco.</li></ul><h3>Estereótipo de associação</h3><figure><img alt="Diagrama de classes em que a a classe Order delega a execução para a classe ShippingCalculator" src="https://cdn-images-1.medium.com/max/711/1*dE2sOGEvF6_81VfpgrqbAQ.png" /><figcaption>A classe Order delega a execução para a classe ShippingCalculator</figcaption></figure><p>As associações podem ser rotuladas com estereótipos que alteram os seus significados.</p><ul><li>O estereótipo <strong>create</strong> indica que o destino da associação é criado pela origem;</li><li>O estereótipo <strong>local</strong> é usado quando a classe de origem cria uma instância do destino e a mantém em uma variável local;</li><li>O estereótipo <strong>parameter</strong> mostra que a classe de origem obtém acesso à instância de destino por meio do parâmetro de uma de suas funções;</li><li>O estereótipo <strong>delegate</strong> é usado quando a classe de origem encaminha a chamada de uma função membro para o destino.</li></ul><h3>Classes associativas</h3><p>As associações com multiplicidade nos informam que a origem está ligada a muitas instâncias do destino, mas o diagrama não nos informa que tipo de classe contêiner é usada. Isso pode ser representado pelo uso de uma classe associativa.</p><figure><img alt="Diagrama de classes em que a classe OrderItem atua como uma classe associativa no relacionamento entre Order e Item" src="https://cdn-images-1.medium.com/max/494/1*B8s8i0awo5EnXxe7Oso5xw.png" /><figcaption>A classe OrderItem atua como uma classe associativa no relacionamento entre Order e Item</figcaption></figure><p><strong>As classes associativas mostram como uma associação específica é implementada</strong>. No diagrama, elas aparecem como uma classe normal ligada à associação.</p><h3>O suficiente para começar</h3><p>Caso tenha absorvido todos os conceitos retratados nas seções anteriores, saiba que você já possui a base suficiente para começar a desenhar os seus próprios diagramas de classes quando precisar, seja em projetos pessoais ou profissionais.</p><p>Assim como os outros modelos da UML, o diagrama de classes também possui vários conceitos e componentes adicionais. Entretanto, dificilmente eles são aplicados no dia a dia e é muito provável que você nunca sentirá falta de usá-los.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f237f53cb45" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/conhecendo-os-diagramas-de-classe-da-uml-6f237f53cb45">Conhecendo os diagramas de classe da UML</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desbravando os diagramas de estados da UML]]></title>
            <link>https://medium.com/fora-de-assunto/desbravando-os-diagramas-de-estados-da-uml-632597c7a919?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/632597c7a919</guid>
            <category><![CDATA[uncle-bob]]></category>
            <category><![CDATA[uml]]></category>
            <category><![CDATA[fsm]]></category>
            <category><![CDATA[uml-diagrams]]></category>
            <category><![CDATA[unified-modeling-language]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Wed, 08 Jun 2022 11:40:23 GMT</pubDate>
            <atom:updated>2022-06-08T11:47:25.652Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>Nas últimas semanas, tivemos a oportunidade de aprender quais são os principais diagramas da <em>Unified Modeling Language</em> e como podemos aplicá-los da melhor forma em projetos de software.</p><p><a href="https://medium.com/fora-de-assunto/trabalhando-com-diagramas-uml-f4bd1424924b">Trabalhando com diagramas UML</a></p><p>Agora chegamos no ponto de desbravarmos com maior riqueza de detalhes cada um dos diagramas, a começar pela máquina de estados. Veremos a seguir os princípios essenciais para construir um modelo como esse, com o intuito de facilitar a compreensão de todos e mostrar o que realmente interessa.</p><h3>Os fundamentos</h3><p>Conforme visto no artigo <em>Introdução à visão geral da UML</em>, um diagrama de transição de estados — <strong>State Transition Diagram</strong>, é formado por alguns componentes. Os elementos de maior importância são os retângulos arredondados, que representam os<strong> estados do sistema</strong>. Em grande parte dos desenhos, o nome de cada estado se localiza no compartimento superior. Enquanto isso, no compartimento inferior, estão as <strong>ações especiais</strong> que determinam o que deve ser feito ao entrar ou sair do estado.</p><p>Por fim, as setas entre os estados são chamadas de <strong>transições</strong>. Cada uma delas é rotulada com a denominação do <strong>evento</strong> que aciona a transição. De maneira complementar, existe a possibilidade de receberem o nome de uma <strong>ação</strong> que será executada quando ocorrer a transição.</p><h3>Eventos especiais</h3><p>Na seção anterior, constatou-se que o compartimento inferior de um estado costuma possuir <strong>pares de evento/ação</strong>. Os eventos <em>entry</em> e <em>exit</em> são padrão, mas o dono do diagrama pode criar eventos personalizados. Se um desses eventos acontece quando a <em>FSM</em> está no estado esperado, logo a ação correspondente é ativada.</p><h3>Superestados</h3><p>O recurso dos <strong>superestados</strong> é útil quando o analista se depara com inúmeros estados que respondem aos seus eventos da mesma maneira. Diante desse cenário, ele pode desenhar um superestado em torno dos estados que apresentam um comportamento comum. Feito isso, todas as setas de transição passam a sair do superestado, e não mais individualmente de cada estado.</p><p>Semelhante aos estados normais, os superestados estão autorizados a terem ações <em>entry</em>, <em>exit</em> e eventos especiais.</p><h3>Pseudoestados iniciais e finais</h3><p>As máquinas de estado sempre começam a existir no processo de transição do <strong>pseudoestado inicial</strong>. A transição que sai desse pseudoestado não pode ter um evento, afinal de contas o evento é a própria criação da FSM. Todavia, essa transição pode conter uma ação, que será a primeira ativada.</p><p>Uma máquina de estado é encerrada no processo de transição para o <strong>pseudoestado final</strong>. Qualquer ação na transição para esse pseudoestado será a última executada pela FSM.</p><h3>Máquina de estados para login</h3><figure><img alt="Diagrama de máquina de estados para uma funcionalidade de login" src="https://cdn-images-1.medium.com/max/935/1*4PqIeujCL6s8smJ4QhXE_A.png" /><figcaption>Diagrama de máquina de estados para uma funcionalidade de login</figcaption></figure><p>De modo a consolidar boa parte dos conceitos, trago um exemplo simples de uma máquina de estados que retrata um fluxo de login. O diagrama acima foi retirado diretamente da obra <em>Princípios, Padrões e Práticas Ágeis em C#</em>, escrito por Robert C. Martin e Micah Martin.</p><p>Repare que o modelo apresentado inicia-se com o <strong>pseudoestado</strong> de criação da FSM. Ele dispara o primeiro estado proposto, chamado de <em>Solicitando Login</em>, o qual possui duas <strong>ações</strong>: <em>exibirTelaLogin</em>, ativado na sua entrada, e <em>ocultarTelaLogin</em>, ativado na transição para o estado <em>Validando usuário</em>.</p><p>A etapa de validação do usuário é capaz de gerar dois <strong>eventos</strong>. O primeiro deles, denominado <em>válido</em>, realiza a transição para o estado<em> Usuário válido</em>. Já o segundo deles, identificado como <em>falhou</em>, faz a transição para o estado <em>Login falhou</em>.</p><p>Neste momento, novamente dois eventos podem acontecer. Começando por <em>tentar novamente</em>, que aciona <em>ocultarTelaFalhaLogin</em> e concretiza a transição para o estado <em>Solicitando Login</em>. Em paralelo<em>, esqueceu da senha </em>também demanda a execução de <em>ocultarTelaFalhaLogin</em>, mas, por outro lado, estabelece a transição para o estado <em>Enviando Senha</em>, que impulsiona em sua entrada a ação <em>enviarSenha</em>.</p><p>Conforme boa parte dos outros estados, este detém dois eventos possíveis: <em>falhou</em>, que muda para o estado <em>Enviar senha falhou</em>, e enviou, que troca para o estado <em>Enviar senha foi um sucesso</em>. Atente-se que ambos os estados estão envolvidos por um <strong>superestado</strong>. Isso porque a saída deles resulta em um mesmo evento, o qual possui ainda o mesmo destino: o estado <em>Solicitando Login</em>.</p><h3>Preparado para modelar?</h3><p>Essencialmente, um diagrama de estados é elaborado apenas com os elementos que acabamos de examinar. A UML oferece outros recursos para tornar o modelo mais requintado, contudo em quase todas as ocasiões, não será preciso utilizar além do que foi comentado por aqui.</p><p>Portanto, quando surgir a chance, aproveite para exercitar os seus novos conhecimentos e desenhar uma máquina de estados que represente um problema que você está tentando resolver.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=632597c7a919" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/desbravando-os-diagramas-de-estados-da-uml-632597c7a919">Desbravando os diagramas de estados da UML</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Trabalhando com diagramas UML]]></title>
            <link>https://medium.com/fora-de-assunto/trabalhando-com-diagramas-uml-f4bd1424924b?source=rss----4ffd537c83df---4</link>
            <guid isPermaLink="false">https://medium.com/p/f4bd1424924b</guid>
            <category><![CDATA[uml]]></category>
            <category><![CDATA[unified-modeling-language]]></category>
            <category><![CDATA[uncle-bob]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[uml-diagrams]]></category>
            <dc:creator><![CDATA[Lucas Ruiz Dirani]]></dc:creator>
            <pubDate>Wed, 11 May 2022 11:33:17 GMT</pubDate>
            <atom:updated>2022-05-11T11:33:17.150Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="Logo da Unified Modeling Language (UML)" src="https://cdn-images-1.medium.com/max/1024/1*Sj_F0CJ72VDKRwiwL6wnrQ.png" /></figure><p>No último artigo do Fora de Assunto, identificamos os principais diagramas da <em>Unified Modeling Language</em> — classes, objetos, sequência, colaboração e máquina de estados, discorrendo a respeito de suas características básicas e apresentando exemplos para ilustrá-los com maior precisão.</p><p><a href="https://medium.com/fora-de-assunto/vis%C3%A3o-geral-da-uml-e984ccbb1519">Visão Geral da UML</a></p><p>Hoje, de modo a preparar o terreno dos próximos posts, trarei dicas valiosíssimas escritas pelo Uncle Bob em seu livro <strong>Princípios, Padrões e Práticas Ágeis em C#</strong>, que nos permitem entender como devemos trabalhar com os diagramas existentes no catálogo da UML.</p><h3>Por que modelar?</h3><p>Muitas vezes fazemos algo sem pensar ou questionar. Tal ação pode resultar em um desperdício de tempo, dinheiro e esforço, e isto não é diferente com a <em>modelagem de software</em>.</p><p>Robert Martin afirma que os modelos são construídos para descobrir se uma determinada parte do programa irá funcionar. Implica-se que qualquer modelo construído <strong>deve ser passível de testes</strong>. Logo, se elaborarmos um modelo incapaz de ser avaliado, ele não trará valor ao ciclo de desenvolvimento.</p><p>Além disso, Martin ressalta que a modelagem em um projeto compensa somente quando o seu custo é menor do que o sistema idealizado. Se a atividade de modelar for mais cara que a codificação do aplicativo, é responsabilidade da equipe técnica descartar o seu uso.</p><p>Portanto, a aplicabilidade da UML está diretamente atrelada à <strong>necessidade de testar funcionalidades que serão definitivas </strong>e aos seus<strong> gastos que precisam ser mais baratos</strong> em relação às tarefas voltadas para a programação do sistema.</p><h3>Modelos devem ser feitos antes de codificar?</h3><p>Esta pergunta costuma ser recorrente entre os programadores e analistas. Por sorte, Uncle Bob nos fornece uma resposta esclarecedora quanto ao dilema em questão.</p><p>De acordo com o autor, e conforme visto na seção anterior, desenhar os diagramas da UML nem sempre é mais barato do que escrever o próprio código. Inclusive, vários times investem uma extensão maior de recursos nos diagramas do que no software.</p><p>Todavia, Robert Martin conclui que não é tão simples estabelecer que o descarte de um diagrama durante o projeto sempre custará mais do que refazer uma funcionalidade, por exemplo.</p><p>Assim sendo, não podemos dizer com toda a certeza que a modelagem prévia de um segmento do sistema possa resultar em uma redução ou aumento de gastos. Diante desse impasse, Martin sugere que os <strong>diagramas sejam feitos iterativamente</strong>.</p><h3>Como usar os diagramas UML de modo eficiente?</h3><p>Até o momento, os questionamentos que foram expostos sobre a UML geraram incertezas econômicas: diagramar encarece ou barateia o projeto?</p><p>Além de adotar uma abordagem iterativa, Robert Martin nos concede outras dicas para que a diagramação UML torne-se um processo eficiente ao longo do desenvolvimento de sistemas, e por consequência evite gastos elevados e desnecessários.</p><p>Segundo o consultor, os diagramas são úteis para se comunicar com outras pessoas e para ajudar a solucionar problemas. Tendo isso em vista, o desenvolvedor deve <strong>utilizar somente a quantidade de detalhes essencial para atingir o seu objetivo</strong>. Um diagrama com muitos “enfeites” é contraproducente.</p><p>Uncle Bob salienta ainda que os diagramas precisam ser os mais <strong>simples</strong> e <strong>limpos </strong>que pudermos criar.</p><h3>O que é a roteirização da UML?</h3><p>Com base em sua experiência profissional, Martin relata que a UML pode ser benéfica para <strong>roteirizar grandes estruturas de um software</strong>. Esses roteiros possibilitam uma maneira rápida de descobrir os relacionamentos entre as principais classes, e <strong>servem de referência para a arquitetura do sistema</strong>.</p><p>Os diagramas que compõem um roteiro capturam o conhecimento que os programadores devem ter em mente para trabalhar eficientemente no software. Isto posto, projetos com escopo e complexidade maiores podem usufruir das vantagens proporcionadas pela roteirização.</p><h3>O que manter e o que jogar fora?</h3><p>Aprendemos há pouco que os desenvolvedores devem desenhar diagramas que transmitam simplicidade e agreguem valor. A partir dessa linha de pensamento, Uncle Bob alega que todo programador também precisa aprender a <strong>jogar fora os seus modelos</strong>.</p><p>Nas palavras de Robert, uma boa parcela dos diagramas pode ser elaborada em quadros brancos ou até mesmo folhas de papel. Complementarmente, ele aconselha que ferramentas e programas de modelagem não sejam impostos ao time de desenvolvimento, já que <strong>a maioria dos protótipos UML terá vida curta</strong>.</p><p>Contudo, Martin abre um parênteses e relembra que alguns diagramas eventualmente exigirão uma atenção especial — <strong>aqueles que expressam uma solução de projeto comum no sistema</strong>. Isso significa que modelos responsáveis por registrar protocolos complexos, os quais são difíceis de ver no código, são bons candidatos para se tornarem diagramas permanentes.</p><h3>Qual a dinâmica pretendida entre diagrama e código-fonte?</h3><p>No início da publicação, compreendemos que a modelagem de software possui o objetivo de validar as estruturas por trás das <em>features</em> mais importantes de uma aplicação. Com essa ideia em mente, Robert Martin diz ser fundamental que os <strong>diagramas garantam a visualização do código-fonte que será escrito</strong>.</p><p>Os bons desenvolvedores usam os diagramas como atalhos para o código, e não como substitutos dele. Se desenharmos diagramas que não podem ser transformados em código, nenhum valor será obtido. Ao diagramar, é imprescindível que o programador pare o que está fazendo e teste simultaneamente se o código-fonte consegue incorporar o modelo.</p><h3>Quando desenhar diagramas e quando parar?</h3><blockquote>Não estabeleça a regra de que tudo deve ser diagramado. Tais regras são inúteis. Quantidades enormes de tempo de projeto e energia podem ser desperdiçadas na busca de diagramas que ninguém lerá.</blockquote><p>A citação de Uncle Bob evidencia, mais uma vez, que precisamos ser criteriosos ao escolher quais partes de um sistema serão modeladas. A seguir, temos uma lista de situações que indicam <strong>quando a diagramação é indispensável</strong>:</p><ul><li>Várias pessoas precisam entender a estrutura de um setor específico do projeto;</li><li>Duas ou mais pessoas discordam sobre como um conceito deve ser projetado;</li><li>Uma nova ideia precisa ser construída e os diagramas auxiliam o desenvolvedor a pensar sobre isto;</li><li>O desenvolvedor precisa explicar a estrutura de algum trecho do código para outra pessoa ou para si mesmo.</li></ul><p>Por outro lado, agindo de contraponto, há a relação dos itens que apontam <strong>quando não devemos diagramar</strong>:</p><ul><li>O processo da empresa ou equipe exige isso;</li><li>O desenvolvedor sente-se culpado por não desenhar os diagramas;</li><li>Para criar documentação abrangente;</li><li>Para outras pessoas codificarem.</li></ul><h3>Travel Light</h3><p>Por mais que a discussão do artigo tenha sido bastante teórica, asseguro que o conhecimento adquirido por quem leu até o final foi enriquecedor. As boas práticas relacionadas à diagramação UML geralmente são negligenciadas por muitos, e por conta disto acredito que o conteúdo abordado tenha cumprido o seu dever.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4bd1424924b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fora-de-assunto/trabalhando-com-diagramas-uml-f4bd1424924b">Trabalhando com diagramas UML</a> was originally published in <a href="https://medium.com/fora-de-assunto">Fora de assunto</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>