<?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 Dherik Barison on Medium]]></title>
        <description><![CDATA[Stories by Dherik Barison on Medium]]></description>
        <link>https://medium.com/@dherik?source=rss-7ba52e01c279------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*LFqVzBcDgzB_bReJzxwA7g.png</url>
            <title>Stories by Dherik Barison on Medium</title>
            <link>https://medium.com/@dherik?source=rss-7ba52e01c279------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 18:57:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dherik/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[Qual o tamanho ideal de  uma equipe?]]></title>
            <link>https://dherik.medium.com/qual-o-tamanho-ideal-para-uma-equipe-d6f258aea757?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/d6f258aea757</guid>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[scrum-guide]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Mon, 07 Dec 2020 23:51:18 GMT</pubDate>
            <atom:updated>2021-02-24T22:59:57.234Z</atom:updated>
            <content:encoded><![CDATA[<h3>Qual o tamanho ideal de uma equipe?</h3><figure><img alt="“Software Team Leader announcing new Code Review Procedure.” by karburator.eu is licensed under CC BY-NC-SA 2.0" src="https://cdn-images-1.medium.com/max/1024/0*zSTyhtLXldYe9nTB.jpg" /><figcaption>Lead propondo novo procedimento de Code Review. Seria mais fácil entrar em acordo com um time menor :). (by karburator.eu is licensed under CC BY-NC-SA 2.0)</figcaption></figure><p>Muitas discussões, pesquisas e teorias existem sobre este tema. Encontrar o tamanho ideal para uma equipe costuma ser um desafio, porém já existe material e experiências suficientes que nos ajudam a indicar o melhor caminho e escapar de algumas armadilhas.</p><p>Podemos afirmar que o conceito de adotar equipes menores no desenvolvimento de software, por serem mais eficientes, foi <a href="https://www.scrumguides.org/scrum-guide.html#team-dev">popularizado com o Scrum</a>. E do <em>Scrum Guide</em> temos:</p><blockquote>Fewer than three Development Team members decrease interaction and results in smaller productivity gains. Smaller Development Teams may encounter skill constraints during the Sprint, causing the Development Team to be unable to deliver a potentially releasable Increment. Having more than nine members requires too much coordination. Large Development Teams generate too much complexity for an empirical process to be useful.</blockquote><p>Embora este seja um conceito que muitas pessoas compartilhem, não raro as pessoas não sabem o motivo exato no qual as equipes grandes não funcionam bem e, pior ainda, muitas não entendem como isto pode ser prejudicial a um projeto.</p><p>A explicação do <em>Scrum Guide</em>, embora contundente, carece de alguns detalhes. Por que, afinal, um time com mais de nove pessoas gera mais complexidade?</p><p>Bem, isto tem muita relação com a <strong>quantidade de canais de comunicação</strong> existentes em um time dada a quantidade de pessoas no mesmo.</p><p>A fórmula para calcular esta quantidade é: <em>n * (n — 1)/2, </em>sendo <strong><em>n </em></strong>o número de pessoas da equipe<em>.</em></p><p>Ou seja, com 3 pessoas temos 3 canais de comunicação: 3*(3–1)/2=3. Já com 4 pessoas, teremos 6 canais de comunicação. Com 9 pessoas na equipe teremos 32 canais de comunicação. Como podem notar, este número se multiplica facilmente conforme aumenta o número de pessoas.</p><figure><img alt="Temos 6 canais de comunicação com 4 pessoas na equipe" src="https://cdn-images-1.medium.com/max/300/0*RkyB9SmqLoAb2yV_.jpg" /><figcaption>Sendo cada esfera uma pessoa, temos 6 canais de comunicação com 4 pessoas na equipe</figcaption></figure><p>Avaliando a quantidade canais de comunicação, 9 pessoas pode ser considerado um número elevado para uma equipe. As chances de uma informação importante não circular por todos os canais é alta. Ou seja, há uma maior chance de problemas de comunicação dentro da equipe. Mas ainda seria possível trabalhar com este número.</p><p><a href="https://www.infoq.com/news/2009/04/agile-optimal-team-size">Estudos</a> relacionados a memória de curto-prazo sugerem que o número ideal seria entre 5 e 9 pessoas, mas devido a <a href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2657600/">complexidade do tema</a>, estes números acabam sendo mais uma especulação com base no que as experiências mostram sobre a quantidade de números ou palavras que uma pessoa consegue reter a curto-prazo.</p><p>Talvez a melhor resposta para a pergunta do título venha da própria experiência dos times. Uma <a href="https://hackerlife.co/poll/team-size">pesquisa feita pela HackerLife</a> mostra que mais de 50% das pessoas acredita que o tamanho ideal de equipe seja de 4–5 pessoas. Outros <a href="http://jeffsutherland.com/2003/02/scrum-keep-team-size-under-7.html">estudos</a> mostram que a produtividade de equipes menores que 7 pessoas é substancialmente maior.</p><p>Como podem ver, a área acadêmica e profissionais de software ainda procuram por uma resposta definitiva para este assunto. Embora o chavão de que “aumentar o número de pessoas de uma equipe não traz mais produtividade” seja bem difundido, é sempre importante estar atento se os problemas de coordenação, comunicação e produtividade da equipe não sejam decorrência do tamanho da mesma. Talvez a melhor solução para um problema assim seja diminuir/quebrar a equipe em equipe menores, ao invés de burocratizar processos e aumentar formalizações para que um time “grande” fique minimamente funcional. Como diz o M<a href="https://agilemanifesto.org/">anifesto Ágil</a>:</p><blockquote>Individuals and interactions over processes and tools.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d6f258aea757" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Qual API você está criando: RESTful, baseada em REST ou RPC com HTTP?]]></title>
            <link>https://dherik.medium.com/qual-api-voc%C3%AA-est%C3%A1-criando-restful-based-rest-ou-rpc-com-http-38d2dc1099cc?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/38d2dc1099cc</guid>
            <category><![CDATA[restful-api]]></category>
            <category><![CDATA[hateoas]]></category>
            <category><![CDATA[rest-api]]></category>
            <category><![CDATA[rpc]]></category>
            <category><![CDATA[rest]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Wed, 15 Jan 2020 20:51:54 GMT</pubDate>
            <atom:updated>2020-01-29T15:54:33.710Z</atom:updated>
            <content:encoded><![CDATA[<p>Muitos desenvolvedores assumem que uma API RESTful¹ se resume em usar os métodos POST, DELETE, PUT e GET com o retorno de códigos HTTP. Mas será que uma API assim pode ser considerada RESTful?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*krZl43BSkNeQ_VOO" /></figure><p>Quem cunhou o termo REST (<strong><em>Re</em></strong><em>presentational </em><strong><em>S</em></strong><em>tate </em><strong><em>T</em></strong><em>ransfer</em>) foi <a href="https://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm">Roy Feilding</a> que, dentre as várias características apontadas que definem o que é REST, a que considero uma das mais importantes é a de <strong>interface uniforme</strong>.</p><p>O que é bem comum de se observar em APIs pela Internet é que boa parte dos sistemas criam, na verdade, uma API RPC (<em>Remote Procedure Call</em>) em cima do HTTP. Em suma, uma API desta natureza faz requisições síncronas que não seguem um padrão observável de interface. Ou seja, o simples fato de <strong>enviar um Json de um lado para outro não faz sua API seguir o padrão REST</strong>.</p><p>Focando então nesta necessidade de ter uma interface uniforme em uma API, os aspectos mais importantes deste assunto que gostaria de abordar são três: <strong>métodos HTTP</strong>, <strong>códigos HTTP</strong> e <strong>organização dos recursos</strong>.</p><p>Vamos falar de cada um deles.</p><h3>Métodos HTTP</h3><p>Creio que este seja o ponto onde existe menos divergência.</p><p>Ao invés de resumirmos tudo em GET e POST, como ocorria antigamente, temos também no nosso leque de <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Methods">principais métodos</a> o PUT, DELETE e PATCH.</p><p>De certa forma, é simples de entender:</p><ul><li>GET: para consultas;</li><li>POST: para criação de recursos;</li><li>DELETE: para remoção de recursos.</li></ul><p>Já a atualização de um recurso pode envolver um <a href="https://stackoverflow.com/questions/28459418/rest-api-put-vs-patch-with-real-life-examples">pouco de confusão</a>, pois temos o PUT e o PATCH para isto. Mas resumindo, o PUT serve para atualização do recurso <strong>inteiro </strong>enquanto o PATCH é uma atualização de <strong>um ou mais campos </strong>daquele recurso.</p><h3>Códigos HTTP</h3><p>Nesta parte, entendo que a confusão começa a aumentar. Embora existam <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Status">muitos códigos HTTP</a>, existem as escolhas mais comuns e óbvias para alguns casos. Para outros, nem tanto.</p><p>Primeiro, vamos analisar os códigos de casos de sucesso:</p><ul><li>200: requisição feita com sucesso. Comumente usado com o método GET, POST e PUT.</li><li>201: recurso criado com sucesso. Comumente usado em métodos POST.</li><li>204: requisição feita com sucesso, mas não retorna conteúdo. Comumente usado com os métodos DELETE, PUT ou POST.</li></ul><p>Para os casos de falha do cliente, podemos listar:</p><ul><li><a href="https://stackoverflow.com/questions/16133923/400-vs-422-response-to-post-of-data">400</a>: requisição mal formada pelo cliente. Pode ocorrer quando algum campo obrigatório está faltando, foi enviado com formato incorreto, etc.</li><li>401: usuário não está autenticado.</li><li>403: usuário não tem permissão para acessar o recurso</li><li>404: recurso não encontrado. Pode ser usado em um GET/PUT/DELETE no qual o recurso informado não existe. Pode ser usado dentro do POST quando está referenciando algum recurso no <em>body </em>que não existe.</li><li>409: conflito. Pode ser usado quando uma requisição está sendo criada com uma informação que deve ser única no sistema, mas já tem um recurso que a utiliza. Por exemplo, cadastrar dois usuários com o mesmo e-mail.</li><li><a href="https://stackoverflow.com/a/12031664/2387977">412/422</a>: para problemas de validação, onde a requisição em si está correta mas alguma validação interna do sistema recusou a requisição. Já usei 412 nas minhas APIs, mas atualmente o consenso é usar o 422.</li></ul><p>E, finalmente, temos os casos de erro no servidor:</p><ul><li>500: erro interno do servidor. O sistema enfrentou alguma condição inesperada.</li></ul><p>Existem muitos códigos HTTP disponíveis e você pode estender o uso deles o quanto quiser, conforme for identificando cenários claros de uso para cada um deles. Mas, em vários momentos, você irá perceber que não tem um código HTTP exatamente para o que precisa.</p><h3>Organização dos recursos</h3><p>É aqui que concentra-se o principal problema que observo nas APIs.</p><p>Em uma API, nós estamos trabalhando com os recursos, que podem variar dependendo da sua API: podem ser pedidos, contratos, pessoas, pagamentos, endereços, etc. Estes recursos também podem ter parentescos, como: pessoas terem endereços, pedidos terem pagamentos, pagamentos terem endereços, etc.</p><p>Assim, a criação dos <em>endpoints </em>que atenderão estes recursos devem observar esta organização.</p><p>Importante também usar de forma correta os métodos HTTP ao trabalhar com os recursos e criação dos seus <em>endpoints</em>. Não raro vejo APIs que usam verbos nos seus <em>endpoints </em>sem necessidade: /pedidos/listar-pedidos, /pedidos/criar, etc.</p><p>Vamos aos exemplos. Se queremos listar os pagamentos disponíveis ou filtrar os pagamentos por cartão, podemos criar nossos <em>endpoints </em>desta maneira:</p><blockquote>GET /pagamentos/<br>GET /pagamentos?tipo=cartao</blockquote><p>Se queremos listar todas as pessoas ou buscar a pessoa com determinado CPF:</p><blockquote>GET /pessoas<br>GET /pessoas/12333356733</blockquote><p>Perceba que nossos recursos estão todos nos plural e é preferível mantê-los <a href="https://stackoverflow.com/questions/6845772/rest-uri-convention-singular-or-plural-name-of-resource-while-creating-it">desta maneira</a>.</p><p>A criação, atualização ou remoção de recursos se dá pelo próprio método HTTP também, respectivamente:</p><blockquote>POST /pessoas<br>POST /pedidos</blockquote><blockquote>PUT/pessoas/12333356733<br>PUT /pedidos/88333</blockquote><blockquote>DELETE /pedidos/88333</blockquote><p>O parentesco entre recursos, mencionado no início, também pode ser contemplado e combinado com filtros:</p><blockquote>GET /pessoas/12333356733/enderecos?rua=benjamim<br>POST /pessoas/12333356733/enderecos</blockquote><h3>E agora, posso chamar minha API de RESTful?</h3><p>De <a href="https://roy.gbiv.com/untangled/2008/rest-apis-must-be-hypertext-driven">acordo com Roy</a>, <strong>não</strong>:</p><blockquote>if the engine of application state (and hence the API) is not being driven by hypertext, then it cannot be RESTful and cannot be a REST API. Period.</blockquote><p>O que ele está dizendo acima de forma bem categórica é que, basicamente, uma API REST precisa implementar o que conhecemos hoje por <a href="https://restfulapi.net/hateoas/">HATEOAS</a> (<strong><em>H</em></strong><em>ypertext </em><strong><em>A</em></strong><em>s </em><strong><em>T</em></strong><em>he </em><strong><em>E</em></strong><em>ngine </em><strong><em>O</em></strong><em>f </em><strong><em>A</em></strong><em>pplication </em><strong><em>S</em></strong><em>tate</em>) para ser considerada REST.</p><p>Por <a href="https://stackoverflow.com/q/20335967/2387977">diversos motivos</a>, o HATEOAS não se popularizou até hoje. Então, por definição, temos muito mais APIs <em>baseadas em REST</em> do que RESTful. Como poucas pessoas conhecem esta definição, é comum entender que uma API é RESTful mesmo não tendo HATEOAS.</p><p>Esta discussão, inclusive, acabou originando o conceito de <a href="https://martinfowler.com/articles/richardsonMaturityModel.html">níveis de maturidade</a> de uma API ao implementar REST.</p><h3>Conclusão</h3><p>O conceito base de criação de uma API RESTful (ou <em>baseada em REST</em> :) ) segue um conjunto inicial de padrões que são simples de entender e seguir.</p><p>Porém, certamente você enfrentará vários casos onde ficará em dúvida de como irá criar seu endpoint:</p><ul><li>Se eu precisar fazer operações (criar, atualizar ou remover) em lote? Como informar ao usuário os que foram processados com sucesso ou erro? Qual método e código HTTP usarei?</li><li>Se eu precisar chamar uma API só de validação, como evitar o uso de um verbo no endpoint?</li><li>Se a identidade do meu recurso usa chave composta, como faço um GET/PUT/DELETE dela?</li></ul><p>Existem diversas maneiras para solucionar os problemas acima. Apenas tenha em mente que o ideal é que quem consuma este endpoint consiga <strong>facilmente entender o que ele faz apenas olhando para a assinatura dele</strong>. A organização apresentada no texto é uma forma de agilizar este entendimento pois favorece a auto-documentação da própria API.</p><p>Para finalizar, meu recado final é: seja consistente na sua API. Faça seu estudo, faça suas escolhas e mantenha a consistência destas decisões por toda ela. Pior que um padrão “ruim” é não ter padrão algum.</p><p>[1]. Um serviço RESTful é simplesmente aquele que realiza a implementação do padrão REST.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38d2dc1099cc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[De volta para o futuro: usando Clock para manipular o tempo nos seus testes]]></title>
            <link>https://dherik.medium.com/de-volta-para-o-futuro-usando-clock-para-manipular-o-tempo-nos-seus-testes-f004bbb7fa4c?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/f004bbb7fa4c</guid>
            <category><![CDATA[teste]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[futuro]]></category>
            <category><![CDATA[passado]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Sat, 14 Dec 2019 01:41:31 GMT</pubDate>
            <atom:updated>2019-12-30T13:27:40.487Z</atom:updated>
            <content:encoded><![CDATA[<p>Conhecer a linguagem de programação muitas vezes não é só essencial para criar um bom código mas também para criar bons testes.</p><p>Um destes conhecimentos que pode ser estranho para uma parte significativa dos desenvolvedores Java 8+ é a classe <a href="https://docs.oracle.com/javase/8/docs/api/java/time/Clock.html"><em>Clock</em></a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/452/1*pWQO4MkVD7kCt38c-VeQ_A.jpeg" /><figcaption>Voltar no tempo com Java é bem mais simples</figcaption></figure><p>A classe <em>Clock </em>é responsável por providenciar o tempo atual, que no Java é chamado de <strong>instante </strong>(<em>instant</em>). Quando fazemos, por exemplo, um <em>LocalDate.now()</em>, o Java lê o instante do relógio do seu computador. Porém, podemos manipular este instante colocando um <em>Clock </em>diferente no lugar dele.</p><p>Usando o exemplo do <em>LocalDate.now()</em>, podemos “enganá-lo” quanto ao instante em que ele está, bastando passar um <em>Clock </em>para o método<em> now()</em> como parâmetro, da seguinte forma: <em>LocalDate.now(clock).</em></p><p>Agora, como posso manipular o tempo (ou instante) com o <em>Clock</em>?</p><p>Existem diferentes maneiras. Uma das mais simples é esta:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e13836f59087e3b77eadc73700853768/href">https://medium.com/media/e13836f59087e3b77eadc73700853768/href</a></iframe><p>Porém, isto levanta questões práticas de como usá-lo:</p><ul><li>Como passar o <em>Clock </em>para o método <em>now()</em> em um projeto de verdade?</li><li>Como alternar o instante real com o instante que quero no meu teste?</li></ul><p>A melhor prática e <a href="https://docs.oracle.com/javase/8/docs/api/java/time/Clock.html">oficialmente recomendada</a> para lidar com este cenário é usar a injeção de dependência<strong> por construtor</strong>, assunto este já abordado em <a href="https://medium.com/cwi-software/os-benef%C3%ADcios-de-usar-inje%C3%A7%C3%A3o-por-construtor-8cd442884adc">outro texto</a>.</p><p>Basicamente, você cria o objeto <em>Clock </em>como uma dependência injetável e passa para dentro do construtor da classe. Isto vai permitir que o <em>Clock </em>seja injetado pelo seu framework de injeção e, para o teste unitário, permitirá ao desenvolvedor instanciar o <em>Clock </em>com o instante no tempo que preferir.</p><h3>Usando…</h3><p>Vamos mostrar abaixo um exemplo de como conseguimos montar este cenário todo usando o framework Spring.</p><p>Sua classe que receberá a injeção de <em>Clock </em>ficaria assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fdb0c79c7518325e1d7eb5929ad69791/href">https://medium.com/media/fdb0c79c7518325e1d7eb5929ad69791/href</a></iframe><p>O teste unitário de uma classe assim é igualmente simples. Basta instanciar a classe e depois passar o <em>Clock </em>como parâmetro:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b8db892c21f801e13befc25fb78fad4e/href">https://medium.com/media/b8db892c21f801e13befc25fb78fad4e/href</a></iframe><p>Agora vamos criar uma classe injetável (<em>bean</em>) a partir do <em>Clock</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f16a70873fb2021db83e3ecf4f0d32af/href">https://medium.com/media/f16a70873fb2021db83e3ecf4f0d32af/href</a></iframe><p>Com isto, temos tudo pronto: o código que receberá a injeção do <em>Clock</em>, o teste unitário e o <em>Clock </em>injetável.</p><h3>… e abusando</h3><p>Se você ainda quiser abusar do <em>Clock</em>, você pode aplicar este mesmo conceito para os seus <a href="https://www.baeldung.com/integration-testing-in-spring">testes de integração</a>, criando cenários inteiros de teste manipulando o tempo, mockando o <em>Clock </em>com @MockBeane alterando o instante dele.</p><p>Já implementei vários testes automatizados, executando diversos cenários, usando este recurso. A flexibilidade proporcionada por esta estratégia para criar testes que precisam de dados cadastrados no passado é excelente.</p><h3>… e abusando²</h3><p>Agora, se você deseja estressar ao máximo os limites de um teste com <em>Clock</em>, fica a dica: você pode criar um serviço qualquer (Rest, Servlet, você escolhe!), desde que fique disponível <strong>apenas em ambiente de desenvolvimento</strong>, que possa permitir manipular a data da aplicação da maneira que quiser, bastando passar a data desejada neste serviço disponibilizado. Lembra daqueles testes que seu QA reclamava que eram difíceis de se fazer, pois dependiam de registros passados? Então, não mais :).</p><p>Este tipo de funcionalidade basicamente envolve a alteração em tempo de <em>runtime </em>de beans do Spring. <a href="https://github.com/dherik/spring-clock-time-machine">Criei um repositório com uma implementação funcional</a> usando um <em>bean </em><strong>Delorean </strong>para fazer o meio de campo com o <em>Clock, </em>apenas para ilustrar esta possibilidade. Vocês podem conferir mais detalhes e algumas observações sobre a implementação no próprio repositório.</p><p>Bem, é isto. Para testes que uma máquina do tempo viria a calhar, o <em>Clock </em>irá te ajudar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f004bbb7fa4c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tecnologia na Europa: o quão longe eles estão de nós, brasileiros? Parte 1: Aeroporto]]></title>
            <link>https://dherik.medium.com/tecnologia-na-europa-o-qu%C3%A3o-longe-eles-est%C3%A3o-de-n%C3%B3s-brasileiros-parte-1-aeroporto-e56fc7bf6bce?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/e56fc7bf6bce</guid>
            <category><![CDATA[aeroporto]]></category>
            <category><![CDATA[tecnologia]]></category>
            <category><![CDATA[europa]]></category>
            <category><![CDATA[brasil]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Mon, 04 Nov 2019 20:43:24 GMT</pubDate>
            <atom:updated>2020-06-30T23:29:44.807Z</atom:updated>
            <content:encoded><![CDATA[<h3>Tecnologia na Europa: o quão na frente eles estão de nós, brasileiros? Parte 1: Aeroporto</h3><p>Recentemente fiz uma viagem para a Europa, especificamente visitando as seguintes cidades: Paris, Londres, Bruxelas e Amsterdã. Além das características mais óbvias destas cidades europeias, tais como segurança, limpeza, organização, etc, algo que me chamou muito a atenção foi a tecnologia, organização e automação empregada por eles para resolver problemas comuns a nós todos.</p><p>A ideia então é trazer um pouco do que observei e trazer a reflexão dos motivos de estarmos distantes deles em alguns aspectos. Vou distribuir tudo que observei por lá em mais de um texto, pois foram várias coisas e gostaria de comentar cada uma delas.</p><h3>Check-in integrado entre as companhias aéreas</h3><p>Na Europa existe muito mais concorrência entre companhias aéreas que no Brasil que, por si só, já éum exemplo de país com pouquíssima concorrência.</p><p>Contudo, creio que esta abundância de empresas lá também fomentou na união de algumas soluções comuns a todas elas, para facilitar o lado delas e também do cliente. Estou falando especificamente da parte de check-in do voo.</p><p>Diferente do Brasil, que cada empresa aérea tem um sistema de check-in diferente, várias empresas na Europa usam uma solução de uma empresa rival, a <a href="http://www.klm.com/%E2%80%8E">KLM</a>. Com o token da KLM você pode fazer check-in em voos de várias outras empresas, deixando tudo mais simples para os passageiros. Por exemplo, meu voo foi pela AliItalia mas o check-in foi feito pelo site da KLM.</p><h3>Despacho de malas</h3><p>O despacho de malas no aeroporto de Amsterdã foi bem interessante.</p><p>Ao invés de pegar uma fila e aguardar ser atendido por uma pessoa para a pesagem, etiquetagem e (principalmente) despacho da mala, tudo isto é feito apenas por você. No Brasil, até onde sei, o despacho final da mala ainda depende de uma pessoa, mas lá todo o processo é feito pelo cliente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LXu5o11lhC95F2JJv5n0vA.jpeg" /><figcaption>Câmaras de hibernação do filme <em>2001: Uma odisseia no espaço</em></figcaption></figure><p>No aeroporto de Amsterdã você encontrará uma espécie de totem com uma “gaveta” ligada a esteira de malas. De alguma forma me lembrou daquelas câmaras de hibernação do filme <em>2001: Uma odisseia no espaço</em>. Com seu cartão de embarque, você habilita ela, coloca a mala para pesagem, aguarda a impressão da etiqueta e depois de colocar a etiqueta na mala, a “gaveta” confere se a etiqueta está na mala e então a despacha. Sem intervenção humana além da sua :).</p><h3>Devolução da bandeja do detector de metais</h3><p>Quando as pessoas precisam passar por aquela porta com detector de metais e de outras substâncias, antes de acessar a área de portões do aeroporto, é normal temos a disposição aquela bandeja de plástico para colocar objetos pessoais pessoais de metal, tais como cinto, celular, moedas e etc. Porém, quando a bandeja chega ao final da esteira, é comum no Brasil alguém precisar organizar as bandejas, empilhá-las e levá-las até o começo da esteira. O tempo todo.</p><p>No aeroporto de Amsterdã isto também é automatizado. Quando chega a vez da pessoa, ela encontra 3 espaço com bandejas ao lado da esteira, onde você pode pegar a bandeja disponível. Ao retirar a bandeja, uma outra é recolocada no lugar, ficando disponível para você ou para a próxima pessoa. Ao final a pessoa coloca a bandeja dentro de um espaço ao final da esteira, onde uma esteira interna se encarrega de devolver a bandeja ao começo da esteira em um destes 3 lugares. Isto também agiliza a fila, pois ajuda a paralelizar o depósito dos pertences das pessoas nas bandejas, mantendo o detector sempre ocupado.</p><h3>Localização das tomadas</h3><p>Quem nunca quis muito carregar o celular no aeroporto, mas percebia que todos os assentos que tinham uma tomada disponível estavam ocupados? E, pior ainda, que muitas destas pessoas nem ao menos estavam usando a bendita tomada?</p><p>Pois é, o aeroporto de Amsterdã resolveu isto de maneira bem simples.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/0*jex2CkTBxF9saMtr" /><figcaption>Os bancos perto das tomadas eram quase idênticos a este</figcaption></figure><p>Ao invés de colocar as tomadas perto de confortáveis assentos, eles colocarem as tomadas de energia sobre mesas altas e com bancos altos sem encosto, parecidos com aquelas bancos de barzinho. Ou seja, bem desconfortáveis. Isto evita naturalmente que as pessoas ocupem estes lugares por muito tempo, ocupando assim estas cadeiras apenas pelo tempo necessário para que seus celulares/notebooks/etc atinjam a carga desejada.</p><h3>Banheiros</h3><p>A torneira, sabonete líquido, secagem de mãos e descarga eram todos automáticos. Nada muito novo aqui, temos tudo isto no Brasil, mas fica registrado que estas soluções são mais a regra do que exceção por lá.</p><h3>Painéis de LED</h3><p>No aeroporto de Roma, em especial, é possível notar o uso e abuso de painéis de LED, com mais de 2 metros quadrados e revestindo colunas e paredes inteiras. Estes painéis lá são usados, basicamente, para propagandas comerciais: perfumes, carros, etc.</p><h3>Avião</h3><p>Na volta para o Brasil, o avião não tinha nada de muito especial em termos de tecnologia se comparado ao que já é visto nos carros, mas o ponto aqui é que ele também não devia nada.</p><p>Todos assentos eram equipados com uma espécie de tablet com boa resolução, bom contraste de cores, entrada USB e respondia rapidamente aos comandos. Acredito que também espelhava a tela do celular, mas não testei. O software usado era bem intuitivo e completo. Era possível também acessar pelo tablet as 2 câmeras externas do avião, que exibiam o que estava na frente e atrás do mesmo. O avião também contava com Internet por Wi-fi, mas o preço era proibitivo: o pacote mais básico era de 2 euros para 10 MB (ao menos foi o que entendi).</p><p>Bem, minhas impressões sobre os aeroportos e aviões foram estas. Se lembrar de mais algo, eu adiciono aqui :).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e56fc7bf6bce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entenda o porquê no qual adicionar o PowerMock ao seu projeto é uma má ideia]]></title>
            <link>https://dherik.medium.com/entenda-o-porqu%C3%AA-no-qual-adicionar-o-powermock-ao-seu-projeto-%C3%A9-uma-m%C3%A1-ideia-c9a949885dee?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/c9a949885dee</guid>
            <category><![CDATA[testes-unitários]]></category>
            <category><![CDATA[boas-práticas]]></category>
            <category><![CDATA[powermock]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[teste-de-software]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Mon, 17 Jun 2019 13:54:03 GMT</pubDate>
            <atom:updated>2019-09-04T17:01:49.270Z</atom:updated>
            <content:encoded><![CDATA[<h3>Entenda por que adicionar o PowerMock ao seu projeto é uma má ideia</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hEbJvltnslRrdEzjWQ7Img.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@lucabravo?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Luca Bravo</a> on <a href="https://unsplash.com/search/photos/programming?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>O PowerMock é um dos frameworks de teste unitário mais poderosos disponíveis para o Java. Seu objetivo é transpassar algumas limitações que os frameworks de testes unitários EasyMock e Mockito têm, fornecendo mais recursos para lidar com algumas situações específicas.</p><p>Estas situações incluem, basicamente, códigos que atualmente são difíceis de serem testados unitariamente. Códigos estes <a href="https://quinngil.com/2018/12/16/tool-impact-on-developer-discipline-powermock/">com algumas destas características</a>, por exemplo:</p><ul><li>Métodos estáticos que precisam ser evitados</li><li>Métodos privados que precisam ser testados, mas também precisam continuar como privados</li><li>Mockar a injeção de uma dependência quando está <a href="https://medium.com/p/8cd442884adc?source=your_stories_page---------------------------">usando <em>Field Injection</em></a></li></ul><p>Entre outros.</p><h3>O problema</h3><p>Depois desta breve introdução, não é difícil reparar que a maior parte dos casos que o PowerMock entra como solução tratam-se de casos onde o problema <strong>poderia ter sido evitado ao escrever o código</strong>.</p><p>É por esta razão que o PowerMock normalmente aparece para lidar com código legado, onde temos um código já existente que precisa de testes unitários antes de qualquer alteração/refatoração no mesmo.</p><p>Agora, se você acaba de criar um projeto já com a dependência do PowerMock, eu sugiro voltar atrás e não cair na tentação de adicioná-lo ao seu projeto.</p><p>O motivo? Veja um exemplo a seguir.</p><p>Se você escreve uma classe com um método privado ou método estático e <a href="https://stackoverflow.com/a/6386065/2387977">sente a necessidade</a> de mockar eles para simplificar ou mesmo viabilizar seu teste, isto é um forte indício de que sua classe ou método estão fazendo muitas coisas. A presença do PowerMock pode encorajar os desenvolvedores, principalmente os menos experientes, a utilizá-lo, realizar o mock e seguir em frente, ao invés de fazer a refatoração necessária para evitar esta situação que irá <a href="https://martinfowler.com/articles/is-quality-worth-cost.html">cobrar seu preço mais tarde</a>.</p><p>Um aviso parecido vem do próprio <a href="https://github.com/powermock/powermock">README</a> do PowerMock:</p><blockquote>Please note that PowerMock is mainly intended for people with expert knowledge in unit testing. Putting it in the hands of junior developers may cause more harm than good.</blockquote><p>Por fim, encorajo a todos a tentarem remover a dependência do PowerMock de seu projetos, pois isto acaba sendo um dos diversos sinais que estamos diante de um código saudável. Se por acaso estiver lidando com código legado, PowerMock te ajudará a trilhar um caminho por testes unitários para que, no fim, ele também deixe de ser necessário e possa ser removido.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c9a949885dee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Aposentando o termo “DTO” do nome das suas classes, variáveis e métodos]]></title>
            <link>https://dherik.medium.com/aposentando-o-termo-dto-do-nome-das-suas-classes-vari%C3%A1veis-e-m%C3%A9todos-78c94e151085?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/78c94e151085</guid>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[boas-práticas]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Wed, 12 Jun 2019 17:31:01 GMT</pubDate>
            <atom:updated>2019-10-28T15:09:23.823Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZXixptvL4rzkx3EDuj38xw.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@cdr6934?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Chris Ried</a> on <a href="https://unsplash.com/search/photos/programming?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Todo desenvolvedor Java que se preze, em algum momento da sua vida de programador, já criou alguma classe com o sufixo “DTO”. Normalmente estas situações incluem o transporte de informações de um ponto a outro. Nada mais justo, afinal o significado de DTO é <em>Data Transfer Object</em>.</p><p>Porém, existem vários contras no simples uso do sufixo DTO no nome de uma classe.</p><p>A <strong>primeira</strong> é que o sufixo “DTO” <a href="https://stackoverflow.com/a/35341664/2387977">diz muito pouco</a> sobre a responsabilidade da classe.</p><p>Por exemplo, digamos que temos um PedidoDTO usado para guardar informações de pedido. Até aqui, tudo bem. Mas o nome da classe não diz muito sobre o destino ou origem destas informações, o que levanta várias questões:</p><ul><li>Este DTO é usado para exibir informações em uma API?</li><li>Este DTO é usado para receber informações em uma API?</li><li>Este DTO é usado como uma mensagem entre micro serviços?</li><li>Este DTO é usado para guardar informações de pedido em algum cache?</li><li>Etc.</li></ul><p>Vemos claramente aqui um espaço para melhoria do nome desta classe, e de uma maneira bem simples. Respectivamente, veja como podemos usar um nome diferente para cada cenário apresentado anteriormente: PedidoResponse, PedidoRequest, PedidoMessage e PedidoCache.</p><p>O <strong>segundo </strong>contra<strong> </strong>é o sufixo em si. Digamos que você não quer abrir mão do termo DTO, mas ainda assim há mais um porém ao usá-lo. Normalmente o uso de siglas em maiúsculo no meio de variáveis, métodos ou nomes de classes traz uma certa confusão na leitura do código. Podemos citar, além do DTO, as seguintes siglas: CPF, CNPJ, NFE, etc.</p><p>Veja o seguinte exemplo de trecho de código para entender esta confusão:</p><pre>Pessoa pessoa = converterDTOParaEntidade(pessoaDTOOrigem); </pre><p>No código acima, temos dois pontos que dão um nó na cabeça ao lê-lo, são eles: DTOParae DTOOrigem. Como temos 2 letras maiúsculas juntas que não fazem parte da mesma palavra ou termo, você acaba não distinguindo imediatamente o termo DTO do código acima, mas sim DTOP ou DTOO, o que não faz sentido.</p><p>Sendo assim, ficaria mais legível se usássemos:</p><pre>Pessoa pessoa = converterDtoParaEntidade(pessoaDtoOrigem);</pre><p>Como já estamos acostumados no <a href="https://pt.wikipedia.org/wiki/CamelCase">CamelCase</a> a ler cada palavra que começa com maiúsculo como se fosse uma palavra diferente, é mais fácil ler o código acima do que o código anterior. Usei o DTO como exemplo, mas como disse anteriormente, este problema é compartilhado com qualquer situação onde temos uma sigla que é representada por letras maiúsculas.</p><p>Embora o uso do “Dto” possa ser justificado em alguns casos, é bem provável que na maioria deles você conseguirá encontrar um termo melhor para substituir este sufixo, dando mais significado para a responsabilidade daquela classe e trazendo mais clareza na leitura do código.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=78c94e151085" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como não usar o Optional do Java]]></title>
            <link>https://dherik.medium.com/como-n%C3%A3o-usar-o-optional-do-java-d7ccf51cbf2e?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/d7ccf51cbf2e</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[optional-type]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Thu, 09 May 2019 20:16:28 GMT</pubDate>
            <atom:updated>2019-06-18T12:39:18.912Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/711/1*yeVFT2YKwxu9aLsRXpDvyw.jpeg" /></figure><p>Por muito tempo que trabalhei com Java eu me conformei com a possibilidade de um NullPointerExceptionser um perigo iminente no código. Sempre à espreita, podendo aparecer em qualquer lugar a qualquer momento. Os <em>nulls</em>, indo e vindo no código, praticamente me diziam “Em algum momento você vai esquecer de me tratar!”, não havendo uma possibilidade de ter controle sobre eles sem apelar para uma programação defensiva, algo que costuma maltratar o código.</p><p>Muitos vêem o <em>null </em>com naturalidade no mundo da programação. Embora seja um ponto de vista polêmico, o próprio criador da “referência nula”, Tony Hoare, <a href="https://www.codebyamir.com/blog/stop-returning-null-in-java">se arrepende</a> de sua criatura:</p><blockquote>This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.</blockquote><p>Esta opinião parece ser compartilhada pela comunidade de desenvolvimento. <a href="https://stackoverflow.com/questions/28106234/are-there-languages-without-null">Boa parte das linguagens novas</a> não têm o conceito de referência nula, preferindo representar que uma informação pode não existir com o operador Élvis (?) ou mesmo com tipos <em>maybe</em>, <em>optional</em>, <em>option</em>, etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/401/1*nY0UsbKbZVwN9644HHbEJw.jpeg" /><figcaption>Para quem tiver curiosidade sobre a origem do nome “élvis” para o operador :)</figcaption></figure><p>No mundo Java, embora <a href="https://google.github.io/guava/releases/19.0/api/docs/com/google/common/base/Optional.html">algumas bibliotecas</a> já oferecessem uma possibilidade para tratar isto há muito tempo, a adoção desta prática só se popularizou quando o próprio Java forneceu uma alternativa para evitar os nulls no código, com a introdução do <a href="https://www.oracle.com/technetwork/pt/articles/java/optional-java-se-8-2262752-ptb.html">Optional no Java 8</a>.</p><p>Porém, ainda assim, é comum a existência de dúvidas na forma de utilizar o Optional corretamente. Só o fato de usar Optional não faz com que você esteja fazendo o uso correto do mesmo.</p><p>A seguir, vou apresentar um erro clássico no uso do Optional.</p><h3>Optional como parâmetro</h3><p>O conceito e vantagem de retornar Optional de um método ao invés de null é fácil de explicar. Ao receber uma informação opcional, você <a href="https://stackoverflow.com/a/26328555/2387977"><strong>sempre verifica</strong></a> se ela realmente existe e obtém a informação. Simples.</p><p>Porém, é comum os desenvolvedores passarem o Optional como parâmetro de um método ou construtor, delegando a decisão de o que fazer com o Optional para um outro método. Esta é uma prática não recomendada devido às desvantagens envolvidas. Mas quais seriam elas?</p><p>Tomemos como exemplo o seguinte código:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9b98c92ee966fc46f1bdebde709e62c6/href">https://medium.com/media/9b98c92ee966fc46f1bdebde709e62c6/href</a></iframe><p>A princípio, parece inofensivo. Porém, quem chama este método precisaria fazer:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/196188eb414a865dac0de5a10b298bca/href">https://medium.com/media/196188eb414a865dac0de5a10b298bca/href</a></iframe><p>Convenhamos: mesmo com apenas um parâmetro opcional, não é um código de leitura tão simples. Um método com mais parâmetros opcionais fica pior ainda de ler:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/55a2eeca7ee2200ae39ca99044e739df/href">https://medium.com/media/55a2eeca7ee2200ae39ca99044e739df/href</a></iframe><p>Mesmo assim, muitos desenvolvedores podem não se importar em como este código possa parecer. Uma questão de gosto, talvez.</p><p>Podemos então usar como argumento uma autoridade. <a href="https://stackoverflow.com/users/3553087/brian-goetz">Brian Goetz</a>, arquiteto de linguagem da Oracle, certa vez <a href="https://en.wikipedia.org/wiki/Tony_Hoare#Apologies_and_retractions">disse</a> em uma conferência que o Optional foi criado para resolver um problema de <strong>retorno </strong>dos dados e não de entrada, ao tratar sobre o mesmíssimo assunto.</p><p>Se você se convenceu, a próxima pergunta será: o que fazer, então?</p><p>Existem <a href="http://dolszewski.com/java/java-optional-parameters/">diferentes respostas</a> para esta pergunta. A minha preferida, por ser aplicável na maioria dos casos, é ter um método diferente para cada situação. Pegando o exemplo anterior, se é possível criar uma pessoa apenas com nome ou com nome <strong>e </strong>sobrenome, podemos ter um método para cada caso, usando <em>overloading</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c32df740bd2433b87057c3e60e38bc65/href">https://medium.com/media/c32df740bd2433b87057c3e60e38bc65/href</a></iframe><p>Deixando as chamadas bem mais simples de entender. Compare com a solução utilizando Optional no parâmetro:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/481fae1778f6a7473b4c74ab2965541e/href">https://medium.com/media/481fae1778f6a7473b4c74ab2965541e/href</a></iframe><p>Inclusive, esta mesma ideia pode ser aplicada para <a href="https://medium.com/@amlcurran/clean-code-the-curse-of-a-boolean-parameter-c237a830b7a3">evitar parâmetros booleanos</a> no código: criar diferentes métodos.</p><h3>Se null é ruim, posso usar Optional para tudo?</h3><p>No Java não é possível. O Optional não foi criado para abolir o null de todos os contextos possíveis. <a href="https://stackoverflow.com/a/26328314/2387977">Veja alguns</a> locais onde o Optional não é bem-vindo:</p><ul><li>em entidades e DTOs, por não serem serializáveis;</li><li>como parâmetro de entrada em um método ou como parâmetro de construtor, pelos motivos explicados anteriormente.</li></ul><p>A ideia do texto foi dar uma visão geral do bom uso de Optional e casos onde ele não é aplicável. A utilização do Optional já <a href="https://stackoverflow.com/q/49316751/2387977">alcançou os frameworks mais populares</a>, então é o momento de exercitar o conceito e aplicá-lo corretamente no seu projeto.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7ccf51cbf2e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Diferenças entre testes unitários usando injeção por construtor e por campo]]></title>
            <link>https://dherik.medium.com/diferen%C3%A7as-nos-testes-unit%C3%A1rios-entre-inje%C3%A7%C3%A3o-de-depend%C3%AAncia-por-construtor-e-por-campo-qual-%C3%A9-8316eb903d0a?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/8316eb903d0a</guid>
            <category><![CDATA[testes-unitários]]></category>
            <category><![CDATA[mockito]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[teste]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Fri, 25 Jan 2019 16:33:29 GMT</pubDate>
            <atom:updated>2019-04-15T16:25:54.783Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1ChfUF7VxwkZMIcDWmrY2g.jpeg" /></figure><p>No <a href="https://medium.com/cwi-software/os-benef%C3%ADcios-de-usar-inje%C3%A7%C3%A3o-por-construtor-8cd442884adc">último texto que publiquei</a> mencionei as vantagens de usar injeção de dependência por construtor. Entre elas estavam algumas relacionadas a criação de testes unitários. Segue o trecho mais relevante sobre o assunto no texto:</p><blockquote><strong><em>Mock </em>é mais fácil e confiável</strong>: <a href="http://olivergierke.de/2013/11/why-field-injection-is-evil/">comparado ao injeção por campo</a>, é mais fácil <em>mockar </em>as dependências em um teste unitário, porque você não precisa de nenhum contexto de <em>mock </em>ou uso de <em>reflection </em>para acessar a dependência dentro da classe. Também <a href="https://tedvinke.wordpress.com/2014/02/13/mockito-why-you-should-not-use-injectmocks-annotation-to-autowire-fields/">não será enganado</a> por estas técnicas. Você apenas instancia a classe e passa as dependências no construtor: simples e fácil de entender.</blockquote><p>Algumas pessoas me procuraram e disseram que seria interessante apresentar um exemplo de teste unitário demonstrando esta diferença entre injeção por construtor e por campo. Achei a ideia boa e resolvi fazer este texto!</p><p>Primeiro, vou mostrar como fazer um teste unitário usando injeção de dependência por <strong>campo </strong>no framework Spring, usando <a href="https://site.mockito.org/">Mockito</a>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a15eb2a092cd9397295a7683070ce2f/href">https://medium.com/media/3a15eb2a092cd9397295a7683070ce2f/href</a></iframe><p>Podemos observar neste teste que:</p><ul><li>Temos algumas anotações de mock ( @Mocke @InjectMocks) no corpo da classe de teste;</li><li>As dependências mockadas são compartilhadas entre os testes;</li><li>Temos que chamar o métodoinitMocksantes de executar o teste;</li><li>Não temos certeza da quantidade de dependências que a classe PessoaService tem, pois aquelas que não são usadas no teste não precisam estar declaradas na classe PessoaServiceTest com a anotação@Mock.</li></ul><p>Agora, o mesmo teste usando injeção por <strong>construtor</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/26592d44d347817aae7efe9de091a291/href">https://medium.com/media/26592d44d347817aae7efe9de091a291/href</a></iframe><p>Podemos observar neste teste que:</p><ul><li>Temos chamadas de métodos estáticos do Mockito no lugar das anotações. O Mockito, inclusive, torna-se menos essencial para o teste, já que não precisamos mais dos recursos de <em>reflection </em>dele para injeção quando comparado ao teste anterior;</li><li>As dependências mockadas ficam isoladas em cada teste;</li><li>Sabemos quantas dependências tem o PessoaService ao instanciá-lo.</li></ul><p>Por fim, os pontos levantados acima, mais aqueles levantados em <a href="https://medium.com/cwi-software/os-benef%C3%ADcios-de-usar-inje%C3%A7%C3%A3o-por-construtor-8cd442884adc">meu texto anterior</a>, mostram como os testes unitário com injeção por construtor apresentam-se como mais vantajosos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8316eb903d0a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Os benefícios de usar injeção de dependência por construtor]]></title>
            <link>https://dherik.medium.com/os-benef%C3%ADcios-de-usar-inje%C3%A7%C3%A3o-por-construtor-8cd442884adc?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/8cd442884adc</guid>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[teste-de-software]]></category>
            <category><![CDATA[melhores-praticas]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Thu, 01 Nov 2018 16:30:23 GMT</pubDate>
            <atom:updated>2021-03-10T13:22:21.172Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/747/1*oySQVUab8KqDV3L3-7ROQA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/2xU7rYxsTiM?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Sergi Kabrera</a> on <a href="https://unsplash.com/search/photos/computer?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Normalmente vemos nos projetos que a forma mais comum de injeção de dependências é a por <strong>campo</strong>, técnica mais conhecida como <em>Field Injection. </em>Veja um exemplo abaixo deste tipo de injeção usando Java e o framework <a href="https://spring.io/">Spring</a>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/388fdb20b2df7070b06ed1bacd36d63a/href">https://medium.com/media/388fdb20b2df7070b06ed1bacd36d63a/href</a></iframe><p>No exemplo acima, estamos injetando o serviço EnderecoService na classe PessoaService.</p><p>Basicamente, esta é a forma mais comum de injeção de dependência com Spring e, creio eu, também com outros frameworks.</p><p>Esta técnica é, sem dúvida, uma das mais usadas pelos desenvolvedores. Das possíveis explicações para a popularidade dessa forma de injeção de dependência, consigo apontar as seguintes como as mais plausíveis:</p><ul><li>Simplicidade;</li><li>Utilização de pouco código;</li><li>Técnica mais comum ensinada em tutoriais e exemplos pela Internet;</li><li>Técnica mais adotada em projetos;</li><li>Desconhecimento de outros métodos de injeção.</li></ul><p>E é sobre este último ponto que gostaria de discutir.</p><p>Embora seja uma prática muito comum, a injeção de dependência por campo é a que <strong>menos </strong>traz benefícios ao desenvolvedor e ao código. Eis as razões para isto:</p><ul><li><strong>Aumenta a dificuldade de <em>mockar</em> dependências</strong>: você precisa usar frameworks de <em>reflection </em>para conseguir injetar as dependências no teste unitário;</li><li><strong>As dependências da classe ficam ocultas</strong>: isto cria uma tendência dos desenvolvedores adicionarem mais dependências para a classe sem se preocupar com as consequências, que são: aumento do tamanho da própria classe e aumento da complexidade da mesma;</li></ul><p>Quais são as alternativas, então?</p><p>Temos duas: a injeção por <strong>método</strong> (<em>Setter Injection</em>) ou a por <strong>construtor</strong> (<em>Constructor Injection</em>) da classe. Veja, respectivamente, um exemplo de cada:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/09e4083eb3a19d0b9dbef7dc5e7e02a1/href">https://medium.com/media/09e4083eb3a19d0b9dbef7dc5e7e02a1/href</a></iframe><p>A vantagem mais óbvia de ambas, se comparadas com a injeção por campo, é que não é preciso mais apelar para um método de <em>reflection </em>para injetar as dependências na classe em testes. No primeiro caso você pode usar o método set e no segundo o construtor da classe.</p><p>Agora, se compararmos a injeção por campo apenas com a injeção por construtor, temos mais algumas vantagens:</p><ul><li><strong>As dependências da classe ficam expostas</strong>: as dependências da classe <a href="http://blog.indrek.io/articles/to-field-inject-or-not-to/">são mais óbvias</a> se comparadas ao método de injeção por campo ou método<em>, </em>no qual as classes ficam próximas a uma <a href="https://en.wikipedia.org/wiki/Black_box">caixa preta</a>. Os desenvolvedores tendem, pela minha experiência, a não se importar com classes com muitas dependências escondidas, que por outro lado ficam bem óbvias quando você tenta <em>mockar </em>elas usando o construtor da classe. A própria “bagunça” que pode ser causada pelo uso do construtor em uma classe com muitas dependências também vira <a href="https://www.petrikainulainen.net/software-development/design/why-i-changed-my-mind-about-field-injection/">um sinal claro</a> de que há algo errado. Lembre-se: <strong>um problema que incomoda os desenvolvedores tem mais sucesso em ser priorizado e resolvido</strong>. Lembrando que uma classe com muitas dependências provavelmente deve<a href="https://softwareengineering.stackexchange.com/a/150781/172464"> estar violando</a> o <em>Single Responsibility Principle</em> (SRP).</li><li><strong><em>Mock </em>é mais fácil e confiável</strong>: <a href="http://olivergierke.de/2013/11/why-field-injection-is-evil/">comparado ao injeção por campo</a>, é mais fácil <em>mockar </em>as dependências em um teste unitário, porque você não precisa de nenhum contexto de <em>mock </em>ou uso de <em>reflection </em>para acessar a dependência dentro da classe. Também <a href="https://tedvinke.wordpress.com/2014/02/13/mockito-why-you-should-not-use-injectmocks-annotation-to-autowire-fields/">não será enganado</a> por estas técnicas. Você apenas instancia a classe e passa as dependências no construtor: simples e fácil de entender.</li><li><strong>Ferramentas de análise de código vão te ajudar mais</strong>: Ferramentas de análise de código, como o Sonar, podem te avisar sobre uma classe que está ficando muito complexa, porque uma classe com muitos parâmetros no construtor é provavelmente uma classe que precisa de refatoração e, por consequência, as ferramentas de análise de código vão avisar sobre este problema. Estas mesmas ferramentas não conseguem identificar situação similar usando injeção por campo ou método. Aliás, falando em Sonar, ele próprio <a href="https://rules.sonarsource.com/java/RSPEC-3306">considera como bug</a> o uso de injeção por campo ao invés do uso <a href="https://rules.sonarsource.com/java/RSPEC-4288">por construtor</a>.</li><li><strong>Código independente</strong>: com menos anotações de injeção no seu código, ele fica menos dependente do framework de injeção. Eu sei que a possibilidade de mudar o framework de injeção é bem remota em um projeto, mas muitas vezes é melhor manter o seu código o mais agnóstico possível, algo que aprendi da <a href="http://blog.ploeh.dk/2010/02/03/ServiceLocatorisanAnti-Pattern/">maneira mais difícil</a> com EJB e usando <em>lookup </em>de serviços.</li><li><strong>As dependências podem ser imutáveis</strong>: a imutabilidade é uma <a href="https://stackoverflow.com/a/34385684/2387977">qualidade bem-vinda</a>.</li><li><strong>Pode prevenir dependência circular</strong>: se estiver <a href="https://docs.spring.io/spring/docs/3.1.x/spring-framework-reference/html/beans.html#d0e2778">usando Spring</a>, ele é capaz de detectar dependência circular entre classes usando injeção por construtor.</li></ul><p>Para finalizar, a equipe do Spring <a href="http://spring.io/blog/2007/07/11/setter-injection-versus-constructor-injection-and-the-use-of-required">recomenda</a> também o uso de injeções por construtor:</p><blockquote>I think constructor injection is much more usable for application code than it is for framework code. In application code, you inherently have a lesser need for optional values that you need to configure</blockquote><h3>Pensamentos finais</h3><p>Se você ainda não está seguro em usar apenas a injeção por construtor, talvez a ideia de usar a injeção por método com a de construtor <a href="https://docs.spring.io/spring/docs/3.1.x/spring-framework-reference/html/beans.html#d0e2778">possa ser útil</a>:</p><blockquote>Since you can mix both, Constructor- and Setter-based DI, it is a good rule of thumb to use constructor arguments for mandatory dependencies and setters for optional dependencies</blockquote><p>Mas lembre-se que a injeção por campo é, provavelmente, a única opção que <a href="http://vojtechruzicka.com/field-dependency-injection-considered-harmful/">deve ser evitada</a> dentre as três.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8cd442884adc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Boas práticas: o porquê de fazer um teste unitário para cada bug encontrado]]></title>
            <link>https://dherik.medium.com/boas-pr%C3%A1ticas-o-porqu%C3%AA-de-fazer-um-teste-unit%C3%A1rio-para-cada-bug-encontrado-c5385fa708ed?source=rss-7ba52e01c279------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5385fa708ed</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[desenvolvedor]]></category>
            <category><![CDATA[testes-de-software]]></category>
            <dc:creator><![CDATA[Dherik Barison]]></dc:creator>
            <pubDate>Thu, 02 Aug 2018 19:47:17 GMT</pubDate>
            <atom:updated>2018-10-17T18:52:43.055Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iavfzeXW_b8kWXr5dwVgCg.jpeg" /><figcaption><a href="https://www.flickr.com/photos/132527206@N05/17397919896/">“Programming”</a> by <a href="https://www.flickr.com/people/132527206@N05/"><em>Fredrik Walløe</em></a></figcaption></figure><p>Uma boa prática conhecida (mas nem sempre aplicada) dentro do desenvolvimento de software é a de fazer testes unitários para cada bug encontrado no sistema.</p><p>O processo funciona mais ou menos assim:</p><ol><li>Identificar onde o bug ocorre;</li><li>Fazer um teste para reproduzir o bug;</li><li>Fazer a correção do bug;</li><li>Verificar se o teste passa após a correção do bug.</li></ol><p>Contudo, há vários questionamentos com relação a esta atividade:</p><ul><li>Não é um exagero fazer isto para cada bug?</li><li>E se o cenário para reproduzir o bug for difícil?</li><li>E se o erro for oriundo de uma consulta ao banco de dados?</li></ul><p>Entre outras perguntas.</p><p>Acredito que fazer um teste unitário para cada bug encontrado não é um dever ou obrigação, mas algo que os desenvolvedores <strong>deveriam considerar </strong>como uma boa prática para melhorar a qualidade das entregas.</p><p>Para saber <strong>quando</strong> fazer, é preciso entender o cenário do bug. E quando digo cenário, não falo apenas do código envolvido, mas também do estado atual do seu projeto. Vamos lá então.</p><p>Se a reprodução via teste unitário é <strong>simples </strong>de ser feita, não vejo desculpas para não o fazer: você reproduz o problema no teste, realiza a correção e garante que o mesmo bug não voltará. São muitas vantagens para ignorar :).</p><p>Já se a reprodução for mais <strong>complexa</strong>, temos que verificar qual a severidade do bug, a complexidade de fazer e manter o teste, da probabilidade dele ocorrer novamente e confrontar a criação deste teste com as outras <em>deadlines </em>do seu projeto. Não raro temos bugs no código que são simples de resolver, mas muito complicados de se reproduzir em um teste. Perder um tempo considerável fazendo um teste, sendo que o projeto tem outros problemas pedindo sua atenção, pode ser uma má escolha.</p><p>Bugs envolvendo <strong>regras de negócio</strong> merecem um capítulo à parte. Como eles fazem parte do <em>core </em>do seu projeto e são mais propensos <a href="https://softwareengineering.stackexchange.com/a/244709/172464">a quebrar</a> no futuro, eles são quase sempre fortes candidatos a receberem um teste.</p><p>O teste para reprodução do problema também pode envolver a criação de testes de integração¹, podendo cobrir problemas em consultas ao banco de dados, garantir que a injeção de dependências das suas classes está correta, se a sua API está aceitando o contrato correto, etc.</p><p>Em geral, na maior parte das vezes é viável criar um teste para cada bug encontrado. Portanto, avalie a situação e pense com carinho em criar um teste para o próximo bug do seu projeto.</p><p>¹. Como este termo pode ter diferentes entendimentos, estou adotando o conceito de <em>narrow integration tests d</em>o <a href="https://martinfowler.com/bliki/IntegrationTest.html">Martin Fowler</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5385fa708ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>