<?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 Jeremias Pereira dos Reis on Medium]]></title>
        <description><![CDATA[Stories by Jeremias Pereira dos Reis on Medium]]></description>
        <link>https://medium.com/@jeremias.pereiraa?source=rss-d048f6a8c88e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Jeremias Pereira dos Reis on Medium</title>
            <link>https://medium.com/@jeremias.pereiraa?source=rss-d048f6a8c88e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 00:54:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jeremias.pereiraa/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[Débito Técnico]]></title>
            <link>https://medium.com/dev-cave/d%C3%A9bito-t%C3%A9cnico-22397ef1f472?source=rss-d048f6a8c88e------2</link>
            <guid isPermaLink="false">https://medium.com/p/22397ef1f472</guid>
            <dc:creator><![CDATA[Jeremias Pereira dos Reis]]></dc:creator>
            <pubDate>Sun, 19 Mar 2017 23:58:33 GMT</pubDate>
            <atom:updated>2017-10-25T12:31:35.231Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você já trabalhou em algum projeto ágil, com certeza você sabe muito bem sobre o que este post irá tratar, porém, se você ainda não tem muito conhecimento em processos (ágil principalmente), <a href="http://devcave.com.br/processo-processo-processo/">comece por aqui</a>.</p><p>Vamos falar de uma coisa bastante polêmica; odiado por uns, defendido por outros e está bastante relacionado com projetos ágeis, o porquê de tudo isso? Veremos.</p><p>Veremos, como é fazer uma dívida com o nosso próprio código, isso é bom ou ruim e onde se aplica?</p><h4>O que é</h4><p>A definição de débito técnico segundo <a href="https://www.techopedia.com/definition/27913/technical-debt">techopedia</a> (tradução literal): é um conceito em programação que reflete a necessidade de um esforço extra no desenvolvimento que aparece quando implementa-se um código fácil e rápido ao invés da melhor solução conhecida.</p><p>Entre outras inúmeras tentativas de definições que encontramos por aí, todas levam ao mesmo raciocínio, é uma metáfora com um empréstimo financeiro, você precisa de algo fácil e rápido, hoje, você empresta mas amanhã terá que pagar e com certeza terá juros. <a href="http://wiki.c2.com/?WardExplainsDebtMetaphor">Veja uma breve explicação do surgimento disso com as palavras de seu próprio idealizador</a>.</p><p>Contextualizando, você está desenvolvendo um software e entregando suas funcionalidades gradualmente ao cliente conforme a demanda, seu cliente pede uma funcionalidade para ser entregue em três dias ou todo o restante do projeto será comprometido e você pode acabar perdendo-o, mas segundo sua estimativa de desenvolvedor [o correto] levaria uma semana. Porém, se você criar uma solução mais enxuta, deixar alguns “gaps” de segurança e performance passarem, minimizar ao máximo a complexidade de desenvolvimento (e por consequência maximizar a de manutenção) você consegue entregar em três dias. E então, você prefere falar para o seu cliente que não tem como entregar o que ele está pedindo em três dias e correr o risco de talvez até perder o projeto ou entregar a funcionalidade pendente de futuras melhorias e assumir o risco dos efeitos colaterais no futuro como problemas de performance, segurança, dificuldade de manutenção etc?</p><p>É uma escolha bem difícil, e foi devido a recorrência constante deste cenário nos projetos ágeis que se começou a discutir o conceito de débito técnico nas <a href="https://www.agilealliance.org/introduction-to-the-technical-debt-concept/">comunidades de princípios e práticas de desenvolvimento Ágil</a>.</p><p>Voltando a discutir a resposta correta para a questão acima, a primeira opção não é uma escolha muito inteligente, entre outras consequências, dependendo do contexto, você poderá estar infringindo já o <a href="https://www.agilealliance.org/agile101/12-principles-behind-the-agile-manifesto/">primeiro princípio do manifesto ágil</a>. Então, podemos dizer que a segunda opção (e única restante) é a “menos pior”, digo isso pois a opção ideal é entregar a solução da melhor maneira, dentro do prazo e sem dependências posteriores, não é porque débito técnico está <a href="https://www.agilealliance.org/project-management-and-technical-debt/">definido no agile alliance</a> e é discutido (até um pouco defendido) por <a href="https://martinfowler.com/bliki/TechnicalDebt.html">grandes nomes do desenvolvimento de software</a> que ele seja uma boa prática e que devemos aplicar sempre que possível. Mas não sejamos utópicos, emergências existem, imprevistos também e temos que saber lidar com eles, às vezes a felicidade e a razão são alternativas diferentes na vida não é mesmo?</p><h4>O que NÃO é</h4><blockquote><em>A Mess is not a Technical Debt.</em></blockquote><blockquote>Uncle Bob</blockquote><p>Vale lembrar também que <a href="https://sites.google.com/site/unclebobconsultingllc/a-mess-is-not-a-technical-debt">código mal escrito não é um débito técnico</a>, ou seja, má decisões tomadas espontaneamente, código sem boas práticas mesmo com prazo disponível etc. Considere débito técnico, implementações simplistas por falta de prazo e não por falta de conhecimento ou habilidade técnica.</p><p>Algumas pessoas definem débito técnico como um preço que você paga por más decisões no seu código, não gosto dessa definição, pois ela deixa o termo muito vago e induz o desenvolvedor a entender qualquer “gambiarra” é um débito técnico, NÃO, débito técnico é aquilo que devidamente alinhado com o cliente foi desenvolvido de maneira mais simples/enxuta do que o correto devido interferências externas ou qualquer outro empecilho cujo a área de negócios não poderia esperar por tal desimpedimento.</p><h4>Quer dizer que pode dar certo?</h4><p>O alinhamento com o cliente é fundamental, o desenvolvedor poderá sugerir a criação de um débito técnico para uma entrega mais rápida, porém a decisão final deverá ser do cliente, afinal ele é quem sofrerá a consequência do prazo, uma hora ou outra, o tempo total estimado para desenvolver a funcionalidade deverá ser gasto, criando um débito técnico, esse tempo será apenas postergado. Se o cliente não está alinhado ou não está ciente do que é de fato um débito técnico, com certeza ele não irá entender quando a equipe de desenvolvimento pedir um prazo para trabalhar nos débitos técnicos, já que a maioria dos débitos técnicos não possuem valor de negócio palpável para ele.</p><p>Já parou para pensar sobre o acúmulo de débitos técnicos? Um projeto em que está com sérios problemas de prazo e o cliente nunca libera os desenvolvedores para resolverem os débitos técnicos pendentes, e a cada ciclo de desenvolvimento surgem novos débitos técnicos etc.</p><p>Se você conseguiu imaginar o cenário acima, muito provavelmente já passou por ele, infelizmente, esse cenário não é nenhuma novidade nos projetos ágeis atualmente, ainda existem muitos problemas que ainda não foram solucionados e muitas soluções que ainda não foram <strong>devidamente</strong> disseminadas no mercado, débito técnico é uma delas por exemplo, em muitos dos casos, ainda falta <a href="http://www.disciplinedagiledelivery.com/technical-debt/">disciplina na sua utilização</a>.</p><h4>Qual a sua opinião?</h4><p>Meu ponto de vista sobre débito técnico é, mesmo pesquisando bastante sobre o que é para escrever esse post, mesmo defendendo a utilização em alguns momentos, mesmo utilizando no meu dia a dia profissional, não sou a favor, acho que a sua utilização induz cada vez mais utilizá-lo e cada vez mais ser mais liberal quanto a critérios de definição, chegando ao ponto de considerar qualquer possível melhoria como débito técnico e inclusive a criação de débitos técnicos sem o alinhamento com o cliente, ou seja, de pouco em pouco, caminhamos para o cenário citado acima.</p><p>E você, já parou para refletir sua posição a respeito disso? Já sofreu com isso? Já utilizou? Já conseguiu utilizar com responsabilidade? Utilize os comentários, vamos debater !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22397ef1f472" width="1" height="1" alt=""><hr><p><a href="https://medium.com/dev-cave/d%C3%A9bito-t%C3%A9cnico-22397ef1f472">Débito Técnico</a> was originally published in <a href="https://medium.com/dev-cave">Dev Cave</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Por trás da programação funcional do JAVA 8]]></title>
            <link>https://medium.com/dev-cave/por-tr%C3%A1s-da-programa%C3%A7%C3%A3o-funcional-do-java-8-bd8c0f172d45?source=rss-d048f6a8c88e------2</link>
            <guid isPermaLink="false">https://medium.com/p/bd8c0f172d45</guid>
            <dc:creator><![CDATA[Jeremias Pereira dos Reis]]></dc:creator>
            <pubDate>Thu, 02 Feb 2017 17:49:40 GMT</pubDate>
            <atom:updated>2017-10-25T12:31:33.296Z</atom:updated>
            <content:encoded><![CDATA[<p>Ultimamente, o termo programação funcional tem sido bastante usado e discutido na maioria das comunidades de desenvolvedores. Basta uma simples <a href="https://www.google.com.br/webhp?sourceid=chrome-instant&amp;ion=1&amp;espv=2&amp;ie=UTF-8#q=programa%C3%A7%C3%A3o+funcional">pesquisa no Google</a> que veremos inúmeros resultados, diversos posts onde tentam explicar a origem, o que consiste, benefícios etc. Por esse motivo não vamos abordar a parte conceitual de programação funcional nem como programar funcional com java, vamos direto ao ponto, como o java 8 se comporta com programação funcional e se podemos considerá-lo uma linguagem funcional, o objetivo deste post é analisar se o java 8 de fato é funcional ou se ele ainda será.</p><p>Sim, em pleno 2017 eu ainda falando de java 8 (culpa da Oracle que não lança logo o 9 para testarmos e escrevermos posts novos). Então, se você programa em java 8 há algum tempo, já foi até a quinta página de resultados do Google pesquisando sobre java 8 e como funciona a a programação funcional nele, provavelmente esse post será mais do mesmo para você, caso use java 8 e seu conhecimento teórico e conceitual ainda seja fraco (e deseja melhorar), continue lendo, é para você mesmo que estou escrevendo.</p><p>Não precisa ser um super fã de java para saber que nesta última atualização, tivemos algumas novidades um tanto que curiosas, a principal delas; o lambda (também conhecido como função de “setinhas”), muita gente comemorou a sua chegada um pouco tardia, já que não era nenhuma novidade em outras linguagens do mesmo propósito, inclusive o .NET (seu maior rival). Vamos falar a maior parte do post sobre lambdas, vamos ver alguns pontos interessantes, o porque demorou tanto para chegar ao java e como conseguiram implementar essa nova funcionalidade.</p><h3>Lambda</h3><p>Na maioria das linguagens de paradigma não-funcional que implementam lambda, ele é basicamente definido pela capacidade de declarar funções anônimas. Se formos um pouco <a href="https://pt.wikipedia.org/wiki/C%C3%A1lculo_lambda">mais a fundo sobre cálculo lambda</a>, o conceito de uma função não precisar ser nomeada explicitamente é apenas a ponta do iceberg, e se pesquisarmos um pouco mais sobre <a href="http://blog.caelum.com.br/comecando-com-o-calculo-lambda-e-a-programacao-funcional-de-verdade/">cálculo lambda no âmbito computacional</a>, veremos que programar utilizando o paradigma funcional e lambdas é muito mais que usar as famosas “setinhas” para declarar uma função.</p><p>Um caso muito comum na utilização de lambdas (ou funções anôminas) é a ordenação de uma lista (se você já utiliza java 8 e ainda implementa anônimamente a interface Comparator para ordenar uma lista, por favor, pare tudo e repense sua vida). Como ordenávamos uma lista no java 7:</p><pre>Collections.sort(cars, new Comparator&lt;Car&gt;() {<br>    @Override<br>    public int compare(Car car1, Car car2) {<br>        return car1.getId() - car2.getId();<br>    }<br>});</pre><p>Normal, o método sort da classe Collections recebe como parâmetro uma lista (List) e um comparador (Comparator), como o comparador é para um único propósito e utilização, ou seja, muito provável que não iremos utilizar ele em outra parte do código, para não criarmos um novo arquivo apenas para uma classe que implemente a interface Comparator que iremos utilizar apenas uma única vez, criamos a implementação desta interface em tempo de execução, criamos uma instância da nova classe e passamos a referência desse objeto como parâmetro, as famosas classes anônimas. Agora, vejamos como podemos ordenar a mesma lista no java 8:</p><pre>Collections.sort(cars, (car1, car2) -&gt; car1.getId() - car2.getId());</pre><p>O fato de reduzirmos de 6 para 1 linha de implementação e ainda melhorar a legibilidade do código sem impacto nenhum na performance, já são argumentos suficentes para utilizarmos lambda no lugar de classes anônimas (quando possível) e sem questionamentos. A situação é a mesma do primeiro exemplo, muito provável que só iremos utilizar essa implementação nesta parte do código, então implementamos a comparação dos elementos dessa lista em tempo de execução.</p><p>Se analisarmos a documentação da classe Collections no <a href="https://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#sort(java.util.List,%20java.util.Comparator)">java 7</a> e no <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#sort-java.util.List-java.util.Comparator-">java 8</a>, nada mudou, a assinatura do método sort, continua a mesma coisa, recebendo uma lista e um comparador, porém, até quem não conhece nada de lambda, consegue perceber no exemplo acima que o segundo parâmetro não tem como ser um objeto, conseguimos facilmente identificar uma operação de comparação, ou seja, ainda estamos implementando um método que compara dois objetos do tipo carro, porém, agora estamos apenas declarando uma função, a famosa função anônima do java 8 (ou lambda), e não mais uma classe anônima. O segredo está na interface <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html">Comparator</a>, que ganhou a anotação <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/FunctionalInterface.html">@FunctionalInterface</a>. Podemos perceber que não é em todos os lugares que conseguimos utilizar lambdas, o java permite apenas em implementações de interfaces funcionais, na verdade, não precisa necessáriamente estar anotada com @FunctionalInterface, basta ser uma interface e possuir apenas um método que o compilador irá entender. Então vamos entender o que o java faz para compilar um lambda.</p><p>OBS: O intellij já está reportando <em>warnings</em> quando você implementa uma interface funcional através de classe anônima.</p><h3>Compilação de lambdas</h3><p>Com certeza, a pergunta que não quer calar é, como que uma linguagem imperativa e orientada a objetos, fortemente tipada, ou melhor, como que uma linguagem cuja classe é sua entidade real onde todo código deve existir sob o domínio de uma classe, todo código deve ser referenciado através de uma classe, nos permite de uma hora para outra, referenciar uma função anônima e ainda com tipagem de parâmetros opcional? Primeiramente, sim, realmente tudo indica que estamos referenciando uma função função anônima, e que essa função não pertence a uma classe, mas não é bem assim que o compilador faz para a JVM entender esse código.</p><p>O fato do uso de lambdas estar restrito apenas com interfaces funcionais não é coincidência, como uma interface funcional possui apenas um método, já da pra perceber o que o compilador faz por baixo dos panos né. Mas ainda não é tão simples assim.</p><p>Quando o compilador encontra uma expressão lambda no código, a primeira coisa que ele faz é, utilizando <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/LambdaMetafactory.html">LambdaMetafactory</a> extrair a lambda para uma função tipada e encontrar sua devida interface funcional na qual o método irá implementar, a tipagem dos parâmetros e a interface funcional correta é obtida lexicalmente, após isso, graças a <a href="https://www.infoq.com/articles/invokedynamic">JSR 292</a> implementada no java 7, a JVM consegue fazer toda a mágica para chamar o método dinamicamente através do <a href="https://www.infoq.com/articles/Invokedynamic-Javas-secret-weapon?utm_source=infoq&amp;utm_campaign=user_page&amp;utm_medium=link"><em>invokedynamic</em></a>. Uma explicação muito bem detalhada sobre como o compilador converte expressões lambda pode ser <a href="http://cr.openjdk.java.net/~briangoetz/lambda/lambda-translation.html">encontrada aqui</a>.</p><p>A mesma coisa acontece quando referenciamos um método:</p><pre>cars.stream().sorted(Comparator.comparingInt(Car::getId));</pre><p>O compilador irá utilizar a classe LambdaMetafactory para referenciar o método que será conhecido e chamado pela JVM em tempo de execução.</p><h3>Afinal, é funcional ou não?</h3><p>Sim, e não, se olharmos como desenvolvedores, quando utilizamos lambda estamos referenciando uma função, por mais que no final o compilador transforme tudo isso, coloque dentro de uma classe e tudo volta como era antes, para quem está desenvolvendo, lambda é a referência de uma função anônima, a operação acima, é a passagem de um método como parâmetro. Porém não podemos afirmar com todas as forças do universo que o java 8 é uma linguagem com paradigma funcional, ainda não podemos assinar funções a uma variável, ainda não temos total controle sobre estado de objetos etc.</p><p>Agora se formos binários, não, java não é uma linguagem de paradigma funcional e se a intenção for se tornar funcional um dia, o que não é verdade, está muito longe disso. Há mais de 15 anos o java vem conseguindo combinar muito bem o paradigma de orientação a objetos com alguns outros, e com o funcional não será diferente. Ser funcional é muito mais do que permitir uma pequena abstração de lambda, talvez, muitos recursos de imperatividade e até mesmo de orientação a objetos deveriam ser sacrificados.</p><p>O lambda veio para o java por suas qualidades (que não são poucas), a facilidade e praticidade de utlizar sem impacto em performance, a legibilidade que deixa no código, a economia de linhas por função (que não é pouco) etc, o mesmo acontece com streams e referência de métodos. Ou seja, o java apenas implementou o que a programação funcional possui de melhor, com adaptações, restrições, porém mantendo seu legado.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bd8c0f172d45" width="1" height="1" alt=""><hr><p><a href="https://medium.com/dev-cave/por-tr%C3%A1s-da-programa%C3%A7%C3%A3o-funcional-do-java-8-bd8c0f172d45">Por trás da programação funcional do JAVA 8</a> was originally published in <a href="https://medium.com/dev-cave">Dev Cave</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Arquitetura Hexagonal]]></title>
            <link>https://medium.com/dev-cave/arquitetura-hexagonal-4668a8ffac57?source=rss-d048f6a8c88e------2</link>
            <guid isPermaLink="false">https://medium.com/p/4668a8ffac57</guid>
            <dc:creator><![CDATA[Jeremias Pereira dos Reis]]></dc:creator>
            <pubDate>Thu, 26 Jan 2017 02:11:08 GMT</pubDate>
            <atom:updated>2017-10-25T12:31:32.303Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Olá</strong></p><p>Muito prazer, sou o Jeremias, e assim como todos os escritores do blog, as vezes escrevo algumas coisas legais sobre algumas coisas legais de TI, esse é o meu primeiro (de muitos) post por aqui e espero que gostem do conteúdo, afinal, já ouviram falar sobre <strong>Arquitetura Hexagonal?</strong> Eu também não, até ter que fazer um trabalho na pós sobre o assunto, e por incrível que pareça, me interessei a ponto de escrever sobre.</p><p>Arquitetura hexagonal, consiste em dividir uma aplicação em camadas de acordo com suas responsabilidades e enfatizar uma camada em especial, onde ficará a lógica principal da aplicação, a camada de domínio ou <em>domain</em> (do termo original)<em>.</em></p><blockquote>Quando falamos em divisão de aplicação em camadas, o céu é o limite, porém cautela e caldo de galinha não fazem mal a ninguém.</blockquote><p>A divisão de uma aplicação em camadas pode ser feita de diferentes formas, vai depender da necessidade e realidade de cada aplicação. Podemos, por exemplo, dividir as camadas apenas a nível organizacional de código, utilizando pacotes ou outro meio de organizar arquivos e códigos, podemos dividir a aplicação em módulos fazendo com que cada módulo represente uma camada, que por sua vez, esses módulos podem estar em apenas um artefato ou podemos dividi-los utilizando artefatos diferentes e até mesmo colocar em servidores diferentes, podemos ir mais além, transformando esse módulos em aplicações independentes e definindo um protocolo de comunicação entre eles, assim, cada camada será uma aplicação diferente em servidores diferentes se comunicando por protocolos distintos, etc.</p><p>Quando falamos em divisão de aplicação em camadas, o céu é o limite. Alguns exemplos citados acima, foram apenas para ilustrar a diversidade que temos, mas na hora de decidir como dividir, quantas camadas teremos, qual o tamanho ou quantas responsabilidades terá cada camada temos que olhar para a situação atual do sistema e considerar alguns fatores relevantes para essa decisão, tais como tamanho da aplicação, infraestrutura de servidores, tamanho da equipe técnica, frequência de entregas em produção (caso desenvolvida em agile), frequência de manutenção, performance, etc; essas são algumas particularidades que irão nos dizer como e até quanto iremos dividir a aplicação. Cuidado, não é por que dividir uma aplicação possui bastante vantagens, que todas as aplicações são possíveis ou poderão ser dividas, ou que vamos dividir nossa aplicação o máximo o possível, use com moderação, afinal, cautela e caldo de galinha não fazem mal a ninguém.</p><h4>Entendendo a arquitetura hexagonal</h4><p>Como vimos anteriormente, arquitetura hexagonal consiste em dividir a aplicação em camadas, porém mais do que isso, o que essa arquitetura exige, é que toda a lógica da aplicação fique apenas em um único lugar encapsulado e bem “longe” do usuário, quando dizemos longe, nos referimos no sentido de inacessível. Então para considerarmos uma aplicação hexagonal, ela deverá ser divida em camadas, não importa quantas, nem como, desde que satisfaça as condições: exista a camada de domínio, esta deve ser encapsulada do usuário pela camada de aplicação, esta por sua vez irá acessar e expor os dados de maneira específica e padronizada, como veremos a diante.</p><p>A camada de domínio é a principal camada da aplicação e nela colocamos o que consideramos mais importante da aplicação, ou seja, aquilo que de fato é exclusivo e agrega valor para a aplicação, a lógica. Se olharmos uma representação gráfica da arquitetura hexagonal, percebemos que independente de quantas camadas tivermos, a camada de domínio sempre ficará no centro, encapsulada pelas demais.</p><p>Arquitetura hexagonal também é conhecida como <em>ports and adapters architecture.</em> Não existe muito material em português sobre o assunto e para não ficar usanto termos em inglês no artigo, resolvi chamar <em>ports</em> de interfaces e <em>adapters</em> de serviços, arquitetura baseada em interfaces e serviços, eu também odeio traduções de “coisas” que não possuem ou não fazem sentido traduções, mas enfim, lembre-se que estes termos são para o contexto deste artigo em português apenas. E também não sou o único que tento encontrar sinônimos ou traduções, alguns blogs chamam <em>adpters</em> de <em>application</em>, <em>implementation</em> até mesmo de <em>infrastructure</em>.</p><p>A camada de domínio deverá expor suas informações de alguma forma, como ela deve ser encapsulada do usuário final, teremos uma camada responsável para tal exposição, que será a camada de serviços, ela será acessada pelo usuário requisitando informções, e terá a responsabilidade fazer o intermédio para a camada de domínio.</p><p>O usuário irá acessar a camada de serviço de alguma forma, utilizando algum protocolo de comunicação etc, essa camada deverá ser implementada de maneira que o usuário ou qualquer outro sistema externo a acesse. A camada de domínio também por sua vez, deverá expor seus dados para a camada de serviço, essa exposição por parte da camada de domínio será mais simples, ela será através das interfaces. Basicamente, interfaces para comunicação interna e serviços para comunicação externa.</p><p>Isolando toda a lógica da aplicação em uma camada e disponibilizando uma interface para acesso desta, a camada de domínio estará altamente coesa e fracamente acoplada. Sua responsabilidade será apenas guardar a lógica e disponibilizar interfaces para exposição dos resultados, quem se preocupará em como essa informação será enviada para o usuário será a camada seguinte (serviços), e o usuário por sua vez, não saberá como a informação foi obtida nem de onde veio, pois acessou através de um serviço.</p><p>Apenas por curiosidade, o nome hexagonal não possui nenhuma relação com o número 6 nem mesmo com o hexágono, a relação está com a figura geométrica, o polígono, ou seja, poderia ser também representada por um pentágono ou heptágono, pois a ideia é representar algo que possui diversos lados, que são as diferentes implementações e tecnologias que uma aplicação pode utilizar para expor seus resultados, podemos dizer que os lados representam a camada de serviço e suas implementações.</p><h4>Interface (<em>Port)</em></h4><p>Interface é o meio pelo qual a lógica da camada de domínio é acessada, uma interface é caracterizada por ser simples, única, objetiva. É responsabilidade da camada disponibilizar interfaces para acesso a suas informações. A interface de uma camada será acessada pela sua camada seguinte. Interface nunca irá se preocupar com a formatação de resposta para o usuário, nem mesmo com a relevância dos dados para o mesmo, ela irá expor exatamente o que a lógica da camada de domínio retornar.</p><p>A interface da camada de domínio também nunca será disponibilizada diretamente para um usuário, até porque isso lesionaria gravemente o encapsulamento, que é uma das técnicas defendidas e aplicadas nesta arquitetura. Interface será apenas um intermédio entre a camada de domínio e a camada seguinte, esta provavelmente estará servindo um usuário ou alguma outra aplicação externa.</p><h4>Serviço (<em>Adapter</em>)</h4><p>Serviço é uma camada seguinte da camada de domínio, que através das interfaces irá acessá-la e alimentar os sistemas externos que requisitam tal informação. O serviço nada mais é que o intermédio entre a camada de domínio e o requisitante da informação, que pode ser um usuário final ou aplicações externas. É responsabilidade do serviço se preocupar com a implementação do protocolo de comunicação que usuário irá utilizar, com a formatação da resposta, o controle de acesso etc. Na visão do usuário, o serviço é a interface para a lógica da aplicação.</p><p>O objetivo da arquitetura hexagonal é encapsular a lógica, de maneira que nada externo acesse-a diretamente, então, o meio de um usuário acessar uma informação gerada pela camada de domínio é através de um serviço. Ou seja, externamente, conheceremos apenas a camada de serviço, o objetivo e não expor publicamente nenhuma informação sequer diretamente da camada de domínio.</p><h4>Benefícios</h4><p>Quando falamos de arquitetura hexagonal as vezes lembramos um pouco de DDD, preocupação com o domínio da aplicação, encapsulamento e segurança do domínio etc, são coisas em comum entre eles. Isso nos faz refletir um pouco mais sobre a importância da lógica de uma aplicação para o negócio. Muitos projetos de desenvolvimento de software as vezes pensam muito nos dados, como serão armazenados, segurança, backup etc, e acabam esquecendo da lógica da aplicação, dos serviços. Muitas vezes, por uma falha ou falta de atenção na lógica, os dados acabam ficando vulneráveis ou sendo violados.</p><p>Perceba que quando implementamos uma arquitetura hexagonal, a lógica da nossa aplicação fica totalmente independente de qualquer coisa, a grande vantagem já começa aí, nos testes. Para testarmos a camada de domínio, ou seja, a lógica da aplicação, não teremos dependência com nada, podemos fazer testes isolados e sem nenhuma interferência de outra camada.</p><p>Com tantas variedades e evoluções que temos a cada dia, ontem usávamos SOAP, hoje usamos REST, amanhã iremos migrar para algo melhor, mais prático ou simplesmente mais novo. Se necessário mudar o protocolo, tecnologia ou simplesmente o formato de comunicação externa, a primeira coisa que pensamos é o quanto isso irá impactar na lógica, correto? E a resposta para essa pergunta quando se usa uma arquitetura hexagonal é NENHUMA. Se necessário mudar ou implementar um algo que seja relacionado a “área externa” da aplicação; tudo isso será na camada de serviço.</p><p>Se o servidor não estiver aguentando a carga de acessos, ou a tecnologia usada não for mais adequada, podemos fazer uma melhoria apenas na camada de serviço, colocar em uma nova infraestrutura, migrar de tecnologia, etc; a lógica permanecerá intacta e segura.</p><p>Desde os testes até a mantenabilidade, quanto temos uma aplicação corretamente divida, coesa e minimamente acoplada, tudo se torna menos doloroso, principalmente quando se fala de lógica e regra de negócio.</p><h4>Quando utilizar</h4><p>Qualquer aplicação pode ser arquitetada como hexagonal, porém devemos nos atentar se nossa aplicação está realmente precisando, se é factível tal migração ou implementação, nem sempre a melhor solução seja a adequada para determinados cenários. Arquitetura hexagonal traz bastante benefícios, em aplicações grandes com a divisão em camadas, em aplicações muito complexas com o encapsulamento da lógica, em aplicações com muita integração com a utilização de interfaces e serviços, tudo isso garante um aumento considerável na facilidade de manutenção e escalabilidade.</p><p>Geralmente aplicações que possuem muitos sistemas consumidores são de difícil manutenção, quando necessário, o impacto externo também acaba sendo grande se os serviços não forem desacoplados da lógica.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4668a8ffac57" width="1" height="1" alt=""><hr><p><a href="https://medium.com/dev-cave/arquitetura-hexagonal-4668a8ffac57">Arquitetura Hexagonal</a> was originally published in <a href="https://medium.com/dev-cave">Dev Cave</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>