<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kaique Prazeres on Medium]]></title>
        <description><![CDATA[Stories by Kaique Prazeres on Medium]]></description>
        <link>https://medium.com/@kaiqueprazeres?source=rss-39fc83287e42------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*HNfKSHQ_RrnMF6Mr5gl51g.jpeg</url>
            <title>Stories by Kaique Prazeres on Medium</title>
            <link>https://medium.com/@kaiqueprazeres?source=rss-39fc83287e42------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 20:09:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kaiqueprazeres/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[6 técnicas do Clean Code que ajudam a reduzir custos com desenvolvimento e manutenção de sistemas…]]></title>
            <link>https://kaiqueprazeres.medium.com/6-t%C3%A9cnicas-do-clean-code-que-ajudam-a-reduzir-custos-com-desenvolvimento-e-manuten%C3%A7%C3%A3o-de-sistemas-898be054669a?source=rss-39fc83287e42------2</link>
            <guid isPermaLink="false">https://medium.com/p/898be054669a</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[código-limpo]]></category>
            <dc:creator><![CDATA[Kaique Prazeres]]></dc:creator>
            <pubDate>Tue, 31 May 2022 14:25:42 GMT</pubDate>
            <atom:updated>2024-02-25T14:11:46.141Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>6 técnicas do Clean Code que ajudam a reduzir custos com desenvolvimento e manutenção de sistemas na prática</strong></h3><p>Desenvolver sistemas com grande longevidade e fácil manutenção é um desafio comum enfrentado pela maioria dos times de engenharia de software. Isso requer mais que conhecimento técnico em padrões ou tecnologias do momento. Envolve a capacidade de tomar decisões durante o processo que impactará na experiência do próprio desenvolvedor que irá dar a manutenção no sistema.</p><p>Enquanto maior parte dos esforços são direcionados para a parte inicial do desenvolvimento de um novo sistema, a atenção com aspectos que facilitarão a manutenção no futuro continuará sendo negligenciada.</p><p>Passamos a maior parte do tempo estudando e lendo código escrito por outros desenvolvedores e muitas vezes, nos deparamos com trechos difíceis de entender, fazendo com que a maior parte do tempo investido seja apenas para a compreensão do que com a evolução de implementações.</p><p>Neste artigo, você conhecerá algumas técnicas de Clean Code que ajudam a reduzir os custos de desenvolvimento e manutenção e que também equilibram o tempo de compreensão com o tempo de evolução de novas implementações no código.</p><p><strong>O que é Clean Code e por que aplicar suas técnicas?</strong></p><p>O próprio nome já diz, mas de acordo com o livro, Clean Code, escrito por Robert C. Martin, “é um conjunto de atributos de qualidade aliado a boas práticas que garantem que um código possibilite fácil manutenção em todos os aspectos” . Resumindo, é um código simples, eficiente, testável, fácil de entender, de se manter, evoluir e reaproveitar independente de quem escreveu — seja júnior, pleno, sênior, desenvolvedor, analista, engenheiro ou arquiteto.</p><p>Mas por que aplicar as técnicas de Clean Code durante o desenvolvimento e manutenção?</p><ul><li>Ter um código limpo;</li><li>Ajudar a reduzir a dívida técnica;</li><li>Ter um time mais produtivo, incluindo novos membros;</li><li>Vantagem competitiva na velocidade de desenvolvimento em relação ao concorrente;</li><li>Obter ainda mais valor no futuro;</li><li>Prevenir o software de se tornar legado pelo caos na manutenção.</li></ul><p>Os motivos listados acima poupam incontáveis horas gastas com recursos que poderiam estar focados em construir uma nova solução, implementando melhorias que gerem valor para o negócio e para o próprio time de desenvolvimento, de forma rápida ou pensando nas próximas funcionalidades.</p><p>Também evitará que o produto tenha dívidas técnicas impagáveis, ou seja, impedindo que no futuro, mais horas de trabalho sejam gastas em itens técnicos que já deveriam ter o mínimo de qualidade garantida. Em outras palavras, retrabalho.</p><p>À medida que essa confusão aumenta, a produtividade diminui a quase zero. E é isso que as técnicas do Clean Code nos ajudam a evitar. Nos fazendo refletir sobre o impacto financeiro gerado e sobre a relação entre produtividade, qualidade e manutenção.</p><p><strong>6 Técnicas de Clean Code</strong></p><p><strong>1 — Regra do escoteiro</strong></p><p>Não basta escrever um código bom, é preciso melhorá-lo cada vez que o revisitarmos, pois qualquer código limpo pode ficar sujo com o tempo, por isso é importante ter a constante prática de melhoria contínua.</p><p>Isso não se limita ao mesmo trecho do código que foi desenvolvido ou alterado, e sim a qualquer parte dele. Não precisa ser algo grande, pode ser a troca do nome de uma variável, constante, método, função, classe ou eliminar uma pequena duplicidade de código.</p><p><strong>Por que utilizar?</strong></p><p>Quando isso se torna um hábito não há espaço para bagunça, para fazer as coisas de qualquer jeito independente do prazo ou pressão que ocorra. É uma questão de mentalidade e cuidado com a qualidade do trabalho realizado.</p><p>Essa prática evita que horas extras sejam dedicadas no futuro só para entender o que é e como foi feito.</p><p><strong>2 — Use nomes a partir do domínio da solução</strong></p><p>Tudo que for escrito no código será lido por outros desenvolvedores e todos os envolvidos no projeto precisam estar na mesma página.</p><p>Na prática, se algum analista de negócio ou responsável por um departamento da empresa fala de um termo específico em suas orientações de como quer que o sistema funcione, os mesmos devem ser utilizados quando o código for escrito e isso deve ser feito sem adaptações.</p><p><strong>Por que utilizar?</strong></p><p>Isso facilitará para outros desenvolvedores o que significa aquele termo. Por exemplo, pense em um sistema que está sendo desenvolvido para um banco, e o termo “francesinha” é mencionado pelas pessoas envolvidas no projeto, sendo que o termo represente o extrato de movimentação de títulos mantidos na carteira de cobrança bancária. A maioria das pessoas envolvidas com o contexto bancário está habituada com este termo.</p><p>Agora imagine o cenário em que o desenvolvedor acha o termo cômico ou não gosta dele e resolve escrever outro termo para substituir, como “XPTO” e implementa isso nas telas do sistema e no código.</p><p>Provavelmente os usuários que utilizam o app e estão acostumados com o termo ficarão sem entender o que significa “XPTO”, pois terão a sensação de que a funcionalidade “francesinha” deixou de existir. E não só os usuários, mas também nas reuniões que envolvem entendimento das regras de negócio que utilizam o termo para desenvolvimento de outras funcionalidades. E novos desenvolvedores que atuarem no projeto, pois serão aculturados com o termo errado que não é conhecido pelos envolvidos.</p><p>Usar nomes a partir do domínio da solução, ajuda o time a não perder tempo inventando termos não utilizados pela área de negócio e evita que desenvolvedores percam tempo tentando tirar dúvidas sobre o que significa enquanto poderiam estar focados em evoluir o que já existe com base no entendimento comum sobre os termos específicos da área de negócio.</p><p><strong>3 — Use nomes passíveis de busca</strong></p><p>“Usar nomes passíveis de busca” é uma técnica que está diretamente conectada a técnica de “Usar nomes a partir do domínio da solução”.</p><p>Durante o desenvolvimento do código-fonte é comum desenvolvedores buscarem atalhos para driblar a necessidade de pensar e dar nomes. Aliás, boa parte do desenvolvimento de sistemas consiste em “<em>dar nome aos bois códigos</em>”.</p><p>E usar nomes passíveis de busca é uma técnica que orienta a determinar que os nomes utilizados no código de um software sejam em variáveis, funções, classes, métodos, arquivos (trechos de código que são modificados com frequência), que sejam nomes fáceis de pesquisar. De forma que tenham uma identificação própria ou represente alguma informação de forma lógica. Diferente de usar apenas letras, códigos ou abreviações que só quem desenvolveu determinado trecho de código consegue entender.</p><p><strong>Por que utilizar?</strong></p><p>Essa técnica facilita a busca durante a manutenção. Os desenvolvedores que precisam realizar uma alteração facilmente saberão identificar o que faz determinados trechos de código pelo nome que foi dado e pelo que representa no contexto. Reduzindo a quantidade de tempo necessária para entender o que cada trecho faz ou o que significa.</p><p>Um exemplo comum, que pode representar de forma prática quanto tempo se perde não usando nomes passíveis de busca é o código que tem uma série de variáveis, funções, classes, métodos e arquivos com abreviações de termos verbosos (grandes) e letras como “i”, “a”, “j” que são utilizadas.</p><p>Agora, imagine quanto tempo o desenvolvedor que dará manutenção em um código cheio de letras e siglas que não representam nenhum conceito de negócio levará para realizar a entrega esperada pela área de negócio simplesmente porque “<em>não deu nome aos bois códigos</em>”? Gastos com horas e horas podem ser poupadas com essa técnica.</p><p><strong>4 — Evite o mapeamento mental</strong></p><p>Outra técnica que orienta o cuidado com os nomes dados nos códigos. Todo nome deve ser significativo e claro, seja de variável, funções, classes, arquivos, ou etc. Isso significa que devem ser óbvios.</p><p>O mapeamento mental faz com que desenvolvedores que tem contato com o código tentem adivinhar o que significa cada trecho. Inclusive o significado de siglas, letras, números perdidos e nomes que só fazem sentido na cabeça de quem escreveu o código.</p><p><strong>Por que utilizar?</strong></p><p>Pelo mesmo motivo que usar nomes a partir do domínio da solução e usar nomes passíveis de busca facilitam a procura e a compreensão por parte de quem está dando manutenção.</p><p>Isso reduz a quantidade de horas gastas com tentativas de entendimento do código que sofrerá alterações a curto, médio e longo prazo. Essa quantidade de horas não gasta, é uma grande economia, podendo em alguns casos economizar uma ou mais sprints.</p><p><strong>5 — Evite repetição</strong></p><p>Essa técnica está diretamente ligada a um princípio da própria programação, o DRY (Don’t Repeat Yourself). Como o próprio nome da técnica e o princípio afirmam: Evite repetição.</p><p>Ou seja, evitar a repetição de trechos de código e permitir que sejam reutilizados por meio de estruturas que possam ser usadas com pouco esforço, seja por meio de uma função, método, classe, arquivo etc.</p><p><strong>Por que utilizar?</strong></p><p>A repetição de código gera um efeito colateral que aumenta exponencialmente o consumo de horas em uma manutenção. Como? Ao alterar uma funcionalidade ou módulo que possui diversos códigos repetidos e espalhados fazendo a mesma coisa, vai exigir que quando uma regra ou trecho for alterado, os outros também sejam em diversos outros lugares. Em sistemas de médio e grande porte isso é um verdadeiro caos, pois quanto mais pontos duplicados houver, mais consumo de hora será necessário para alterá-los.</p><p>Com isso serão perdidas horas com:</p><ul><li>Pesquisa dos trechos duplicados;</li><li>Alteração da mesma regra em vários pontos do sistema;</li><li>Pesquisa dos trechos que não foram atualizados por esquecimento;</li><li>Investigação da causa de um problema gerado por um trecho de código que foi copiado e duplicado sem avaliar seus detalhes.</li></ul><p>Evitar repetição de código ajuda a reduzir o tempo de desenvolvimento e manutenção através do reaproveitamento, que é garantido conforme o código é modularizado, reduzindo o tempo de horas gastas com pesquisas das duplicações, acabando com o risco de gerar bugs a partir da prática de copiar e colar sem especializar o trecho, prevenindo bugs causados por esquecimento de uma atualização do trecho repetido em cada parte do sistema.</p><p><strong>6 — Use constantes ao invés de números mágicos</strong></p><p>É comum encontrar em métodos e outros trechos de código números fixos, sendo usados muitas vezes para comparação, cálculo, ou como limite numérico. Porém um número sozinho pode não expressar por si só o que representa no código. Isto é o que chamamos de número mágico.</p><p>Os números mágicos podem atrapalhar o entendimento geral de um trecho de código por não explicitar uma lógica de negócio ou o que ele representa. Imagine encontrar no código um número 1, 3 ou 7 perdidos e não saber o que eles significam? Agora imagina o tempo gasto para entender isso, ou o tempo buscando disponibilidade de alguém da área de negócio para talvez ajudar a entender algo a respeito? Esse tempo poderia ser otimizado com o uso de constantes e o esforço estaria inteiramente destinado a evolução da funcionalidade associada a este código.</p><p><strong>Por que utilizar?</strong></p><p>Substituir números mágicos por constantes ajuda a reduzir custos com manutenção de 3 maneiras:</p><ul><li>O que o número representa fica explícito no código, bastando apenas olhar o nome da constante;</li><li>O próprio uso de uma constante mostra que aquele valor não mudará em tempo de execução, ele é sempre o mesmo, ou seja, fixo, só mudará por uma necessidade de negócio (quando, e se acontecer);</li><li>Caso o número seja utilizado mais de uma vez no código ou em outros arquivos, a mesma constante pode ser utilizada por meio do reaproveitamento.</li></ul><p>Utilizar constantes ajuda não somente por exprimir melhor a utilidade de tal número, também a detectar facilmente onde o número é utilizado. Também verificando se há outros números associados e entendendo o que representam em cada contexto, além de permitir o reaproveitamento.</p><p><strong>Como essas técnicas ajudam a reduzir o custo de desenvolvimento e manutenção na prática?</strong></p><p>Aumentando a eficiência na manutenção ou evolução de funcionalidades através de práticas que reduzem o tempo e esforço necessário de entendimento e implementação do “que” e do “como” será feito no código.</p><p>A produtividade dos times de engenharia de software também está associada à qualidade técnica dos projetos. E quanto menor a qualidade técnica, maior é o custo de manutenção.</p><p>De acordo com o artigo gerado a partir do estudo <em>Clean Code: On the Use of Practices and Tools to Produce Maintainable Code for Long-Living Software,</em> a escolha de procedimentos e práticas é mais cultural do que problema técnico.</p><p>Tendo isso em mente, o time que prioriza a adoção de práticas que aumentam a eficiência da manutenção e pensam no longo prazo, tendem a poupar futuras modernizações e dificuldades de evolução em funcionalidades existentes.</p><p>A aplicação do Clean Code incentiva uma atuação proativa focada em longo prazo. E seus resultados também podem ser comprovados através de uma comparação realizada com cenários que envolvem sistemas em que essas técnicas não foram aplicadas.</p><p><strong>Clean Code investimento evolutivo</strong></p><p>Sistemas de sucesso geralmente são medidos pela sua capacidade de adaptação e extensibilidade para permitir uma rápida evolução frente as necessidades de negócio e de mercado. Infelizmente a maioria dos sistemas são construídos sem que boas práticas e técnicas que facilitam a manutenção sejam consideradas.</p><p>Quanto mais bem sucedido é o sistema, por mais tempo será mantido e menos problemas enfrentará.</p><p>Em vista disso, para garantir que a manutenção de sistemas não se torne um grande problema para as empresas, trazendo custos com horas de manutenção que poderiam ser revertidas em evolução com foco no negócio, se faz necessária a aplicação de técnicas de Clean Code através de um processo contínuo e incremental.</p><p>Os ganhos da aplicação dessas técnicas podem ser comprovados e medidos de forma empírica no dia a dia conforme evolução dos sistemas que estão sendo desenvolvidos. E no final, o que se gasta financeiramente com manutenção, será investido com evolução.</p><p><strong>Referências</strong></p><p><strong>Martin, Cecil Robert. Clean Code. 2008.<br>Clean Code: On the Use of Practices and Tools to Produce Maintainable Code for Long-Living Software</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=898be054669a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Os 4 Pilares da Programação Orientada a Objetos com Exemplos Práticos]]></title>
            <link>https://kaiqueprazeres.medium.com/os-4-pilares-da-orienta%C3%A7%C3%A3o-a-objetos-com-exemplos-pr%C3%A1ticos-91697976a618?source=rss-39fc83287e42------2</link>
            <guid isPermaLink="false">https://medium.com/p/91697976a618</guid>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[orientação-a-objeto]]></category>
            <dc:creator><![CDATA[Kaique Prazeres]]></dc:creator>
            <pubDate>Wed, 17 Nov 2021 21:05:39 GMT</pubDate>
            <atom:updated>2022-07-20T13:59:30.982Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*atmRtJ4ODcX1HMI-0FBGOg.png" /><figcaption>Os 4 Pilares da Orientação a Objetos</figcaption></figure><p>Este “artigo” técnico é um complemento a uma publicação que realizei no Linkedin com o intuito de abordar de forma resumida e objetiva os 4 pilares da orientação a objetos sem entrar no mérito dos detalhes de uma abordagem mais aprofundada ou filosófica sobre o tema.</p><p>Minha intenção com a publicação do Linkedin foi atingir os desenvolvedores juniores, iniciantes em programação, desenvolvedores que não foram bem em entrevistas técnicas neste tema ou tiveram algum branco (esquecimento) quando confrontado com as perguntas e quem tem dificuldade de entender esses 4 pilares e como aplicá-los na prática. (<a href="https://www.linkedin.com/posts/activity-6866844548769951744-AmgR">Link da publicação aqui</a>)</p><blockquote><strong>Aviso Importante:</strong> Algumas linguagens orientada a objetos ou que oferecem suporte possuem mecanismos próprios que permitem explicitar em código alguns dos pilares do paradigma. Por isso, para ilustrar os exemplos, a linguagem utilizada é o C#.</blockquote><blockquote>A exemplo do polimorfismo. Em linguagens como PHP e Javascript ainda não é possível realizar sobrecarga e/ou sobreposição de métodos de forma explicita e simples. Enquanto que no C#, Java e outras linguagens, isso é mais transparente.</blockquote><blockquote>De forma alguma o objetivo aqui é afirmar que uma linguagem é melhor que outra por conta disso, mas, vale ressaltar que tal mecanismo facilita o desenvolvimento e o entendimento sobre como aplicar alguns conceitos.</blockquote><h3>Abstração</h3><p>É a capacidade de representar o mundo real em código, seja em classes e/ou interfaces e de criar um conjunto de rotinas capazes de serem reutilizadas para complementar outras, com seus detalhes de implementação ocultos de quem vai usar.</p><p>Envolve a implementação da lógica necessária para execução do código. Só que de forma “oculta” de quem usa. Pois quem usa, só precisa saber o que as classes/interfaces fazem, não como fazem. Este pilar é também considerado uma extensão do Encapsulamento.</p><p><strong>Exemplo Prático: Representando um Desenvolvedor do mundo real em código.</strong></p><p>Note que no exemplo a seguir a classe abstrata “Desenvolvedor” é uma representação do desenvolvedor no mundo real. Devido a isso ela possui nome, linguagem de programação preferida e anos de experiência como características (atributos) e codar, escrever testes unitários, escrever código, verificar tempo de experiência, beber café e etc… como comportamentos (métodos) que ele possui.</p><p>Ao usar a classe Desenvolvedor como um objeto precisamos apenas saber o que ela faz ou pode fazer e não precisamos nos preocupar com o como ela faz.</p><p>Somente ela conhece e lida com a complexidade de seus métodos. <br>E no mundo real, só o desenvolvedor sabe lidar com a complexidade de seus comportamentos também.</p><p>Além disso, é possível que outra abstração seja criada utilizando essa como “base” e complemento.</p><p>Resumindo, se essa classe fosse instanciada (caso não fosse abstrata, é claro) só precisariamos nos preocupar com os métodos que ela oferece para usar. E não como o processo de execução do método é feito.</p><blockquote><strong>Aviso Importante:</strong> Abstração não consiste necessariamente em criar uma classe abstrata. A classe “Desenvolvedor” foi criada como abstrata somente para fins didáticos e para ser reaproveitada na explicação dos outros pilares.</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a7503000f31abdd96a63352e3fafbcc5/href">https://medium.com/media/a7503000f31abdd96a63352e3fafbcc5/href</a></iframe><h3>Encapsulamento</h3><p>Mecanismo usado para esconder atributos e detalhes de implementação dos dados passados para a instância da classe. Garantindo que o acesso a dados ocorra apenas através de métodos públicos, impedindo que eles sejam alterados em tempo de execução de fora da classe.</p><p>Sabe o que é interessante no encapsulamento? É que ele é uma extensão da abstração! Por que?</p><p>Porque quando aplicado ele garante que só a própria classe conheça os detalhes de implementação e disponibilize apenas o que é possível fazer com os dados da classe como dito na definição anteriormente.</p><p>E como que aplica o encapsulamento na prática mesmo? Simples: Tornando os atributos privados ou protegidos através dos modificadores de acesso ou visibilidade “private” e “protected” e criando métodos que retornem estes atributos apenas.</p><p>A seguir, Note que no exemplo da abstração os atributos eram públicos e tinha um setters. Ou seja, podiam ser modificados na instância por qualquer pessoa que utilizasse a classe “Desenvolvedor” e a qualquer momento.</p><blockquote><strong>Aviso Importante:</strong> O encapsulamento da classe do exemplo a seguir ainda poderá ser “violado” somente pelas classes derivadas (filhas) através de herança, pois a visibilidade está definida como protegida (protected), não como privada (private).</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fc554c4d4f60b3fe890ca65e00cf462e/href">https://medium.com/media/fc554c4d4f60b3fe890ca65e00cf462e/href</a></iframe><h3>Herança</h3><p>É uma das formas de relacionar classes/objetos e/ou compartilhar lógica de implementação.</p><p>Comumente utilizada para permitir o reuso das características (atributos) e comportamentos (métodos ) que são comuns para coisas que tem algum tipo de parentesco.</p><p>Esse tipo relação é comumente expressada como “classe pai e classe filha”, “Super Classe e Subclasse”, “Super Classe e Classe Derivada” e também como “é um(a) alguma coisa”.</p><p>A seguir, o exemplo mostra 2 classes derivadas da classe “Desenvolvedor”, são elas “DesenvolvedorCSharp” e “DesenvolvedorJava”. Observe que no mundo real ambos os desenvolvedores tem características e desenvolvem comportamentos similares. Só que cada um de sua forma.</p><p>Veja que as características (atributos) e comportamentos (métodos) comuns entre ambos não foram específicados em sua totalidade novamente. Pois, foi tirado proveito do benefício da herança! (Veja que a classe contém métodos abstratos)</p><p>Sobre os métodos definidos como abstratos na classe Desenvolvedor, estamos dizendo para as classes que serão derivadas (filhas) dela, que obrigatoriamente elas devem ter aqueles métodos, mas a forma como a lógica deles é executada pode ser diferente uma da outra. Ou seja, eles fazem a mesma coisa de formas diferente.</p><blockquote><strong>Aviso Importante:</strong> A herança não é a única forma de criar relacionamento entre classes. Existem outras formas como Associação, Composição e Agregação. Mas aqui, apenas a herança será abordada. Pois ela é considerada um dos pilares da orientação a objetos, as outras são consideradas técnicas.</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5ab142feee166f5ee7c3757b86aa2c10/href">https://medium.com/media/5ab142feee166f5ee7c3757b86aa2c10/href</a></iframe><h3>Polimorfismo</h3><p>É o mecanismo que permite que duas ou mais classes que herdam comportamentos (métodos) através de herança, se comportem de forma diferente.</p><p>Ou seja, métodos com o mesmo nome podem executar códigos e lógicas opostas, parecidas, complementares ou completamente diferentes mesmo!</p><p>E isso pode ser feito de duas formas: Estática ou Dinâmica.</p><p><strong>Polimorfismo na forma estática (Sobrecarga — Overload)</strong></p><p>O polimorfismo na forma estática é também muito conhecido como “sobrecarga” ou para os mais íntimos como “overload”.</p><p>Isso permite a existência de vários métodos com o mesmo nome mas com quantidade, tipos e/ou ordem de parâmetros levemente diferentes.</p><p>Para aplicá-lo é necessário apenas criar outro método com o mesmo nome e uma quantidade de parâmetros diferentes, ordens diferentes ou tipos diferentes (ou não).</p><p><strong>Polimorfismo na forma dinâmica(Sobreposição, Reescrita — Override)</strong></p><p>Já o polimorfismo na forma forma dinâmica é também muito conhecido como “sobreposição”, “reescrita” ou para os mais íntimos “override”.</p><p>Diferente da sobrecarga (forma estática), na sobreposição é necessário que os métodos tenham exatamente o mesmo nome, tipo de retorno e quantidade de parâmetros.</p><p>Para aplicá-lo, basta criar outro método com o mesmo nome, tipo e retorno, não precisa necessariamente ter parâmetros. A implementação de sua lógica que deve ser diferente. Inclusive, ela pode ser complementada com o método da classe base (pai/herdada) caso ele já tenha implementação (Olha só como abstração pode ser complementada, lembra?)</p><p>Note que no exemplo a seguir as duas formas de polimorfismo são aplicadas. tanto a sobrecarga como a sobreposição.</p><blockquote><strong>Aviso Importante:</strong> Por se tratar de um exemplo com objetivos didáticos, a implementação foi feita de forma bem sútil.</blockquote><blockquote>Em um projeto real as diferenças podem ser gritantes. Além disso, no exemplo da sobrecarga apenas a ordem dos parâmetros foi alterada.</blockquote><blockquote>E no exemplo da sobrescrita apenas os valores de comparação foram alterados e foi feita a inclusão de uma verificação adicional.</blockquote><blockquote>Note a presença das palavras-chave <em>virtual</em>e <em>override</em>que no C# tratam-se de um recurso que nos permite sinalizar e identificar métodos que sofrem aplicação do polimorfismo na forma dinâmica. Onde “virtual” indica que o método da classe base pode ser sobrescrito por um método da classe deriva e essa sobrescrita é feita através do uso da palavra-chave “override” .</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fd535e4101c2b697d80fee0ffb27467b/href">https://medium.com/media/fd535e4101c2b697d80fee0ffb27467b/href</a></iframe><h3>Conclusão</h3><p>Acredito que agora você tem uma ideia melhor sobre os 4 pilares básicos da orientação a objetos e poderá explicá-lo para os outros de forma simples. Seja no dia a dia de trabalho, na faculdade ou até mesmo na entrevista técnica!!! Além disso saberá também como aplicar na prática!!! Olha que top?!!</p><p>Mas lembre-se sempre de que estes pilares sempre estarão na vanguarda de qualquer linguagem de programação orientada a objetos.</p><p>Eles podem até parecer complicados no começo, mas quando você entende de fato qual o papel de cada um deles você só colhe benefícios, especialmente quando sabe aplicar bem na prática.</p><p>E eles existem neste paradigma para facilitar nossa compreensão sobre concepção, segurança, relações e comportamentos de classes e objetos em qualquer linguagem de programação que ofereça suporte nativamente ou não.</p><p>Se você gostou desse artigo, deixa seu “gostei” e compartilha com algum amigo ou colega de trabalho. E se tiver alguma crítica, complemento ou sugestão de correção de algum “BUG” detectado no artigo, deixa nos comentários ou entra em contato comigo através do linkedin.</p><p>Será um prazer ouvi-lo(a)!!!!</p><h3>Referências</h3><ul><li>WEISFELD, Matt. The Object-Oriented Thought Process. 5. ed. San Francisco, Ca: Addison-Wesley Professional, 2019.</li><li><strong>CARDELLI</strong>, L.; <strong>WEGNER</strong>, P. On Understanding Types, Data Abstraction, and Polymorphism. ACM Computing Surveys (CSUR). vol.17, pag. 471–524. 1985.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=91697976a618" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Princípio da Responsabilidade Única — SRP — SOLID]]></title>
            <link>https://kaiqueprazeres.medium.com/princ%C3%ADpio-da-responsabilidade-%C3%BAnica-srp-solid-b7ec76e207e?source=rss-39fc83287e42------2</link>
            <guid isPermaLink="false">https://medium.com/p/b7ec76e207e</guid>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <category><![CDATA[single-responsibility]]></category>
            <category><![CDATA[solid]]></category>
            <dc:creator><![CDATA[Kaique Prazeres]]></dc:creator>
            <pubDate>Wed, 31 Mar 2021 18:53:01 GMT</pubDate>
            <atom:updated>2021-04-10T01:03:39.459Z</atom:updated>
            <content:encoded><![CDATA[<h3>Princípio da Responsabilidade Única — SRP — SOLID</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/262/1*TukP6gsYzw5aTGz6TNTo2g.jpeg" /><figcaption>Princípio da Responsabilidade Única, Clean Achitecture, Robert C. Martin</figcaption></figure><p>O <strong>princípio da reponsabilidade única</strong> é um princípio de “<a href="https://en.wikipedia.org/wiki/Software_design">Design de Software</a>” utilizado em conjunto com diversos paradigmas de programação. Mas, amplamente difundido no <a href="https://en.wikipedia.org/wiki/Object-oriented_programming">paradigma de programação orientada a objetos</a>.</p><p>Também é conhecido como o primeiro dos princípios que compõem o acrônimo <a href="http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod"><strong>SOLID</strong></a><strong> </strong>e como uma técnica de desenvolvimento de código que facilita a localização de mudanças e pontos de evolução.</p><p>Este principio foi identificado com base no trabalho de DIJKSTRA (1974), DEMARCO (1979), CONSTANTINE (1974), PAGE-JONES (1988) e PARNAS (1971), e parte da ideia de que cada módulo de software deve ter um, e apenas um, motivo para mudar.</p><p>Mais tarde, no final da década de 1990, o princípio foi consolidado como o “princípio da reponsabilidade única” pelo <a href="https://pt.wikipedia.org/wiki/Robert_Cecil_Martin">Robert C. Martin</a>, mais conhecido como Uncle Bob.</p><p>E segundo ele, este é o princípio menos compreendido pela maioria dos profissionais que trabalham com desenvolvimento de software.</p><p><em>¹ Segundo o </em><a href="https://pt.wikipedia.org/wiki/Robert_Cecil_Martin"><em>Robert C. Martin</em></a><em> quando nos referimos a “Módulo” estamos nos referindo a um código fonte de uma classe, estrutura de dados ou conjunto de códigos coesos voltados para um contexto apenas. Não um conjunto de funcionalidades aleatórias que fazem referência indiretamente a uma classe.</em></p><h3>O que diz o Princípio da Reponsabilidade Única</h3><blockquote>Um módulo deve ser responsável por um, e apenas um, ator.¹</blockquote><p>Essa é a definição mais recente formulada pelo próprio <a href="https://pt.wikipedia.org/wiki/Robert_Cecil_Martin">Robert C. Martin</a> em seu livro “<a href="https://g.co/kgs/R2bajT">Arquitetura Limpa</a>”. Em outras palavras, devemos reunir as coisas que mudam pelas mesmas razões e separar coisas que mudam por diferentes razões. (Robert C. Martin 2020, Solid-Relevance)</p><h3>O Objetivo</h3><p>Escrever código simples.</p><p>De forma mais detalhada, o objetivo é atender as necessidades das pessoas do negócio garantindo que os papéis não se confundam no código-fonte, que haja apenas 1 motivo para mudança e que as regras de negócio não se misturem com regras técnicas de baixo nível como validações, consultas, SQL etc…</p><h3>Por que aplicar?</h3><p>Aqui, darei um resumo dos motivos que justificam o porque de aplicar o princípio da responsabilidade única. Mais a frente os detalharei como vantagens e desvantagens.</p><ul><li>O código fica mais simples de manter.</li><li>As chances de causar bugs acidentalmente são reduzidas.</li><li>As funcionalidades ficam isoladas e organizadas.</li><li>O custo de manutenção é reduzido.</li><li>Facilita entender o código desenvolvido.</li></ul><h3>O que considerar antes de aplicar?</h3><p>1º — Estudar. compreender bem toda a teoria que fundamenta o princípio, o contexto, e torná-lo um hábito ao modelar novas funcionalidades.</p><p>2º — Entender que este princípio não é uma bala de prata. <br>Assim como toda ferramenta, tecnologia, processo, metodologia, abordagem, técnica, arquitetura, este princípio não resolve todos os problemas. Apenas alguns deles.</p><p>3º — O princípio foi identificado por alguém que atua na área há muitos anos, possui muita bagagem em design de software e contribui muito com área. Isso nos mostra que o conceito e a prática não foram baseadas em puro achismo.</p><p>E que apesar deste princípio ter sido identificado por grandes nomes da área, não somos obrigados a aplicá-lo ou segui-los “cegamente”. Podemos optar por questioná-lo, criticá-lo, inclusive não aplicá-lo.</p><p>4º — Entender a importância de aplicar na prática um conhecimento comum entre boa parte dos desenvolvedores sérios e experientes que buscam simplificar seu trabalho em um desenvolvimento de software guiado por princípios bem fundamentados.</p><p>5º — Software está sempre evoluindo e precisa de uma manutenção fácil e intuitiva.</p><h3>Vantagens</h3><h4>Facilidade de manter e evoluir requisitos</h4><p>Como o princípio orienta que uma classe deve ser responsável por apenas um contexto de um ator, será mais fácil de identificar a qual contexto as regras de negócio pertencem.</p><p>Além disso, sua atenção no momento da manutenção estará altamente voltada para o que aquela classe faz naquele no contexto em que está inserida.</p><p>Isso ajudará você a não perder o foco tentando melhorar implementações relacionadas.</p><h4>Facilidade de entender o código escrito</h4><p>Mais clareza e objetividade no que precisa ser modificado, onde e como, pois a classe se refere apenas ao contexto de um ator. E isso reduz o seu esforço para entender como esse ator interage com os outros e as <a href="https://en.wikipedia.org/wiki/Business_rule">regras de negócio</a> relacionadas e quando uma alteração “simples” precisa ser feita.</p><h4>Facilidade de alterar o código com o menor esforço necessário</h4><p>O código desenvolvido aplicando o princípio da responsabilidade é mais coeso, ou seja, faz o que diz que ela faz (é coerente), se conecta facilmente a outras funcionalidades. Logo, você precisará alterar apenas uma parte. E consequentemente sua entrega será mais rápida e sua produtividade aumentará.</p><h4>Facilidade de Testar</h4><p>Por ter um código com um nível de isolamento mais alto, a facilidade de criar testes será maior.</p><h4>Facilidade de Reaproveitar</h4><p>Por ter <a href="https://en.wikipedia.org/wiki/Cohesion_(computer_science)">alta coesão</a> e <a href="https://en.wikipedia.org/wiki/Coupling_(computer_programming)">baixo acoplamento</a>, no momento em que reaproveitar a funcionalidade, você precisará mudar poucos detalhes para adaptar ao novo contexto. Haverá pouquíssimas ou nenhuma dependência que não farão sentido de serem reaproveitadas.</p><h4>Complexidade Reduzida e Legibilidade Melhorada</h4><p>Por ter um código mais objetivo e focado em um ator, as chances de você entender o que o código faz com uma olhada rápida aumenta.</p><h4>Acoplamento Reduzido e Coesão Aumentada</h4><p>A dependência de outras funcionalidades é reduzida. O código faz exatamente o que ele diz que faz. Se você alterar uma parte dele, dificilmente quebrará outra parte relacionada.</p><h4>Menor Duplicação e Fragilidade do Código</h4><p>O código está em apenas um lugar. Você não precisará alterar a mesma coisa em outros lugares.</p><h4>Maiores chances de evolução sem aumentar muito a complexidade</h4><p>Se a essa altura você já tem facilidade de entender, reaproveitar e alterar o código com o menor esforço necessário as chances de evoluir sem aumentar demais a complexidade do código são maiores.</p><h3>Desvantagens</h3><h4>Aumento do Número de Arquivos</h4><p>A medida em que o principio é aplicado é possível que o número de arquivos aumente. E a depender de como você enxerga o aumento da quantidade de arquivos, pode ser um problema ter que lidar com isso a longo prazo.</p><h3>Princípio da Responsabilidade Única na Prática</h3><p>Os exemplos mostrados aqui terão um pouco mais de profundidade do que os exemplos superficiais que normalmente encontramos por ai.</p><p>1º Exemplo.</p><p>O diretor de marketing de uma empresa decide criar uma campanha digital em uma loja virtual para divulgar um novo produto que terá seu preço definido pelo diretor comercial, será vendido pelo vendedor e disponibilizados em um relatório para ser consultado pelo diretor financeiro.</p><ul><li>O Diretor de Marketing deseja que seja possível criar campanha pelo sistema.</li><li>O Diretor Financeiro deseja que seja possível gerar o relatório do faturamento.</li><li>O Diretor Comercial deseja que seja possível gerenciar o produto.</li><li>O Vendedor deseja que a venda possa ser registrada e algumas validações sejam aplicadas no momento do registro.</li></ul><p>Então, teremos a seguinte representação não aplicando o princípio da responsabilidade única:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/623/1*8npozRycVFRuh9BJ420-kg.png" /></figure><blockquote>Nota: Os exemplos deste artigo são escritos em C#. Por se tratar de uma linguagem orientada a objetos e ter uma sintaxe fácil de ser entendida.</blockquote><p>Ao abstrair o mundo real para orientação a objetos alguns papéis se confundiram, a classe Venda ficou responsável por todos os atores e por regras de baixo nível como conversão de datas e acesso a banco de dados.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/62cda05a459536d922fef7b6c1060bba/href">https://medium.com/media/62cda05a459536d922fef7b6c1060bba/href</a></iframe><p>O código acima é um típico exemplo de violação desse princípio.</p><p>Os 4 atores possuem diferentes responsabilidades, mas no sistema eles são representados apenas por uma classe. E de quebra, temos mais duas responsabilidades: Lidar com persistência de dados e com conversão de data.</p><p>Existem contextos em que isso faz sentido, mas não é este o caso.</p><p>No mundo real o Vendedor é responsável por registrar a venda e dar descontos, no sistema, quando representado pela classe Venda, suas responsabilidades são criar campanhas, gerar relatório, definir preço de produto, registrar, salvar e consultar venda e converter datas para um formato específico.</p><p>No mundo real, de acordo com o nosso exemplo, o contexto foi traduzido corretamente?</p><blockquote>“Ah, mas, tudo isso é relacionado a venda e o vendedor no final das contas”</blockquote><p>Sim, tem relação com o Vendedor, mas ele não tem a responsabilidade de cuidar do que não diz respeito diretamente a ele. Pode ser que em alguns contextos sim, mas não neste. Além disso, outras solicitações partiram de outros atores, não somente do Vendedor.</p><p>Se uma nova funcionalidade for desenvolvida a partir da premissa ingênua de que a relação entre atores e contexto permite que mais responsabilidades sejam atribuidas a eles em um sistema, teremos um emaranhado de confusão em código.</p><p>Os efeitos práticos disso?</p><ul><li>Abstração confusa que não representa fielmente as responsabilidades dos atores de negócio no mundo real.</li><li>Código bagunçado. Pois tem código de persistência, consulta de dados e conversão de datas misturados com regras de negócio.</li><li>Dificuldades no reuso, modularização e manutenibilidade.</li><li>Maior dificuldade no entendimento do código.</li></ul><p>Os efeitos práticos acima são suficientes para dificultar a evolução do sistema. Em alguns casos podem até IMPEDIR que algum tipo de evolução aconteça. <br>Mas não é o nosso caso. Pois, temos uma solução!</p><p>Vamos a um exemplo mais realista de como isso pode acontecer ao longo do tempo na prática.</p><p>Em outro momento, as pessoas do negócio solicitam novas funcionalidades para o sistema.</p><ul><li>O Diretor de Marketing deseja que seja possível veicular campanhas criadas em um período específico.</li><li>O Diretor Comercial deseja que seja possível criar promoção para o produto por um período específico.</li><li>O Vendedor deseja que seje possível dar descontos na venda.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*vyvFaCCLPZH9ThBuIRETbA.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4d9138a6002ec004e1ad491bf8ecb796/href">https://medium.com/media/4d9138a6002ec004e1ad491bf8ecb796/href</a></iframe><p>Vamos assumir que esse número se multiplique ainda mais ao longo do tempo.</p><p>Facilmente essa será uma forte candidata a se tornar uma classe DEUS (Classe que faz tudo). E a facilidade de manutenção dela será minimizada.</p><h4>Solução aplicando o Princípio da Responsabilidade Única</h4><p>Antes de mostrar a solução, mostrarei algumas perguntas que realizei para chegar a uma solução para este contexto. O que facilitou a aplicação do principio de acordo com a definição.</p><p>As perguntas foram:</p><ul><li>No mundo real, o Vendedor realmente tem todas essas responsabilidades que foram atríbuidas em sua representação no sistema?</li><li>O Vendedor confirma que todas essas tarefas são executadas por ele?</li><li>Há outros papéis na empresa que são responsáveis por algumas atividades que foram atribuídas ao Vendedor?</li><li>Quem são os outros atores que costumam solicitar mudanças?</li><li>Qual a fronteira do contexto de cada ator?</li><li>Existem responsabilidades com perfil mais técnico que normalmente são do próprio sistema?</li></ul><p>As perguntas ajudaram a chegar na seguinte solução:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z8dCJBmEQCqbxc__k-OaGA.png" /></figure><p><strong>Classe:</strong> Venda<br><strong>Ator:</strong> Vendedor</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/310e9cdf9e0efa397f5814df4c094096/href">https://medium.com/media/310e9cdf9e0efa397f5814df4c094096/href</a></iframe><p><strong>Classe:</strong> GerenciamentoProduto<br><strong>Ator:</strong> Diretor Comercial</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d600cf24a8bf7c44ed96341c35118529/href">https://medium.com/media/d600cf24a8bf7c44ed96341c35118529/href</a></iframe><p><strong>Classe:</strong> Faturamento<br><strong>Ator:</strong> Diretor Financeiro</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fd8c78aa2af4559b7c0ecbbde648200f/href">https://medium.com/media/fd8c78aa2af4559b7c0ecbbde648200f/href</a></iframe><p><strong>Classe:</strong> Divulgacao<br><strong>Ator:</strong> Diretor de Marketing</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/16012ae01c6bc8fd2f834734163a8b84/href">https://medium.com/media/16012ae01c6bc8fd2f834734163a8b84/href</a></iframe><p><strong>Classe:</strong> VendaRepositorio<br><strong>Ator:</strong> DBA</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/12c333a1cbc40a51cf0cf72b97c08e00/href">https://medium.com/media/12c333a1cbc40a51cf0cf72b97c08e00/href</a></iframe><p><strong>Classe:</strong> ConversorDeData<br><strong>Ator:</strong> Sistema</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/356caf4dff043bd9dcfe41b40f6ea641/href">https://medium.com/media/356caf4dff043bd9dcfe41b40f6ea641/href</a></iframe><p>Note que novos atores (DBA e Sistema) apareceram e cada um deles foi representado por uma classe que possui um conjunto de métodos que lidam com regras de baixo nível.</p><p>Isso foi feito porque regras de baixo nível como consultas de dados, conversão de datas possuem outras razões para mudar e não faz sentido misturá-las com regra de negócio.</p><p>Além disso, os novos atores foram incluídos com o intuito de representar ações que não dizem respeito aos atores que solicitaram as mudanças (Os Diretores e o Vendedor).</p><blockquote>“Ah, mas agora que o princípio foi aplicado temos muitas classes”</blockquote><p>Estamos trabalhando com orientação a objetos. Consequentemente o número de arquivos aumentarão a medida que o sistema for evoluindo e mais necessidades de negócio forem surgindo, além disso, na maioria das linguagens que adotam esse paradigma é recomendado ter uma classe por arquivo. E um dos benefícios é o isolamento.</p><p>E lembre-se que uma classe deve ter apenas 1 motivo para mudar e deve ser responsável somente por 1 ator, certo? Então, agora, quando houver motivo para mudança, ela será feita apenas em uma das classes.</p><p>Com a separação do contexto de cada ator, as responsabilidades de cada um deles no sistema não se misturam.</p><p>Diferente do exemplo de violação onde tínhamos uma classe DEUS.</p><p>Aproveito e deixo a seguinte provocação: Será que o crescimento do número de arquivos em softwares bem projetos não é algo inevitável? Reflita.</p><h3>Atores e Papéis</h3><p>Ter papéis associados as pessoas bem definidos é um desafio. Pois isso pode variar em cada contexto. Em uma empresa pequena por exemplo, 1 ator pode ter vários papéis, enquanto que em empresas maiores os papéis podem estar dissipados com responsabilidades bem definidas.</p><p>Mas ainda sim, é mais fácil pensar em pessoas realizando determinados papéis do que imaginar que uma pessoa faz todos. E assim, associamos o papel a cada ator.</p><p>E com isso temos os motivos para mudanças bem definidos.</p><blockquote>O princípio da responsabilidade única trata de reunir coisas que mudam pelas mesmas razões e de separar coisas que mudam por diferentes razões. <br>(Uncle Bob, SOLID Relevance)</blockquote><p>Por estes motivos, temos uma série de classes isoladas no sistema representando cada coisa do mundo real.</p><h3>A Confusão nas interpretações</h3><p>Em sua primeira definição, o princípio dizia que:</p><blockquote>Uma classe deve ter um, e apenas um, motivo para mudar.</blockquote><p>E é comum encontrar desenvolvedores que interpretaram essa definição da seguinte forma:</p><blockquote>Cada classe deve ter um, e apenas um método.</blockquote><p>Mas não é isso que o princípio diz. Pois a definição mais recente deixa mais claro e com menos margem para esse tipo de interpretação.</p><blockquote>Um módulo deve ser responsável por um, e apenas um, ator.</blockquote><h3>Motivos para mudanças, sua origem e responsabilidade</h3><p>Mas o que são esses motivos para mudança e de onde eles vem?</p><p>Os motivos para mudanças vem das pessoas da área de negócio e surgem a partir das necessidades dessas pessoas ou do contexto que estão inseridas.</p><p>Seguindo esse raciocínio, imagine que uma dessas pessoas perceba que o sistema da empresa precise de alguma adequação em alguma funcionalidade. Essa pessoa entende que isso precisa acontecer, então, ela solicita a mudança a partir dessa necessidade.</p><p>Essa necessidade é atendida por alguma representação no sistema. E essa representação no sistema possui responsabilidade sobre as mudanças que o ator solicitou.</p><blockquote><em>Então, uma responsabilidade é um conjunto de funções que serve a um ator em particular. (Robert C. Martin)</em></blockquote><p>Por que…</p><blockquote>Se uma classe tem mais de uma responsabilidade, as responsabilidades se tornam acopladas. Mudanças em uma responsabilidade podem prejudicar ou inibir a capacidade da classe de cumprir as outras. Esse tipo de acoplamento leva a projetos frágeis que estragam de maneiras inesperadas quando alterados <br>(Robert C. Martin 2002)</blockquote><p><strong>Continuando com o exemplo…</strong></p><p>Ok, o Princípio da Responsabilidade Única foi aplicado seguindo a sua definição mais recente.</p><p>Observando o exemplo apresentado, conseguimos extrair os seguintes pontos:</p><ul><li>Ficou mais fácil entender quais são as responsabilidades de cada classe.</li><li>Os contextos estão separados e limitados por autor, logo a organização aumentou.</li><li>A coesão de cada classe está maior, pois a responsabilidade dela é direcionada exclusivamente ao contexto de apenas 1 ator.</li><li>O acoplamento está mais baixo pois o número de dependências entre os processo foi isolado.</li><li>Ficou mais fácil de dar manutenção. Pois é fácil saber qual a responsabilidade de cada classe, além disso é mais simples reutilizar cada uma delas sem ter que levar todas as dependências junto ou código desnecessário .</li><li>Separamos as regras de negócio das regras de persistência, consulta de dados e dos detalhes da conversão de datas.</li><li>Ficou mais fácil entender por quais motivos as mudanças acontecem e onde elas devem acontecer</li></ul><h3>Respostas para dúvidas comuns</h3><ul><li><strong>Uma classe deve ter somente um método?</strong><br>Não. Ele pode ter outros métodos privados, públicos ou protegidos, desde que façam parte do mesmo contexto e tratem de comportamentos do mesmo ator.</li><li><strong>Uma classe pode ser responsável por mais de 1 ator?</strong><br>A definição do princípio diz que não. Mas, aplicar o princípio criando exceções e desconsiderando a própria definição é o mesmo que não aplicá-lo.</li><li><strong>É obrigatório aplicar o Princípio da Responsabilidade única?</strong><br>Não. O princípio não é uma lei. Se um dos objetivos não é facilitar a manutenção, evolução, melhoria e entendimento não precisa aplicar. Ou até mesmo, senão quiser, não precisa aplicar.</li><li><strong>Regras de validação ou consultas SQL também podem ser responsabilidades da mesma classe? </strong><br>Não. Alias, esse também é um dos motivos desse princípio existir. Separar regras de baixo nível das regras de negócio.</li><li><strong>Este princípio só pode ser aplicado com orientação a objetos?</strong><br>Não necessariamente. Há quem diga que não é possível aplicar os princípios SOLID sem orientação a objetos e há quem defenda o contrário. É um assunto que cabe uma grande discussão, pois dependendo do contexto ou tecnologias envolvidas, este princípio pode ser aplicado de uma forma diferente do convencional.</li></ul><h3>As Críticas e Questionamentos ao Princípio da Responsabilidade Única</h3><p>Como dito anteriormente, apesar do princípio ter sido identificado por grandes nomes do desenvolvimento de software, ele também está sujeito a críticas e questionamentos.</p><p>Pois, não são leis que devemos seguir cegamente.</p><p>Diante disso, faço algumas considerações a respeito.</p><h4>Definição Ambígua e Abertura para interpretações variadas</h4><p>As definições (Primeira e mais recente) deste princípio passaram uma ideia vaga sobre o que significa responsabilidade única e gerou muita confusão sobre como aplicá-lo.</p><p>Responsabilidade significa atribuição e unicidade, representa apenas 1 coisa. <br>Quando associamos a primeira definição com “classes” a ideia que é passada sobre fazer uma coisa, ter uma única responsabilidade, é de que a classe deve ter apenas um método, e não um contexto.</p><p>Esse tipo de abertura na interpretação, consequentemente forçou a atualização da definição (Acredito eu).</p><p>E o problema disso é que o tornou mais um daqueles conceitos do mundo da programação que a maioria dos desenvolvedores interpretam de forma simplista e com a profundidade de um pires. E para piorar, utilizam exemplos reducionistas e mal elaborados para exemplificar como funciona na prática.</p><h4>Verbosidade</h4><p>O princípio da responsabilidade única de certa forma incentiva a criação de mais componentes, e a longo prazo isso significa ter mais arquivos. O que para alguns pode tornar a manutenção mais complicada.</p><p>No entanto, isso também é uma consequência da evolução de todo software que um dia se tornará grande e precisa ter uma organização mais elaborada.</p><p>O aumento do número de arquivos é inevitável, exceto se tudo for feito em uma quantidade especificada de arquivos ou que tudo seja feito em apenas um.</p><p>Mas imagina se levarmos a primeira definição ao pé da letra? O que acontece? Milhares de classes com apenas 1 método.</p><h4>Responsabilidade não é única com a Herança</h4><p>Outro ponto que chama atenção é a herança. Em casos que se faz necessário o uso dela, a palavra “única” acaba perdendo um pouco do sentido. Pois, uma classe que herda características e comportamentos passa a ter mais responsabilidades além das suas, só que através de um tipo de associação.</p><p>Para facilitar, pense no clássico exemplo das classes Pessoa, PessoaFisica e PessoaJuridica.</p><p>Onde Pessoa é a abstração Base que terá derivações representadas por PessoaFisica e PessoaJuridica através da herança. É a forma de associação mais comum de ser utilizada pela maioria dos desenvolvedores.</p><p>Agora pensa comigo. A responsabilidade da pessoa física é representar o indivíduo enquanto sujeito detentor de direitos e de deveres. Enquanto que a classe pessoa tem a responsabilidade de representar o ser humano, uma criatura, etc..</p><p>Ambas as pessoas compartilham algumas responsabilidades, tanto no mundo real, quanto no código normalmente. Até ai quase tudo certo.</p><p>Mas e no caso da pessoa jurídica quando herda da classe Pessoa?</p><p>Ela herda caracteristicas e responsabilidades que não são de uma pessoa jurídica (empresa).</p><p>E a herança, consequentemente quebra o princípio em muitos contextos.</p><p>Diante dessa perspectiva, a responsabilidade acaba nem sempre sendo única. Se isso viola o princípio da responsabilidade única do SOLID, neste caso, o que consideramos? rsrs, não é meio contraditório?</p><h4>Um termo novo para falar sobre Coesão e Acoplamento</h4><p>Me questiono o por que anos depois um princípio é criado dizendo as mesmas coisas que dois dos princípios <a href="https://en.wikipedia.org/wiki/GRASP_(object-oriented_design)">GRASP</a> (Coesão e Acoplamento), só que de forma ambígua em uma das definições e aberta a variadas interpretações.</p><p>Coesão e Acoplamento são conceitos descritos pelo <a href="https://en.wikipedia.org/wiki/Larry_Constantine">Larry Constantine</a> no IBM Systems Journal em 1974.</p><p>Não seria mais simples enfatizar a importância desses conceitos ao invés de criar um novo inicialmente confuso?</p><p>Tudo isso faz com que muitos desenvolvedoras tenham dificuldade de entender a importância do princípio e como ele deve ser aplicado.</p><p>Principalmente os iniciantes e os que resolvem se aventurar com Design e Arquitetura de Software.</p><h4>1 Motivo para mudança. Na prática faz sentido?</h4><p>Outro ponto que é bem relevante é o motivo da mudança.</p><p>Quando se trata de negócio, existem vários motivos para um sistema mudar. Inclusive suas entidades (módulo, classe ou método).</p><p>Mas, como é possível ter <strong>UM</strong> motivo para mudança se além das regras de negócio é possível que uma validação necessite de modificação, uma consulta, ou condição seja melhorada ou removida? Esse <strong>UM </strong>motivo consequentemente não desencadeia mais motivos?</p><p>Pense nisso…</p><h3>Conclusão</h3><p>Este princípio descreve uma forma de representar o negócio de forma coerente em um sistema, facilitar a manutenção e como dito anteriormente: Se refere as necessidades dos atores de negócio seus motivos para mudanças.</p><p>Apesar de algumas confusões em sua interpretação, ele orienta uma maneira de escrever código simples guiado por princípios que restringem os programadores de produzir códigos ruins e confusos.</p><p>Mas como tudo na vida, ele também tem suas vantagens e desvantagens. Que precisam ser consideradas para entender se faz ou não sentido aplicá-lo em em alguns contextos. Apesar de que, de uma geral, na maioria dos contextos se fazem necessárias a aplicação dele.</p><p>No entanto, aplicá-lo “parcialmente” a partir de “exceções”, é o mesmo que não aplicá-lo e fugir da simplicidade que ele propõe.</p><p>E já que há muitos benefícios, por que não aplicar?</p><p>Espero ter ajudado a compreender.</p><p>Aguardo por críticas, sugestões e uma boa discussão sobre este princípio.</p><h3>Referências</h3><p>Robert C. Martin, Clean Architecture. Single Responsability Principle. 2017</p><p><a href="http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod">ArticleS.UncleBob.PrinciplesOfOod (butunclebob.com)</a></p><p>Robert C. Martin, Solid Relevance, 2020. <a href="https://blog.cleancoder.com/uncle-bob/2020/10/18/Solid-Relevance.html">Clean Coder Blog</a></p><p>Robert C. Martin, Single Reponsibility Principle, <a href="https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html">Clean Coder Blog</a></p><p>Stevens, Wayne P.; Myers, Glenford J.; Constantine, Larry LeRoy (June 1974). “Structured design”. IBM Systems Journal.</p><p>DIJKSTRA, Edsger W. <em>On the role of scientific thought.</em> Burroughs Research Fellow, Netherlands, 1974.</p><p>MARTIN, Robert C. <em>The Single Responsibility Principle</em>. 2014</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b7ec76e207e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>