<?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 Ricardo Dias on Medium]]></title>
        <description><![CDATA[Stories by Ricardo Dias on Medium]]></description>
        <link>https://medium.com/@ricardopedias?source=rss-9d370e09a683------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GAns0nNwejXmtBT4JAaDMg.png</url>
            <title>Stories by Ricardo Dias on Medium</title>
            <link>https://medium.com/@ricardopedias?source=rss-9d370e09a683------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 12:29:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ricardopedias/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[Git Básico]]></title>
            <link>https://medium.com/contexto-delimitado/como-usar-o-git-fa880674f1dd?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa880674f1dd</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[aplicativos]]></category>
            <category><![CDATA[versionamento-de-código]]></category>
            <category><![CDATA[ferramentas]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Sat, 15 Aug 2020 02:02:29 GMT</pubDate>
            <atom:updated>2020-09-21T21:09:20.768Z</atom:updated>
            <content:encoded><![CDATA[<h4>Para iniciantes no mundo Git</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f9pRshup5aVlvuDO26OPCQ.png" /></figure><p>O Git é o mais famoso versionador de código fonte (e também de outros tipos de dados) atualmente no mercado. Trata-se de um software robusto e indispensável para todos os desenvolvedores na atualidade, principalmente àqueles que trabalham em equipe.</p><p>O Git <em>“foi criado em 2005 por Linus Torvalds, o mesmo criador do Linux, que estava descontente com o </em><a href="http://www.bitkeeper.org/"><em>BitKeeper</em></a><em>, o sistema de controle de versão utilizado no desenvolvimento do kernel do Linux.”</em> (AQUILES &amp; FERREIRA).</p><p>Neste artigo, você conhecerá os truques desta incrível ferramenta e como utilizá-la “like a boss”.</p><h3>1. Os termos do mundo Git</h3><p>Para entender o funcionamento de todo o processo, é necessário conhecer os termos que envolvem a manipulação do código fonte gerido pelo Git. A seguir, tentarei explicar, de forma bem concisa, os principais termos usados:</p><ul><li><strong>Repositórios:</strong> são uma espécie de “recipientes” onde todo o código-fonte é armazenado. Diferente de um diretório comum, um repositório é capaz de armazenar toda a história de cada arquivo. Dessa forma, é possível obter uma modificação efetuada há um ano atrás e descobrir tudo o que já foi feito em um arquivo.</li><li><strong>Repositório Remoto:</strong> onde os arquivos permanecem versionados. O repositório remoto pode ser acessado por outros desenvolvedores que, por ventura, tenham permissão para isso;</li><li><strong>Repositório Local:</strong> é um clone do repositório remoto, onde o desenvolvedor pode fazer suas alterações no código fonte, localmente, em seu computador;</li><li><strong>Arquivos:</strong> os arquivos podem possuir dois estados diferentes. Quando um novo arquivo é criado, ele possui o estado de “<strong>não rastreado</strong>”. Para que um arquivo possa ser versionado, ele deve passar para o estado de “<strong>rastreado</strong>” (Staged). Apenas arquivos rastreados podem ser adicionados como parte do repositório;</li><li><strong>Commit:</strong> é o processo que acrescenta um arquivo com estado de “rastreado” no repositório local. Cada grupo de alterações deve ser “comitado” (juntamente com um texto descritivo) para que as modificações efetuadas possam ser identificadas no histórico do repositório. Durante o desenvolvimento, o programador efetua vários “commits”, tudo localmente, em seu repositório local;</li><li><strong>Push:</strong> após concluir o seu trabalho, o desenvolvedor deve submeter todos os commits efetuados em seu repositório local para que seja adicionados no repositório remoto. Esse processo se chama “push”;</li><li><strong>Pull:</strong> é o processo inverso do “push”. Ao efetuar um “pull”, o código que existe no repositório remoto é sincronizado com o repositório local, garantindo que o desenvolvedor esteja usando o código fonte atualizado;</li><li><strong>Branchs:</strong> muitas vezes, não se deseja trabalhar diretamente no código fonte definitivo. Modificações diretas poderiam quebrar a execução da aplicação e inutilizá-la. Para permitir que o desenvolvedor faça alterações com segurança, sem afetar o código atualmente em uso, o git permite a criação de “branchs”. Tratam-se de ramificações do projeto real, que, a partir do ponto onde são criadas, possuem código fonte diferente da ramificação principal (geralmente chamada de “branch master”);</li><li><strong>Merge:</strong> após fazer todas as alterações desejadas em um branch, é preciso realizar o “merge” deste branch trabalhado com o branch principal. O “merge” irá mesclar os códigos existentes, juntando tudo no branch de destino;</li><li><strong>Conflitos:</strong> durante o processo de mesclagem, poderão ocorrer conflitos (quando duas pessoas alteram o mesmo trecho de código). O Git irá notificar o usuário, adicionando anotações no código para apontar onde os conflitos ocorreram e nortear o desenvolvedor para efetuar a devida correção;</li><li><strong>Tags:</strong> são marcações que podem ser efetuadas em um determinado “commit” na ramificação principal. As tags geralmente são usadas para definir onde ocorream as mudanças de versões (releases) em uma aplicação.</li></ul><h3>2. Instalando o Git</h3><h4>No Windows</h4><p>Faça o download e instale de <a href="http://msysgit.github.io/">http://msysgit.github.io/</a>. Após a instalação, acesse o <em>Git Bash</em> e será aberto um terminal, com o prompt de comando.</p><h4>No Mac</h4><p>Faça o download e instale de <a href="https://code.google.com/p/git-osx-installer/downloads">https://code.google.com/p/git-osx-installer/downloads</a>. Após a instalação, abra um terminal e o git estará disponível.</p><h4>No Linux</h4><p>Para instalar o <em>Git</em> no Ubuntu, ou em uma outra distribuição baseada no Debian, execute no terminal:</p><pre>$ sudo apt-get install git</pre><p>Para as demais distribuições do Linux, veja o comando em <a href="http://git-scm.com/download/linux">http://git-scm.com/download/linux</a></p><h3>3. Configurando o usuário desenvolvedor</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BGaYpkuKEoJKkSf4o-ajkg.jpeg" /></figure><h4>3.1. O usuário commiter</h4><p>Para que seja possível enviar alterações (commits) para um repositório, é preciso configurar o usuário desenvolvedor.</p><p>As informações deste usuário aparecerão no histórico de envios e servem para identificar quem foi o autor de determinada funcionalidade ou correção submetida ao repositório.</p><p>Isso pode ser feito de duas maneiras, como será explicado a seguir.</p><h4><strong>3.2. Configuração global</strong></h4><p>Configurando dessa forma, as informações do desenvolvedor serão usadas por padrão para todos os repositórios criados com Git no computador pessoal:</p><pre>$ git config --global user.name &quot;Nome do Desenvolvedor&quot;<br>$ git config --global user.email usuario.padrao@gmail.com</pre><h4><strong>3.3. Configuração local</strong></h4><p>Existem casos onde o desenvolvedor deseja enviar suas alterações ao repositório de um projeto com uma outra identificação. Isso é comum quando um mesmo computador é usado para trabalho e para projetos pessoais.</p><p>O Git permite que, além de configurar um desenvolvedor globalmente, seja possível configurar o desenvolvedor para cada projeto.</p><p>Estando no diretório do projeto (que já deve ser um repositório do Git), basta executar os seguintes comandos:</p><pre>$ git config user.name &quot;Nome do Usuário&quot;<br>$ git config user.email usuario.local@gmail.com</pre><p>Estas informações são gravadas no arquivo <em>/caminho/ate/meu/repositorio/.git/config</em>, com o seguinte formato:</p><pre>[user]<br>    email = usuario@gmail.com<br>    name = Nome do Usuário</pre><h3>4. Gerindo repositórios</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*KB7EBonn0QNVfFOSnZqmEw.png" /></figure><h4>4.1. Criando um repositório local</h4><p>Para transformar um diretório qualquer em um repositório local do Git, basta executar o comando <strong><em>git init</em></strong>:</p><pre>$ cd /home/ricardo/projeto<br>$ git init<br><em>Initialized empty Git repository in /home/ricardo/projeto/.git/</em></pre><p>Pronto, o projeto já é um repositório local vazio. Observe que foi criada uma pasta oculta com o nome <strong><em>.git</em></strong>. Nela estão todos os arquivos necessários para o repositório local funcionar.</p><pre>$ cd /home/ricardo/projeto<br>$ ls -la<br><em>total 11<br>drwxr-xr-x  3 ricardo ricardo 4096 jan 21 13:29 .<br>drwxr-xr-x 32 ricardo ricardo 4096 jan 21 13:50 ..<br>drwxr-xr-x  7 ricardo ricardo 4096 jan 21 13:29 .git</em></pre><h4>4.2. Vinculando um repositório local com um repositório remoto</h4><p>Após criar novos arquivos e codificar alguma coisa, será preciso enviar este novo conteúdo para um repositório remoto. No entanto, se você criou seu novo repositório como explicado no item 4.1, ele ainda não possui um repositório remoto configurado.</p><p>Para que seja possível enviar seu código-fonte para o repositório remoto, é preciso que o Git saiba onde ele está. Isso é feito com o comando <strong><em>git remote</em></strong>:</p><pre>$ git remote add origin https://github.com/fulano/meu-repo.git</pre><p>Ao executar o comando acima, o repositório local estará vinculado ao repositório remoto, que chamamos aqui de de “origin” (poderia ser qualquer nome). <strong>Esse nome é importante, pois será usado para identificar o repositório nas operações com arquivos.</strong></p><blockquote>Por questões de organização, será explicado como enviar e receber arquivos do repositório remoto no item 5 deste artigo.</blockquote><h4>4.3. Clonando um repositório remoto</h4><p>No cenário explicado no item 4.1, criou-se um novo repositório localmente e depois vinculou-se com um repositório remoto. Isso é útil, especificamente, para quando ambos os repositórios (local e remoto) são novos, mas quando um repositório remoto já contém código fonte, é mais interessante utilizar o comando <strong><em>git clone</em></strong>:</p><pre>$ cd /home/ricardo/projeto<br>$ git clone <a href="https://github.com/fulano/meu-repo.git">https://github.com/fulano/meu-repo.git</a> .<br><em>Cloning into &#39;</em><em>projeto&#39;...<br>remote: Enumerating objects: 9, done.<br>remote: Counting objects: 100% (9/9), done.<br>remote: Compressing objects: 100% (8/8), done.<br>remote: Total 9 (delta 0), reused 5 (delta 0), pack-reused 0<br>Unpacking objects: 100% (9/9), 61.81 KiB | 393.00 KiB/s, done.</em></pre><p>Durante a execução, o <em>git clone</em> irá fazer o download do repositório remoto (https://github.com/fulano/meu-repo.git), gerando uma cópia local. Além disso, ele criará automaticamente um vínculo chamado “origin”, ligando os dois repositórios.</p><p>Em outras palavras, o <em>git clone</em> é mais prático na maioria dos casos.</p><h4>4.4. Gerindo os vínculos com repositórios remotos</h4><p>É possível vincular um mesmo repositório local com vários repositórios remotos, a fim de manipular arquivos entre eles.</p><p>Para exibir os repositórios remotos atualmente vinculados, faça:</p><pre>$ git remote<br>$ git remote -v<br><em>origin </em><em>https://github.com/fulano/meu-repo.git (fetch)<br>origin </em><em>https://github.com/fulano/meu-repo.git (push)</em></pre><p>Com base no item 4.3, existe apenas um vínculo chamado “<strong>origin</strong>” que aponta para o URL “<strong>https://github.com/fulano/meu-repo.git</strong>”.</p><p>Para ver informações sobre um repositório remoto, usa-se o comando <strong><em>git remote show</em></strong> seguido do nome do vínculo:</p><pre>$ git remote show origin<br><em>* remote origin<br>  Fetch URL: https://github.com/fulano/meu-repo.git<br>  Push  URL: https://github.com/fulano/meu-repo.git<br>  HEAD branch: master<br>  Remote branch:<br>    master tracked<br>  Local branch configured for &#39;git pull&#39;:<br>    master merges with remote master<br>  Local ref configured for &#39;git push&#39;:<br>    master pushes to master (up to date)</em></pre><p>Para renomear um repositório remoto vinculado:</p><pre>$ git remote rename origin nome-legal</pre><p>E para desvincular um repositório remoto:</p><pre>$ git remote rm nome-legal</pre><h4>4.5. Removendo um repositório local</h4><p>Para remover um repositório local, basta apagar o diretório <em>/home/ricardo/projeto/.git</em> e o projeto deixará de ser um repositório para tornar-se um diretório comum:</p><pre>$ cd /home/ricardo/projeto<br>$ rm -Rf .git</pre><pre>$ git status<br><em>fatal: not a git repository (or any of the parent directories): .git</em></pre><h4>4.6. Listando conteúdo de um repositório</h4><p>Para listar os arquivos que se encontram no repositório usa-se git ls-files Apenas os arquivos que estejam em estado de <strong><em>Staged</em></strong>, <strong><em>Committed</em></strong> ou <strong><em>Pushed</em></strong> serão listados:</p><pre>$ git ls-files</pre><blockquote><strong>Obs: </strong>Será abordado mais sobre os estados no decorrer do artigo.</blockquote><h4>4.5. Verificando o status do repositório</h4><p>É muito útil verificar como está o repositório local antes de submeter alterações para o repositório remoto. Isso inclui saber quais são os arquivos novos, os que foram modificados e os que foram excluídos. Pode-se fazer isso usando o comando <strong><em>git status</em></strong>:</p><pre>$ git status<br><em>No ramo master<br>No commits yet<br>nada para enviar (crie/copie arquivos e use &quot;git add&quot; para registrar)</em></pre><h3>5. Gerindo arquivos</h3><p>Os arquivos no Git possuem quatro estados, por onde passam desde a sua criação até serem enviados ao repositório remoto:</p><ol><li><strong>Unstaged:</strong> arquivo novo foi salvo dentro do diretório, mas ainda não é rastreado pelo Git;</li><li><strong>Staged:</strong> arquivo está sendo rastreado pelo Git localmente mas ainda não está vinculado ao repositório local;</li><li><strong>Committed:</strong> arquivo está vinculado apenas ao repositório local;</li><li><strong>Pushed:</strong> arquivo está vinculado também com o repositório remoto.</li></ol><h4>5.1. Rastreando um arquivo (Staged)</h4><p>Para mudar o estado de um arquivo <em>Unstaged</em> (não rastreado) para <em>Staged</em> (rastreado), usa-se o comando <strong><em>git add</em></strong>:</p><pre>// restreia um único arquivo<br>$ git add heroes/ironman.txt </pre><pre>// rastreia um diretório inteiro<br>$ git add heroes/ </pre><pre>// rastreia todos os que não estiverem rastreados<br>$ git add . </pre><pre>//ou</pre><pre>$ git add -A </pre><h4>5.2. Não-rastrear um arquivo (Unstaged)</h4><p>Existem casos onde nos arrependemos de rastrear determinados arquivos, pois não queremos que sejam versionados no dado momento, mas só futuramente. Para removê-los do rastreio (voltando para o estado inicial), usa-se o comando <strong><em>git reset</em></strong>:</p><pre>// remove o rastreio de um único arquivo<br>$ git reset heroes/ironman.txt </pre><pre>// remove o rastreio de um diretório inteiro<br>$ git reset heroes/</pre><pre>// remove o rastreio de todos que ainda não foram vinculados<br>$ git reset</pre><h4>5.3. Atualizando o histórico local (Commited)</h4><p>Após rastrear os arquivos desejados, é preciso pedir ao Git para vinculá-los ao repositório local. Toda vez que fazemos isso, cada alteração efetuada até o momento é armazenada no <strong>histórico de alterações</strong> do Git, permitindo que possamos acessá-las posteriormente sempre que precisarmos.</p><blockquote>O histórico do Git funciona como a funcionalidade de “Desfazer” (Ctrl + Z), presente na maioria dos programas. A diferença é que o “Desfazer” do Git é armazenado de forma permanente e pode ser executado a qualquer momento, mesmo que seja 5 anos depois.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*W4d4nuf3_S5nyAQcAPhGBQ.png" /><figcaption>O histórico do Git guarda cada alteração</figcaption></figure><p>Para vincular o conteúdo rastreado (Staged) ao repositório local (Commited), usa-se o comando <strong><em>git commit</em></strong>:</p><pre>// Vinculando arquivos Staged (rastreados) ao repositório local<br>$ git commit -m “Meu comentário bem legal” </pre><p>Também é possível vincular diretamente arquivos Unstaged (não rastreados), pulando assim uma etapa. Isso é feito acrescentando a opção <strong>-a</strong>:</p><pre>// Vinculando arquivos Unstaged (não rastreados) diretamente<br>$ git commit -a -m “Meu comentário bem legal”</pre><h4>5.4. Enviando para o histórico remoto (Push)</h4><p>Uma vez que seus novos arquivos e implementações estejam no histórico local (Commited), é possível sincronizar esse histórico local com o histórico do repositório remoto. Isso é feito usando o comando <strong><em>git push</em></strong>:</p><pre>// envia o histórico local para o repositório remoto vinculado<br>$ git push</pre><p>Se existir mais de um repositório vinculado, será necessário especificar o nome do repositório de destino:</p><pre>// O mesmo comando especificando o repositório &quot;origin&quot;<br>$ git push origin</pre><h4>5.6. Recebendo arquivos do repositório remoto (Pull)</h4><p>Em projetos onde várias pessoas usam o mesmo repositório, certamente enquanto uma pessoa efetua suas alterações, outras pessoas já atualizaram o repositório remoto com coisas novas. Por esse motivo, antes de submeter o que foi feito, é preciso obter todas as alterações feitas pelos outros membros do time. Isso é feito usando o comando <strong><em>git pull</em></strong>:</p><pre>// recebe o histórico do repositório remoto vinculado<br>$ git pull </pre><p>Da mesma forma que o comando <em>git push</em>, se existir mais de um repositório vinculado, será necessário especificar o nome do repositório remoto:</p><pre>// O mesmo comando especificando o repositório &quot;origin&quot;<br>$ git pull origin</pre><p>Ao executar esse comando, as alterações das outras pessoas serão obtidas para o histórico local. Nesse processo, <strong>o Git irá tentar resolver automaticamente quaisquer conflitos</strong>, comparando o que a pessoa fez, com o que o resto do time efetuou.</p><p>Mas isso nem sempre é possível! <strong>Existem momentos onde o Git precisa de uma intervenção humana</strong>, para escolher o que deve ou não ser mudado no processo de mesclagem.</p><h3>6. Gerindo conflitos</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*b4ZFy-ZEZU5ukvB9zyTPVw.png" /></figure><h4>6.1. Resolvendo manualmente</h4><p>Como nem tudo são mil maravilhas, os conflitos acontecem. Ideal seria que a equipe se organizasse de tal forma (e o código fonte fosse implementado de maneira tão desacoplada) que o mínimo de conflitos pudesse existir.</p><p>Porém, mesmo nas melhores equipes, nem sempre isso é possível. Conformar-se irá tornar esse fardo mais leve. Fato é que, uma hora ou outra, teremos que lidar com os conflitos.</p><p>Imagine que no repositório remoto exista um arquivo chamado “teste.txt”. Depois que o repositório remoto foi clonado no computador do João, o Marcos (que havia clonado o mesmo repositório) alterou o arquivo “teste.txt” e submeteu-o ao repositório remoto com o seguinte conteúdo:</p><pre>1. Que legal<br>2.</pre><p>O João, em seu repositório local, também alterou o arquivo “teste.txt”, deixando a mesma linha com o seguinte conteúdo:</p><pre>1. Que coisa<br>2.</pre><p>Quando o João efetuar um <em>git pull</em>, o processo de mesclagem não conseguirá decidir qual dos dois textos é o correto, pois estão na mesma linha. Isso é um conflito entre o código do João e do Marcos!</p><pre>$ git pull<br><em>remote: Counting objects: 3, done.<br>remote: Compressing objects: 100% (2/2), done.<br>remote: Total 3 (delta 1), reused 0 (delta 0)<br>Unpacking objects: 100% (3/3), 277 bytes | 92.00 KiB/s, done.<br>From https://github.com/fulano/meu-repo<br> c25c1aa..1c3b328 master -&gt; origin/master<br>Mesclagem automática de teste.txt<br>CONFLITO (conteúdo): conflito de mesclagem em teste.txt<br>Automatic merge failed; fix conflicts and then commit the result.</em></pre><p>Para não perder nenhuma das duas informações, o Git irá atualizar o arquivo “teste.txt”, adicionando informações sobre os conflitos ocorridos. Após isso, o arquivo ficará como a seguir:</p><pre>&lt;&lt;&lt;&lt;&lt;&lt;&lt; HEAD<br>Que coisa<br>=======<br>Que legal<br>&gt;&gt;&gt;&gt;&gt;&gt;&gt; 1c3b3280714b6866f20f023947ae37f9c174c97b</pre><p>Uma divisória separa o que existe no repositório local do que existe no repositório remoto.</p><p>O bloco HEAD identifica a alteração existente no repositório local do programador local, enquanto o bloco 1c3b3280… corresponde à última alteração feita no repositório remoto, ou seja, o último <em>git commit</em> que alguém efetuou.</p><p>A resolução do conflito consiste em editar adequadamente o arquivo “teste.txt”, removendo o bloco a ser descartado e submetendo o arquivo modificado para o repositório remoto:</p><pre>$ git add teste.txt<br>$ git commit -m “Resolução do conflito”<br>$ git push origin</pre><p>Após isso os repositórios estarão novamente consolidados.</p><h4>6.2. Resolvendo conflitos automaticamente</h4><p>Em casos específicos, após a geração de conflitos, pode-se optar por escolher um lado do conflito e aceitar todas as suas modificações, poupando bastante tempo.</p><blockquote><strong>Mas esteja avisado: </strong>escolher cegamente um dos dois lados poderá causar a perda de dados. Ou seja, use as opções abaixo com consciência!</blockquote><p>Suponha o mesmo caso explicado no item anterior:</p><pre>&lt;&lt;&lt;&lt;&lt;&lt;&lt; HEAD<br>Que coisa<br>=======<br>Que legal<br>&gt;&gt;&gt;&gt;&gt;&gt;&gt; 1c3b3280714b6866f20f023947ae37f9c174c97b</pre><p>Para manter apenas o conteúdo de HEAD e descartar os outros conflitos, usa-se o comando <strong><em>git checkout-index</em></strong>:</p><pre>mv $(git checkout-index --temp --stage=&quot;2&quot; &quot;teste.txt&quot;)</pre><p>O comando acima irá extrair o conteúdo do arquivo “teste.txt” em seu <strong>estado LOCAL</strong> (identificado pela opção <strong><em>stage=“2”</em></strong>) e gerar um arquivo temporário. Em seguida, o comando <strong><em>mv</em></strong> irá mover o arquivo temporário, sobrescrevendo o arquivo “teste.txt” com seu conteúdo. Ou seja, o arquivo “teste.txt” ficará como a seguir:</p><pre>1. Que coisa<br>2.</pre><p>Para manter o conteúdo REMOTO (1c3b3280…), basta passar a opção <strong>stage com o valor 3</strong>:</p><pre>mv $(git checkout-index --temp --stage=&quot;3&quot; &quot;teste.txt&quot;)</pre><p>Ou seja, o arquivo “teste.txt” ficará com o conteúdo do <strong>estado REMOTO</strong>:</p><pre>1. Que legal<br>2.</pre><p>Os estágios possíveis para a opção <strong><em>stage</em></strong> são:</p><ul><li>Código BASE: valor 1;</li><li>Conteúdo LOCAL: valor 2;</li><li>Conteúdo REMOTO: valor 3;</li></ul><h3>Conclusão</h3><p>Embora este artigo tenha explanado as funcionalidades básicas do Git, o leitor já conseguirá começar a trabalhar com código versionado.</p><p>Em um próximo artigo, explicarei como trabalhar de uma forma mais “intermediária”, usando recursos que permitirão um melhor gerenciamento do código fonte, principalmente para trabalho em equipe.</p><p>Espero que o conteúdo tenha sido útil. Até a próxima!</p><h3>Referências para Aprofundamento</h3><p>AQUILES, Alexandre; FERREIRA, Rodrigo. Controlando Versões com Git e GitHub, São Paulo, SP. Casa do Código.</p><p>MORAES, Gleicon. Caixa de Ferramentas DevOps. São Paulo, SP. Casa do Código.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa880674f1dd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/como-usar-o-git-fa880674f1dd">Git Básico</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Extreme Programming]]></title>
            <link>https://medium.com/contexto-delimitado/extreme-programming-fffcd61182b9?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/fffcd61182b9</guid>
            <category><![CDATA[engenharia-de-software]]></category>
            <category><![CDATA[processo-de-software]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[gerenciamento-de-projetos]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Thu, 16 Jul 2020 18:07:06 GMT</pubDate>
            <atom:updated>2021-08-09T12:36:52.286Z</atom:updated>
            <content:encoded><![CDATA[<h4>Métodos Ágeis</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TpRIUZA0f_Hiu8vGQ5XaZw.png" /></figure><p>O artigo anterior desta série abordou sobre o <a href="https://medium.com/contexto-delimitado/o-processo-unificado-d102b1fc9d00">Processo Unificado</a>, que inovou no desenvolvimento do software orientado a objetos. No entanto, embora seu formato fosse estruturado e a introdução da <em>UML</em> tenha sido um grande avanço, muitas dificuldades ainda persistiam na tentativa de obter o controle do projeto. A maior delas era a quantidade de artefatos para controlar o processo que dificultava a adoção por pequenos cases.</p><p>Mas essa época foi um momento fértil na Engenharia de software e rapidamente apareceram várias outras metodologias que alavancaram a produção de software e mudaram a forma de pensar de muitos projetistas.</p><p>Uma delas foi o <em>E</em><strong><em>X</em></strong><em>treme </em><strong><em>P</em></strong><em>rogramming </em>(XP), sobre o qual será abordado agora.</p><h3>Os métodos Ágeis</h3><p>Antes de falar sobre o XP, é importante lembrar da situação em que o desenvolvimento de software se encontrava e como os eventos desta época impactaram no futuro da engenharia.</p><p>Na virada do milênio, começaram a ganhar visibilidade vários processos alternativos, que prometiam uma entrega mais rápida de software e ao mesmo tempo focavam num melhor relacionamento com o cliente.</p><p>Neste cenário de acontecimentos, em “<em>fevereiro de 2001 um grupo de profissionais extraordinários do desenvolvimento de software reuniu-se em um Resort de Ski em Wasatch Range para discutir melhores maneiras de desenvolver software. Esse encontro deu origem ao </em><a href="https://agilemanifesto.org/iso/ptbr/manifesto.html"><em>Manifesto para Desenvolvimento Ágil de Software</em></a><em>, uma declaração com os princípios que regem o desenvolvimento ágil</em>” (GOMES, 2014).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*C1ih6M-Ij2YaDXag4r1VMg.png" /><figcaption>Partindo da esquerda, Stephen Mellor, Ward Cunningham, Dave Thomas, Andrew Hunt, Martin Fowler e James Grenning</figcaption></figure><p>O Manifesto se tornou o embasamento filosófico para os chamados Métodos Ágeis que, segundo SOMMERVILLE (2011), “<em>universalmente, baseiam-se em uma abordagem incremental para a especificação, o desenvolvimento e a entrega do software. Eles são mais adequados ao desenvolvimento de aplicativos nos quais os requisitos de sistema mudam rapidamente durante o processo de desenvolvimento</em>”.</p><p>Esse evento em especial acendeu um estopim que faria uma explosão de inovações surgirem nos anos que se seguiram. Esse manifesto mudou muitas mentes e continua mudando.</p><p>Para conferir o manifesto, acesse <a href="https://agilemanifesto.org/">https://agilemanifesto.org</a>.</p><h3>A programação extrema</h3><p>A partir do manifesto, algumas metodologias inovadoras ganharam visibilidade na comunidade, o XP foi uma delas.</p><p>Segundo PRESSMAN (2006), “<em>apesar do trabalho inicial sobre as ideias e métodos associados ao Extreme Programming (XP) ter ocorrido durante o final da década de 1980, o trabalho pioneiro sobre o assunto, escrito por Kent Beck, foi publicado em 1999</em>”.</p><p>Em sua essência, trata-se de um processo de desenvolvimento que busca assegurar que o cliente receba o máximo de valor de cada dia de trabalho da equipe de desenvolvimento.</p><p>Ele é organizado em torno de conjunto de valores e práticas que atuam de forma harmônica e coesa para assegurar que o cliente sempre receba um alto retorno do investimento em software (TELES, 2004)</p><p>O ciclo de vida do XP é baseado em quatro valores, que o desenvolvedor precisa aplicar o tempo todo:</p><ol><li>Comunicação;</li><li>Simplicidade;</li><li>Feedback;</li><li>Coragem.</li></ol><h4>Comunicação</h4><p>A comunicação deve ser contínua, tanto com o cliente como entre os membros da equipe. O objetivo é criar o melhor relacionamento possível, dando preferência às conversas pessoais em detrimento de outros meios como telefone, email, chats etc.</p><h4>Simplicidade</h4><p>É preciso fomentar a implementação de funcionalidades com base nos problemas de hoje, deixando os problemas do futuro para o futuro. Como os requisitos são mutáveis, deve-se implementar apenas o que é estritamente necessário, de forma simples e com o mínimo de código possível.</p><h4>Feedback</h4><p>Para o XP funcionar, os membros da equipe precisam ser profissionais comunicativos e com facilidade de se relacionar. Assim os feedbacks sobre as estratégias e, principalmente, sobre alterações no código são melhor recebidas e aceitas pelos membros do time.</p><h4>Coragem</h4><p>Errar é natural, e quebrar o código de um sistema acontece cedo ou tarde. Por isso é necessário ter coragem para lidar com isso e confiança nos mecanismos de proteção do XP como, por exemplo, os <em>Testes Automatizados</em>.</p><p>A coragem ajuda, principalmente, quando a possibilidade de simplificar o software é detectada. A <em>Refatoração</em> deve ser feita o quanto antes, mantendo a legibilidade do código (isso será abordado mais adiante neste artigo). Por isso a equipe precisa ser corajosa e acreditar nos valores do XP para que o software evolua com segurança e agilidade.</p><h3>As práticas do XP</h3><p>As atividades são baseadas em quatro atividades básicas:</p><ul><li><strong>Ouvir:</strong> é preciso ouvir (e ouvir bastante) para entender as regras de negócio do sistema. Antes de qualquer coisa é preciso ter domínio sobre o negócio a ser implementado, para que o <em>Design</em> e a codificação ocorram de forma fluida;</li><li><strong>Desenhar:</strong> o bom design é uma excelente ferramenta para o entendimento de sistemas complexos. Por isso, <strong>é preciso manter o design sempre simples, evitando aumentar a complexidade que ocorre pela criação de funcionalidades que não sejam realmente necessárias</strong>. Para isso existe o princípio YAGNI (<em>You aren’t gonna need it/Você não vai precisar disso</em>) que diz para fazer as coisas somente no momento em que realmente for preciso. Antecipar a implementação antes que seja necessário é um desperdício de tempo, porque aumenta a complexidade do design do software e talvez a implementação adicional nunca seja usada de fato;</li><li><strong>Codificar:</strong> o código fonte deve ser coletivo, ou seja, todos os membros podem modificá-lo e devem ter o conhecimento claro sobre ele. <strong>Por isso deve existir um guia para padronização do código</strong> (que pode ser definido pelo próprio time), de forma que todos codifiquem da mesma forma;</li><li><strong>Testar:</strong> os <em>Testes Automatizados</em> devem ser escritos antes do código real ser produzido. Além disso, <strong>os times ágeis devem utilizar a prática da <em>Integração Contínua</em>, para certificar que tudo está realmente funcionando</strong> antes de colocar o novo código em produção.</li></ul><p>Observando essas quatro atividades, o XP apresenta 13 práticas para que o processo aconteça.</p><h3>Prática 1. A presença do Cliente</h3><p>O XP insiste que o cliente deve estar presente no dia a dia do projeto, pois isso contribui para o sucesso. O contrário também é considerado verdade, pois a ausência do cliente é um sério fator de risco.</p><p>A presença do cliente para tirar dúvidas, sempre que for possível, propicia uma série de pequenos ajustes e evita mudanças bruscas ao longo do caminho. Isso poupa um tempo incrível de trabalho.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*0qtHVBQhOhgw4Eu8ZYxi1g.png" /></figure><p>Apesar de existirem vários meios de comunicação, a conversa presencial é a forma mais eficaz, pois proporciona identificar outras informações como os gestos do cliente, expressões faciais, postura, tom de voz, entre outros.</p><p>As <strong>expressões faciais que demonstram falta de entendimento, por exemplo, não são visíveis por telefone ou por chat</strong>, e podem ocasionar interpretações e decisões equivocadas no projeto.</p><h3>Prática 2. O jogo de planejamento</h3><p>O planejamento acontece diversas vezes ao longo do projeto, para que todos tenham a oportunidade de revisar as prioridades, garantindo que a equipe esteja trabalhando no que é mais importante para o cliente.</p><p>Os projetos são divididos em <em>Releases</em> e <em>Interações</em>, de forma que o cliente e a equipe tenham oportunidade de revisar o planejamento.</p><ul><li><strong>Interações:</strong> são períodos de poucas semanas, onde um conjunto de funcionalidades é implementado.</li><li><strong>Releases:</strong> são períodos de alguns meses, onde as entregas geram um valor definido, ou seja, o cliente pode usar o software;</li></ul><h4><strong>As interações</strong></h4><p>Para cada <em>Interação</em>, ocorre uma reunião chamada de <strong><em>Jogo do Planejamento</em></strong>, onde “<em>o cliente escreve histórias de usuário em cartões que representam a necessidade da funcionalidade a ser desenvolvida, e explica para os desenvolvedores tudo o que for preciso para que eles possam implementá-la</em>” (GOMES, 2014).</p><p>Como <em>“parte da equipe de desenvolvimento, o cliente discute cenários com outros membros da equipe. Juntos, eles desenvolvem um ‘Cartão de História’, englobando as necessidades do cliente”</em> (SOMMERVILLE, 2011)</p><p>As funcionalidades são descritas pelo cliente nesses pequenos cartões chamados de “<em>Histórias</em>”, respeitando o espaço de cada cartão para ficar o mais objetivo possível. Isso força o cliente a pensar melhor na funcionalidade. Em seguida, o cliente atribui um valor (de prioridade) para cada cartão.</p><p>“<em>Membros da equipe XP avaliam, então, cada História e lhe atribuem um custo, medido em semanas de desenvolvimento. Se a História precisar de mais do que três semanas de desenvolvimento, pede-se para o cliente dividir a História em Histórias menores e a atribuição de valor e custo ocorre novamente</em>” (PRESSMAN, 2006).</p><p>Nesse processo o cliente fica sabendo dos custos do desenvolvimento e, junto com a equipe, prioriza as funcionalidades que deverão fazer parte de cada <em>Release</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*BHMqij_8eG7rC1nL3KGEyQ.png" /><figcaption>Exemplo de um cartão de História</figcaption></figure><h4><strong>Os releases</strong></h4><p>Com as <em>Histórias</em> definidas, o cliente deve colocá-las nos <em>Releases</em>. Não é necessário que todas as <em>Histórias</em> sejam distribuídas, pois durante as reuniões de <em>Interação</em>, o cliente vai aos poucos aprendendo mais sobre o sistema e, mudando sua visão, identificará melhor suas reais necessidades.</p><p>Segundo SOMMERVILLE (2011), cada <em>Release</em> deve conter “<em>um conjunto mínimo de funcionalidades útil, que fornece o valor do negócio</em>”.</p><p>Os <em>Realeases</em> devem ser ordenados, com tamanhos fixos e pequenos o suficiente para entregas rápidas. “<em>Cada projeto é realizado para atender às necessidades atuais, e nada mais</em>” (SOMMERVILLE, 2011).</p><h4><strong>O trabalho dos programadores</strong></h4><p>Após definidas as <em>Histórias</em> da <em>Interação</em>, os integrantes do time escolhem os cartões que irão implementar naquele dia de trabalho. Isso ocorre todos os dias até a próxima reunião de <em>Interação</em>, onde as mudanças e novas prioridades poderão ser definidas.</p><h4><strong>As mudanças nos requisitos</strong></h4><p>Em cada reunião de <em>Interação</em>, o cliente poderá mudar as <em>Histórias</em> que achar necessário, criando novas, substituindo as existentes ou removendo as desnecessárias. Assim, o XP simplifica as mudanças do projeto, gerando benefícios para o cliente mais rapidamente.</p><p>O cliente pode mudar o projeto quantas vezes quiser, mas só é permitido fazer isso na reunião de <em>Interação</em>. Uma vez definidas as <em>Histórias</em> de uma <em>Interação</em>, o cliente não poderá alterá-las e terá que concordar com o que está sendo implementado até a próxima reunião, onde poderá solicitar uma <em>História</em> que ajuste o que foi feito ou deixar como está.</p><h3>Prática 3. Reunião diária</h3><p>Chamada de “<em>Stand up meeting” (ou “Reunião em Pé</em>”) para denotar uma conversa rápida, esta reunião deve ocorrer todos os dias (preferencialmente de manhã) com todos os integrantes do time e, se possível, com a presença do cliente.</p><p>Cada membro deve comentar o que fez no dia anterior, fazendo com que a equipe fique atualizada sobre o andamento do projeto. Também é propício cada um apresentar os desafios enfrentados e as soluções criadas por eles. Esse feedback ajuda principalmente quando um desafio parecido acontecer novamente, pois todos saberão como resolver ou a quem procurar para um auxílio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*0sNFQaqFePY1GpXxke_lCA.png" /><figcaption>Stand up meeting deve ser uma reunião diária</figcaption></figure><p>Nessa reunião é decidido diariamente quais os cartões de <em>História</em> irão para quais membros do time. <strong>Isso não deverá ser decidido apenas por um único membro, mas por toda a equipe</strong>, pois assim, com uma visão do todo, será possível ter uma decisão mais assertiva sobre as dependências e desafios de cada <em>História</em>.</p><p>É importante que esta reunião seja o mais breve possível, mas é muito importante que todos os membros falem por alguns minutos.</p><h3>Prática 4. Programação em pares</h3><p>No XP, os desenvolvedores nunca trabalham sozinhos, sempre em pares. O “<em>Pair Programming”</em> <em>(ou Programação em pares)</em> deve acontecer em um mesmo computador, onde duas pessoas trabalhem juntas. Uma das pessoas será o <strong><em>Condutor</em>, que assumirá o teclado</strong> e digitará os comandos. A outra pessoa será o <strong><em>Navegador</em>, que acompanhará o trabalho</strong> como estrategista.</p><p>Quando o <em>Condutor</em> estiver cansado, poderá pedir para trocar de posição, tornando-se um <em>Navegador</em>. Esse revesamento é fundamental e deve ser praticado sempre. Não apenas a troca de papel (<em>Condutor/Navegador</em>), mas também a troca de pares, de forma a propiciar um conhecimento abrangente de toda a equipe dentro do projeto.</p><p>Esse processo provoca uma revisão permanente do código, pois enquanto o <em>Condutor</em> está digitando, o <em>Navegador</em> estará o tempo todo observando para evitar que algum erro passe despercebido. Dessa forma, erros que dariam muito trabalho para serem detectados e corrigidos depois, são corrigidos facilmente, detectados pela pessoa que não está com as mãos no teclado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*s_TIwpCX8xN8oW9kRWQHwg.png" /><figcaption>Programação em Pares</figcaption></figure><p>A programação em par produz ideias mais simples e eficazes, pois quando uma pessoa sugere uma solução muito difícil, a outra identifica a complexidade e, na medida que terá dúvidas, poderá sugerir simplificações.<br>O código produzido é quase livre de defeitos, pois por causa do processo contínuo de revisão, pouquíssimos erros permanecem no código.</p><p>Distrações como e-mail, mensagens instantâneas, cansaço ou internet causam uma perda de produtividade que o programador não consegue perceber. Mas com a presença do companheiro, ele terá um compromisso maior, porque seu trabalho envolve mais alguém.</p><h3>Prática 5. Refatoração</h3><p>A <em>Refatoração</em> é o ato de alterar um código sem afetar a funcionalidade que ele executa. É utilizado para tornar o software mais simples de manter, utilizando <em>Testes Automatizados</em> para garantir que as modificações não interrompam seu funcionamento original (TELES, 2004).</p><p>O código-fonte mal formulado despende muito tempo para ser entendido e modificado. Em contrapartida, um código legível é rapidamente corrigido ou alterado. <strong>A <em>Refatoração</em> não deve alterar o comportamento do código, mas apenas torná-lo mais legível</strong>.</p><p>A prática da <em>Refatoração</em> é especialmente útil para código coletivo, onde todos que precisarem analisá-lo possam entendê-lo. Quando não se usa a refatoração, o código vai ficando cada vez mais ilegível na medida que vai crescendo, dificultando para toda a equipe.</p><p><strong>Em XP, um projeto sem <em>Refatoração</em> não tem a menor chance de sobrevivência</strong>. A agilidade de produzir feedback rapidamente para o cliente só é possível com alterações rápidas e constantes no código.</p><p>O XP enfatiza uma continua remodelagem através da <em>Refatoração</em>!</p><blockquote>“<em>Todos os desenvolvedores devem refatorar o código continuamente assim que encontrarem melhorias de código. Isso mantém o código simples e manutenível</em>” (SOMMERVILE, 2011)</blockquote><p>Porém, a <em>Refatoração</em> também tem um preço: é acompanhada pelo risco de código parar de funcionar. Para resolver isso, o XP possui um ferramenta que combate o risco de se quebrar um código que está funcionando, como será abordado na próxima prática do XP.</p><h3>Prática 6. Desenvolvimento Guiado por Testes</h3><p>A ideia principal do “<em>Test-Driven Development</em>” <em>(ou Desenvolvimento Guiado por Testes)</em> é minimizar ao máximo o tempo de depuração em um projeto, através da implementação de <em>Testes Automatizados</em>.</p><blockquote><strong>Atenção: </strong>Quem não está acostumado com o termo, pode confundir “Teste Automatizado” com “Teste Automático”, mas são duas coisas diferentes. Para ser <strong>“automático”</strong>, bastaria uma ferramenta que fizesse uma bagatela de testes partindo de um simples clique num botão. Já para um teste <strong>“automatizado”</strong>, alguém tem que “automatizá-lo”, ou seja, implementar uma rotina que efetue os testes desejados. É este segundo cenário que chamamos de “Testes Automatizados”.</blockquote><p>Os <em>Testes Automatizados</em> avisam se o código continua produzindo as mesmas respostas após ter sido alterado, provendo uma enorme segurança ao processo de <em>Refatoração</em> e injetando coragem no desenvolvedor.</p><p>Como os testes precisam ser implementados pelo desenvolvedor, produzi-los é um investimento que gera retornos no futuro, tais como:</p><ul><li>Por serem implementados, os testes se tornam grandes aliados para o entendimento do design do sistema, servindo de “documentação” para a compreensão do código fonte;</li><li>Sempre que um teste detecta uma falha, a equipe ganha tempo de desenvolvimento, pois tem a oportunidade de corrigir o problema rapidamente;</li><li>Evita longas sessões de depuração que costumam tomar boa parte do tempo dos projetos.</li></ul><blockquote>“Quanto mais tempo se leva para descobrir que você cometeu um erro, mais caro é para corrigi-lo” (BOEHM, 1988)</blockquote><p>O XP trabalha com dois tipos de testes:</p><ol><li><strong>Teste de Unidade:</strong> é realizado sobre cada unidade (classe, método ou função) do sistema com a finalidade de verificar se os resultados gerados estão corretos;</li><li><strong>Teste de Aceitação:</strong> são efetuados sobre cada <em>História</em> do sistema, verificando não apenas uma unidade em particular, mas as interações entre um conjunto de classes ou rotinas que implementam uma funcionalidade.</li></ol><p>Para implementar os testes, a equipe pode fazer uso de <em>frameworks</em> de testes, que já possuem diversas funcionalidades, permitindo asserções para várias situações.</p><p>Uma característica importante do TDD é o conceito de “<em>test-first</em>”, ou seja, “<em>primeiro o teste</em>”. Isso significa que cada nova funcionalidade, após ser devidamente pensada, deve ter seu <em>Teste de Unidade</em> implementado “<em>antes que a funcionalidade em si seja implementada</em>” (SOMMERVILLE, 2011).</p><p>Isso força o desenvolvedor a “<em>pensar antes de fazer</em>”, o que gera código mais simples de entender e livre de remendos, que poderiam ser causados por erros de design.</p><h3>Prática 7. Código Coletivo</h3><p>Um projeto implementado de forma clássica, geralmente é dividido em pedaços, de forma que cada membro da equipe fique responsável por uma ou mais partes. Isso gera nos projetos as chamadas “<em>Ilhas de Expertise</em>” onde uma pessoa sozinha acaba possuindo o domínio sobre uma área do projeto, de forma que somente ela conhece aquela parte do código.</p><p>O XP defende o contrário! <strong>O conhecimento do projeto não deve ser limitado a uma pessoa, mas, pelo contrário, toda a equipe deve ter o conhecimento de tudo</strong> e saber como alterar qualquer parte do projeto.</p><p>O XP incentiva a propriedade coletiva do software, isto é, “<em>os pares de desenvolvedores trabalham em todas as áreas do sistema, de modo que não se desenvolvam ilhas de expertise. Todos os conhecimentos e todos os desenvolvedores assumem responsabilidade por todo o código. Qualquer um pode mudar qualquer coisa</em>”. SOMMERVILLE (2011)</p><p>Dessa maneira, cada parte do software pode ser mantida por diferentes desenvolvedores ao longo de sua vida, forçando que o código esteja sempre sendo revisado e levando a equipe a ser mais ágil no desenvolvimento. <br>Como não existe um único especialista, qualquer pessoa pode mexer no código sem precisar esperar por uma pessoa mais experiente.</p><p>O código coletivo exige coragem por parte dos desenvolvedores, pois diversas vezes ao dia o desenvolvedor terá de mexer em partes do sistema que não foram construídas por ele. <strong>Isso só é possível através de <em>Refatoração</em> e <em>TDD</em></strong>.</p><h3>Prática 8. Padrões de codificação</h3><p>Um dos valores fundamentais do XP é a comunicação, o que inclui o código fonte produzido. A equipe deve se comunicar de forma clara através do código fonte.</p><p><strong>Como são diferentes programadores, existirão diferentes estilos. Essa diferença no código dificulta a compreensão do código por todos da equipe.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/951/1*WeZ0mAc8ChyiO8MwCcSX8A.png" /><figcaption>Trecho de um documento de padronização de estilo de programação</figcaption></figure><p>Por esse motivo, deve-se adotar um mesmo estilo de codificação por todos para que exista a mesma velocidade de compreensão. Isso é alcançado estabelecendo um padrão que seja aceito pela maioria e documentado em algum lugar para ser usado como referência.</p><p>Nos momentos de <em>Programação em Pares</em>, o <em>Navegador</em> pode ajudar o <em>Condutor</em>, lembrando-o sobre o padrão documentado e mantendo assim a qualidade do código.</p><h3>Prática 9. Design simples</h3><p>O XP procura entregar valor para o cliente, determinando que <strong>é preciso sempre assumir o design mais simples possível</strong> e que faça uma funcionalidade passar nos <em>Testes Automatizados</em>.</p><p>Em um projeto de software a mudança é constante, pois requisitos, design, tecnologia e os membros da equipe mudam. O problema não está na mudança em si, mas na incapacidade de lidar com ela.</p><blockquote>“Não é o mais forte que sobrevive, nem o mais inteligente, mas o que melhor se adapta às mudanças.” (Charles Darwin)</blockquote><p>Segundo TELES (2004), para manter um design simples, o XP recomenda os quatro valores mencionados no começo deste artigo:</p><ol><li><strong>Comunicação:</strong> o design simples comunica sua intenção de forma mais eficaz que um design complicado;</li><li><strong>Simplicidade:</strong> o design simples torna o software mais leve e mais fácil de ser alterado a qualquer momento, visto que é mais fácil de ser compreendido. Como explica PRESSMAN (2006), “<em>um projeto XP segue rigorosamente o princípio KIS (Keep it simple/mantenha a simplicidade). Um projeto simples é sempre preferível em relação a uma representação mais complexa</em>”;</li><li><strong>Feedback:</strong> com um design simples, a equipe é capaz de avançar de forma mais ágil e obter feedback do cliente mais rapidamente;</li><li><strong>Coragem:</strong> o design simples é aquele que a equipe trabalha apenas para resolver o problema de hoje. Problemas do futuro, mesmo que já sejam previstos, são deixados para o futuro. É necessário coragem para assumir que a equipe será capaz de resolver o problema no futuro caso ele realmente se manifeste.</li></ol><p>Segundo PRESSMAN (2006), “<em>se um problema de projeto difícil é encontrado […] o XP recomenda a criação imediata de um protótipo operacional daquela parte do projeto. Denominado ‘Solução de Ponta’, este protótipo é implementado e avaliado</em>”.</p><p>Ao longo das reuniões de <em>Integração</em>, o design precisa evoluir, mas deve manter-se simples e claro para que a equipe possa fazer alterações no software a qualquer momento e com facilidade.</p><p>Mais uma vez, <strong>isso só é possível com <em>Refatoração</em> e <em>TDD</em></strong>.</p><h3>Prática 10. Metáfora</h3><p>Muitas vezes, alguém está explicando algo e não há nada que faça o interlocutor compreendê-lo. Depois de algumas tentativas, a pessoa faz uma comparação daquele assunto com algo que o interlocutor conhece bem. Neste momento, em um instante, consegue entender toda a explicação simplesmente porque a outra pessoa utilizou um artifício chamado <em>Metáfora</em>.</p><p>O XP utiliza a <em>Metáfora</em> para comunicar diversos aspectos do projeto e criar uma visão comum. A equipe deve buscar <em>Metáforas</em> que permitam explicar as ideias centrais do projeto de forma simples e objetiva. Isso facilitará a comunicação com o cliente e com os outros envolvidos no projeto.</p><p>Falar da <em>Metáfora</em> é muito fácil, o problema é criá-la :)</p><p>Desenvolver uma <em>Metáfora</em> é um exercício de criatividade e abstração. Para TELES (2004), é necessário olhar para os lados e pensar nas coisas mais absurdas, tentando relacioná-las com o problema a ser resolvido. Normalmente, um simples “insight” pode economizar meses de trabalho.</p><p>A utilização da <em>Metáfora</em> é uma prática que anda de mãos dadas com <em>Ritmo Sustentável</em>, que será abordado a seguir, pois sem um <em>Ritmo Sustentável</em> fica difícil ter criatividade e boas ideias.</p><h3>Prática 11. Ritmo sustentável</h3><p><strong>O XP desaconselha o uso de horas extras</strong>, recomendando <em>Ritmos Sustentáveis</em> de trabalho. Por duas razões:</p><ol><li>Permitir que os desenvolvedores trabalhem apenas oito horas por dia é mais humano e demonstra respeito com a individualidade;</li><li>A integridade de cada membro da equipe aumenta a agilidade do projeto.<br>Programadores exaustos cometem mais erros, assim, a equipe que não trabalha por um tempo excessivo se mantém mais efetiva.</li></ol><p><strong>Os desenvolvedores devem chegar descansados todos os dias.</strong> Pessoas descansadas produzem melhor, têm ideias eficazes, são mais atentas e poupam tempo do desenvolvimento, ou seja, não é vantagem trabalhar mais. Vantagem é trabalhar de forma mais eficaz e inteligente.</p><p>ASTELS (2002) fala da necessidade de equilíbrio entre a carga de trabalho e a de descanso, recomendando que se “<em>trabalhe 100% durante as 40 horas e descanse 100% no resto. Se algum deles não tiver foco feito com 100%, um afetará o outro</em>”.</p><p>O XP compreende a natureza humana do desenvolvimento de software e percebe que trabalhar mais horas significa diminuir o ritmo de produção e atrasar o projeto, por mais estranho que isto possa parecer no início.</p><p>A adoção do <em>Ritmo Sustentável</em> é um desafio a ser vencido! As equipes que conseguem adotar esta prática colhem muitos frutos dela. Seus projetos são mais ágeis, as pessoas convivem de forma mais harmoniosa e não precisam sacrificar a vida pessoal em nome do trabalho.</p><h3>Prática 12. Integração contínua</h3><p>Quando uma nova funcionalidade é implementada ela pode afetar outras que já estavam funcionando. Por isso <strong>é imprescindível uma integração que coloque todas as funcionalidades para operarem juntas e certificar que os novos códigos adicionados não esteja quebrando nada dentro do sistema</strong>.</p><p>Nos processos clássicos, novos módulos são integrados após um determinado ciclo de desenvolvimento. No XP não é assim! Ao invés de esperar muito tempo para integrar as partes do sistema, <strong>a equipe deve integrar com a maior frequência possível, testando o sistema inteiro várias vezes por dia</strong>. Essa prática é chamada de <em>Integração Contínua</em> (JEFFRIES, 2001).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*SLVJp3ZgcAJn8oae75Wg9Q.png" /><figcaption>XP = integração várias vezes por dia</figcaption></figure><p>Uma das dificuldades de se integrar diversas vezes ao dia diz respeito ao tempo necessário para fazer o <em>build</em> de todo o sistema, por isso, esse tempo precisa ser mantido baixo ao longo de todo o projeto.</p><p>As formas de conseguir isso são:</p><ul><li>Fazer com que a interdependência (acoplamento) entre os arquivos seja baixa;</li><li>Para softwares compilados, é preciso que o compilador só processe os arquivos que tiverem sido editados e utilize diretamente o código objeto para os demais. Trabalhar com carregamento dinâmico de bibliotecas quando isso for possível é uma ótima alternativa;</li><li>Para softwares baseados na web, é preciso usar ferramentas para <em>build</em> baseadas em conteinerização (<em>Git HUB actions, Bitbucket Pipelines, TravisCi, CircleCi etc</em>), que instalam o projeto e executam testes sempre que um novo código fonte é adicionado.</li></ul><p>Se o <em>build</em> começar a ficar lento, a equipe precisa tratar logo da questão e descobrir uma forma de mantê-lo rápido. Isso é uma prioridade!</p><p>O uso da <em>Integração Contínua</em> permite que a equipe possa avançar com agilidade ao mesmo tempo que diminui a possibilidade de erros.</p><p>Duas categorias de ferramentas são sumamente necessárias:</p><ol><li><strong>Sistema de controle de versão:</strong> é uma ferramenta essencial no processo de integração, pois possibilita facilidade e rapidez na tarefa de obter o código fonte e armazenar as suas mudanças, detectando conflitos entre as versões e oferecendo maneiras de resolvê-los. A mais popular (pelo menos no momento que este artigo foi escrito) é o GIT;</li><li><strong>Ferramenta de build:</strong> é uma ferramenta capaz de compilar todo o sistema e executar outras atividades que se façam necessárias. A ferramenta deve ser capaz de obter o código fonte do repositório, instalar as dependências do projeto e executar os <em>Testes Automatizados</em>, devolvendo um feedback sobre a situação atual do projeto</li></ol><h3>Prática 13. Releases curtos</h3><p>O XP objetiva gerar um fluxo contínuo de valor para o cliente, de forma que o projeto produza pequenos avanços gradualmente, buscando grandes recompensas o mais rapidamente possível.</p><p>Para isso acontecer, é preciso implementar <em>Releases Curtos</em>.</p><p>O XP sugere que a equipe de desenvolvimento implemente o quanto antes as funcionalidades mais importantes, solicitando ao cliente que selecione primeiro o conjunto de funcionalidades que poderá gerar o valor mais alto. Assim, os primeiros <em>Releases</em> deverão fornecer o máximo de valor, de modo que o cliente consiga obter retorno o mais rápido possível.</p><p>Trabalhando com <em>Releases Curtos</em>, o cliente tem oportunidade de avaliar o projeto com mais frequência, tendo mais chances de reduzir eventuais despesas caso o projeto não esteja atingindo os resultados esperados.</p><p>A abordagem tradicional é mais arriscada que a do XP, pois os usuários não têm a chance de avaliar o software sempre, e o projeto só começa a gerar receita após a conclusão.</p><h3>Conclusão</h3><p>O XP é ideal para equipes que desejam agilidade no seu processo, mas não querem abrir mão da excelência técnica.</p><p>Alguns pontos mais polêmicos como <em>Testes Automatizados</em>, <em>Programação em pares</em>, <em>Código Coletivo</em> e, principalmente, ausência de horas extras acabam causando estranheza para algumas equipes. Não se pode tirar a razão destes, pois se essas práticas forem mal usadas, podem realmente trazer aumento de custo e de prazo nos projetos.</p><p>Por isso é importante entender bem o propósito do XP e sua real essência.</p><p>Disciplina e criatividade são duas qualidades imprescindíveis para quem pretende usar <em>Métodos Ágeis</em> em projetos. Somente a partir de uma visão criativa sobre a metodologia e uma disciplina equilibrada para cumpri-la é que todos poderão ter benefícios reais e palpáveis.</p><h3>Leia todos os artigos desta série:</h3><ul><li><a href="https://medium.com/contexto-delimitado/os-processos-de-software-56a2e70fddfb">Os Processos de Software</a></li><li><a href="https://medium.com/contexto-delimitado/o-modelo-em-cascata-f2418addaf36">O Modelo em Cascata</a></li><li><a href="https://medium.com/contexto-delimitado/o-modelo-incremental-b41fc06cac04">O Modelo Incremental</a></li><li><a href="https://medium.com/contexto-delimitado/o-modelo-em-espiral-de-boehm-ed1d85b7df">O Modelo em Espiral de Boehm</a></li><li><a href="https://medium.com/contexto-delimitado/o-processo-unificado-d102b1fc9d00">O Processo Unificado</a></li><li><a href="https://medium.com/contexto-delimitado/extreme-programming-fffcd61182b9">Extreme Programming</a></li></ul><h3>Referências para Aprofundamento</h3><p>ASTELS, David; MILLER, Granville; NOVAK, Miroslav. <em>Extreme Programming: Guia prático</em>. Rio de Janeiro, RJ, Campus, 2002.</p><p>BOEHM, B.W; Papaccio, P.N. <em>Understanding and Controlling Software Costs</em>. IEEE. 1988.</p><p>GOMES, André Faria. <em>Agile: Desenvolvimento de software com entregas frequentes e foco no valor de negócio</em>. São Paulo, SP, Brasil. Casa do Código, 2014.</p><p>JEFFIES, Ron; ANDERSON, Ann; HENDRICKSON, Chet. <em>Extreme Programming Installed 1a Edição</em>. Addison-Wesley Professional, 2001</p><p>PRESSMAN, Roger S; <em>Engenharia de Software. 6a edição</em>. McGraw-Hill, New York, EUA, 2006.</p><p>SOMMERVILLE, Ian. <em>Engenharia de Software 9a. Edição</em>. São Paulo, SP, Pearson, 2011.</p><p>TELES, V. M. <em>Extreme Programming</em>. São Paulo, SP, Brasil. Novatec, 2004.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fffcd61182b9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/extreme-programming-fffcd61182b9">Extreme Programming</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O Princípio da Inversão de Dependência]]></title>
            <link>https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-invers%C3%A3o-de-depend%C3%AAncia-d52987634fa9?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/d52987634fa9</guid>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <category><![CDATA[design-patterns]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Mon, 17 Feb 2020 22:10:14 GMT</pubDate>
            <atom:updated>2020-08-05T22:31:22.787Z</atom:updated>
            <content:encoded><![CDATA[<h4>Dependency Inversion Principle — DIP</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oGUz9aPzKNuq99aUDyqIvg.png" /></figure><p>Este artifício de arquitetura foi publicado inicialmente no artigo <em>OO Design Quality Metrics </em>(MARTIN 1994) e definido como princípio na revista C++ Report (MARTIN 1996). Basicamente, se os princípios <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f"><strong><em>OCP</em></strong></a> e <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe"><strong><em>LSP</em></strong></a> forem cumpridos corretamente, o <strong><em>DIP</em></strong> também estará sendo cumprido.</p><blockquote><strong>Atenção:</strong> não confunda “Inversão de Dependência” com “Injeção de Dependências”, pois são coisas diferentes!! Enquanto o primeiro é um “Princípio de Arquitetura”, o segundo é um padrão de design (Design Pattern). Neste artigo estamos falando da Inversão, ou seja, do princípio criado por Martin!</blockquote><p>Enquanto <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f"><strong><em>OCP</em></strong></a> indica o objetivo da arquitetura Orientada a Objetos, o <strong><em>DIP</em> </strong>indica o mecanismo principal. <strong>A <em>inversão de dependência</em> é a estratégia de depender de interfaces ou classes abstratas, ao invés de classes concretas</strong>.</p><blockquote>Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender de abstrações;<br>Abstrações não devem depender de detalhes. Detalhes devem depender de abstrações. (MARTIN 1996)</blockquote><p>Para entender as afirmações de Martin, vamos tentar exemplificar uma situação prática. Mas antes, é importante descobrir o que significam alguns termos:</p><ul><li><strong>Módulos de alto nível:</strong> são as rotinas mais fáceis de entender, mais próximas da realidade de qualquer programador. Tendem a exigir menos carga mental para serem usadas;</li><li><strong>Módulos de baixo nível:</strong> são as rotinas mais complexas e difíceis de entender. Geralmente são compostas de implementações de cálculos ou comportamentos específicos.</li><li><strong>Detalhes:</strong> são os artefatos que não deveriam fazem parte da arquitetura de forma acoplada, mas que, no entanto, são necessários para um sistema funcionar. O acesso ao banco de dados, por exemplo, é um detalhe; assim como o gerenciamento de arquivos.</li></ul><p>No diagrama abaixo, pode-se observar uma estrutura altamente acoplada, que segue uma realidade comum em projetos desenvolvidos com paradigma <a href="https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_procedural">procedural</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ctCgGCiNCWDM6DIyejMj3Q.png" /><figcaption>Estrutura de dependências em um paradigma procedural</figcaption></figure><p>O esquema acima mostra uma cascata clássica, oriunda da natureza própria de projetos procedurais (que não são orientados a objetos). Para entender melhor, observe o código PHP abaixo:</p><pre>function gerarNotaFiscal(int $pedidoId)<br>{<br>    $preçoPedido = <strong>calcular</strong>($pedidoId);<br>    // rotina para gerar a nota fiscal<br>}</pre><pre>function <strong>calcular</strong>(int $pedidoId) : float<br>{<br>    $produtos = <strong>obterProdutos</strong>($pedidoId);<br>    // rotina que calcula a soma de todos os produtos<br>    return 678.50;<br>}</pre><pre>function <strong>obterProdutos</strong>(int $pedidoId) : array<br>{<br>    // rotina que busca a lista de produtos<br>    // no banco de dados com base no id do pedido<br>    return [];<br>}</pre><p>No exemplo, as dependências seguem uma sequência, onde o fluxo começa com a função de <strong>alto nível</strong> (<em>gerarNotaFiscal</em>), que depende de uma função de <strong>baixo nível</strong> (<em>calcular</em>) que, por sua vez, depende de um <strong>detalhe</strong> (<em>obterProdutos</em>).</p><p>Uma implementação como essa é, naturalmente, acoplada. Isso é um dos presentes inclusos em linguagens de programação procedural.</p><p>Agora imaginemos um desenvolvedor que trabalhe com um paradigma procedural e esteja aprendendo o paradigma de orientação a objetos. Ao se deparar com a realidade acima, ele facilmente transformaria a implementação, deixando-a como no exemplo abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rZhZE2wkQjvsHJa_cEWRJQ.png" /><figcaption>Estrutura de dependências em um paradigma OO</figcaption></figure><p>Só de olhar esse diagrama, comparando-o com o modelo procedural anterior, percebemos que nada mudou a nível de arquitetura. As funções foram transformadas em métodos dentro de classes e nada mais:</p><pre>class NotaFiscal<br>{<br>    public function gerarNota(int $pedidoId)<br>    {<br>        $calculo = new Calculo;<br>        $preçoPedido = $calculo-&gt;<strong>calcularPreçoPedido</strong>();<br>        // rotina para gerar a nota fiscal<br>    }<br>}</pre><pre>class Calculo<br>{<br>    public function <strong>calcularPreçoPedido</strong>(int $pedidoId) : void<br>    {<br>        $produtos = new Produtos;<br>        $lista = $produtos-&gt;<strong>obterProdutos</strong>($pedidoId);<br>        // rotina que calcula a soma de todos os produtos<br>        return 678.50;<br>    }<br>}</pre><pre>class Produtos<br>{<br>    public function <strong>obterProdutos</strong>(int $pedidoId) : array<br>    {<br>        // rotina que busca a lista de produtos<br>        // no banco de dados com base no id do pedido<br>        return [];<br>    }<br>}</pre><p>As dependências continuam seguindo a mesma sequência, começando com a classe de <strong>alto nível</strong> (<em>NotaFiscal</em>), que depende de uma classe de <strong>baixo nível</strong> (<em>Calculo</em>) que, por sua vez, depende de um <strong>detalhe</strong> (<em>Produtos</em>).</p><p><strong>Qualquer mudança em qualquer uma dessas classes irá quebrar todas as que estiverem ligadas a partir das dependências provenientes do acoplamento.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*34SKoiHycfNcc9rCI7ITLg.png" /><figcaption>Se quebrou, vai ter que consertar! Não importa a dificuldade.</figcaption></figure><h3>Controlando o acoplamento</h3><p>De maneira geral, será impossível criar uma aplicação onde a arquitetura seja totalmente desacoplada e abstrata, pois acoplamentos concretos sempre existirão!</p><p>Segundo ANICHE (1998), o segredo está em saber diferenciar os acoplamentos ruins dos acoplamentos bons, pois assim <em>“modelaremos nossos sistemas fugindo dos ‘acoplamentos perigosos’ ”</em>.</p><blockquote>“Toleramos as dependências concretas porque sabemos e confiamos que elas não mudarão”. (MARTIN 2019)</blockquote><p>Um exemplo de tolerância coerente é quando usamos como base algum framework ou, ainda, quando fazemos uso de funcionalidades contidas na própria linguagem de programação utilizada. Nesses casos, geralmente não será produtivo reinventar a roda a fim de criar abstrações desnecessárias. O consumo das funcionalidades existentes nas classes concretas será o melhor caminho.</p><h3>Controlando as dependências voláteis</h3><p>Quando não conseguimos ter uma noção sobre o futuro de uma classe, podemos considerá-la como uma classe volátil.</p><p>Os elementos voláteis são, geralmente, as rotinas ou algoritmos que estão em processo de desenvolvimento e que, por sua natureza, sofrem mudanças frequentes. É preciso cuidado e parcimônia ao criar dependências com esses tipos de implementações.</p><blockquote>Deve-se “evitar depender de elementos voláteis do nosso sistema.” (MARTIN 2019)</blockquote><p>Na dúvida sobre como tratar a volatilidade das dependências, lembre-se sempre<strong> </strong>que<strong> se <em>“uma classe for depender de outra, ela deve depender sempre de outro módulo mais estável do que ela mesma” </em></strong>(ANICHE 1998).</p><p>Em outras palavras, <em>“se </em><strong><em>A</em></strong><em> depender de </em><strong><em>B</em></strong><em>, a ideia é que </em><strong><em>B</em></strong><em> seja mais estável que </em><strong><em>A</em></strong><em>”</em>. Isso significa que <em>“suas classes devem sempre andar em direção à estabilidade”</em>, ou seja, elas devem depender de módulos mais estáveis do que ela própria (ANICHE 1998).</p><h3>Invertendo as dependências</h3><p>Como dito no início deste artigo, para atingir o objetivo proposto pela arquitetura orientada a objetos, é preciso um mecanismo. Essa é a missão do <em>Princípio da Inversão de Dependência</em>.</p><p>De acordo com BOOCH (1996), <em>“… todas as arquiteturas orientadas a objetos e bem estruturadas … </em><strong><em>possuem camadas claramente definidas</em></strong><em>, onde cada camada fornece algum conjunto coerente de serviços … </em><strong><em>por meio de uma interface bem definida e controlada</em></strong><em>”</em>.</p><p>As <strong>classes não devem ser acopladas a outras classes concretas ou a classes que possam ser instanciadas</strong> (como vimos nos exemplos anteriores). Em vez disso, <em>“classes devem ser acopladas a outras classes base ou abstratas” </em>(SILVA 2013). Se o acoplamento é inevitável, que seja por meio de abstração.</p><blockquote>“Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender de abstrações.” (MARTIN 1996)</blockquote><blockquote>“Os sistemas mais flexíveis são aqueles em que as dependências de código-fonte se referem apenas a abstrações e não a itens concretos.” (MARTIN 2019)</blockquote><p>Para adequar o exemplo anterior ao <em>DIP</em>, vamos <strong>inverter as dependências</strong>. Ao invés de depender de classes concretas vamos fazer as classes dependerem de abstrações:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N-cNf7xTIqh3cpnQthEJnQ.png" /><figcaption>Dependência invertida para uma estrutura mais estável.</figcaption></figure><p>No diagrama acima a direção das cetas indica a dependência das classes. Note que a ceta vermelha está invertida, quebrando a cascata. Agora, todas as classes dependem de abstrações (ICalculoPedidos e IProdutos).</p><pre>class NotaFiscal<br>{<br>    public function gerarNota(<strong>ICalculo</strong> $calculo)<br>    {<br>        $preçoPedido = $calculo-&gt;<strong>total</strong>();<br>        // rotina para gerar a nota fiscal<br>    }<br>}</pre><pre>interface ICalculo<br>{<br>    public function calcularPreçoPedido(IProdutos $produtos) : void;<br>    public function <strong>total</strong>() : float;<br>}</pre><pre>class Calculo implements ICalculo <br>{<br>    private $produtos;<br>    public function calcularPreçoPedido(<strong>IProdutos</strong> $produtos) : void<br>    {<br>        <em>$this</em>-&gt;produtos = $produtos;<br>    }</pre><pre>    public function <strong>total</strong>() : float<br>    {<br>        $lista = <em>$this</em>-&gt;produtos-&gt;<strong>obterProdutos</strong>();<br>        // rotina que soma os preços dos produtos ...<br>        return 678.50;<br>    }<br>}</pre><pre>interface IProdutos<br>{<br>    public function setarPedidoId(int $pedidoId) : void;<br>    public function <strong>obterProdutos</strong>() : array;<br>}</pre><pre>class Produtos implements IProdutos<br>{<br>    private $pedidoId;</pre><pre>    public function setarPedidoId(int $pedidoId) : void<br>    {<br>        <em>$this</em>-&gt;pedidoId = $pedidoId;<br>    }</pre><pre>    public function <strong>obterProdutos</strong>() : array<br>    {<br>        return <em>$this</em>-&gt;consultarNoBanco(<em>$this</em>-&gt;pedidoId);<br>    }</pre><pre>    private function consultarNoBanco(int $pedidoId) : array<br>    {<br>        // implementação qualquer ...<br>        return [];<br>    }<br>}</pre><pre>$produtos = new Produtos;<br>$produtos-&gt;setarPedidoId(55);</pre><pre>$calculo = new Calculo;<br>$calculo-&gt;calcularPreçoPedido($produtos);</pre><pre>$preço = new NotaFiscal;<br>$preço-&gt;gerarNota($calculo);</pre><p><em>“Esse conceito, de acoplamento abstrato, é o meio pelo qual o LSP alcança sua flexibilidade, mecanismo essencial ao DIP, e é o coração do OCP.” </em>Em outras palavras, o DIP é <em>o “resultado estrutural do uso rigoroso do OCP e LSP” </em>(SILVA 2013).</p><p>É claro que <strong>essa ideia não deve ser tratada como uma regra absoluta</strong>. Haverão casos onde será necessário “tolerar” a dependência de uma funcionalidade concreta. <strong>O DIP deve ser seguido sempre que possível e quando seu uso for coerente</strong>.</p><h3>Práticas e cuidados ao programar</h3><p>Martin resume o <em>Princípio da Inversão de Dependência</em>, enumerando algumas práticas de programação bem específicas (MARTIN 2019), a fim de facilitar a identificação das diversas situações o desafio de arquitetar uma aplicação:</p><ul><li><strong>Não se refira a classes concretas voláteis:</strong> deve-se evitar o uso de classes voláteis na especificação de tipos em argumentos ou de retorno em métodos. Nesses casos, é preferível usar uma interface abstrata ao invés de referenciar diretamente a classe volátil. Leia o artigo <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">O Princípio da Substituição de Liskov</a> para mais informações sobre o uso correto de tipos;</li><li><strong>Não derive de classes concretas voláteis:</strong> complementando a regra anterior, Martin explica que a herança deve ser usada com muito cuidado. Classes voláteis, se herdadas, propagarão erros ou alterações para seus dependentes e isso é tudo o que desejamos evitar;</li><li><strong>Não sobrescreva métodos concretos:</strong> podem existir dependências de código-fonte em métodos concretos. Portanto, ao sobrescrever esses métodos (fazer override), essas dependências não serão eliminadas mas continuarão presentes após o override, servindo apenas como lixo.</li></ul><h3>Conclusão</h3><p>O <em>Princípio da Inversão de Dependência</em> é o ponto ápice do SOLID. Após dominar todos os princípios anteriores e colocá-los em prática, o DIP servirá como uma luva na maioria dos casos.</p><p>Implementar um bom software não é uma tarefa fácil, pois exige muito treino e, principalmente, aprendizado com os próprios erros e acertos. Aí se encontra a mágica: não existe mágica!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*DV_iav-eQuVCVO25IghsAg.png" /></figure><p>O que difere os “apertadores de teclas” dos artesãos de código-fonte é justamente a busca pela excelência e conhecimento. Qualquer um pode apertar teclas e colocar caracteres um na frente do outro, mas dar sentido e clareza a essa sequencia de caracteres é como uma sinfonia: exige disciplina, persistência e principalmente paixão.</p><p>É muito mais do que saber essa ou aquela linguagem de programação, é preciso se aprofundar na arte de dar sentido, com a humildade e a consciência de saber que fazemos parte do vasto universo de conhecimento e que, na verdade, o que sabemos ainda não é nada perto do que ainda vamos aprender.</p><p>Espero que esta série tenha sido e continue sendo útil para você. Até a próxima!</p><h4>Leia todos os artigos desta série:</h4><ul><li><a href="https://medium.com/contexto-delimitado/os-princ%C3%ADpios-solid-34b136f507bb">Os Princípios SOLID</a></li><li><a href="https://medium.com/contexto-delimitado/o-dna-s%C3%B3lido-e82cb0956212">O DNA do Software Sólido</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">O Princípio da Responsabilidade Única</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">O Princípio Aberto Fechado</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">O Princípio da Substituição de Liskov</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-segrega%C3%A7%C3%A3o-de-interfaces-2b673374406e">O Princípio da Segregação de Interfaces</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-invers%C3%A3o-de-depend%C3%AAncia-d52987634fa9">O Princípio da Inversão de Dependência</a></li></ul><h3>Referências para Aprofundamento</h3><p>ANICHE, Maurício. <em>Orientação a Objetos e SOLID para ninjas</em>. São Paulo, SP, Brasil. Casa do Código, 1998.</p><p>GAMMA, Erich; HELM, Richard; JONSON, Ralph; VLISSIDES, John. <em>Design Patterns: Elements of Reusable Object-Oriented Software</em>. Addison-Wesley, 1995.</p><p>BOOCH, Grady. Object Solutions, Addison Wesley, 1996;</p><p>MARTIN, Robert C. <em>Design Principles and Design Patterns.</em> Disponível em &lt;<a href="https://fi.ort.edu.uy/innovaportal/file/2032/1/design_principles.pdf">https://fi.ort.edu.uy/innovaportal/file/2032/1/design_principles.pdf</a>&gt;. Acesso em 03/08/2019.</p><p>MARTIN, Robert C. <em>OO Design Quality Metrics</em>. 1994. Disponível em &lt;<a href="https://linux.ime.usp.br/~joaomm/mac499/arquivos/referencias/oodmetrics.pdf">https://linux.ime.usp.br/~joaomm/mac499/arquivos/referencias/oodmetrics.pdf</a>&gt;. Acesso em 01/09/2019</p><p>MARTIN, Robert C. <em>The Dependency Inversion Principle</em>. 1996. Disponível em &lt;<a href="http://www.butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod">http://www.butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod</a>&gt;. Acesso em 01/09/2019</p><p>MARTIN, Robert C. <em>Princípios, Padrões e Práticas Ágeis em C#</em>. Bookman, Porto Alegre, RS, 2011.</p><p>MARTIN, Robert C. <em>Arquitetura Limpa: O guia do artesão para estrutura e design de software</em>. Alta Books Editora, Rio de Janeiro, RJ, 2019.</p><p>SILVA, Álvaro Pereira da. Princípios de design aplicados na melhoria de código-fonte em sistemas orientados a objetos, UFLA, Lavras, MG, 2013.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d52987634fa9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-invers%C3%A3o-de-depend%C3%AAncia-d52987634fa9">O Princípio da Inversão de Dependência</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O Princípio da Segregação de Interfaces]]></title>
            <link>https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-segrega%C3%A7%C3%A3o-de-interfaces-2b673374406e?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b673374406e</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[orientação-a-objeto]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Mon, 02 Dec 2019 17:57:57 GMT</pubDate>
            <atom:updated>2020-08-05T22:31:02.581Z</atom:updated>
            <content:encoded><![CDATA[<h4>Interface Segregation Principle — ISP</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EUEvpaFu16PSES_tgtXUVQ.png" /></figure><p>Este princípio declara que é preciso evitar a implementação de “interfaces ou classes inchadas”, preferindo sempre mantê-las da forma mais coesa e objetiva possível. De acordo com ANICHE (1998), interfaces coesas são aquelas que possuem uma única responsabilidade, ou seja, elas devem cumprir o <em>Princípio da Responsabilidade Única</em>. Se forem coesas, essas interfaces possibilitam um maior reúso, tendem a ser mais estáveis e impedem a ocorrência de “gambiarras”.</p><p>Lembrando que quando usamos os termo “<em>interface”</em>, nos referimos à qualquer estrutura de linguagem capaz de impor obrigações. Ou seja, tanto <strong><em>Interfaces</em></strong><em> </em>como <strong><em>Classes Abstratas</em></strong> são conceitualmente consideradas <em>“interfaces” </em>ou<em> “contratos”</em>, como pode ser conferido no<em> </em><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">artigo anterior</a>.</p><p>Outra terminologia importante presente neste artigo diz respeito a <em>“Clientes e Servidores”.</em> <strong>Num primeiro momento, o leitor poderá confundir esses termos com conceitos de back-end (<em>software rodando no Servidor</em>) e front-end (<em>software rodando no Cliente/Navegador</em>)</strong>. Na engenharia de software, esses termos possuem um significado diferente:</p><ul><li><strong>Servidor:</strong> é uma <em>Classe Servidora</em>, abstrata ou não, que fornece funcionalidade a ser utilizada por uma <em>Classe Cliente</em>;</li><li><strong>Cliente:</strong> é aquela classe que utiliza-se de outras classes para poder funcionar, ou seja, depende de <em>Classes Servidoras</em>.</li></ul><p>Ficando claro sobre os termos acima explicados, podemos continuar.</p><p>Como explica MARTIN (2002), o <em>Princípio da Segregação de Interfaces</em> foi formulado e usado pela primeira vez em uma consultoria realizada para a Xerox, para a melhoria de um sistema para impressoras que executava uma variedade de tarefas. O software para esse sistema tinha um problema grave de design, onde quase todas as tarefas usavam uma única <strong>classe abstrata chamada Worker que continha todos os recursos necessários </strong>para a execução de inúmeras operações. Assim, uma tarefa de grampear teria conhecimento de todos os métodos da impressora, embora não houvesse necessidade deles. Na medida que o software crescia, ficava cada vez mais difícil evoluí-lo, tornando inviável o processo de desenvolvimento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*s81WR53MQLhJ8B6yKFHmWw.png" /><figcaption>Crie a classe Polvo para que ela faça tudo. Mas não me peça para mexer nela!</figcaption></figure><p>Martin solucionou o problema criando uma estrutura parecida com o padrão Template Method (GAMMA et all 1995). O princípio usado (<em>que futuramente se tornou conhecido como Princípio da Segregação de Interfaces</em>), consistiu na criação de uma camada de interface entre a classe Worker e suas classes <em>clientes</em>. Em vez de ter uma grande classe Worker contendo a implementação de todas as operações, foram criadas interfaces específicas para cada tarefa. Isso separou o software em contextos menores, facilitando a manutenção e diminuindo o custo de seu desenvolvimento.</p><h3>O problema das interfaces inchadas</h3><p>Segundo MARTIN (2011), classes inchadas causam acoplamentos bizarros e prejudiciais entre seus <em>clientes</em>. Quando um <em>cliente</em> obriga uma mudança na classe inchada, todos os outros <em>clientes</em> serão afetados. Esse problema pode ser solucionado dividindo a interface da classe inchada em várias interfaces específicas para cada <em>cliente</em>.</p><p>Usando os exemplos dos <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">artigos anteriores</a>, suponhamos que na implementação dos tipos de funcionários (Gerente, Vendedor e Operário) queira-se obrigar a implementação de métodos específicos para cada um deles. Assim sendo:</p><ul><li><em>Gerente</em> deve possuir um método para <strong><em>gerenciarProdutos</em></strong>;</li><li><em>Vendedor </em>para <strong><em>venderProduto</em></strong>;</li><li>Operário para <strong><em>operarEstoque</em></strong>.</li></ul><p>Mantendo a estrutura do <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">cenário anterior</a>, seriam adicionadas novas assinaturas na interface <em>IFuncionário</em> para tornar obrigatória a implementação dos métodos. Observe no diagrama a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*seBtrX4GWv9CLWHKiALLAw.png" /><figcaption>Interface inchada IFuncionário, ferindo o Princípio da Segregação de Interfaces</figcaption></figure><p>Note que agora, as classes <em>Gerente, Vendedor</em> e <em>Operário</em> são obrigadas a implementar os três novos métodos.</p><h4>Problema:</h4><p>Usando como exemplo a classe <em>Vendedor</em>, a regra de negócio a ser implementada não irá utilizar os métodos <strong><em>gerenciarProdutos</em></strong> e <strong><em>operarEstoque</em></strong>, pois não fazem parte da responsabilidade do <em>Vendedor</em>.</p><h4>Solução para este cenário:</h4><p>A alternativa para resolver esse problema é implementar os três métodos (mesmo que não sejam usados) e adicionar uma exceção nos “<em>métodos indesejados</em>”. Observe no exemplo de código escrito em PHP:</p><pre>class <strong>Vendedor</strong> implements <strong>IFuncionário</strong><br>{<br>    public function calcularSalário(): float <br>    {<br>        // implementa a regra de negócio normalmente<br>        // ...<br>    }</pre><pre>    public function <strong>gerenciarProdutos</strong>(): bool <br>    { <br>        <strong>throw new BadMethodCallException(<br>            &#39;Este método não está disponível&#39;);</strong><br>    }</pre><pre>    public function venderProduto(): bool <br>    {<br>        // implementa a regra de negócio normalmente<br>        // ...<br>    }</pre><pre>    public function <strong>operarEstoque</strong>(): bool <br>    {        <br>        <strong>throw new BadMethodCallException(<br>            &#39;Este método não está disponível&#39;);</strong><br>    }</pre><pre>}</pre><p>Na tratativa acima, os métodos indesejados foram inutilizados, impossibilitando que um programador desavisado invoque-os erroneamente. Parece uma <em>“boa solução”</em>, pois ao invocar o método errado, a exceção será disparada e o programa será encerrado, revelando a falha na implementação. No entanto, <strong>isso é uma “gambiarra”!</strong></p><blockquote>“Os clientes não devem ser obrigados a depender de métodos que não utilizam.” (MARTIN 2011)</blockquote><p>Como dito no início deste artigo, o termo “<em>clientes</em>” se refere às classes utilizadoras das interfaces, que se forem inchadas causarão acoplamentos bizarros. <em>“Num dado momento, quando algum cliente necessitar de uma mudança na classe inchada, todos os outros clientes serão afetados”</em> (MARTIN 2011).</p><p>Segundo MARTIN (2019), <em>“é prejudicial depender de módulos que contenham mais elementos do que você precisa”</em>, justamente porque essas implementações incham as classes com implementações desnecessárias e aumentam o acoplamento entre elas, podendo causar <em>“problemas inesperados” </em>(MARTIN 2019).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*0FxOhOfzJ0gnLy-b47A3zg.png" /><figcaption>Questione-se: eu sozinho realmente preciso de tudo isso?</figcaption></figure><h3>Usando o Princípio da Segregação de Interfaces</h3><p>Para entender como funciona o princípio, iremos corrigir o caso anterior, injetando coesão e organização na implementação com base no <em>Princípio da Segregação de Interfaces</em>.</p><blockquote>“Muitas interfaces específicas do cliente são melhores que uma interface de propósito geral” (MARTIN 2000)</blockquote><p>Para MARTIN (2011), os clientes devem depender apenas dos métodos que chamam. Isso pode ser alcançado dividindo-se a interface da classe inchada em várias interfaces específicas do cliente.</p><p>No cenário abordado, será necessário criar mais três interfaces, uma para cada tipo de funcionário, totalizando em quatro interfaces segregadas:</p><ul><li><strong>IFuncionário:</strong> contendo a assinatura para calcularSalário(), comum a todos os funcionários;</li><li><strong>IGerente:</strong> contendo a assinatura do método gerenciarProdutos();</li><li><strong>IVendedor:</strong> contendo a assinatura do método venderProduto();</li><li><strong>IOperário:</strong> contendo a assinatura do método operarEstoque().</li></ul><p>Dessa forma será possível, a cada tipo de funcionário, implementar suas próprias obrigações, sem adaptações ou “gambiarras”, como pode ser observado no diagrama abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gh3_aiccIfsZKfzvi7Tr1g.png" /><figcaption>Implementação coesa, que cumpre o Principio da Segregação de Interfaces</figcaption></figure><p>Para ficar mais claro ainda, observe no exemplo de código escrito em PHP:</p><pre>class <strong>Vendedor</strong> implements <strong>IFuncionário, IVendedor</strong><br>{<br>    public function <strong>calcularSalário</strong>(): float <br>    {<br>        // implementa a regra de negócio normalmente<br>    }</pre><pre>    public function <strong>venderProduto</strong>(): bool <br>    {<br>        // implementa a regra de negócio normalmente<br>    }<br>}</pre><p>Agora, a classe <em>Vendedor</em> será obrigada a implementar apenas os dois métodos pelos quais ela é responsável, ou seja, <strong>calcularSalário e venderProduto</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*PtaZozQw2rRyd7oYPtgq7Q.png" /><figcaption>Se cada classe faz o que é de sua responsabilidade, o código será mais fácil de entender e manter!</figcaption></figure><h3>Conclusão</h3><p>Na prática, a ideia é ter interfaces pequenas e especializadas para cada parte do sistema, dando flexibilidade às implementações e reduzindo o acoplamento.</p><p>Assim como todos os princípios, deve-se tomar cuidado para não exagerar. O espectro de uma classe com centenas de interfaces diferentes, algumas segregadas por <em>cliente</em> e outras segregadas por versão, seria realmente assustador. (MARTIN 2000)</p><h4>Leia também o próximo artigo sobre o assunto:</h4><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-invers%C3%A3o-de-depend%C3%AAncia-d52987634fa9">O Princípio da Inversão de Dependência</a></p><h4>Leia todos os artigos desta série:</h4><ul><li><a href="https://medium.com/contexto-delimitado/os-princ%C3%ADpios-solid-34b136f507bb">Os Princípios SOLID</a></li><li><a href="https://medium.com/contexto-delimitado/o-dna-s%C3%B3lido-e82cb0956212">O DNA do Software Sólido</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">O Princípio da Responsabilidade Única</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">O Princípio Aberto Fechado</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">O Princípio da Substituição de Liskov</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-segrega%C3%A7%C3%A3o-de-interfaces-2b673374406e">O Princípio da Segregação de Interfaces</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-invers%C3%A3o-de-depend%C3%AAncia-d52987634fa9">O Princípio da Inversão de Dependência</a></li></ul><h3>Referências para Aprofundamento</h3><p>ANICHE, Maurício. <em>Orientação a Objetos e SOLID para ninjas</em>. São Paulo, SP, Brasil. Casa do Código, 1998.</p><p>GAMMA, Erich; HELM, Richard; JONSON, Ralph; VLISSIDES, John. <em>Design Patterns: Elements of Reusable Object-Oriented Software</em>. Addison-Wesley, 1995.</p><p>MARTIN, Robert C. <em>Design Principles and Design Patterns.</em> 2000 &lt;<a href="https://fi.ort.edu.uy/innovaportal/file/2032/1/design_principles.pdf">https://fi.ort.edu.uy/innovaportal/file/2032/1/design_principles.pdf</a>&gt;. Acesso em 03/08/2019.</p><p>MARTIN, Robert C. <em>Agile Software Development: Principles, Patterns and Practices 1st edition</em>. Pearson, 2002.</p><p>MARTIN, Robert C. <em>Princípios, Padrões e Práticas Ágeis em C#</em>. Bookman, Porto Alegre, RS, 2011.</p><p>MARTIN, Robert C. <em>Arquitetura Limpa: O guia do artesão para estrutura e design de software</em>. Alta Books Editora, Rio de Janeiro, RJ, 2019.</p><p>RAVEENDRAN, Prasad. C# Corner. 2019 &lt;<a href="https://www.c-sharpcorner.com/article/learn-about-solid-principles/">https://www.c-sharpcorner.com/article/learn-about-solid-principles</a>&gt;. Acesso em 17/11/2019.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b673374406e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-segrega%C3%A7%C3%A3o-de-interfaces-2b673374406e">O Princípio da Segregação de Interfaces</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O Princípio da Substituição de Liskov]]></title>
            <link>https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/df5648906fbe</guid>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[orientação-a-objeto]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Sat, 19 Oct 2019 15:01:01 GMT</pubDate>
            <atom:updated>2020-08-05T22:30:42.666Z</atom:updated>
            <content:encoded><![CDATA[<h4>Liskov Substitution Principle — LSP</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lFs_0EG6AR5waXyR5_Sg1A.png" /></figure><p>Conforme o leitor for avançando nessa sequência de artigos, perceberá que os princípios SOLID se complementam e um princípio acaba ajudando o outro a ser cumprido. No <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">último artigo</a>, <strong>o <em>Princípio da Responsabilidade Única</em> auxiliou o <em>Princípio Aberto Fechado</em></strong>. O mesmo acontece com o <em>Princípio da Substituição de Liskov</em>, como será explicado a seguir.</p><p>Este princípio foi cunhado em 1988 por Barbara Liskov na obra sobre abstração de dados e teoria de tipos (LISKOV 1988). O princípio da substituição foi derivado do conceito de <em>Design by Contracts</em> (DBC), difundido em 1986 por Bertrand Meyer (MEYER 1986).</p><h3>Um pouco sobre Contratos</h3><p>Segundo MEYER (1986), a ideia central do <em>Design by Contracts</em> (Design por Contratos) pode ser entendida como uma <strong>metáfora</strong>, proveniente do mundo dos negócios.</p><h4>Nos negócios</h4><p>No âmbito empresarial, um <em>contrato</em> estabelece as <strong>obrigações mútuas entre um <em>Cliente</em> e um <em>Fornecedor</em></strong>. Neste contrato, são definidas as obrigações e os benefícios de ambas as partes, como no seguinte exemplo:</p><ul><li>É obrigação do <em>Cliente</em> pagar o valor;</li><li>É obrigação do <em>Fornecedor</em> prover o produto ao <em>Cliente</em>;</li><li>É benefício do <em>Cliente</em> obter o produto;</li><li>É benefício do <em>Fornecedor</em> receber o pagamento</li></ul><p>Os envolvidos devem cumprir suas obrigações, através das regras e regulamentações, aplicadas no <em>contrato</em>.</p><h4>Na programação</h4><p>Como já dito, um <em>contrato</em> é uma metáfora e no âmbito do desenvolvimento de software, ele estabelece obrigações mútuas para um <strong><em>Cliente (rotina que utilizará a funcionalidade)</em></strong> e um <strong><em>Fornecedor (classe com funcionalidades)</em></strong>.</p><p>Se uma classe provê funcionalidade (<em>Fornecedor</em>), ela deve definir uma fórmula preestabelecida (<strong><em>obrigação</em></strong>) de como a rotina utilizadora (<em>Cliente</em>) deve obter a funcionalidade.</p><p>Isso evita a utilização da funcionalidade por outros meios que não sejam os estabelecidos no <em>contrato</em>.</p><p>Os “<strong><em>benefícios</em></strong>” também devem ser garantidos pelo <em>contrato</em>, de forma que a rotina solicitante (<em>Cliente</em>) obtenha, de fato, a informação solicitada. Dessa maneira, a programação por <em>contratos</em> estabelece que:</p><ul><li>É obrigação do <em>Cliente</em> implementar o método da maneira estabelecida;</li><li>É obrigação do <em>Fornecedor</em> prover as formas de se implementar;</li><li>É benefício do <em>Fornecedor</em> executar a funcionalidade sem imprevistos;</li><li>É benefício do <em>Cliente</em> obter o resultado desejado</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*7eQyo1OxxKujduzv7h_pwA.png" /></figure><p>Um <em>contrato</em> pode ser implementado utilizando <strong><em>classes abstratas</em></strong> ou <strong><em>interfaces</em></strong><em>,</em> pois ambas proveem a possibilidade de impor obrigações.</p><blockquote><strong>Observação:</strong> a forma de se trabalhar com abstração e imposição de obrigações depende da linguagem de programação utilizada. Linguagens estaticamente tipadas como C#, C++, Java e PHP 7 com type hints dão mais poder para impor obrigações, já em linguagens dinamicamente tipadas essa garantia deve ser feita programaticamente através de asserções dentro do método em questão.</blockquote><p>Observe abaixo o trecho de código escrito em PHP onde a classe <strong><em>Operário</em></strong> é obrigada a implementar o método <strong><em>calcularSalário</em></strong><em>, </em>imposto pela interface<em> </em><strong><em>IFuncionário</em></strong>:</p><pre>interface <strong>IFuncionário</strong> // contrato<br>{<br>    <strong>public function calcularSalário(): float</strong>; // assinatura<br>}</pre><pre>class Operário implements <strong>IFuncionário</strong> // fornecedor da funcionalidade<br>{<br>    <strong>public function calcularSalário(): float</strong> // obrigação<br>    {<br>        //implementação do método<br>    }<br>}</pre><pre>$objeto = new Operário(); // Cliente</pre><p>No exemplo acima, de acordo com o <em>Design by Contracts</em>, a interface <em>IFuncionário</em> é chamada de <strong><em>contrato</em></strong> e o método <em>calcularSalário</em> é chamado de <strong><em>assinatura</em></strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*4Cn2Jcc9WJkAvv45NK-eVQ.png" /></figure><p>Quando a classe <em>Operário</em> for instanciada, se não possuir a implementação correta da <strong>“<em>assinatura</em> <em>calcularSalário”</em></strong>, uma exceção fatal será disparada e o programa será encerrado. Isso porque a classe <em>Operário</em> tem o <strong>“<em>contrato IFuncionário”</em></strong> que estabelece as seguintes “<strong><em>obrigações</em></strong>”:</p><ul><li>o método <em>calcularSalário</em> deve ser implementado;</li><li>seu valor de retorno deve ser um número flutuante;</li><li>sua visibilidade deve ser pública.</li></ul><p>Dessa forma, sempre que um novo tipo de funcionário precisar ser implementado, o contrato <em>IFuncionário</em> irá garantir que a nova classe estará de acordo com as regras estabelecidas.</p><h3>O funcionamento do princípio</h3><p>Uma vez entendido o funcionamento dos <em>contratos</em>, podemos abordar o <em>Princípio da Substituição de Liskov</em>, o qual defende que:</p><blockquote>Classes derivadas devem ser substituíveis por suas classes base.</blockquote><p>Em outras palavras, um objeto que utilize uma classe base deve continuar a funcionar corretamente quando um objeto derivado dessa classe base for passado para ele.</p><p><em>Segundo LISKOV (</em>1988<em>), “o que se deseja aqui é algo como a seguinte propriedade de substituição: se para cada objeto </em><strong><em>O1 do tipo S</em></strong><em> existe um objeto </em><strong><em>O2 do tipo T</em></strong><em>, tal que, para todos os programas </em><strong><em>P</em></strong><em> definidos em termos de </em><strong><em>T</em></strong><em>, o comportamento de </em><strong><em>P</em></strong><em> fica inalterado quando </em><strong><em>O1</em></strong><em> é substituído por </em><strong><em>O2</em></strong><em>, então </em><strong><em>S</em></strong><em> é um subtipo de </em><strong><em>T</em></strong><em>.”</em></p><p>A primeira vista parece complicado, mas basicamente LISKOV (1988) está dizendo que se uma classe <strong>S</strong> herda de uma classe <strong>T</strong>, então a classe <strong>S</strong> deve se comportar igual a classe <strong>T</strong>. Ou seja, a <strong>T é a classe base</strong> e ela deve responder por todas as classes filhas dela, inclusive a <strong>S</strong>.</p><p>Outra especificação do princípio, define que:</p><blockquote>O subtipo deve ser utilizado como seu tipo base sem nenhuma surpresa.</blockquote><p>Surpresas são muito boas em outros contextos, mas na programação especificamente é sinônimo de dor de cabeça.</p><p>Suponha que uma parte do sistema está utilizando uma determinada funcionalidade. Se essa funcionalidade precisar ser trocada por outra (dinâmica ou estaticamente), a outra deverá devolver o mesmo tipo de informação, caso contrário, o sistema quebrará.</p><p>Neste contexto, para garantir que a classe <strong><em>S</em></strong> tenha o mesmo comportamento que a classe base <strong><em>T</em></strong>, é imprescindível a utilização de um <em>contrato</em> (interface ou classe abstrata), contendo as <em>assinaturas</em> (definições de métodos) necessárias para que as classes que a herdarem sejam obrigadas a implementá-las.</p><h4>Cenário das mil maravilhas</h4><p>O cenário demonstrado no <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">artigo anterior</a> é um bom exemplo do <em>Princípio da Substituição de Liskov</em> em ação, por isso podemos utilizar o mesmo estudo de caso:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FMy5mMzdZKGT7ta0NNkLZw.png" /><figcaption>Modelo utilizando três princípios: SRP, OCP, e LSP</figcaption></figure><p>Perceba que as classes <em>Operário</em>, <em>Gerente</em> e <em>Vendedor</em> recebem a <strong><em>“obrigação”</em></strong> de implementar o <strong><em>“contrato IFuncionário”</em></strong> que, por sua vez, possui a <strong><em>“assinatura calcularSalário”</em></strong> exigindo o retorno de um número do tipo <em>float</em>.</p><p>Qualquer classe que herdar <em>IFuncionário</em> deverá implementar o método <em>calcularSalário</em> para cumprir a exigência da assinatura.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*izm7opkQtKMt2Ae1V-BFbQ.png" /><figcaption>Modelo cumprindo o Princípio da Substituição de Liskov usando interface</figcaption></figure><p>Para facilitar o entendimento, observe o código abaixo escrito em PHP, onde o método <em>pagarFuncionário</em> invoca o método <em>calcularSalário</em> e fica esperando um valor do tipo flutuante (float):</p><pre>class Financeiro<br>{<br>    public function pagarFuncionário(IFuncionário $cargo)<br>    {<br>        <strong>$salárioFloat</strong> = $cargo-&gt;calcularSalário();<br>        <br>        // restante da rotina que usa o <br>        // número flutuante para efetuar o pagamento<br>        ...<br>    }<br>}</pre><pre>$funcionário = new Operário();</pre><pre>$transação = new Financeiro();<br>$transação-&gt;pagarFuncionário($funcionário);</pre><p>No cenário acima, qualquer um dos três objetos derivados de <em>IFuncionário</em> (<em>Operário</em>, <em>Gerente</em> ou <em>Vendedor</em>) irão ser compatíveis com a invocação do método <em>pagarFuncionário</em>, pois <em>calcularSalário</em> sempre será obrigado a retornar um número flutuante.</p><p>Da mesma forma, se uma classe qualquer for derivada de <em>Operário, Gerente</em> ou <em>Vendedor</em>, ao fornecê-la para o método <em>pagarFuncionário</em>, <strong>o comportamento deverá ser o mesmo</strong>, ou seja, retornar um número flutuante. Isso é demonstrado no diagrama abaixo, na implementação da classe <em>Ajudante</em>, que estende a classe <em>Operário</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N0XtgcOMmRoMMdnrqT8WQA.png" /><figcaption>Modelo cumprindo o Princípio da Substituição de Liskov usando abstração</figcaption></figure><p>Tudo funcionará bem, pois as implementações estão cumprindo o <em>Princípio da Substituição de Liskov. </em>Note que ao cumprir este princípio, acaba-se cumprindo também o <em>Princípio Aberto Fechado</em>, abordado no <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">artigo anterior</a><em>.</em></p><h4>Cenário da dor de cabeça</h4><p>Vamos mudar um pouco o modelo da implementação para criar um cenário mais permissivo, de forma que o leitor possa entender como o princípio pode ser ferido e ter uma noção das consequências desastrosas dessa falha na implementação.</p><p>Não será preciso mudar muita coisa! Basta remover a exigência do <em>contrato IFuncionário</em>, <strong>ignorando a obrigação</strong> de retornar um número flutuante:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VW6Pix3oWcVnZcryT2Ofaw.png" /><figcaption>Remoção da exigência de retornar um número flutuante na assinatura calcularSalário</figcaption></figure><p>Parece inofensivo… até que num belo dia, um programador desavisado decida implementar o método <em>calcularSalário</em> sem o conhecimento exato do que deve ser retornado.</p><p><strong>Importante lembrar:</strong> na classe <em>Financeiro</em>, <strong>o método <em>pagarFuncionário</em> continua esperando um número flutuante</strong> para prosseguir com o restante da rotina.</p><p>Digamos que um programador deduza, por algum motivo, que na classe <em>Operário</em>, o método <em>calcularSalário</em> deva retornar um valor booleano, ou pior, que deva retornar uma string contendo a frase “<em>O salário do Ricardo deve ser de R$ 16.000</em>”. Neste caso, o programa irá quebrar, pois cálculos matemáticos precisam de números!</p><p>Parece um exemplo simplório, mas se o leitor já tiver experiência com programação, saberá que acontece de tudo neste universo :)</p><p>No caso acima, imagine se fosse um sistema real: os gerentes e os vendedores iriam receber seus salários normalmente. No entanto, <strong>por causa da falha no programa</strong> (que nesse caso só aconteceria no dia do pagamento), <strong>o pagamento de todos os operários seria comprometido</strong>, forçando o pessoal do departamento financeiro a efetuá-lo de forma manual, o que certamente iria gerar bastante transtorno.</p><h3>O LSP e sua relação com testes</h3><p>Olhando para os exemplos propostos, parece simples implementar o princípio, no entanto, conforme um programa começa a crescer, isso não fica tão simples.</p><p>O grande objetivo de um bom design de código é propiciar a refatoração. Sistemas mudam o tempo todo e flexibilidade é a joia mais preciosa que uma equipe de desenvolvedores pode almejar.</p><p>Quando muitas classes herdam de um mesmo contrato, ao precisarmos fazer alguma manutenção que exija uma mudança mais profunda (como a mudança do nome de métodos), teríamos que mudar todas as classes filhas. Isso geralmente causa medo e os programadores preferem deixar do jeito que está.</p><p>Um grande aliado nesse cenário é a implementação de <strong><em>Testes de Unidade</em></strong> e <strong><em>Testes de Integração</em></strong> para as classes baseadas em contratos. Isso garante que suas assinaturas sejam cumpridas e facilita muito na hora de mudar as coisas no sistema. Com <em>Testes de Unidade</em>, qualquer alteração errada será rapidamente apontada e, consequentemente, rapidamente corrigida.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*HGitHyZnXCExExIIzTT4FQ.png" /></figure><p>Segundo MEYER (1994), um design baseado em contratos facilita a implementação destes testes. O leitor que nunca programou <em>Testes de Unidade</em>, ao começar, não conseguirá mais desenvolver sem eles, por causa da grande facilidade de manutenção que agregam ao projeto.</p><p>Enquanto o <strong><em>Teste de Unidade</em></strong> verifica uma classe de forma isolada e certifica que os contratos foram implementados conforme a exigência das assinaturas, o <strong><em>Teste de Integração</em></strong> avalia o funcionamento das classes de forma conjunta e certifica que todas estão operando corretamente entre si.</p><p>Além de tudo, os testes dão mais confiança ao programador, que não terá medo de alterar o código na preocupação de quebrar alguma coisa e demorar para descobrir onde ocorreu.</p><h3>Conclusão</h3><p>O poder obtido pela substituição de subtipos permite que um módulo, ao implementar um tipo base, seja extensível sem necessidade de modificação. Ou seja, a flexibilidade obtida com o <em>Princípio Aberto Fechado</em> só é realmente possível se o <em>Princípio da Substituição de Liskov</em> for aplicado conjuntamente.</p><p>O uso de <em>contratos</em> adiciona grande segurança para o design de um programa, mas deve ser bem compreendido. Os programadores devem aprender a depender implicitamente dos <em>contratos</em> impostos pelo código. Isso irá evitar implementações equivocadas, muito recorrentes em softwares legados.</p><p>Além disso, os <em>contratos</em> darão ao programador valiosas pistas de como se deve implementar e o que pode ser utilizado, bastando olhar para o <em>contrato</em> em questão.</p><p>Por enquanto é isso. Espero que o conteúdo esteja sendo útil. Até a próxima!</p><h4>Leia também o próximo artigo sobre o assunto:</h4><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-segrega%C3%A7%C3%A3o-de-interfaces-2b673374406e">O Princípio da Segregação de Interfaces</a></p><h4>Leia todos os artigos desta série:</h4><ul><li><a href="https://medium.com/contexto-delimitado/os-princ%C3%ADpios-solid-34b136f507bb">Os Princípios SOLID</a></li><li><a href="https://medium.com/contexto-delimitado/o-dna-s%C3%B3lido-e82cb0956212">O DNA do Software Sólido</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">O Princípio da Responsabilidade Única</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">O Princípio Aberto Fechado</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">O Princípio da Substituição de Liskov</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-segrega%C3%A7%C3%A3o-de-interfaces-2b673374406e">O Princípio da Segregação de Interfaces</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-invers%C3%A3o-de-depend%C3%AAncia-d52987634fa9">O Princípio da Inversão de Dependência</a></li></ul><h3>Referências para Aprofundamento</h3><p>LISKOV, Barbara. <em>Data Abstraction and Hierarchy</em>. SIGPLAN Notices, 23, 1988. Disponível em &lt;<a href="https://pdfs.semanticscholar.org/36be/babeb72287ad9490e1ebab84e7225ad6a9e5.pdf">https://pdfs.semanticscholar.org/36be/babeb72287ad9490e1ebab84e7225ad6a9e5.pdf</a>&gt;. Acesso em 05/10/2019.</p><p>LISKOV, Barbara; WING, Jeannette. <em>Family Values: A Behavioral Notion of Subtyping</em>. Laboratory for Computer Science Massachusetts Institute of Technology MIT, Cambridge, MA, 1994. Disponível em &lt;<a href="https://www.cs.cmu.edu/~wing/publications/LiskovWing94.pdf">https://www.cs.cmu.edu/~wing/publications/LiskovWing94.pdf</a>&gt;. Acesso em 03/08/2019.</p><p>MARTIN, Robert C. <em>Design Principles and Design Patterns.</em> Disponível em &lt;<a href="https://fi.ort.edu.uy/innovaportal/file/2032/1/design_principles.pdf">https://fi.ort.edu.uy/innovaportal/file/2032/1/design_principles.pdf</a>&gt;. Acesso em 03/08/2019.</p><p>MARTIN, Robert C. <em>Princípios, Padrões e Práticas Ágeis em C#</em>. Bookman, Porto Alegre, RS, 2011.</p><p>MARTIN, Robert C. <em>Arquitetura Limpa: O guia do artesão para estrutura e design de software</em>. Alta Books Editora, Rio de Janeiro, RJ, 2019.</p><p>Meyer, Bertrand: <em>Design by Contract</em>, Technical Report TR-EI-12/CO, Interactive Software Engineering Inc., 1986</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=df5648906fbe" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">O Princípio da Substituição de Liskov</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O Princípio Aberto Fechado]]></title>
            <link>https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/9341b96f060f</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Mon, 14 Oct 2019 23:15:23 GMT</pubDate>
            <atom:updated>2020-08-05T22:30:22.757Z</atom:updated>
            <content:encoded><![CDATA[<h4>Open Closed Principle — OCP</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H5NsgCLDVAg2cs1Nlu8S-A.png" /></figure><p>Na engenharia de software, este é considerado por muitos como um dos mais importantes princípios. Definido em 1988 por Bertrand Meyer e publicado em 1994 em seu livro “Object Oriented Software Construction”, o <em>Princípio Aberto Fechado</em> é importantíssimo para a construção de softwares que visam a longevidade, ou seja, que objetivem ter longos anos de operação sem necessidade de serem totalmente refeitos.</p><h3>Um paradigma modular</h3><p>No <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">artigo anterior</a> tentei fazer um explicação sobre o que é um módulo, usando uma citação de CONSTANTINE (1974). Para fixar o assunto, é importante entender que um módulo é qualquer conjunto de código, agrupado por um motivo comum. <strong>Não importa se o conjunto de código está dentro do núcleo do software (ao lado de regras de negócio, por exemplo) ou separados na forma de pacotes avulsos</strong>. Os módulos são agrupamentos de código que fazem parte de um contexto próprio.</p><p>Por exemplo, pode-se ter um módulo responsável pelo gerenciamento de Funcionários. Nele, podem existir várias classes, cada uma com sua responsabilidade (falamos disso no <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">artigo anterior</a>):</p><ul><li>classe para exibir dados de funcionários;</li><li>classe para salvar e obter dados no banco;</li><li>classe para gerar relatórios etc.</li></ul><p>O desafio de qualquer projetista de software é produzir módulos, pois eles geram economia e lucratividade para a empresa. Módulos bem feitos podem ser reutilizados e, consequentemente, reduzir o tempo de entrega das novas demandas da empresa.</p><h4>Shotgun Surgery</h4><p>Todos os programadores, em especial os mais veteranos, já se depararam com o estilo de programação chamado <a href="https://en.wikipedia.org/wiki/Shotgun_surgery">Shotgun Surgery, ou Cirurgia de Espingarda</a>, que é exatamente o contrário de uma programação modular sadia.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*DXtiu6wN_SsHpd6VS_YGig.png" /><figcaption>Cirurgia de Espingarda: um módulo tem sua regra de negócio espalhada em diversos outros módulos</figcaption></figure><p>O estilo tem esse nome porque, ao invés de uma funcionalidade estar toda agrupada (em um módulo independente), <strong>a mesma é espalhada em vários lugares do sistema, sem um contexto definido</strong>. Quando é necessário fazer uma correção, por menor que seja, o programador é forçado a ficar “procurando alfinete no palheiro” e seguindo pistas até chegar na fonte do problema. Como acontece em uma cirurgia onde o paciente levou um tiro de espingarda, pois os estilhaços se alojam em várias partes do corpo.</p><h4>Decompondo o design do software em módulos</h4><p>Com a finalidade de evitar a proliferação do efeito <em>Shotgun Surgery</em>, existe o design modular. Segundo MEYER (1994), <em>“uma técnica de decomposição modular satisfatória deve atender a mais um requisito: deve produzir módulos abertos e fechados”. </em>Neste sentido, a base do <em>Princípio Aberto Fechado</em> regulamenta que:</p><blockquote>Um módulo deve estar aberto para extensão mas fechado para modificação.</blockquote><p>Olhando para essa afirmação, parece que estamos diante de um paradoxo. O mesmo acontece quando lemos o nome do princípio: <em>“Aberto Fechado”</em>. Como uma coisa pode ser aberta e fechada ao mesmo tempo? É como dizer que vamos subir para baixo! À primeira vista parece estranho, mas vai fazer todo o sentido no decorrer deste artigo.</p><p>Um módulo, continua MEYER (1994), <em>“</em><strong><em>será considerado aberto</em></strong><em> se estiver disponível para extensão. Por exemplo, deve ser possível adicionar campos às estruturas de dados que ele contém ou novos elementos ao conjunto de funções que ele executa”.</em></p><p>O módulo também “<strong><em>será considerado fechado</em></strong><em>, se estiver disponível para uso por outros módulos… um módulo fechado é aquele que pode ser armazenado em uma biblioteca, para uso de outros … </em><strong><em>publicando sua interface para</em></strong><em> o beneficiar os designers de </em><strong><em>outros módulos</em></strong><em>” </em>(MEYER 1994). Outrossim, o <em>Princípio Aberto Fechado</em> afirma que:</p><blockquote>Você deve poder estender o comportamento de um sistema sem precisar modificá-lo.</blockquote><p>Isso significa que precisamos escrever um módulo, de forma que sua funcionalidade possa ser estendida, sem precisar modificar esse módulo. Em outras palavras, queremos poder <strong>alterar o que os módulos fazem, sem alterar o código-fonte dos módulos</strong>.</p><p>Observe abaixo, o seguinte código de exemplo escrito em PHP:</p><pre>class Financeiro<br>{<br>    public function pagarFuncionário($cargo)<br>    {<br>        $salarios = new Salários();</pre><pre>        if ($cargo == &quot;operário&quot;) {<br>            $valor = $salarios-&gt;calcularSalárioOperário();<br>        }</pre><pre>        if ($cargo == &quot;gerente&quot;) {<br>            $valor = $salarios-&gt;calcularSalárioGerente();<br>        }</pre><pre>        // restante da rotina que usa o <br>        // valor obtido para efetuar o pagamento<br>        ...<br>    }<br>}</pre><pre>class Salários <br>{<br>    public function calcularSalárioOperário(): float<br>    {<br>        // rotina que calcula o salário<br>    }</pre><pre>    public function calcularSalárioGerente(): float<br>    {<br>        // rotina que calcula o salário<br>    }<br>}</pre><pre>$transação = new Financeiro();<br>$transação-&gt;pagarFuncionário(&quot;operário&quot;);</pre><p>A classe <strong><em>Financeiro</em></strong> é responsável pela escolha de qual salário calcular, enquanto a classe <strong><em>Salários</em></strong> é responsável pelo cálculo de cada cargo disponível na empresa, no caso, Operários e Gerentes.</p><h4>Qual é o problema dessa abordagem?</h4><p>Se forem adicionados novos cargos na classe <strong><em>Salário</em></strong>, isso obrigará uma adaptação relacionada na classe <strong><em>Financeiro</em></strong>, adicionando novos “ifs” para suportar os novos cargos.</p><pre>class Financeiro<br>{<br>    public function pagarFuncionário($cargo)<br>    {<br>        ... </pre><pre>        // suporte ao novo cargo<br>        <strong>if ($cargo == &quot;vendedor&quot;) {<br>            $valor = $salarios-&gt;calcularSalárioVendedor();<br>        }<br></strong><br>        // restante da rotina de pagamento<br>        ...<br>    }<br>}</pre><pre>class Salários <br>{<br>    ...        </pre><pre>    // criação do cálculo para o cargo Vendedor<br>    <strong>public function calcularSalárioVendedor(): float<br>    {<br>        </strong>// rotina que calcula o salário<strong><br>    }</strong><br>}</pre><p>Em outras palavras, a classe <strong><em>Financeiro</em></strong> fere o <em>Princípio Aberto Fechado</em> pois:</p><ul><li><strong>Não é “fechada para modificação”</strong> quando para estendê-la é necessário modificar seu conteúdo, adicionando “ifs”;</li><li><strong>Não é “aberta para extensão”</strong>, pois para que ela calcule o salário é passada uma chave simples (‘operário’, ‘gerente’ ou ‘vendedor’) que não agrega nenhuma funcionalidade nova ao Funcionário sem alterar seu conteúdo com “ifs”.</li></ul><p>Outro problema, que pode ser percebido, é que a classe <strong><em>Salários</em></strong> fere o <a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590"><em>Princípio da Responsabilidade Única</em></a>, pois possui três responsabilidades diferentes, enquanto lida com três tipos distintos de cargos.</p><p>Resumindo, esta implementação está altamente acoplada e fere os dois princípios mais básicos.</p><h4>Melhorando o design com SOLID</h4><p>A primeira medida para melhorar essa abordagem é separar as responsabilidades da classe <em>Salários</em> para cumprir o <strong><em>Princípio da Responsabilidade Única</em></strong>. Para isso precisamos desmembrar as rotinas de cálculo de salários em classes específicas, de acordo com cada contexto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ounUy9kefeY20gULvvsLiw.png" /></figure><p>Nesta nova abordagem, cada classe possui sua própria implementação para calcular o salário, cumprindo a exigência da interface <em>IFuncionário</em>. Os objetos <em>Operário, Gerente e Vendedor</em> estarão <strong><em>“disponíveis para uso”</em></strong> no módulo <em>Financeiro</em>, como prega o <em>Princípio Aberto Fechado</em>:</p><blockquote>“<strong><em>será considerado fechado</em></strong><em>, se estiver disponível para uso por outros módulos… </em><strong><em>publicando sua interface para</em></strong><em> o beneficiar … </em><strong><em>outros módulos</em></strong><em>” </em>(MEYER 1994)</blockquote><p>Para identificar qual funcionalidade está “disponível para uso”, basta consultar a interface <em>IFuncionário</em> para descobrir, neste caso, o método <em>calcularSalário</em>.</p><p>A segunda medida é oferecer flexibilidade ao novo design. A classe <em>Financeiro</em> deverá estar <strong><em>“disponível para extensão”</em></strong>, permitindo agregar funcionalidades a ela sem modificá-la. Isso pode ser conseguido usando composição de objetos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xILftx-MmKRPw9AHz514pQ.png" /></figure><p>Nesta abordagem, o objeto <em>Financeiro</em> será capaz de receber qualquer instância do tipo <em>IFuncionário</em> através do método <em>pagarFuncionário()</em>. Para entender melhor, observe o trecho de código PHP a seguir:</p><pre>class Financeiro<br>{<br>    public function pagarFuncionário(IFuncionário $cargo)<br>    {<br>        $salárioFloat = $cargo-&gt;calcularSalário();<br>        <br>        // restante da rotina que usa o <br>        // número flutuante para efetuar o pagamento<br>        ...<br>    }<br>}</pre><pre>$funcionário = new Operário();<br>$transação = new Financeiro();<br>$transação-&gt;pagarFuncionário($funcionário);</pre><p>Note que a partir de agora, não será mais necessário mudar a classe <em>Financeiro</em> para adicionar novos cargos, pois ela pode prever que o método <em>calcularSalário()</em> irá sempre retornar um número flutuante (float) graças à exigência de <em>IFuncionário</em>.</p><p>Dessa maneira o método <em>calcularSalário()</em> <strong><em>“adiciona um novo elemento ao conjunto de funções”</em></strong> que a classe <em>Funcionário</em> executa, como pede o <em>Princípio Aberto Fechado</em>:</p><blockquote><em>“</em><strong><em>será considerado aberto</em></strong><em> se estiver disponível para extensão … deve ser possível adicionar campos … ou novos elementos ao conjunto de funções que ele executa </em>(MEYER 1994)</blockquote><h3>Arquitetura de plugins</h3><p>MARTIN (2014) afirma que “<em>ouviu dizer que o Princípio Aberto Fechado é errado, inviável, impraticável e não é para programadores reais com trabalho real</em>”.</p><p>Para refutar essa opinião, Martin usa como exemplo a utilização de <em>Plug-ins</em>, por vários softwares do mercado. <strong>Os <em>Plug-ins</em> nada mais são que módulos abertos e fechados, que oferecem novas funcionalidades ao software sem modificá-lo</strong>.</p><p><em>“E se o comportamento do seu sistema fosse amplamente controlado pela configuração de seus plugins? Que poder isso lhe daria? Quão fácil seria adicionar novos recursos, novas interfaces de usuário? … Quão fácil seria adicionar ou remover o REST? Quão fácil seria adicionar ou remover Spring, ou Rails, ou Hibernate, ou Oracle…”</em> MARTIN (2014)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5EgJ1nIC4Z9czpGWjH767A.png" /><figcaption>No VSCode, os <strong><em>Plug-ins</em></strong> permitem codificar em qualquer linguagem de programação.</figcaption></figure><h3>Conclusão</h3><p>Um design modular é muito interessante para adicionar flexibilidade a aplicações, ao mesmo tempo que pode facilitar a manutenção concorrente por parte de vários membros de um mesmo time de programadores. Como os contextos são separados, uma alteração no código dificilmente irá afetar outras áreas, como acontece com softwares que não seguem o <em>Princípio Aberto Fechado</em>.</p><p>Por enquanto é isso. Espero que o conteúdo esteja sendo útil. Até a próxima!</p><h4>Leia também o próximo artigo sobre o assunto:</h4><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">O Princípio da Substituição de Liskov</a></p><h4>Leia todos os artigos desta série:</h4><ul><li><a href="https://medium.com/contexto-delimitado/os-princ%C3%ADpios-solid-34b136f507bb">Os Princípios SOLID</a></li><li><a href="https://medium.com/contexto-delimitado/o-dna-s%C3%B3lido-e82cb0956212">O DNA do Software Sólido</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">O Princípio da Responsabilidade Única</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">O Princípio Aberto Fechado</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">O Princípio da Substituição de Liskov</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-segrega%C3%A7%C3%A3o-de-interfaces-2b673374406e">O Princípio da Segregação de Interfaces</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-invers%C3%A3o-de-depend%C3%AAncia-d52987634fa9">O Princípio da Inversão de Dependência</a></li></ul><h3>Referências para Aprofundamento</h3><p>CONSTANTINE, Larry L. <em>Structured design</em>. IBM Systems Journal, VOL13, NO 2, 1974.</p><p>MARTIN, Robert C. <em>The Open Closed Principle</em>. 2014. Disponível em &lt;<a href="https://blog.cleancoder.com/uncle-bob/2014/05/12/TheOpenClosedPrinciple.html">https://blog.cleancoder.com/uncle-bob/2014/05/12/TheOpenClosedPrinciple.html</a>&gt;. Acesso em 14/09/2019</p><p>MEYER, Bertrand. <em>Object-Oriented Software Construction. Prentice-Hall International series in computer science</em>. Prentice Hall, Nova Jersey, US, 1994.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9341b96f060f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">O Princípio Aberto Fechado</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O Princípio da Responsabilidade Única]]></title>
            <link>https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a77dee3b590</guid>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[solid]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Fri, 20 Sep 2019 17:27:32 GMT</pubDate>
            <atom:updated>2020-08-05T22:29:57.928Z</atom:updated>
            <content:encoded><![CDATA[<h4>Single Responsibility Principle — SRP</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ScNOhbaQZXQGLUeFQ3LqjA.png" /></figure><p>Este princípio diz respeito às <strong>necessidades das pessoas</strong> e à <strong>organização do conhecimento</strong>. O primeiro passo para usar esse princípio, é entender o que significa “responsabilidade” no contexto de um software.</p><h3>A Responsabilidade Geral</h3><h4>Um Design que comunica informação</h4><p>Gosto muito da forma como EVANS(2016) sugere o desenvolvimento de um aplicativo de sucesso. Embora tenha publicado seu catálogo de práticas somente em 2016, vários conceitos abordados por ele já eram usados de forma avulsa por projetistas de várias partes do globo. Em seu livro EVANS(2016) afirma que os <em>“modeladores de software eficazes digerem conhecimento e … a medida que o modelo avança, torna-se uma ferramenta para organizar as informações que continuam a fluir pelo design”</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*1AEu16v070Jg4nLr1z6V9Q.png" /><figcaption>O design de um software deve conversar com o programador e exalar conhecimento do negócio</figcaption></figure><p>Os modeladores, ou seja, os projetistas do software têm a tarefa de organizar o software de tal forma que ele se torne o mais auto-explicativo possível. Em outras palavras, o código fonte e a maneira como ele é organizado devem <em>“contar a história do software”</em>, revelando informações que fazem sentido e facilitam seu entendimento. O código fonte deve conversar com o desenvolvedor sobre as regras de negócio implementadas.</p><p><strong>Responsabilidade:</strong> a forma como o software é desenhado é <strong>responsável</strong> por emitir as informações que aumentarão o conhecimento do programador sobre o sistema.</p><h4>Um Design organizado</h4><p>A base para um bom software é a organização, que pode ser feita separando as funcionalidades em grupos distintos aos quais chamamos de módulos.</p><p>CONSTANTINE (1974) explica que a palavra <strong>módulo</strong> é um <em>“termo usado para se referir a um conjunto de uma ou mais instruções de programa contíguas com um nome pelo qual outras partes do sistema podem invocá-lo e, de preferência, com seu próprio conjunto distinto de nomes de variáveis.</em>”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*0A53ud6o7TD1Um_EluvJsA.png" /><figcaption>Módulos como bibliotecas independentes são ótimos exemplos de coesão</figcaption></figure><p>Estando dentro de um sistema (como parte do projeto) ou fora (como uma biblioteca), o módulo deve ser implementado da forma mais independente possível. Deve-se decompor uma gama de funcionalidades, de maneira que sejam agrupadas e nomeadas, separando-as de acordo com seu contexto. Em linguagens orientadas as objetos, usa-se os <strong>namespaces</strong> ou <strong>pacotes</strong> para isso. Parece ser uma tarefa fácil, mas não é.</p><p>Segundo PARNAS (1971), <em>“geralmente é incorreto iniciar a decomposição de um sistema em módulos com base em um fluxograma. Em vez disso … </em><strong><em>comece com uma lista de decisões de design que sejam difíceis ou que provavelmente mudarão</em></strong><em>. Um módulo deve ser projetado para ocultar tal decisão dos outros”</em>. Se o módulo for de uma classe só, isso significa que uma classe deve ocultar suas “decisões” das outras classes, pois cada uma deve ter sua própria responsabilidade.</p><p>Esse conceito se completa com a prática da <em>Separação de Interesses (ou Separation of Concerns - SOC como é conhecida)</em>, que consiste em agrupar os módulos (arquivos e classes) de forma que sejam reconhecidos por suas respectivas obrigações ou estados de mudança. Ou seja, <strong>as partes que mudam pouco devem ser agrupadas em um lugar</strong> (as bibliotecas são exemplos de módulos desse tipo), enquanto aquelas que mudam muito devem ser agrupadas em outro (regras de negócio, por exemplo).</p><p>DIJKSTRA (1974) afirma que <em>“qualquer coleção estranha de fragmentos de conhecimento … não constituem uma restrição científica. Para que a separação seja significativa, temos também um requisito interno e um externo. O requisito interno é de coerência: </em><strong><em>o conhecimento deve apoiar as habilidades e as habilidades devem permitir-nos melhorar o conhecimento</em></strong><em>. O requisito externo: … quanto mais auto-sustentável o sub-universo intelectual, menor será a necessidade de detalhar o conhecimento para seus praticantes … e maior será sua viabilidade”</em>.</p><p>Resumindo, é uma via de mão dupla:</p><ul><li>O conhecimento do programador deve ajudar a construir o software;</li><li>As informações expostas na organização do código fonte do software deve ajudar o programador a obter maior conhecimento.</li></ul><p><strong>Responsabilidade:</strong> a forma como o código fonte é separado e agrupado dentro do projeto é <strong>responsável</strong> por emitir as informações que aumentarão o conhecimento do programador sobre o sistema como um todo.</p><h4>Um Design coeso</h4><p>As décadas de 1970 e 1980 foram um período fértil para os princípios da arquitetura de software. Durante esse período, as noções de <strong>Acoplamento e Coesão</strong> foram introduzidas por vários autores na literatura técnica.</p><p>Um dos pioneiros a falar sobre o assunto foi CONSTANTINE (1974). Segundo ele o <strong>acoplamento</strong> surge da <em>“técnica amplamente usada de aproveitar áreas de dados comuns (ou variáveis ​​globais ou módulos sem seu próprio conjunto distinto de nomes de variáveis) que pode resultar em um número enorme de conexões entre os módulos de um programa. </em><strong><em>A complexidade de um sistema é afetada</em></strong><em> não apenas pelo número de conexões, mas </em><strong><em>pelo grau em que cada conexão acopla (associa) dois módulos</em></strong><em>, tornando-os interdependentes e não independentes”.</em></p><p>A atitude de tentar aproveitar o máximo possível do código em todos os lugares do sistema deve ser feita com cautela e sensatez. <strong>Aproveitamento é importante, mas a coesão e facilidade é muito mais!</strong> É preciso saber quando e como aproveitar código, para não transformar o projeto em um emaranhado infinito de conexões onde mudar uma coisa afeta outras dez.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*lgXVxv3B8ZPsfDu06_PyTA.png" /><figcaption>Um código fonte sem coesão é difícil de manter sem quebrar outras partes do sistema</figcaption></figure><p>Para solucionar esse problema, CONSTANTINE (1974) propõe a <strong>coesão</strong> explicando que <em>“</em><strong><em>minimizar as conexões </em></strong><em>entre os módulos também </em><strong><em>minimiza os caminhos pelos quais alterações e erros podem se propagar</em></strong><em> para outras partes do sistema, eliminando efeitos desastrosos de ‘ondulação’, onde alterações em uma parte causam erros em outra, exigindo alterações adicionais em outros lugares e gerando novos erros”.</em></p><p>Módulos bem projetados são coesos, ou seja, fazem sentido para quem quiser entendê-los. Também são independentes, mesmo estando dentro do núcleo do sistema. Trabalhar de forma modular é a melhor saída para coesão e reaproveitamento de código para outros projetos.</p><p><strong>Responsabilidade:</strong> a forma como cada módulo é construído, separado dos demais, é <strong>responsável</strong> por emitir as informações que aumentarão o conhecimento do programador sobre o macro-contexto de cada módulo específico.</p><h3>A Responsabilidade Única</h3><p>No final dos anos 90, MARTIN (2014) consolidou as noções sobre responsabilidade (abordados até agora) em um princípio específico, que chamou de <strong><em>Single Responsability Principle (SRP)</em></strong> ou <strong><em>Princípio da Responsabilidade Única</em></strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*ctL3z0BvNq1Iq5Z467MsDg.png" /></figure><p>No <em>Princípio de Responsabilidade Única</em> regulamenta-se que:</p><blockquote>Cada módulo de software deve ter um e apenas um motivo para mudar!</blockquote><p>Olhando para a declaração de PARNAS (1971), isso parece alinhar-se perfeitamente. Todavia, surge a pergunta: <strong>o que é um motivo para mudar?</strong></p><h4>O que NÃO é um “motivo para mudar”</h4><p>Em um software real, as mudanças acontecem o tempo todo e isso é bom! Um software flexível e com design bem feito propicia que mudanças aconteçam e sejam fáceis de manter. Neste sentido, o leitor pode pensar em alguns motivos como:</p><ul><li>O cliente pediu para <strong>mudar</strong> uma tela;</li><li>A versão da linguagem atualizou-se, necessitando <strong>mudar</strong> algumas coisas;</li><li>A correção de um BUG obrigou-nos a <strong>mudar</strong> o código.</li></ul><p>A questão é que o “<strong>motivo para mudar</strong>”, ao qual Martin se refere, não diz respeito às evoluções ou correções de bugs que todo software precisa para continuar funcionando. <strong>Se fosse assim, seriam sempre vários motivos para mudar e o princípio seria impossível de cumprir</strong>.</p><h4>O que é um “motivo para mudar”</h4><p>O princípio se refere a uma questão de design, ou seja, de como uma funcionalidade pode ser organizada para que tenha uma única responsabilidade e seja fácil de entender e de manter.</p><p>MARTIN (2014b) explica que <em>“No contexto do Princípio da Responsabilidade Única, a </em><strong><em>‘responsabilidade’ é sinônimo de ‘motivo de mudança’</em></strong><em>. Se você olhar para uma classe e encontrar mais de um motivo para mudá-la, essa classe tem mais de uma responsabilidade”</em>.</p><p>Para facilitar a compreensão, vamos transportar a realidade de uma empresa para dentro do design de um software. Suponha que em uma determinada empresa exista a seguinte estrutura de obrigações:</p><ul><li><strong>Diretoria:</strong> são funcionários responsáveis pelas estratégias da empresa e também pela contratação e demissão de funcionários;</li><li><strong>Depto. Financeiro:</strong> os funcionários deste departamento são responsáveis pelo controle das finanças na empresa;</li><li><strong>Depto. de Operações:</strong> os funcionários deste departamento são responsáveis pela organização operacional, incluindo controle das horas trabalhadas;</li><li><strong>Depto. de TI:</strong> os funcionários desse departamento são responsáveis pela manutenção da tecnologia dentro da empresa, gerindo bancos de dados, computadores, redes etc.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*APoUy_No39ZsnY05rRpWSQ.png" /><figcaption>Estrutura de departamentos em uma empresa fictícia</figcaption></figure><p>Perceba que cada departamento tem uma <strong>responsabilidade única e específica</strong>. Na hora de fazer um sistema computacional, os projetistas desenvolvem uma classe chamada <strong>Funcionário</strong> contendo três métodos:</p><ul><li><strong>calcularPagamento:</strong> faz o o cálculo do salário de um funcionário para o <em>Depto. Financeiro</em> efetuar o pagamento do mês;</li><li><strong>reportarHoras:</strong> devolve um relatório das horas trabalhadas e das horas extras para o <em>Depto. de Operações</em> conferir;</li><li><strong>salvarDados:</strong> salva os dados de pagamento no banco de dados que é gerido pelo <em>Depto. de TI</em>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2jy-z0fNp_9Ez5RnxGUMGA.png" /><figcaption>Funcionalidades <strong>acopladas</strong> na classe Funcionário</figcaption></figure><p>Perceba que a classe <strong>Funcionário</strong> possui três responsabilidades:</p><ul><li><strong>calcularPagamento:</strong> responsabilidade do <em>Depto. Financeiro;</em></li><li><strong>reportarHoras:</strong> responsabilidade do <em>Depto. de Operações</em>;</li><li><strong>salvarDados:</strong> responsabilidade do <em>Depto. de TI</em>;</li></ul><p>A classe <strong>Funcionário</strong> possui responsabilidades demais, o que a torna <strong>altamente acoplada</strong>!</p><p>Imagine que o <em>Depto. Financeiro</em> solicite uma mudança na porcentagem para cálculo de horas extras. A mudança aconteceria na classe <strong>Funcionário</strong>.</p><p>E se o <em>Depto. de TI </em>solicitar uma mudança na forma como os dados são salvos no banco de dados? A mudança aconteceria também na classe <strong>Funcionário</strong>.</p><p>E se o <em>Depto. de Operações</em> pedir para acrescentar no relatório, além do reporte de horas extras, um abono diferente para quem trabalhar no feriado? A mudança aconteceria também na classe <strong>Funcionário</strong>.</p><p>Ou seja, <strong>a classe Funcionário tem três motivos para mudar</strong>, o que, consequentemente, acrescenta três motivos para gerar falhas. Se uma coisa der errado em uma responsabilidade, poderá afetar as outras duas, deixando os três departamentos sem funcionar. Isso é desastroso!</p><p>MARTIN (2014b) sugere uma comparação para exemplificar a gravidade dessa situação: <em>“Imagine que você levou seu carro a um mecânico para consertar uma janela elétrica quebrada. Ele liga para você no dia seguinte dizendo que está tudo consertado. Quando você pega o carro, a janela funciona boa; mas o carro não liga. É improvável que você volte a esse mecânico porque ele é claramente um idiota. É assim que os clientes e gerentes se sentem quando quebramos as coisas de que eles se importam e que não nos pediram para mudar”.</em></p><p>Martin vai além: <em>“É por isso que não colocamos SQL em JSPs. É por isso que não geramos HTML nos módulos que calculam resultados. Esse é o motivo pelo qual as regras de negócios não devem conhecer o esquema do banco de dados. Esta é a razão pela qual separamos as preocupações”</em>.</p><p>Para resolver o problema do <strong>acoplamento</strong>, o <em>Princípio da Responsabilidade Única</em> sugere uma abordagem que propicie a <strong>coesão</strong>:</p><blockquote>Reúna as coisas que mudam pelas mesmas razões. Separe as coisas que mudam por diferentes motivos.</blockquote><p>No mesmo cenário que usamos, vamos desfazer o acoplamento <em>(onde tudo é responsabilidade da classe Funcionário)</em> e produzir classes coesas, contendo cada uma sua própria responsabilidade:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*jNrZZ_FUo0jRu9U5vUPdqQ.png" /><figcaption>Funcionalidades <strong>coesas</strong> usando <strong>S<em>eparação de Interesses</em></strong> (SOC)</figcaption></figure><ul><li><strong>FuncionárioFinanceiro:</strong> esta classe só faz o calculo do pagamento;</li><li><strong>FuncionárioOperações:</strong> esta classe só devolve o relatório;</li><li><strong>FuncionárioTI:</strong> esta classe só salva no banco de dados;</li></ul><p>Agora, se uma mudança precisar acontecer no método <strong>cálcularPagamento</strong>, apenas a classe <strong>FuncionárioFinanceiro</strong> será mudada. O melhor disso é que se uma falha acontecer em <strong>FuncionárioFinanceiro</strong>, o relatório continuará funcionando e o dados continuarão sendo salvos no banco de dados.</p><h3>Conclusão</h3><p>Como dito no início deste artigo, o <em>Princípio da Responsabilidade Única</em> diz respeito às <strong>necessidades das pessoas.</strong> Essas necessidades são as razões para haver mudanças no código fonte de um software.</p><p>Da mesma maneira que você <strong>não pode confundir os papéis das pessoas </strong>envolvidas no negócio (perguntar sobre <em>TI</em> para alguém do <em>Financeiro</em>), também <strong>não pode confundir os papéis das classes</strong> no código fonte (implementando regras de <em>TI</em> na classe que trata finanças).</p><p>Por enquanto é isso. Espero que o conteúdo esteja sendo útil. Até a próxima!</p><h4>Leia também o próximo artigo sobre o assunto:</h4><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">O Princípio Aberto Fechado</a></p><h4>Leia todos os artigos desta série:</h4><ul><li><a href="https://medium.com/contexto-delimitado/os-princ%C3%ADpios-solid-34b136f507bb">Os Princípios SOLID</a></li><li><a href="https://medium.com/contexto-delimitado/o-dna-s%C3%B3lido-e82cb0956212">O DNA do Software Sólido</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">O Princípio da Responsabilidade Única</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">O Princípio Aberto Fechado</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">O Princípio da Substituição de Liskov</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-segrega%C3%A7%C3%A3o-de-interfaces-2b673374406e">O Princípio da Segregação de Interfaces</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-invers%C3%A3o-de-depend%C3%AAncia-d52987634fa9">O Princípio da Inversão de Dependência</a></li></ul><h3>Referências para Aprofundamento</h3><p>CONSTANTINE, Larry L. <em>Structured design</em>. IBM Systems Journal, VOL13, NO 2, 1974.</p><p>DIJKSTRA, Edsger W. <em>On the role of scientific thought.</em> Burroughs Research Fellow, Netherlands, 1974.</p><p>EVANS, Eric. <em>Domain-Driven Design, Atacando a Complexidade no Coração do Software</em>. Edição: 3ª. Alta Books, Rio de Janeiro, 2016</p><p>MARTIN, Robert C. <em>The Single Responsibility Principle</em>. 2014. Disponível em &lt;<a href="https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html">https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html</a>&gt;. Acesso em 01/09/2019</p><p>MARTIN, Robert C. <em>The Single Responsibility Principle</em>. 2014b. Disponível em &lt;<a href="http://www.butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod">http://www.butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod</a>&gt;. Acesso em 01/09/2019</p><p>PARNAS, David L. <em>On the Criteria To Be Used in Decomposing Systems into Modules</em>. Carnegie-Mellon University, 1971</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a77dee3b590" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">O Princípio da Responsabilidade Única</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O DNA do Software Sólido]]></title>
            <link>https://medium.com/contexto-delimitado/o-dna-s%C3%B3lido-e82cb0956212?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/e82cb0956212</guid>
            <category><![CDATA[arquitetura-de-software]]></category>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[solid]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Sat, 31 Aug 2019 22:48:27 GMT</pubDate>
            <atom:updated>2020-08-05T22:28:54.944Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5_yNtZI6fLwZktEvlDsw7g.jpeg" /></figure><p>Sempre que um novo projeto se inicia, o entusiasmo toma conta da equipe envolvida e, na mente das pessoas, só há lugar para pensamentos positivos. A ideia de um novo software causa esperanças boas, com aquele pressentimento de que “dessa vez vamos fazer uma obra fantástica”.</p><p>Segundo BOOCH (2007), no desenvolvimento de software, “<em>o principal desafio do gerenciamento é sempre manter a unidade e a integridade do design</em>”.</p><p>Quando a programação começa, todos entendem o design inicial, todos falam dele nas reuniões, sugerem as melhores formas de aproveitar código e apresentam suas soluções para pequenos problemas. Tudo parece bem, a equipe se esforça para entregar um bom código, com indentação impecável e variáveis bem nomeadas.</p><p>Mas, aos poucos, a alegria começa a dar lugar para a preocupação. O design do software, que antes parecia maravilhoso, começa a ficar desajeitado e confuso. Pequenas alterações dão muito mais trabalho e a execução da aplicação começa a perder performance.</p><p>Esse cenário é mais recorrente do que se imagina!</p><p>No decorrer deste artigo, a palavra <strong><em>Design</em></strong> será usada, de forma que leitor deve entendê-la segundo a <em>Engenharia de Software (ES)</em>. Na <em>ES</em>, <strong>quando falamos sobre o <em>Design do Software</em>, nos referimos a forma como o seu código foi arquitetado/projetado</strong>. Em outras palavras, dizer que “<em>a forma como o código foi organizado é coesa e fácil</em>”, é o mesmo que dizer “<em>o Design é coeso e fácil</em>”.</p><h3>O DNA do software</h3><p>Segundo Robert C. Martin, quando um software começa a se tornar muito difícil de dar manutenção, significa que ele tem problemas no seu <em>Design</em>. Neste sentido, o software em questão pode ser comparado a uma pessoa doente:</p><blockquote>No começo não é tão ruim assim. Uma verruga feia aqui, um hack desajeitado ali, mas o design ainda apresenta alguma beleza. No entanto, com o tempo, à medida que a podridão continua, as feias feridas e as inflamações começam a se acumular até dominarem o design da aplicação. O programa se torna uma massa purulenta de código que os desenvolvedores consideram cada vez mais difícil de dar manutenção. Eventualmente, o esforço necessário para realizar até as mudanças mais simples na aplicação torna-se tão alto que os engenheiros e gerentes de linha de frente clamam por um projeto de reformulação. (MARTIN, 2000)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*dfg1FMNBE6oGQ1Qco01xHg.png" /></figure><h4>O hack desajeitado</h4><p>Dentre as várias metáforas utilizadas por Martin, quero começar pelo “<em>hack desajeitado</em>”. Neste contexto, “um hack” significa <strong>uma coisa que está fora do lugar (ou que nem era para existir), pois foi colocada para alterar algum comportamento de forma que a “programação fosse mais rápida”, mesmo estando errada</strong>.</p><p>Nessa tratativa ingênua, geralmente ocasionada por causa da pressão de uma manutenção urgente, o desenvolvedor decide ignorar o Design do software e usar atalhos para resolver o problema.</p><p>Ao invés de <strong>entender a estrutura e a lógica de funcionamento do código</strong> para discernir <strong>qual seria o melhor lugar para colocar a nova tratativa</strong> de forma que o Design seja preservado, o desenvolvedor insere sua “gambiarra” em qualquer lugar que supostamente “dê certo”. Se funcionar, está resolvido… e a solidez do Design está perdida!</p><p>Quando um outro desenvolvedor precisar dar manutenção no mesmo código, terá dificuldade para entender a lógica, pois <strong>o código da regra de negócio estará desajeitado e espalhado em lugares distintos</strong>. O desenvolvedor será obrigado a usar alguma ferramenta externa de <em>debug</em> para entender a sequência de operações.</p><blockquote>Na maioria das linguagens de programação, quando um código está realmente bem feito, não é necessário usar ferramentas externas para o debug de operações. Fica a dica!</blockquote><h4>O acúmulo de inflamações</h4><p>De forma bem simplória, pode-se dizer que a inflamação é uma resposta do corpo humano para algum <strong>tecido morto</strong> presente no corpo. Suponhamos um órgão transplantado. Ele não pertence ao corpo e, a menos que um medicamento seja administrado, o sistema imunológico tentará expulsá-lo, gerando inflamações, apodrecimento e muito pus. Como exemplificado por Martin, se torna um “<em>massa purulenta</em>”.</p><p>Cada software possui um Design, uma forma de organização que o define e dá sentido (<em>pelo menos no começo é assim…</em>). <strong>Mesmo que essa forma não seja agradável ao desenvolvedor, ela representa o DNA do software</strong>. É responsabilidade dos engenheiros e do desenvolvedor zelar pela consistência deste Design, deixando tudo uniforme.</p><p>Uma situação muito comum acontece quando aquele desenvolvedor, apaixonado por Orientação a Objetos, é escalado para dar manutenção em um software com Design procedural. <strong>No código o que impera são estruturas e processos sequenciais e tudo é organizado assim</strong>. Mas o desenvolvedor não resiste a tentação, e decide “<em>melhorar o paradigma</em>”. Então, para implementar a manutenção, <strong>cria algumas “classezinhas” para conter seu código “Orientado a Objetos”</strong> e coloca elas lá no meio do Design, em algum lugar.</p><p>Lembra do “<em>hack desajeitado</em>”? Pois é, a situação que acebei de descrever é uma “versão profissional” dele. Agora não temos apenas um “<em>hack desajeitado</em>”<strong>, temos um “Design desajeitado” que não faz sentido</strong>, pois Orientação a Objetos é muito mais que criar classes, é saber relacioná-las.</p><p>Quando outro desenvolvedor, acostumado com o Design procedural do software, precisar dar manutenção no mesmo código, ele terá muita carga mental para entendê-lo, pois o <strong>Design estará desajeitado, espalhado em paradigmas distintos, </strong>feio e difícil de entender, uma vez que se tornou uma “massa purulenta”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*gXiiTt8ptKogwPf_fl1C5w.jpeg" /></figure><p>Uma exceção seria, se os envolvidos no projeto se reunissem para elaborar uma estratégia de reformulação gradativa, onde o software, aos poucos fosse sendo migrado para o novo Design. Neste cenário a criação de classes seria plausível, embora igualmente custosa.</p><p>Uma segunda situação semelhante pode acontecer quando um desenvolvedor, acostumado com o programação procedural (mas que ainda não compreende muito bem a Orientação a Objetos) é escalado para dar manutenção em um software baseado em OO. Haverá um risco grande de o desenvolvedor gerar vários “<em>hacks desajeitados</em>”.</p><p>Nestes casos, metodologias como <em>Extreme Programming (XP)</em> são muito interessantes para fomentar a troca de experiências entre os envolvidos no desenvolvimento do software.</p><p>Por via de regra, o objetivo é não mudar o DNA do software e lutar para manter as células vivas e organizadas segundo sua natureza.</p><h3>Diagnosticando um Design doente</h3><p>O primeiro passo em direção a qualquer solução é ter consciência do problema. Um médico só pode receitar o melhor remédio para o paciente se antes ele conseguir fazer um diagnóstico adequado.</p><p>Quando a primeira versão do software é lançada, pouquíssimos problemas acontecem, pois, geralmente, o Design está de acordo com o que foi planejado. Os problemas começam a se alastrar na medida que as manutenções de evolução acontecem.</p><p>Para evitar grandes desastres, existem duas proficiências indispensáveis:</p><ul><li><strong>Saber identificar os problemas</strong> o quanto antes, aplicando em seguida uma medida corretiva para prevenir que o problema se alastre ainda mais;</li><li><strong>Desenvolver o software de forma preventiva</strong>, evitando que os problemas aconteçam ou, se acontecerem, sejam fáceis de corrigir.</li></ul><p>As duas qualidades são igualmente importantes e podem determinar o sucesso ou o fracasso de um software.</p><h3>Identificando os problemas</h3><p>Segundo MARTIN (2000) é possível identificar “<em>quatro sintomas primários que revelam o estado de apodrecimento de nossos projetos</em>”. A seguir, uma breve descrição sobre cada um deles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*JJ1n5HCXQ5-yHAkIx2kiKw.png" /></figure><h4>Rigidez</h4><p>Pode-se detectar que a <strong><em>Rigidez</em></strong> está tomando conta do software quando ele começa a ficar difícil de mudar. Mesmo mudanças simples obrigam uma série de alterações em outros módulos.</p><p>Quando a situação está intolerável, os donos do software começam a perder a confiança na equipe de desenvolvimento e no software, impedindo novas implementações por causa do custo alto para evoluí-lo. Nesse ponto a <em>Rigidez</em> se instala definitivamente.</p><h4>Fragilidade</h4><p>A <strong><em>Fragilidade</em></strong> começa a se instaurar quando a alteração em um módulo quebra a aplicação em várias outras áreas que não têm nada a ver com o que se está implementando.</p><p>A probabilidade de quebra vai aumentando gradativamente, tornando o software impossível de dar manutenção, pois cada correção piora a situação, gerando mais problemas do que solução.</p><h4>Imobilidade</h4><p>A <em>Imobilidade</em> é detectada quando os códigos gerados na implementação do software não podem ser reaproveitados em outros projetos, seja pelo Design pobre ou pela quantidade imensa de dependências associadas.</p><p>Segundo HOFMEISTER (2000), por pressão de tempo de desenvolvimento, os desenvolvedores constroem sistemas pouco modularizados ou com módulos muito acoplados, dificultando a manutenção.</p><p>Isso força a reimplementação da mesma funcionalidade, sempre do zero, para cada novo projeto. Cada reimplementação adquire um novo Design “inovador”, composto de novas dependências, mas continuando a não ser reaproveitável.</p><h4>Viscosidade</h4><p>A <strong><em>Viscosidade </em></strong>se torna alta quando é mais fácil fazer os “hacks desajeitados” do que uma implementação que preserve o Design. O código fica pegajoso e atraindo cada vez mais motivos para ignorar o Design. Em outras palavras, é fácil fazer a coisa errada, mas é difícil fazer a coisa certa.</p><h3>Desenvolvimento preventivo</h3><p>O famoso ditado popular já dizia que “é melhor prevenir do que remediar”. Na vida muitas doenças podem ser prevenidas com uma alimentação saudável e exercícios físicos.</p><p>O mesmo se aplica (mais uma vez) ao desenvolvimento de software. Ou seja, sabendo as melhores práticas, é possível prevenir os problemas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*RilryhZ4qusgkN4Np_boLg.jpeg" /></figure><p>Nos últimos 20 anos trabalhando com software, presenciei o sepultamento de vários projetos, que “faleceram” por causa de seu design arquitetural. Tudo parecia lindo no começo, mas em alguns anos os softwares se tornavam impossíveis de manter.</p><p>Após várias frustrações em empresas e projetos diferentes, encontrei, na literatura, pessoas que vivenciaram situações muito parecidas com as minhas e conseguiram transpor os problemas com soluções brilhantes.</p><p>Entre elas pode-se citar os famosos <em>Design Patterns </em>(ou Padrões de Projeto) e as metodologias como o Domain-Driven Design (DDD) e Test-Driven Development (TDD). A maioria desses conceitos e formas de criar software são baseados em princípios e boas práticas de desenvolvimento que começaram a surgir no começo deste milênio.</p><p>Esses princípios nasceram justamente para prevenir os problemas de design em softwares com mudanças constantes. Dentre os mais famosos, destacam-se os Princípios SOLID.</p><h3>Conclusão</h3><p>Neste artigo, tentei demonstrar alguns problemas recorrentes em softwares nos quais tive contato direto. Usei desta premissa com a finalidade de preparar o leitor para os próximos artigos, onde abordarei sobre os princípios SOLID, usados para a produção de softwares de sucesso no Paradigma de Orientação a Objetos.</p><p>Espero que o conteúdo esteja sendo útil. Até lá!</p><h4>Leia também o próximo artigo sobre o assunto:</h4><p><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">O Princípio da Responsabilidade Única</a></p><h4>Leia todos os artigos desta série:</h4><ul><li><a href="https://medium.com/contexto-delimitado/os-princ%C3%ADpios-solid-34b136f507bb">Os Princípios SOLID</a></li><li><a href="https://medium.com/contexto-delimitado/o-dna-s%C3%B3lido-e82cb0956212">O DNA do Software Sólido</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-responsabilidade-%C3%BAnica-4a77dee3b590">O Princípio da Responsabilidade Única</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-aberto-fechado-9341b96f060f">O Princípio Aberto Fechado</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-substitui%C3%A7%C3%A3o-de-liskov-df5648906fbe">O Princípio da Substituição de Liskov</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-segrega%C3%A7%C3%A3o-de-interfaces-2b673374406e">O Princípio da Segregação de Interfaces</a></li><li><a href="https://medium.com/contexto-delimitado/o-princ%C3%ADpio-da-invers%C3%A3o-de-depend%C3%AAncia-d52987634fa9">O Princípio da Inversão de Dependência</a></li></ul><h3>Referências para Aprofundamento</h3><p>BOOCH, Grady; et all. <em>Object-Oriented Analysis and Design with Applications</em>. 3rd ed. Addison Wesley, 2007.</p><p>HOFMEISTER, Christine; et all. <em>Applied Software Architecture</em>, Addison Wesley, 2000.</p><p>MARTIN, Robert C. <em>Design Principles and Design Patterns</em>. 2000. Disponível em &lt;<a href="https://drive.google.com/file/d/0BwhCYaYDn8EgODUxZTJhOWEtMTZlMi00OWRiLTg0ZmEtZWQ5ODRlY2RmNDlk/view">https://sites.google.com/site/unclebobconsultingllc/home/articles</a>&gt;. Acessado em 31 de Agosto de 2019.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e82cb0956212" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/o-dna-s%C3%B3lido-e82cb0956212">O DNA do Software Sólido</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prototipagem de Software]]></title>
            <link>https://medium.com/contexto-delimitado/prototipagem-de-software-7ac07027e6d8?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ac07027e6d8</guid>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[interfaces]]></category>
            <category><![CDATA[ux-design]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Sun, 25 Aug 2019 22:53:15 GMT</pubDate>
            <atom:updated>2019-08-25T23:30:16.759Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6TCsAneorq7Q_Cv8yPy9hA.png" /></figure><p>É comum, na etapa da <em>Análise de Requisitos</em>, conversar com o cliente e ele dizer que entendeu tudo, afirmando que gostou da proposta do sistema e das suas funcionalidades. Ele concorda até mesmo com a documentação elaborada e autoriza a implementação do software com base nos requisitos.</p><p>Porém, no momento em que o software é concluído e apresentado, ele percebe que pensou bem diferente do que realmente aconteceu. Resultado: cliente frustrado com o software entregue.</p><p>Por mais detalhes que tentemos usar durante alguma explicação, é difícil saber o que a outra pessoa está entendendo e imaginando. O contrário também é válido. Esta é uma situação delicada que exige experiência do analista, mas também existem técnicas para amenizar o impacto e facilitar a comunicação. Uma delas é a <em>Prototipagem</em>, uma estratégia concreta, simples e familiar para apresentar ao usuário antecipadamente as funcionalidades requeridas para o software.</p><h3>A técnica da prototipagem</h3><p>Esta técnica tem como finalidade demonstrar as ideias e as características de funcionamento do sistema por meio de desenhos, sejam eles “rabiscos” no papel ou interfaces bem próximas do real, feitas com ferramentas que permitem esboçar a interface de uma maneira semelhante ao sistema final.</p><p>O uso de protótipos possibilita mostrar a interface, o processo de interação com funcionalidades e botões, de uma maneira fácil de se compreender. Por meio dessa informação concreta o usuário poderá não apenas entender, mas também contribuir com segurança, expressando o que gostou ou não, quais são as funcionalidades fáceis e eficazes de se utilizar etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TO96l1DJl3rFwRduzY0YFw.jpeg" /></figure><p>Segundo PRESSMAN (2002), a <em>Prototipagem</em> é uma estratégia utilizada tanto na área da <em>Engenharia de Software</em> (ES) quanto na <em>Interação Humano-Computador</em> (IHC), porém para cada uma há uma finalidade distinta em sua utilização. Na <em>ES</em>, a preocupação está em como o software será desenvolvido do ponto de vista tecnológico, compreendendo os requisitos do sistema e as funcionalidades necessárias. Já na <em>IHC</em> a preocupação está relacionada com o modelo de interação entre o usuário e o sistema, ou seja, quais tarefas serão realizadas por meio do sistema, como elas serão apresentadas, se as opções existentes estão relacionadas com o mapeamento natural do usuário etc.</p><p>Essa estratégia também é muito utilizada no início do processo de desenvolvimento para conversar com cliente, sendo que há várias formas de utilizá-la, você pode levar um desenho pronto para ser discutido, ou pode, simplesmente, levar papel e lápis e, durante a conversa, esboçar um desenho.</p><h3>Tipos de protótipos</h3><p>São três os tipos de protótipos, onde suas principais diferenças estão no nível de fidelidade em relação ao sistema final:</p><h4><strong>1) Baixa-Fidelidade (wireframes)</strong></h4><p>Esses protótipos não são semelhantes ao sistema final, na maioria das vezes, são feitos com auxílio do papel e lápis para esboçar as características iniciais da interface e o seu funcionamento. São usados também como um auxílio na conversa entre o projetista e os usuários sobre as características desejáveis e as soluções mais adequadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*hZi08cvg6FXUXjyoxPjZXw.jpeg" /><figcaption>Protótipo desenhado à mão no papel</figcaption></figure><p>Por causa do tipo de material utilizado para elaborar esses protótipos, eles são mais baratos, rápidos e fáceis de fazer e, por meio deles, é possível coletar muitas informações a respeito dos requisitos da interface.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/1*5aWTfIC3Pget5iA1DoR52A.png" /><figcaption>Protótipo feito com Pencil Project</figcaption></figure><p>Para quem não quer usar o papel mas precisa desenhar protótipos de <em>Baixa-Fidelidade</em> rapidamente, pode usar as seguintes ferramentas:</p><ul><li><a href="https://pencil.evolus.vn/">Pencil Project</a>;</li><li><a href="https://balsamiq.com/wireframes/">Balsamiq</a>;</li><li><a href="https://www.omnigroup.com/omnigraffle/">OmniGraffle</a></li></ul><h4><strong>2) Média-Fidelidade (mockups)</strong></h4><p>Esses protótipos são mais próximos do sistema final, se comparado com os de <em>Baixa-Fidelidade</em>. Geralmente, são feitos utilizando ferramentas computacionais, embora não precisem ser as mesmas ferramentas que serão utilizadas para desenvolver o sistema final. Permitem simular o comportamento de interação da interface e não requerem um mesmo conhecimento técnico necessário para implementar a interface final.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*g1JVPIONmdk0UCb-kU8Rag.gif" /><figcaption>por Ramil Derogongun — <a href="https://dribbble.com/shots/1464790--AEP-Delete-Action">https://dribbble.com/shots/1464790--AEP-Delete-Action</a></figcaption></figure><p>Há algumas ferramentas que podem ser utilizadas para desenvolver protótipos nesse nível de fidelidade, algumas delas são:</p><ul><li><a href="https://www.sketch.com/">Sketch</a>;</li><li><a href="https://www.invisionapp.com/">InVision</a>;</li><li><a href="https://www.adobe.com/br/products/xd.html">Adobe XD</a>;</li><li><a href="https://www.axure.com/">Axure RP</a>;</li><li><a href="https://www.justinmind.com/">JustinMind</a>;</li><li><a href="https://www.uxpin.com/">UXPin</a>;</li><li><a href="https://www.framer.com/">Framer</a>;</li><li><a href="https://origami.design/">Origami</a>;</li><li>entre outras.</li></ul><h4><strong>3) Alta-Fidelidade</strong></h4><p>Esse tipo de protótipo oferece uma interface semelhante à final, pois são utilizadas as mesmas matérias (software e hardware) que serão utilizadas no sistema. Os protótipos são desenvolvidos diretamente em linguagem de programação, permitindo apresentar alguns recursos da interface com interação. Na prototipagem de <em>Alta-Fidelidade</em> já existe a implementação de algumas partes do sistema.</p><p>Esse protótipo oferece alto grau de interatividade e de realismo, pois é possível ver e interagir com uma interface próxima à final. No entanto, há um custo maior no seu desenvolvimento e já é necessário um conhecimento técnico semelhante àquele para desenvolver o produto final.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KO23sj8Ol9e7qAQIan095Q.png" /><figcaption>Tema HTML interativo totalmente funcional (<a href="https://themeforest.net/item/webarch-responsive-admin-dashboard-template/6157416">Theme Forest</a>), pode ser usado para facilitar o protótipo de Alta-Fidelidade</figcaption></figure><p>Para softwares baseados na web, existem algumas ferramentas que poderão ajudar a fazer uma interface interativa:</p><ul><li><a href="https://bootstrapstudio.io/">Bootstrap Studio</a>;</li><li><a href="https://pingendo.com/">Pingendo</a>;</li><li><a href="https://www.bootply.com/">BootPly</a>;</li></ul><h3>A vantagem do p<em>rotótipo de papel na conversa com o cliente</em></h3><p>A seguir será detalhado o processo de prototipagem de <em>Baixa-Fidelidade</em> em papel, pois embora pareça simples, ela é um método bastante eficaz para dar clareza na conversa entre o projetista e o cliente.</p><p>Não é fácil para um usuário comum entender o raciocínio de um programador ou projetista. É justamente neste caso que o desenho (protótipo) passa a ser uma ponte entre eles, criando uma linguagem que os dois possam entender e evitando a necessidade de tentar imaginar o que a outra pessoa está pensando.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*TtucFDVGlMRcbMza-9puVg.jpeg" /></figure><p>É interessante o uso do papel porque ele é uma ferramenta que todos dominam. Além de oferecer flexibilidade e agilidade, podendo-se manipular, rabiscar e modificar de forma bem simples, ainda inclui o cliente no processo dando-lhe mais satisfação em participar da conversa, uma vez que ele conhece bem o lápis e papel.</p><p>Quando o protótipo é feito com uma ferramenta computacional, mesmo que seja “mais bonito”, cria-se uma barreira entre o cliente e o projetista, pois a computação é algo mais distante dos usuários comuns e eles não têm tanto controle.</p><p>Mas, caso se escolha usar o computador para a reunião com o cliente, é <strong>importante que o resultado seja simples para não gerar uma “falsa expectativa”</strong>. Na maioria das vezes, ao usar protótipos de Média ou Alta-Fidelidade, mesmo explicando-lhe que é apenas um protótipo, o cliente insiste em acreditar que o trabalho já está avançado e que aquilo que ele está vendo (interface, navegação entre telas etc.) já é o sistema pronto. <strong>Isso pode gerar desconforto, pois o cliente achará que a entrega será mais fácil e rápida</strong> e, consequentemente, imaginará que o custo será menor.</p><p>Com o protótipo em papel, o cliente consegue perceber de uma maneira fácil que tudo é apenas uma ideia e que está sendo feito um esboço para entender melhor o que ele pensa, permitindo que fique à vontade para expressar-se, dizer suas opiniões, ou seja, rabiscar, também, o papel.</p><h3>O protótipo de papel</h3><p>O conceito de prototipagem tornou-se comum na década de 1990, quando começou a ser utilizado por algumas empresas como a IBM e a Microsoft como uma parte do processo de desenvolvimento de produtos (SNYDER, 2003). No entanto, somente em 2002 houve o crescimento do uso da prototipagem, tanto nas empresas grandes, quanto nas pequenas.</p><p>Se considerarmos o <em>UCD</em>, um bom momento para a prototipagem é na etapa do <em>Desenho</em>, pois você já conhece quem são os usuários e quais as possíveis funcionalidades. Como já possui algumas informações relevantes, é possível mapear os eventos da vida real para o mundo virtual, esboçando os primeiros desenhos. Porém, nada impede que, logo na primeira conversa, alguém pegue um papel para desenhar o que as pessoas estão discutindo.</p><p>SNYDER (2003) aponta alguns passos que podem ser utilizados para criar, apresentar e testar um protótipo:</p><ol><li>Definir os <em>stakeholders</em> (pessoas envolvidas no negócio da empresa) para elaborar as interfaces;</li><li>Escolher algumas das tarefas que o usuário realizará com apoio do sistema a ser projetado;</li><li>Realizar o esboço da interface, que poderá conter menus, páginas, caixas de diálogo, mensagens e outras características para permitir ao usuário desempenhar as funções na tarefa;</li><li>Realizar testes de usabilidade com o protótipo;</li><li>Definir uma pessoa para representar os <em>stakeholders</em>;</li><li>Pedir para essa pessoa realizar uma determinada tarefa, utilizando o protótipo em papel. Algo semelhante ao natural, pressionar o papel para simular um clique no botão, preencher em um retângulo o nome para simular um cadastro etc;</li><li>Um ou dois dos membros da equipe têm de desempenhar as funcionalidades do computador, ou seja, se uma pessoa clica em um botão e a próxima tela está em um próximo papel, então o membro deve trocar as folhas para o usuário ter acesso à outra interface do sistema, como se estivesse navegando;</li><li>Um membro (experiente em usabilidade) deve conduzir o teste enquanto os outros observam se há alguma dificuldade e como o usuário interage com o protótipo. Após a realização desse teste é possível identificar em quais interfaces o usuário teve dificuldade, em quais momentos ele não soube como prosseguir etc.</li></ol><p>Algumas empresas com prestígio no desenvolvimento de aplicativos web estão investindo em protótipos de papel para explicar a todos as funcionalidades de seus sistemas. Um exemplo de sucesso foi realizado pela empresa Google na explicação do <strong>Google Docs</strong>. Por meio de um protótipo em papel, os funcionários da empresa conseguiram explicar, de uma maneira divertida e didática, o funcionamento da ferramenta para todos os usuários da web.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FeRqUE6IHTEA%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DeRqUE6IHTEA&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FeRqUE6IHTEA%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ab0f76cacf1204c553d5365aa6d7aee4/href">https://medium.com/media/ab0f76cacf1204c553d5365aa6d7aee4/href</a></iframe><p>Por enquanto é só! Espero que o conteúdo esteja sendo útil. Um grande abraço e até a próxima!</p><h4>Leia todos os artigos desta série:</h4><ul><li><a href="https://medium.com/codigo-facil/interface-humano-computador-5bd0ee9d7d2e">Interface Humano-Computador</a></li><li><a href="https://medium.com/codigo-facil/a-hist%C3%B3ria-da-interface-4b698537ba15">A História da Interface</a></li><li><a href="https://medium.com/codigo-facil/usabilidade-e-qualidade-565795aeb1ce">Usabilidade e Qualidade</a></li><li><a href="https://medium.com/codigo-facil/o-design-centrado-no-usu%C3%A1rio-9053dbff54f8">Design Centrado no Usuário</a></li><li><a href="https://medium.com/codigo-facil/prototipagem-de-software-7ac07027e6d8">Prototipagem de Software</a></li></ul><h3>Referências para aprofundamento:</h3><p>PRESSMAN, R. S. Engenharia de Software. USA: McGraw-Hill, ed. 2002.</p><p>SNYDER, C. Paper Prototyping: The Fast and Easy Way to Design and Refine User Interfaces. San Francisco: Morgan Kaufmann, 2003.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ac07027e6d8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/prototipagem-de-software-7ac07027e6d8">Prototipagem de Software</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</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 Centrado no Usuário]]></title>
            <link>https://medium.com/contexto-delimitado/o-design-centrado-no-usu%C3%A1rio-9053dbff54f8?source=rss-9d370e09a683------2</link>
            <guid isPermaLink="false">https://medium.com/p/9053dbff54f8</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[interfaces]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Ricardo Dias]]></dc:creator>
            <pubDate>Sun, 25 Aug 2019 22:51:23 GMT</pubDate>
            <atom:updated>2019-08-25T23:26:31.432Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*60EAWTffoMD1b83n4rdzMg.png" /></figure><p>Nos últimos anos, a concorrência na indústria de sistemas computacionais causou um aumento na preocupação em desenvolver software de qualidade. O foco nas características, habilidades e dificuldades dos usuários se tornou um fator determinante para o cliente na hora da aquisição de um software.</p><p>No entanto, identificar todas essas características humanas não é uma tarefa fácil, pois é preciso pensar e ficar bastante atento a elas desde o início do desenvolvimento.</p><h3>Os Processos de Software</h3><p>Na <strong><em>Engenharia de Software (ES)</em></strong>, o uso de processos é uma tarefa muito comum, pois adicionam controle ao desenvolvimento, ajudando a fazer estimativas e pontos de decisão importantes para qualquer projeto, mas principalmente para os de médio e grande porte.</p><p>Existem diversos <strong><em>modelos de processo de software</em></strong>, onde cada um trata os desafios de desenvolvimento e relacionamento com o cliente de formas distintas, porém, visando os mesmos objetivos:</p><ul><li>Fazer software de qualidade;</li><li>Concluir em tempo viável;</li><li>Obter lucro.</li></ul><p>Para saber mais sobre como funcionam esses processos, sugiro que leia uma série de artigos que fiz sobre esse assunto:</p><p><a href="https://medium.com/codigo-facil/os-processos-de-software-56a2e70fddfb">Os Processos de Software</a></p><p>Embora esses modelos, geralmente, se preocupem mais com as funcionalidades do que com o usuário e não estejam diretamente relacionados à <strong><em>Interface Humano-Computador (IHC)</em></strong>, seu estudo é muito importante. Saber como o processo de desenvolvimento funciona auxilia na descoberta de como aplicar a <em>IHC</em> em cada uma das etapas.</p><p>A disciplina defende que não se deve começar a pensar em <em>IHC</em> no meio ou no final do desenvolvimento do sistema, mas sim em cada interação do processo.</p><p>Na maioria dos modelos de desenvolvimento, pouco se fala sobre a maneira de se conversar com o cliente, ou quais passos devem ser dados para facilitar a comunicação, com o objetivo de obter informações sobre os usuários e suas necessidades. Isso acontece porque a <em>Engenharia de Software</em>, onde se originaram esses modelos, foca no software e não as pessoas que irão utilizá-lo. A ênfase está nos requisitos do sistema e não nas características dos usuários.</p><p>A <em>IHC</em> tem como principal característica preocupar-se com os usuários, observando suas características físicas e cognitivas para utilizá-las na criação do sistema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*d2BhBkf6Ror-B9XeRR6wdA.jpeg" /></figure><p>A principal meta de uma empresa moderna de desenvolvimento de software é produzir “cases” competitivos no mercado. Isso é feito estabelecendo uma união entre as duas áreas (<em>ES</em> e <em>IHC</em>), a fim de construir um sistema computacional com qualidade.</p><p>Muitas dúvidas estão relacionadas à ordem de aplicação de um modelo da <em>ES</em> e das técnicas de <em>IHC</em>. Qual deverá ser aplicado primeiro? Devemos nos preocupar primeiro com o sistema ou com o usuário? A resposta é que devemos aplicar os dois ao mesmo tempo, o modelo e as técnicas. As duas áreas devem ser contempladas em todo o desenvolvimento, pois assim, será possível testar o software de acordo com <em>ES</em> e <em>IHC </em>conjuntamente.</p><h3>Design Centrado no Usuário</h3><p>A principal característica da área de <em>Design Centrado no Usuário (User Centered Design ou UCD) </em>é colocar as necessidades do usuário como um todo no centro das decisões. Não importa se são necessidades de requisitos ou necessidades cognitivas, é preciso pensar no usuário final em todo o processo de desenvolvimento. Por isso vários modelos de desenvolvimento incluem a participação do usuário em todo o processo.</p><p>É importante não confundir a “<em>participação do usuário</em>” com “<em>obrigação de saber todos os problemas e soluções</em>”. Segundo NIELSEN (2019), “<strong><em>os usuários não são projetistas, e projetistas não são usuários</em></strong><em>”</em>.</p><p>Outro fator importante a se considerar são as situações onde o usuário está envolvido com suas atividades há muito tempo. Por possuir uma prática imensa, realiza as tarefas de maneira “automática”, sem a necessidade de pensar muito. Estes usuários costumam não levar muito em consideração todas as atividades que realizam, e na hora de passar as informações, acabam usando frases muito genéricas como <em>“gostaria de automatizar o controle de estoque”</em> ou <em>“estou com um problema no controle”</em>. Informações genéricas são importantes mas tem pouco significado. É preciso entender mais profundamente a regra do negócio, ou seja:</p><ul><li>Como é feito o controle de estoque?</li><li>Quais são as atividades mais importantes?</li><li>Quais são as atividades menos importantes?</li><li>Quais são as dificuldades?</li><li>Qual processo é mais simples?</li><li>Qual processo é mais complexo?</li></ul><h4>O que você quer?</h4><p>Outro erro é perguntar diretamente aos usuários “<em>o que eles querem</em>”, pois embora eles saibam que a tecnologia pode ajudar a amenizar ou resolver seus problemas, eles não são projetistas.</p><p>Duas frases se encaixam perfeitamente nessa realidade. A primeira é de Henry Ford, o homem que revolucionou a fabricação de automóveis:</p><blockquote>“S<em>e eu perguntasse aos consumidores o que queriam, eles teriam dito: um cavalo mais rápido!</em>”</blockquote><p>A segunda frase relevante é de Steve Jobs:</p><blockquote>“<em>As pessoas não sabem o que elas querem até que você mostre para elas.</em>”</blockquote><p>Evitar a pergunta “o que você quer” é importante, porque <strong>os usuários não conhecem a tecnologia e todo o seu potencial</strong>. Esse papel pertence aos projetistas de software, que tem o conhecimento necessário da tecnologia. Todavia, para descobrir a melhor maneira de usar a tecnologia, é preciso entender o usuário, suas necessidades e problemas.</p><p>O<em> UCD</em> se preocupa em promover a colaboração entre o projetista e o usuário (que pode ser o próprio cliente ou um funcionário que usará o sistema). Tanto o projetista como o usuário possuem conhecimentos que devem ser compartilhados. Claro que no seu devido contexto, pois o projetista não precisa explicar ao cliente sobre linguagem de programação.</p><p>A comunicação com o usuário tem a finalidade de ser uma ferramenta de extração de conhecimento, para que seja possível entender como ele executa suas atividades. As informações sobre como o fluxo de trabalho acontece na empresa do cliente é muito importante para planejar o sistema, mesmo que várias dessas informações nunca se tornem funcionalidades. Entender a regra de negócio é primordial!</p><p>Segundo WILLIAMS (2009), o <em>UCD</em> abrange várias áreas, dentre elas:</p><ul><li><strong><em>IHC:</em></strong><em> </em>com sua preocupação em entender as características físicas e psicocognitivas dos usuários, os fatores humanos etc;</li><li><strong><em>Engenharia de Usabilidade:</em></strong> que se preocupa em entender os objetivos dos usuários, desenvolver interfaces para eles etc.</li></ul><p>Assim como nos <a href="https://medium.com/codigo-facil/os-processos-de-software-56a2e70fddfb"><em>Modelos de Processos de Software</em></a>, o <em>UCD</em> também possui algumas etapas para auxiliar o projetista nesse contato com o usuário, permitindo um melhor entrosamento, compreensão e colaboração.</p><h3>1. Pesquisa de Design</h3><p>Esta primeira etapa é subdividida em alguns passos:</p><h4><strong>a) Planejamento</strong></h4><p>Neste passo é onde identifica-se o objetivo, as restrições e as suposições do projeto. Essas informações são obtidas com os usuários, por isso há necessidade de se definir quem são os <em>stakeholders</em>, ou seja, as pessoas envolvidas nas regras o negócio que se deseja entender.</p><p>Os <em>stakeholders</em> não são apenas os usuários finais dos sistemas (empregados), mas também os donos da empresa ou outras pessoas que estejam ligadas com o problema a ser resolvido, mesmo que nunca precisem usar diretamente o sistema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*snZ-TyUx-2O9LnO0DR2SDA.jpeg" /></figure><p>Definir os <em>stakeholders</em> é muito importante para conduzir o projeto até o final pois, conhecendo as pessoas envolvidas, será possível conversar e mostrar resultados de acordo com a característica e necessidade de cada um. Enquanto uma pessoa do departamento de <em>Marketing</em> está preocupada em apresentar e vender o produto, uma pessoa do departamento <em>Financeiro</em> está preocupada em contabilizar tudo o que está acontecendo, sendo assim, a conversa e a forma de exibir os resultados para cada uma será completamente diferente.</p><h4><strong>b) Condução</strong></h4><p>Este passo objetiva conduzir a investigação na empresa, onde um projetista irá conhecer as atividades das pessoas e como elas realizam suas tarefas.</p><p>Antes de conversar diretamente com o usuário, é preciso conhecer um pouco da empresa e da linguagem que é utilizada entre as pessoas. Também é muito importante permitir que as pessoas conheçam o projetista, pois isso permitirá um entrosamento. As pessoas precisam sentir liberdade para falar dos problemas e das coisas que gostam ou não, sem a preocupação de serem avaliadas.</p><p>No geral as pessoas sentem medo de serem avaliadas, pensando que se “falarem mal” de algum processo ou atividade da empresa, o chefe ficará sabendo e elas poderão ser demitidas. Em contrapartida, se a pessoas passam a conhecer o projetista e a confiar nele, elas perceberão que ele está na empresa para ajudá-las. Dessa forma, saberão que ele precisa entender o que está acontecendo, quais são as dificuldades e as facilidades do processo, e que todas essas informações são importantes para aprimorar e facilitar as tarefas que elas estão realizando.</p><p>Antes de tudo, o projetista deve se esforçar para conhecer as pessoas e conversar com elas. Tomar um cafezinho ajuda bastante, afinal, um ambiente descontraído pode ser de grande valia nesse momento. Essa estratégia, chamada de <em>Background Research</em>, afirma que uma pesquisa, com o objetivo de conhecer as pessoas, não precisa ser formal, podendo ter uma ambientação descontraída, porém profissional e com um objetivo definido.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FJ5Wb6kSQon7nWmfvLJp5w.jpeg" /></figure><p>Existem várias maneiras de fazer as pesquisas, cada uma com uma abordagem diferente:</p><ul><li><strong>Entrevistas face-a-face:</strong> com essa abordagem você pode conversar com a pessoa pessoalmente, fazendo perguntas e ouvindo suas respostas “face a face”, sem a necessidade de outros recursos, como formulários de papel, por exemplo. É importante planejar antecipadamente a entrevista, elaborando perguntas interessantes. Ao contrário do que acontece quando respondem no papel, as perguntas podem sofrer alterações dependendo das respostas, pois através delas você pode ter interesse em conhecer mais detalhes de um determinado assunto. Nesta modalidade existe a possibilidade de gravar a entrevista, desde que você tenha a permissão da pessoa para isso, para não constrangê-la;</li><li><strong>Perguntas abertas e fechadas:</strong> é uma entrevista, que acontece com o auxílio do papel, por meio de um questionário. Você define algumas perguntas, que podem ser objetivas (fechadas) ou dissertativas (abertas), para que as pessoas respondam. Exemplos de perguntas fechadas são: “<em>Quantos anos você tem?</em>” ou “<em>Qual seu cargo na empresa?</em>” fazendo que a resposta seja muito objetiva. Já as perguntas abertas são mais livres, fazendo que a pessoa formule respostas mais longas. Essa estratégia é muito utilizada quando existe a necessidade de entrevistar uma quantidade grande de pessoas. Se fosse entrevistar pessoalmente uma por uma, precisaria de tempo e dinheiro. Por isso, quando é necessário entrevistar várias pessoas, alguns projetistas costumam aplicar esse questionário para obter uma média com base nas respostas. Com as médias estabelecidas, o projetista pode fazer uma entrevista <em>Face-a-face</em> com algumas pessoas, para saber mais detalhes ou esclarecer algo que ficou pendente;</li><li><strong>Entrevistas remotas:</strong> ocorre quando você não tem a possibilidade de um encontro presencial com a pessoa, então, a entrevista pode ser feita utilizando o telefone, a internet ou qualquer outro meio que lhe permita ter contato com ela. Essa técnica é utilizada, por exemplo, quando a pessoa que se deseja entrevistar está viajando para participar de uma reunião de negócios;</li><li><strong>Entrevista pessoal:</strong> nesta modalidade, o projetista faz uma pergunta para a pessoa e ela responde fazendo uma determinada atividade, ao invés de responder com palavras (falando ou escrevendo). Ou seja, se você pergunta como é feito um determinado processo, ela explicará realizando esse processo. Por meio dessa entrevista pode-se acompanhar todos os detalhes, desde o comportamento do indivíduo até os objetos que ele utiliza para a atividade.</li></ul><p>Todas as perguntas elaboradas devem levar em consideração a função e especialidade de cada <em>stakeholder</em>, podendo-se agrupar pessoas de acordo com sua especialidade na empresa.</p><p>Após a utilização das técnicas explicadas aqui, o projetista terá conhecimento sobre as pessoas, suas atividades, a maneira que elas pensam, entre outras características. Porém, um cuidado importante é necessário na hora de projetar o software, pois é comum entre os projetistas tentar aproveitar todo o processo manual e aplicar no computacional, <strong>tornando o sistema meramente uma reprodução das atividades que as pessoas realizam manualmente</strong>. Embora, através da técnica, se saiba como as pessoas desempenham as atividades, é preciso entender que o computador tem um potencial muito grande e o objetivo de um sistema não é somente reproduzir a vida das pessoas, mas sim facilitá-la (KEINONEN, 2008).</p><h4><strong>c) Análise</strong></h4><p>O terceiro passo consiste em analisar todos os dados coletados nos passos anteriores, com a utilização de várias técnicas descritas na literatura como <em>Análise Quantitativa</em> e/ou <em>Qualitativa</em> (WILLIAMS, 2009). O projetista deverá organizar todas as informações, decidir quais são as prioridades, o que deve ser feito, o que precisa ser mudado, suas propostas, enfim, todas as informações necessárias para, depois, conversar com as pessoas.</p><h4><strong>d) Reporte</strong></h4><p>Esse passo é justamente a conversa com as pessoas sobre tudo o que foi coletado e analisado sobre essas informações. Você pode fazer uma apresentação e/ou escrever um relatório com os principais dados.</p><p>Como já são conhecidas as necessidades e a linguagem da empresa, é importante utilizar essas informações na apresentação para que as pessoas compreendam e se interessem pelo que vai ser falado. Também é importante considerar o <em>stakeholder</em>, ou seja, se a conversa envolver alguém da administração, planeje algo utilizando uma linguagem própria e assuntos que vão interessar às pessoas dessa área.</p><h3>2. Desenho</h3><p>É a segunda etapa do <em>UCD</em>, onde ocorre a consolidação de todas as informações obtidas até esse momento. Pode ser realizada por meio dos primeiros desenhos da interface. Esses desenhos são feitos de acordo com as informações obtidas e pelas conversas feitas durante esta etapa.</p><p>Há várias formas de fazer esse primeiro esboço, uma delas é chamada de <em>Prototipagem</em>, que será abordada em outro artigo. Nela a interface é desenhada pensando em como será a interação entre o sistema e o usuário, definindo a navegação que acontecerá, além de outras características.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fqJI5KOEDlGmtdnKAstLuw.jpeg" /></figure><h3>3. Avaliação do Desenho</h3><p>Terceira e última etapa do <em>UCD</em>, essa etapa avalia tudo o que foi investigado, desenvolvido e representado por meio do <em>Desenho</em>.</p><p>A avaliação pode ser feita com auxílio do usuário, certificando que tudo o que foi planejado e realizado está de acordo com as necessidades e as características do usuário. Se o indivíduo entender o <em>Desenho</em> e conseguir trabalhar com ele, mesmo por intermédio de protótipos, a possibilidade de interagir com a ferramenta computacional será bem maior, ou seja, a certeza de construir um sistema com qualidade é elevada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bL2gzGyTor0vBjs-B4POQA.png" /></figure><p>A <em>Avaliação do Desenho</em> também <strong>pode ser feita sem a ajuda do usuário</strong>, aplicando estratégias que indicam se o usuário conseguirá utilizar o sistema de modo eficaz ou não. Algumas estratégias para realizar a avaliação são:</p><ul><li>Heurística;</li><li>Questionário de satisfação;</li><li>Percurso cognitivo;</li><li>Revisão pelos usuários;</li><li>etc.</li></ul><p>Apesar de parecer simples conversar com uma pessoa para explicar o que se pretende fazer no software, quais serão as atividades e tudo mais, não é uma tarefa fácil, pois ambos (projetista e cliente) possuem conhecimentos e experiências diferentes.</p><h3>Entregando valor para o cliente</h3><p>Os usuários tendem a valorizar mais os sistemas que possuem uma interface boa e utilizável. A forma de utilizar o sistema, quase sempre, é mais importante do que a quantidade de funcionalidades e recursos existentes. Em outras palavras, existe uma clara vantagem competitiva entre sistemas que se preocupam com o usuário e os que se preocupam apenas com as funcionalidades.</p><p>Outra vantagem, que só é percebida após a entrega do sistema, é a minimização dos custos posteriores. Geralmente há uma preocupação com os custos que envolvem o desenvolvimento do software, porém, é necessário colocar este quesito na balança para medir o que será, de fato, mais caro:</p><p><strong>Um custo único </strong>para investir no desenvolvimento do software contemplando as técnicas de <em>IHC</em>, focando sempre no usuário para gerar um software fácil e compreensível;</p><p>ou</p><p><strong>Um custo periódico </strong>para treinar cada novo usuário que entre na empresa, pois sem a preocupação com <em>IHC</em>, o software não pode ser facilmente compreendido, e o usuário não consegue usar o sistema sem orientação prévia.</p><p>Pensar no usuário em todo o processo e testar exaustivamente o software para garantir a qualidade é uma tarefa aparentemente árdua, mas é uma estratégia comprovadamente eficaz para garantir um sistema aceitável e usável.</p><p>Nos próximos artigos, abordarei mais informações sobre como trabalhar para produção de um software que satisfaça as necessidades do cliente. Espero que o conteúdo seja útil. Um grande abraço e até a próxima!</p><h4>Leia também o próximo artigo sobre o assunto:</h4><p><a href="https://medium.com/codigo-facil/prototipagem-de-software-7ac07027e6d8">Prototipagem de Software</a></p><h4>Leia todos os artigos desta série:</h4><ul><li><a href="https://medium.com/codigo-facil/interface-humano-computador-5bd0ee9d7d2e">Interface Humano-Computador</a></li><li><a href="https://medium.com/codigo-facil/a-hist%C3%B3ria-da-interface-4b698537ba15">A História da Interface</a></li><li><a href="https://medium.com/codigo-facil/usabilidade-e-qualidade-565795aeb1ce">Usabilidade e Qualidade</a></li><li><a href="https://medium.com/codigo-facil/o-design-centrado-no-usu%C3%A1rio-9053dbff54f8">Design Centrado no Usuário</a></li><li><a href="https://medium.com/codigo-facil/prototipagem-de-software-7ac07027e6d8">Prototipagem de Software</a></li></ul><h3>Referências para Aprofundamento:</h3><p>KEINONENM, T. User-centered design and fundamental need. Lund — Suécia. The 5th Nordi conference on Human-computer<br>interaction: building bridges, 2008.</p><p>NIELSEN, J. Bridging the Designer–User Gap. Disponível em: &lt;<a href="http://www.useit.com/alertbox/designer-user-differences.html">http://www.useit.com/alertbox/designer-user-differences.html</a>&gt;.<br>Acesso em: 22 jun. 2019.</p><p>WILLIAMS, A. User-centered design, activity-centered design, and goal-directed design: A review of three methods for designing<br>web applications. Bloomington — EUA In: Special Interest Group on Design of Communication (SIGDOC), 2009.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9053dbff54f8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contexto-delimitado/o-design-centrado-no-usu%C3%A1rio-9053dbff54f8">O Design Centrado no Usuário</a> was originally published in <a href="https://medium.com/contexto-delimitado">Contexto Delimitado</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>