<?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 Danilo Dantas on Medium]]></title>
        <description><![CDATA[Stories by Danilo Dantas on Medium]]></description>
        <link>https://medium.com/@dannevesdantas?source=rss-c7861d094d51------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*09ANwznR4SMj3Y-l0W009Q.jpeg</url>
            <title>Stories by Danilo Dantas on Medium</title>
            <link>https://medium.com/@dannevesdantas?source=rss-c7861d094d51------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 15:34:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dannevesdantas/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[DDD vs. Arquitetura em Camadas vs. Arquitetura Hexagonal vs. Clean Architecture]]></title>
            <link>https://medium.com/@dannevesdantas/ddd-arquitetura-em-camadas-n-layer-e-n-tier-hexagonal-e-ports-and-adapters-onion-e-clean-28cd7f910b3d?source=rss-c7861d094d51------2</link>
            <guid isPermaLink="false">https://medium.com/p/28cd7f910b3d</guid>
            <category><![CDATA[ddd]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <category><![CDATA[ports-and-adapters]]></category>
            <dc:creator><![CDATA[Danilo Dantas]]></dc:creator>
            <pubDate>Thu, 07 Dec 2023 15:24:42 GMT</pubDate>
            <atom:updated>2024-09-11T12:56:36.504Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Architectural Patterns: DDD vs. Arquitetura em Camadas vs. Clean Architecture e Arquitetura Hexagonal. Elas NÃO são a mesma coisa!" src="https://cdn-images-1.medium.com/max/1024/1*70XU-elZnocZVbSFh93CUg.jpeg" /></figure><h3>DDD, Arquitetura em camadas N-layer e N-Tier, Arquitetura Hexagonal e Ports and Adapters, Onion e Clean Architecture, Screaming Architecture, Vertical Slice Architecture. Qual é a diferença? (elas não são a mesma coisa)</h3><p>Como Software Engineer você já deve ter ouvido falar muito nesses termos. Afinal de contas, do que se trata cada uma dessas “arquiteturas”, qual é a diferença entre elas? Vamos abordar cada uma delas de forma clara, didática, com palavras bem simples e objetivas. <em>*Todas as fontes estão listadas no final do artigo.</em></p><p><em>*escrito por humano não por IA — Join the </em><a href="https://notbyai.fyi/"><em>Not By AI</em></a><em> Movement Today</em></p><blockquote>“Se você não consegue explicar algo de forma simples, você não entendeu suficientemente bem.” — Albert Einstein</blockquote><h3><strong>DDD — Domain-Driven Design (2003)</strong></h3><p>O Domain-Driven Design é muito frequentemente confundido e citado de forma equivocada, inclusive por arquitetos de software, tech leads e tech managers, para se referir as 3 ou 4 (ou N) camadas de uma aplicação, tais como: User Interface, Application, Domain e Infrastructure.</p><blockquote><em>❌</em>“DDD <strong>não é arquitetura em camadas</strong>”. “Evite utilizar o termo DDD acompanhado de questões que não envolvem diretamente os conceitos do DDD, pois pode dar a entender que você não compreendeu sobre do que se trata o assunto.” — Eduardo Pires, Microsoft MPV em <a href="https://www.eduardopires.net.br/2016/08/ddd-nao-e-arquitetura-em-camadas/">https://www.eduardopires.net.br/2016/08/ddd-nao-e-arquitetura-em-camadas/</a> e também no <a href="https://www.linkedin.com/posts/desenvolvedor-io_desenvolvedorio-dica-ddd-ugcPost-7239589399179493376-RJ_d/">LinkedIn</a></blockquote><blockquote><em>❌</em>“O DDD <strong>não é uma arquitetura</strong>. O DDD não é você criar um monte de pastinhas no seu projeto e ter um projeto em camadas com 5, 6, 7 ou 8 camadas. Isso não é DDD.” — André Secco, Microsoft MVP em <a href="https://www.youtube.com/watch?v=E8pHUyHK3tI&amp;t=664s">https://www.youtube.com/watch?v=E8pHUyHK3tI&amp;t=664s</a></blockquote><blockquote><em>❌</em>“DDD <strong>is not an architecture style or an architecture</strong>.” — Vaughn Vernon, autor do famoso livro ‘Implementing Domain-Driven Design’ no <a href="https://www.linkedin.com/posts/vaughnvernon_psa-trunk-based-development-tbd-is-not-activity-7159993666671931392-yPDw/?utm_source=share&amp;utm_medium=member_desktop#:~:text=DDD%20is%20not%20an%20architecture%20style%20or%20an%20architecture">LinkedIn</a></blockquote><blockquote><em>❌</em>“DDD <strong>não é arquitetura</strong>, DDD não é um estilo arquitetural […] DDD não é umas pastinhas que você cria […] DDD não é isso. DDD é uma filosofia.” — Elemar Jr., Microsoft MVP no grupo de estudos <a href="https://elemarjr.com/clube-de-estudos/ddd-do-jeito-certo/">DDD do Jeito Certo</a>, Masterclass 2, minuto 02:09:00</blockquote><blockquote>✏️ A definição oficial é: “DDD é um conjunto de Práticas de Design [de código], Técnicas e Princípios” (pág. xxi) propostos por Erick Evans em seu famoso <a href="https://www.amazon.com.br/Domain-Driven-Design-Tackling-Complexity-Software-ebook/dp/B00794TAUG/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">livro da capa azul</a>, publicado em 2003.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*0IoswcfqX8foGems3bSU1A.jpeg" /><figcaption>Famoso livro da capa azul de Erick Evans</figcaption></figure><p>O principal objetivo do DDD é promover uma forma de pensar software bem estruturado e flexível de forma sustentável¹ a fim de evitar que seu sistema se transforme em uma <a href="https://deviq.com/antipatterns/big-ball-of-mud">Big Ball of Mud</a>🤮, ou seja, numa grande bagunça², gerando consequentemente <a href="https://www.atlassian.com/br/agile/software-development/technical-debt">débito técnico</a>, alta carga cognitiva, afetando a qualidade das entregas e a produtividade da equipe, colocando o projeto e o negócio em risco³.📉</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/646/0*3PKB2r-Mh0wcOtJz.jpg" /><figcaption>O termo “Big Ball of Mud”—da sigla BBoM é utilizado para se referir a código confuso, mal estruturado, mal escrito, sem limites bem definidos. São difíceis de alterar e de entender devido a altíssima carga cognitiva, é custoso para fazer manutenção³. Geralmente é encontrado em legados, mas também em sistemas novos.</figcaption></figure><h4>Mas, do que se trata e quais são exatamente os “Patterns, Princípios e Praticas” recomendados pelo DDD?🤔</h4><p>O livro do DDD é dividido em duas partes: <strong>Design Estratégico</strong> e <strong>Design Tático</strong>. Em palavras simples e bem resumidas, a parte estratégica do DDD traz algumas recomendações de como <strong>separar o seu software em Componentes ou seja, em partes, ou em módulos </strong>que são chamados de <strong>Bounded Contexts</strong> — ou Contextos Delimitados em português. Já na parte tática são feitas algumas recomendações de como construir o código desses componentes de forma bem estruturada usando o <a href="https://martinfowler.com/eaaCatalog/domainModel.html">Domain Model Pattern</a> e os <a href="https://www.locaweb.com.br/blog/temas/codigo-aberto/ddd-entenda-o-domain-driven-design/#1">Building Blocks do DDD</a>.</p><blockquote><em>Na prática esses “componentes” ou Bounded Contexts dos quais o DDD se refere costumam ser APIs ou </em><a href="https://www.youtube.com/watch?v=yPvef9R3k-M"><em>Microsserviços</em></a>⁴<em>, mas podem ser também ser compostos por diferentes módulos dentro de um </em>modular monolith<em>, como acontece nos ERPs que possuem módulos de Finanças, RH e Vendas por exemplo.</em></blockquote><p>DDD é um assunto extenso mas, em resumo, para evitar que seu software se transforme em uma <a href="https://deviq.com/antipatterns/big-ball-of-mud">Big Ball of Mud</a>🤮 o DDD recomenda que você:</p><ol><li><strong>Primeiro, identifique o seu Domínio.</strong> <em>Em palavras simples domínio é a área de atuação da sua empresa, como por exemplo: Educação infantil, serviços financeiros, seguros, comércio varejista, assistência médica, assessoria jurídica, logística, entre outros;</em></li><li><strong>Depois, identifique os seus Subdomínios.</strong><em> Por exemplo, se você atua numa empresa do setor varejista os subdomínios podem ser: Estoque, Frete, Catálogo de produtos, plataforma de e-commerce, PDV, Marketing, Financeiro, Recursos Humanos, etc. Os Domain Experts, ou seja, os stakeholders mais experientes na empresa são as melhores pessoas para ajudar você a identificar os subdomínios.</em></li><li><strong>Classifique os Subdomínios entre Core, Genérico ou de Suporte. </strong><em>Os subdomínios do tipo Genérico podem ser adquiridos como plataformas de terceiros ou soluções open-source, enquanto você foca os esforços de desenvolvimento nos subdomínios Core que são estratégicos para a empresa do ponto de vista de negócio.</em></li><li><strong>Desenhe os Bounded Contexts.</strong><em> Na prática os Bounded Context, ou seja, os “componentes” se tornarão APIs ou </em><a href="https://www.youtube.com/watch?v=yPvef9R3k-M"><em>microsserviços</em></a><em>. Mas, podem ser implementados também como </em><a href="https://learn.microsoft.com/pt-br/dotnet/csharp/fundamentals/types/namespaces"><em>namespaces </em></a><em>ou </em><a href="https://www.devmedia.com.br/compreendendo-o-uso-de-pacotes-ou-packages/27478"><em>packages</em></a><em> dentro de uma aplicação monolítica, ou então módulos dentro de um modular monolith por exemplo. Aqui, a Linguagem Ubíqua ou Onipresente do DDD pode te ajudar a decidir quais subdomínios ficarão em qual(is) Bounded Context(s), além de evitar problemas de comunicação entre a equipe.</em></li><li><strong>Determine como os componentes do seu software irão se comunicar.</strong> <em>Na prática a comunicação entre os diferentes componentes, ou seja: APIs ou microsserviços do seu software pode ser feita utilizando protocolos como REST, Mensageria, gRPC, GraphQL, entre outros. Os communications patterns do DDD podem te ajudar nessa etapa.</em></li><li><strong>Implemente os Bounded Contexts utilizando os Building Blocks do DDD: Agregados, Entidades, Value Objects e Domain Services.</strong> <em>Na prática, cada Bounded Context se tornará uma aplicação, ou seja, um projeto no Java ou no C# no Visual Studio.</em></li></ol><blockquote><em>🛈</em> Algumas pessoas também se referem ao ato de dividir o sistema em Bounded Contexts como “Modularização” ou as vezes também como “Componentização”.</blockquote><h4>Mas, o que exatamente significa o termo “Domínio” no DDD?🤔</h4><blockquote>✏️ <em>A definição oficial é: <br>“</em>O domínio é <strong>uma esfera de conhecimento, influência ou atividade</strong><em>.” — pág. 512</em></blockquote><p>Domínio no DDD não tem nada a ver com código, e sim com negócios. Na prática, em palavras simples, <strong>o Domínio é a área de atuação da sua empresa</strong>⁵. Algumas empresas se concentram em somente um domínio, como é o caso da Uber por exemplo que foca somente em transporte, enquanto outras empresas atuam em diversos domínios diferentes ao mesmo tempo como é o caso da Mitsubishi, que fabrica desde carros, máquinas industriais, lápis, ar-condicionado, produtos químicos até eletrônicos, atuando em muitos setores e domínios diferentes ao mesmo tempo.</p><blockquote>Saiba mais: <a href="https://medium.com/@dannevesdantas/qual-%C3%A9-a-diferen%C3%A7a-entre-regra-de-neg%C3%B3cio-e-l%C3%B3gica-de-neg%C3%B3cio-e6799e4a7b72">Afinal de contas, qual é exatamente a diferença entre Regra de Negócio e Lógica de Negócio no DDD?</a></blockquote><p>Enfim, DDD nada mais é do que um guia para pensar software complexo de forma estratégica¹, e não sobre Arquitetura em Camadas. O livro recomenda o uso de alguma Arquitetura em Camadas, porém <em>existe uma variedade de Arquiteturas em Camadas diferentes</em> para isolar o Domínio do restante do código da aplicação⁶/⁷/⁸.</p><blockquote>⚠️ <strong>Apesar do livro citar as 4 camadas da Tradicional Arquitetura em Camadas N-Layer o DDD não prescreve quais, nem quantas camadas a sua aplicação deve necessariamente ter…</strong></blockquote><p>… Nem prescreve exatamente o nome que cada camada deve receber no seu projeto no Visual Studio ou IntelliJ. O livro de capa azul de 2003 <strong>sugere</strong> <em>(apensar sugere!)</em><strong><em> </em></strong>que você utilize a tradicional arquitetura em camadas “N-Layer” com 4 camadas (User Interface, Application, Domain e Infrastructure) no Capítulo 4, porém enfatiza e deixa bem claro que existem outros esquemas de camadas <em>no 4º parágrafo da página 69 e no 3º parágrafo da página 75 da versão Kindle, em inglês</em>.</p><figure><img alt="The Domain Layer Is Where the Model Lives" src="https://cdn-images-1.medium.com/max/937/1*WC88D43t_aBZoySwsoG0sQ.png" /><figcaption>Trecho do livro “Domain-Driven Design: Tackling Complexity in the Heart of Software” de Eric Evans — Parte II Capítulo 4.</figcaption></figure><h4>Uma analogia metafórica gastronômica🤔💭</h4><p>Para fazer uma analogia, DDD e Arquiteturas em Camadas seriam como Macarrão e Molho:😋Um sempre está acompanhado do outro. Ninguém come molho puro, nem macarrão sem molho <em>(há exceções rs, mas essa história fica para outro dia)</em>. Da mesma forma, na prática, ninguém aplica DDD sem usar também alguma Arquitetura em Camadas, nem implementa uma Arquitetura em Camadas sem aplicar o DDD na camada de Domínio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/0*AbtHiktOP4X9IHE5.jpg" /><figcaption>Créditos: <a href="https://www.tudogostoso.com.br/receita/8072-molho-branco-para-macarrao.html">TudoGostoso</a></figcaption></figure><p>Apesar de estarem sempre acompanhados, assim como macarrão e molho DDD e Arquitetura em Camadas <strong>são coisas completamente diferentes</strong>. Molho é uma coisa, e Macarrão é outra completamente diferente! Macarrão é uma massa e Molho é um acompanhamento, nem sequer podemos pensar em comparar ambos. Da mesma forma também não faz sentido tentar comparar DDD e Arquitetura em Camadas. Assim como existem diversas Arquiteturas em Camadas, existem também diversos tipos de molhos como molho de tomate, molho branco <em>(o meu preferido)</em>, molho de requeijão e maionese, entre outros. <em>O DDD pode ser aplicado em conjunto com diferentes Arquiteturas em Camadas.</em></p><blockquote>O DDD pode ser aplicado na clássica e tradicional “Arquitetura em Camadas”, que é tecnicamente chamada de N-Layer, como foi sugerido no livro do DDD de capa azul de 2003 do Erick Evans. Porém, o DDD pode ser aplicado também em conjunto de outras arquiteturas em camadas mais modernas, como na Arquitetura Hexagonal por exemplo, ou na Onion Architecture, ou na Clean Architecture… Quem vai determinar em quais, em quantas, e os nomes de cada camada da sua aplicação vai ser a arquitetura em camadas que foi escolhida para o projeto, e não o DDD. Portanto, DDD não é sobre arquitetura em camadas, apesar de ser sempre aplicado dentro, em conjunto, de alguma arquitetura em camadas.</blockquote><p>Tudo que você aprendeu no DDD será implementado <strong>dentro da camada de Domínio</strong>⁹ da arquitetura em camadas que você escolher utilizar. Todas as arquiteturas em camadas possuem uma camada de Domínio.</p><h4><strong>Onde posso aprender mais sobre DDD?</strong></h4><blockquote>&gt; Escrevi um breve artigo com algumas dicas de estudo em <a href="https://medium.com/@dannevesdantas/onde-estudar-ddd-em-2023-97a35d04ca2a">https://medium.com/@dannevesdantas/onde-estudar-ddd-em-2023-97a35d04ca2a</a></blockquote><h3><strong>Architectural Patterns</strong></h3><p>Existem diferentes layered Architectural Patterns¹⁰/¹¹ que podem ser utilizados para dividir a sua aplicação em camadas.</p><blockquote>A Arquitetura em Camadas por sua vez é quem define quais, e em quantas camadas a aplicação vai ser dividida, o nome dessas camadas, o conteúdo, a responsabilidade, o papel e os limites de cada uma.</blockquote><p>A mais comum e famosa é a <strong>Arquitetura em Camadas tradicional</strong>¹², que geralmente possui 3 ou 4 camadas: <em>User Interface, Application, Domain e Infrastructure.</em> Essa arquitetura em camadas tradicional é tecnicamente chamada de <strong>N-Layer Architecture</strong>¹³.</p><blockquote>Sempre que ouvir alguém dizendo “vamos utilizar a arquitetura em camadas” subentende-se que a pessoa está se referindo a Arquitetura em Camadas tradicional, ou seja, a N-Layer Architecture.</blockquote><h3>Arquitetura em Camadas “N-Layer” tradicional (2002)</h3><blockquote>Data de publicação: 5 de novembro de 2002 (antes do DDD).<br>Sinônimos: N-Layer architecture; Layered architecture; Three-layer architecture; Four-layer architecture; Three-Layered Services Application; Multi-layer architecture; N-Tier architecture; Arquitetura em camadas clássica.<br>Visto pela primeira vez em: <a href="https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Addison-Wesley-ebook/dp/B008OHVDFM/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Patterns of Enterprise Application Architecture</a>.<br>Autor: Martin Fowler.</blockquote><p>Se você é desenvolvedor, principalmente no .NET ou Java, e já possui alguns anos de experiência com certeza já deve ter se deparado com projetos, APIs ou microsserviços divididos internamente em camadas, sendo cada camada um projeto ou pastinha diferente dentro da solution. Esse tipo de arquitetura onde a aplicação é dividida em 3 ou 4 (ou N) camadas é chamada de <strong>Arquitetura em Camadas Tradicional</strong>²⁰, ou <strong>N-Layer Architecture</strong>²¹ em inglês.</p><blockquote>O “N” na tradicional Arquitetura em Camadas N-Layer se refere a quantidade de camadas. Podem haver 3 camadas (sem a camada de Application) ou 4 camadas (com a camada de Application). Na N-Layer Architecture a quantidade de camadas a serem utilizadas é livre e fica a cargo dos desenvolvedores decidirem quais e quantas camadas utilizar.</blockquote><p>Originalmente a Arquitetura em Camadas tradicional, conforme proposta por Martin Fowler no livro <a href="https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420"><em>Patterns of Enterprise Application Architecture</em></a> em 2002 era composta por somente 3 camadas: <strong>Presentation layer</strong>, <strong>Business logic layer</strong> e <strong>Data access layer</strong>.²²</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ll9GP6ved_lt77QgFuQd9A.png" /><figcaption>Arquitetura em Camadas tradicional com 3 camadas, ou seja, 3-Layer. Fonte: “Learning Domain-Driven Design” Chapter 8.</figcaption></figure><p>Caso deseje, o dev pode também incluir uma camada de serviço chamada <strong>Service layer</strong> <em>(opcional)</em>, geralmente chamada de <strong>Camada de Application</strong><em>, </em>entre a camada de apresentação e a camada de lógica de negócio.²³</p><blockquote><strong>A principal função da Service layer é desacoplar a Presentation layer da Business logic layer.</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BJgX3SmE1zqDFkQ5zy5P6w.png" /><figcaption>Arquitetura em Camadas tradicional com “Service layer”, totalizando 4 camadas ou seja, 4-Layer. Fonte: “Learning Domain-Driven Design” Chapter 8.</figcaption></figure><blockquote>A <strong>Service layer</strong> <em>(opcional)</em> funciona na prática como uma espécie <a href="https://refactoring.guru/pt-br/design-patterns/facade">Façade</a>²⁴/²⁵ que encapsula a orquestração (ou seja, as chamadas) para as camadas de Business logic e Data access que ficam abaixo dela.</blockquote><blockquote><em>🛈</em> É bom saber: As classes de serviço da Service layer não substituem as classes de Domain Services do DDD, que devem permanecer na Business logic layer. Ao optar por utilizar a Service layer (mais conhecida também como Camada de Application) existirão dois tipos diferentes de Services dentro da sua aplicação: As services de Application e as Domain Services do DDD que devem permanecer dentro da camada de Domain ou seja, dentro da Business logic layer.²⁶</blockquote><p>Se você está trabalhando em um projeto Web utilizando o padrão MVC, a principal vantagem de incluir uma <strong>Service layer</strong> <em>(opcional),</em> mais conhecida também como <strong>Camada de Application</strong>, é facilitar a vida da Presentation layer²⁷, que somente precisará chamar a Service Layer, sem precisar saber detalhes da sua implementação conforme o exemplo abaixo onde a Controller da aplicação, que fica dentro da Presentation layer, faz uma chamada para o método .Create() da _userService<em>, </em>que por sua vez é implementada dentro da Service layer.</p><blockquote>A <strong>Service layer</strong> proposta por Martin Fowler no livro “Patterns of Enterprise Application Architecture” de 2002 é mais conhecida atualmente como <strong>Camada de Application</strong>.</blockquote><pre>namespace MvcApplication.Controllers<br>{<br>    public class UserController: Controller // A controller faz parte da Presentation layer<br>    {<br>        ...<br><br>        [AcceptVerbs(HttpVerbs.Post)]<br>        public ActionResult Create(ContactDetails contactDetails)<br>        {<br>            // Aqui o único trabalho da Controller é chamar o método .Create() da _userService da Service layer da camada de Application.<br>            var result = _userService.Create(contactDetails);<br>            return View(result);<br>        }<br>    }<br>}<br><br>// Fonte: <br>// Khononov, Vlad. Learning Domain-Driven Design (p. 204). O&#39;Reilly Media. Edição do Kindle. </pre><blockquote><em>🛈</em> A camada de Application frequentemente é motivo de discussão e controvérsia entre alguns desenvolvedores: Alguns devs defendem a existência dela, enquanto outros acreditam que a camada de Application é desnecessária. Ao optar por não criar uma camada de Application, a lógica da camada de Application é implementado dentro da Presentation layer, mais especificamente dentro da Controller.</blockquote><h4>Ok, mas, na Arquitetura em camadas N-Layer tradicional o que exatamente deve ser implementado dentro da Presentation layer?🤔</h4><p>A Presentation layer, como o próprio nome diz, é a interface do usuário. No início dos anos 2000 as aplicações desktop reinavam, posteriormente a web ganhou força e um novo tipo de interface surgiu: as páginas HTML. Nos tempos atuais temos também as apps Android e iOS, as aplicações SPA, as CLIs — Interface de Linha de Comando, APIs REST, GraphQL, gRPC e mais uma variedade de maneiras dos usuários interagirem com os sistemas. Todas essas são consideradas também como Presentation layers. A Presentation layer por sua vez não deve executar tarefas pertinentes a outras camadas, somente delegar comandos para elas.²⁸</p><blockquote>É dentro da Presentation layer que é implementado o padrão de projeto <a href="https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller">MVC — Model View Controller</a>, popular em projetos Web, geralmente em conjunto de algum <a href="https://en.wikipedia.org/wiki/Web_framework">Framework Web</a>.</blockquote><h4>E o que exatamente deve ser implementado dentro da <em>Data Access layer (também chamada de camada de Infrastructure)</em>?🤔</h4><p>A função da camada de Data Access layer (mais comumente chamada de Infrastructure ou simplesmente “Infra” nos dias atuais) é fazer acesso/leitura/gravação de dados. Dentro da camada de Infra é onde são implementados os <a href="https://www.youtube.com/watch?v=J-UIdgp1q14">Repositories</a>.³⁰</p><h4>Evolução dos nomes das camadas</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IOp10ku3ioFpRK3E.png" /><figcaption>Nomes original das camadas propostas por Martin Fowler em 2002.</figcaption></figure><p>Com o passar dos anos a terminologia original adotada pelo Martin Fowler em 2002 foi caindo em desuso e foi sendo substituída por outros termos mais modernos. Em 2002 quando Martin Fowler publicou a Arquitetura em Camadas tradicional os sistemas eram muito mais simples e a principal fonte de dados eram os bancos de dados SQL relacionais. Desde então os sistemas se tornaram muito mais complexos, lidando com diversos bancos de dados SQL e NoSQL ao mesmo tempo, caches, APIs REST, GraphQL e gRPC, message brokers, serviços de armazenamento na nuvem como o S3 da AWS ou o Blob Storage do Azure por exemplo. O termo “Data Access Layer” foi sendo substituído pelo termo <em>“Infrastructure layer”, </em>ou simplesmente <em>“Infra”,</em> que é mais abrangente, pois nem sempre os dados vão estar armazenados em bancos de dados. Os termos mais comuns utilizados hoje em dia são:²⁹</p><ul><li>Presentation layer -&gt; <strong>User Interface</strong> layer OU Web</li><li>Service layer <em>(opcional)</em> -&gt; <strong>Application</strong> layer<em> (essa camada é opcional)</em></li><li>Business Logic Layer <em>(BLL)</em> -&gt; <strong>Domain</strong> layer OU Model layer OU Core</li><li>Data Access Layer <em>(DAL)</em> -&gt; <strong>Infrastructure</strong> layer OU “Infra”</li></ul><h4><a href="https://github.com/dotnet-architecture/eShopOnWeb">eShopOnWeb</a>, um projeto open-source</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kw29TQrr6QrBnUgddcKc_Q.png" /><figcaption>Exemplo de aplicação C# .NET dividida em 3 camadas no Visual Studio: ApplicationCore (<em>Business logic layer</em>), Infrastructure (<em>Data access layer</em>) e Web (P<em>resentation layer</em>). Os nomes das camadas podem variar de projeto para projeto, de equipe para equipe ou de empresa para empresa. Fonte: Microsoft Learn.</figcaption></figure><p>Já em projetos Node.js, Python e Go as diferentes camadas da aplicação geralmente são organizadas em pastinhas dentro do projeto.</p><p>Como é possível notar, na imagem acima foi utilizada uma terminologia diferente para o nome das camadas: “<em>ApplicationCore” </em>ao invés de <em>“Business logic layer”</em>,<em> “Infrastructure” </em>ao invés de<em> “Data access layer”</em> e <em>“Web” </em>ao invés de<em> “Presentation layer”.</em></p><blockquote>✏️ Não existe uma norma internacional, RFC, ISO, regra, padrão ou coisa do tipo que impõem ou determina quais exatamente devem ser os nomes de cada uma das camadas na Arquitetura em Camadas N-Layer tradicional. Fica a cargo do desenvolvedor, da equipe ou da empresa definir o nome de cada camada. Devido a isso você encontrará no mercado de trabalho e também no GitHub projetos que podem ter nomes de camadas ligeiramente diferentes, a depender da equipe ou da empresa.</blockquote><h4>Camadas lógicas vs. Estrutura de arquivos física</h4><p>Enquanto as camadas são lógicas, a estrutura de arquivos e pastas da sua aplicação é física. Isso é: O conceito de Camada é abstrato, enquanto os arquivos e pastas presentes no seu projeto são armazenados fisicamente no SSD. Uma camada é composta por um conjunto de classes que possuem uma determinada responsabilidade, de acordo com o que é estipulado pela Arquitetura em Camadas que você escolheu utilizar no seu projeto. Os arquivos de código-fonte.cs, .java, .tsou .pyou .goe pastas do seu projeto não necessariamente devem ou vão refletir exatamente a mesma estrutura lógica das camadas, nem necessariamente vão, ou devem, ou precisam, ter os mesmos nomes das camadas.</p><blockquote>✏️ O que define qual é a arquitetura da aplicação é a forma como o código e as classes estão estruturadas e se relacionam, e não o nome ou a quantidade de pastinhas e arquivos presentes dentro do projeto.</blockquote><blockquote>“Camada e pastas são coisas diferentes.” — Rodrigo Branas no <a href="https://www.branas.io/index.html">Curso de Clean Code e Clean Architecture</a>, turma 11, aula 3, minutagem 1:33:43</blockquote><h4>Onde entra o DDD na Arquitetura em Camadas “N-Layer” tradicional? Como as duas coisas se complementam?🤔</h4><p>Os Agregados, Entidades, Value Objects e Domain Services do DDD <em>(você pode aprender mais sobre eles no livro)</em> são implementados dentro da camada de <strong>Domínio</strong>³¹ ou seja, dentro da<strong> </strong><em>Business Logic Layer</em>. Já os Repositories citados no livro do Erick Evans são implementados dentro da camada de Infrastructure.</p><blockquote>⚠️Como vimos antes, apesar de serem utilizados juntos, DDD e Arquitetura em Camadas são coisas diferentes!</blockquote><p>Em resumo, tudo que você aprendeu no DDD sobre domínios será implementado dentro da camada de <strong>Domínio</strong> ao optar por utilizar a tradicional Arquitetura em Camadas N-Layer³², afinal de contas o DDD é um conjunto de boas práticas que diz respeito ao <strong>Domínio, </strong>e portanto se aplicam ao <strong>Domínio</strong>, dentro da camada de <strong>Domínio</strong>.</p><h4>Domain Services vs. Application Services vs. Infrastructure Services</h4><p>No DDD você deve ter aprendido o conceito de Domain Services, que nada mais são, em palavras simples e resumidas, do que classes stateless que possuem métodos para executar operações pertinentes ao Domínio, como por exemplo: criarPedido(), transferirValor(), fazerMatricula() Porém, não podemos confundir as Domain Services do DDD, que ficam na camada de Domain, com as Application Services, que ficam na camada de Application³³. As Services da camada de Application tem outra função: Elas servem para orquestrar chamadas para as classes da camada de Domínio abaixo dela.</p><p>Na Arquitetura em Camadas tradicional as Application Services podem chamar Domain Services e também podem fazer uso de Infrastructure Services ou Repositories da camada de Infrastructure³³.</p><p>Também existem as Services da camada de Infrastructure que atuam como gateways e tem como responsabilidade fazer chamadas HTTP para APIs externas, ou enviar e-mails por exemplo³³.</p><h4><strong>Onde posso aprender mais sobre a Arquitetura em Camadas N-Layer tradicional?</strong></h4><blockquote>&gt; Capítulo 1 do livro <a href="https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Addison-Wesley-ebook/dp/B008OHVDFM/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series (Fowler)) 1st Edition</a> de Martin Fowler, disponível na Amazon em <a href="https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Addison-Wesley-ebook/dp/B008OHVDFM/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">inglês</a> e em <a href="https://www.amazon.com.br/Padr%C3%B5es-Arquitetura-Aplica%C3%A7%C3%B5es-Corporativas-Martin-ebook/dp/B07FCPZ2R2/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">português</a>.<br>&gt; Capítulo 8 do livro <a href="https://www.amazon.com/Learning-Domain-Driven-Design-Vlad-Khononov-ebook/dp/B09J2CMJZY/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=1701952787&amp;sr=1-1">Learning Domain-Driven Design: Aligning Software Architecture and Business Strategy</a> de Vlad Khononov, disponível na Amazon.<br>&gt; Capítulo 4 do livro <a href="https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215">Domain-Driven Design: Tackling Complexity in the Heart of Software</a> de Erick Evans, disponível na Amazon em <a href="https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215">inglês</a> e em <a href="https://www.amazon.com.br/Domain-driven-design-atacando-complexidades-software/dp/8550800651/ref=asc_df_8550800651/?tag=googleshopp00-20&amp;linkCode=df0&amp;hvadid=379739109739&amp;hvpos=&amp;hvnetw=g&amp;hvrand=1788198744955057142&amp;hvpone=&amp;hvptwo=&amp;hvqmt=&amp;hvdev=c&amp;hvdvcmdl=&amp;hvlocint=&amp;hvlocphy=1031606&amp;hvtargid=pla-809277038576&amp;psc=1&amp;mcid=adb9b45316093284abfc5f620bf43afb">português</a>.<br>&gt; <a href="https://www.amazon.com.br/Implementing-Domain-Driven-Design-English-Vaughn-ebook/dp/B00BCLEBN8/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Implementing Domain-Driven Design</a> de Vaughn Vernon, disponível na Amazon em <a href="https://www.amazon.com.br/Implementing-Domain-Driven-Design-English-Vaughn-ebook/dp/B00BCLEBN8/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">inglês</a> e em <a href="https://www.amazon.com.br/Implementando-Domain-Driven-design-Vernon/dp/8576089521/ref=asc_df_8576089521/?tag=googleshopp00-20&amp;linkCode=df0&amp;hvadid=379748659420&amp;hvpos=&amp;hvnetw=g&amp;hvrand=14886536831150893020&amp;hvpone=&amp;hvptwo=&amp;hvqmt=&amp;hvdev=c&amp;hvdvcmdl=&amp;hvlocint=&amp;hvlocphy=1031606&amp;hvtargid=pla-460804278877&amp;psc=1&amp;mcid=4af905bfed633c81b25d7ebf3f277392">português</a>.</blockquote><h3>N-Tier Architecture (1995)</h3><blockquote>Data de publicação: Janeiro de 1995.<br>Sinônimos: N-Tier architecture; Three-tier architecture; Multi-tier architecture.<br>Visto pela primeira vez em: Eckerson 95. Eckerson, Wayne W. “Three Tier Client/Server Architecture: Achieving Scalability, Performance, and Efficiency in Client Server Applications.” Open Information Systems 10, 1 (January 1995): 3(20).<br>Autor: John J. Donovan.</blockquote><p>Enquanto a Arquitetura em Camadas “N-Layer” tradicional divide o código da aplicação em camadas lógicas de <em>UI</em>, <em>Application</em>, <em>Domain </em>e <em>Infrastructure </em>na horizontal, a arquitetura cliente-servidor N-Tier divide a aplicação em camadas lógicas e <strong>tiers físicos</strong>⁴⁰, geralmente representados na vertical como no exemplo abaixo.</p><blockquote>A letra “N” na N-Tier Architecture significa uma quantidade variável de Tiers. O mais comum é 3 Tiers, mas podem haver mais Tiers em aplicações mais complexas.</blockquote><blockquote><em>⚠️</em>Apesar de ser frequentemente chamada de “arquitetura” a N-Tier é na verdade uma Topologia. — Fonte: <a href="https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a> pág. 224</blockquote><p>Alguns tiers comuns na N-Tier Architecture são: <strong>Presentation tier</strong>, <strong>Business tier</strong>, <strong>Data tier</strong>.⁴¹ Na <em>Business tier</em> é onde são executados os binários do back-end sua aplicação Web escrita em Java, C#, Node.js, Python, PHP ou Go por exemplo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*THvWL5zV9FmD-9WH.png" /><figcaption>Arquitetura N-tier para aplicações Web recomendada pelo time do Azure, rodando em VMs. No exemplo acima a “Web tier” se refere a Presentation tier. Fonte: Microsoft Learn.</figcaption></figure><blockquote>No exemplo acima foram utilizadas de 2 a 3 VMs em cada Tier a fim de proporcionar resiliência, caso alguma das VMs falhe.</blockquote><p>Tiers são fisicamente separados⁴¹, rodando em máquinas separadas. Separar fisicamente os Tiers em máquinas diferentes contribui para a escalabilidade e a resiliência da aplicação, porém também introduz latência de comunicação⁴¹ de rede ao chamar APIs ou acessar bancos de dados executando em outras VMs por exemplo.</p><blockquote>Na arquitetura N-Tier, apesar de cada camada do sistema poder ser hospedada em seu próprio Tier como no exemplo acima, várias camadas podem também ser hospedadas no mesmo Tier.⁴¹</blockquote><p>Imagine que, devido a restrições de orçamento, os Cloud Engineers do time de SRE da empresa onde você atua orientaram você a hospedar os binários do back-end da sua aplicação Web escrita em Java no mesmo servidor, dentro da mesma VM onde é executado o banco de dados PostgreSQL da aplicação. Nesse exemplo hipotético você teria duas layers (Business tier e Data tier) executando no mesmo Tier, ou seja, dentro do mesmo servidor, dentro da mesma VM, prática essa que não é recomendada pois a aplicação Java e o banco de dados PostgreSQL podem passar a competir por recursos de hardware, como memória e CPU.</p><blockquote>Os termos “N-Layer Architecture” e “N-Tier Architecture” frequentemente são confundidos e usados um no lugar do outro, intercambiavelmente.⁴²/⁴³/⁴⁴</blockquote><blockquote>⚠️Apesar de sempre serem utilizadas em conjunto e por vezes serem confundidas e citadas erroneamente como sinônimos, a Arquitetura em Camadas N-Layer e a Arquitetura N-Tier são bem diferentes, como você pôde notar.</blockquote><p>Apesar de terem nomes de camadas muito parecidos, a Arquitetura N-Tier tem muito mais a ver com topologia, cliente-servidor, VMs, servidores, hardware, nuvem e infraestrutura, enquanto a arquitetura em camadas N-Layer se refere a arquitetura de software e design do código interno da aplicação.</p><h4><strong>Onde posso aprender mais sobre a N-Tier Architecture?</strong></h4><blockquote>&gt; Capítulo 1 do livro Patterns of Enterprise Application Architecture de Martin Fowler, disponível na Amazon.<br>&gt; “N-tier architecture style” no Microsoft Learn em <a href="https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/n-tier">https://learn.microsoft.com/pt-br/azure/architecture/guide/architecture-styles/n-tier</a><br>&gt; Treinamento “Tour the N-tier architecture style for your application” no Microsoft Learn em <a href="https://learn.microsoft.com/en-us/training/modules/n-tier-architecture/">https://learn.microsoft.com/en-us/training/modules/n-tier-architecture/</a> disponível em inglês e em português.<br>&gt; Artigo “What is three-tier architecture?” no site da IBM em <a href="https://www.ibm.com/topics/three-tier-architecture">https://www.ibm.com/topics/three-tier-architecture</a></blockquote><h3>Arquitetura Hexagonal e Ports and Adapters (2005)</h3><blockquote>Data de publicação: Criada em 1994 e renomeada em 2003. Publicada em 4 de janeiro de 2005.<br>Sinônimos: Hexagonal Architecture; Ports &amp; Adapters.<br>Visto pela primeira vez em: <a href="https://alistair.cockburn.us/hexagonal-architecture/">alistair.cockburn.us</a><br>Autor: Dr. Alistair Cockburn.</blockquote><p>A Arquitetura Hexagonal foi proposta em 1994 por Alistair Cockburn. Posteriormente, ela foi renomeada por ele para “Ports and Adapters” em 2003.</p><figure><img alt="Dr. Alistair Cockburn" src="https://cdn-images-1.medium.com/max/300/1*nebUSDWPR-fGR-zxtwlyCQ.png" /><figcaption>Dr. Alistair Cockburn, o criador da Ports and Adapters. Fonte: <a href="https://alistair.cockburn.us/">https://alistair.cockburn.us/</a></figcaption></figure><blockquote>“The actual correct pattern name is <strong>Ports and Adapters</strong>” —<a href="https://www.youtube.com/watch?v=AOIWUPjal60&amp;t=479s"> Alistair Cockburn, criador da Arquitetura Hexagonal</a>.</blockquote><p>A Ports and Adapters veio para resolver o principal problema da Arquitetura em Camadas tradicional: A dependência e acoplamento da aplicação com tecnologias e protocolos da infraestrutura externa.⁵⁰</p><h4>Mas por que, de acordo com a Ports and Adapters, eu deveria isolar a minha aplicação de tecnologias externas?🤔</h4><p>São várias as motivações: A possibilidade de trocar de tecnologia de banco de dados ou poder substituir facilmente um message broker por outro são algumas das justificativas mas, talvez a mais impotente motivação seja isolar a aplicação no centro do hexágono, facilitando os <strong>Testes Unitários</strong> e permitindo a utilização de <strong>Fakes</strong>, <strong>Stubs </strong>e <strong>Mocks</strong>.</p><blockquote><em>A Ports and Adapters é utilizada até hoje pela Netflix e ajudou bastante a empresa durante a fase de crescimento nas diversas migrações de tecnologia que eles realizaram ao longo do tempo.</em></blockquote><h4>A Ports and Adapters requer o uso de camadas e do DDD? Se sim, quais e quantas camadas?🤔</h4><p>Não⁵¹. A Ports and Adapter não diz que a sua aplicação deve obrigatoriamente ser dividida em camadas, nem diz exatamente quais nem quantas camadas a sua aplicação deve ter, nem que você deve aplicar os conceitos do DDD⁵². Somente que ela deve implementar Portas e Adaptadores a fim de proteger a aplicação no centro do hexágono, desacoplando a aplicação de tecnologias da infraestrutura externa.</p><blockquote>“The domain model, anemic/rich, is not part of Hexagonal but can exist inside.” — <a href="https://www.linkedin.com/posts/vaughnvernon_hexagonal-architecture-common-pitfalls-activity-7157454786202685440-PH7x?utm_source=share&amp;utm_medium=member_desktop">Vaughn Vernon no LinkedIn</a></blockquote><p>Porém, a convenção no mercado, e também no GitHub, é aplicar as camadas da Arquitetura em Camadas “N-Layer” tradicional: <strong>User Interface</strong>, <strong>Application</strong>, <strong>Domain </strong>e <strong>Infrastructure</strong> na Ports and Adapters aplicando também o DIP — Dependency Inversion Principle, como vamos ver abaixo. <em>Daí a importância de conhecer a Arquitetura em Camadas N-Layer tradicional antes de estudar a Ports and Adapters.</em></p><h4>Qual é o problema da Arquitetura em Camadas “N-Layer” tradicional? Por que ela não é mais utilizada em projetos que estão nascendo hoje?🤔</h4><p>Na Arquitetura em Camadas N-Layer tradicional, proposta por Martin Fowler em 2002, a camada de apresentação/UI depende da camada de Domínio logo abaixo dela, que por sua vez depende da camada de Infrastructure <em>(e dos Repositories que ficam dentro da camada de Infrastructure)</em> para fazer acesso a dados. Repare na direção das setas em vermelho na figura abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YErXE-4y6ASdjNM0dpsbag.png" /><figcaption>Arquitetura em Camadas “N-Layer” tradicional de 3 camadas ou seja, 3-Layer. As setas em vermelho representam uma dependência direta do tipo HAS-A entre classes de uma camada e a outra logo abaixo dela. Fonte: “Learning Domain-Driven Design” Chapter 8.</figcaption></figure><blockquote>“Testar a lógica de negócios [na Arquitetura em Camadas N-Layer tradicional] costuma ser difícil, exigindo um banco de dados de teste.” — <a href="https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures#:~:text=One%20disadvantage%20of,the%20next%20section.">Microsft Learn</a></blockquote><h4>Mas, como se dá exatamente essa “dependência” de uma camada com a outra?🤔</h4><p>Na Arquitetura em camadas “N-Layer” tradicional a camada de Domain fica responsável por, dentro de uma Entidade ou dentro de uma Domain Service, instanciar o Repository da camada de Infrastructure para fazer acesso a dados, usando a palavra reservada new, como no exemplo abaixo.</p><pre>namespace App.BusinessLogicLayer // Na Camada de Domain<br>{<br>    public class UserService<br>    {<br>        public void CreateUser(User user)<br>        {<br>            UserRepository userRepository = new UserRepository(); // Instância um repositório concreto que foi implementado na camada de Infraestructure<br>            userRepository.CreateUser(user);<br>        }<br><br>        ...<br><br>    }<br>}<br><br>// Fonte: <br>// Khononov, Vlad. Learning Domain-Driven Design (p. 204). O&#39;Reilly Media. Edição do Kindle.</pre><p>Ao instanciar um tipo concreto usando a palavra reservada new é criada uma dependência direta entre a classe da camada de Domain que está instanciando o Repository com a camada de Infrastructure, onde a classe UserRepository foi implementada.</p><p>Na Ports and Adapters a dependência da camada de Domain com a camada de Infrastructure é invertida através do <strong>Dependency Inversion Principle</strong>.</p><h4>DIP — Dependency Inversion Principle</h4><p>O Dependency Inversion Principle representa a letra “D” dos princípios SOLID. Em palavras simples, ele serve para inverter a direção da dependência entre duas classes.</p><pre>namespace App.BusinessLogicLayer // Na Camada de Domain<br>{<br>    public class UserService<br>    {<br>        private IUserRepository _userRepository { get; set; }<br><br>        public UserService(IUserRepository userRepository) // Um UserRepository da camada de Infrastructure será passado como parâmetro ou seja, injetado, aqui pelo Framework de DI<br>        {<br>            _userRepository = userRepository;<br>        }<br><br>        public void CreateUser(User user)<br>        {<br>            _userRepository.CreateUser(user);<br>        }<br><br>        ...<br><br>    }<br>}<br><br>// Fonte: <br>// Khononov, Vlad. Learning Domain-Driven Design (p. 204). O&#39;Reilly Media. Edição do Kindle.</pre><p>Ao utilizar Inversão de Dependência para desacoplar a camada de Domain da camada de Infrastructure as dependências se invertem e ficam da seguinte forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YgDcrmis5X5cWjwan0D6pw.png" /><figcaption>Dependência invertida. Repare que agora é a camada de Infrastructure é que depende das Interfaces definidas dentro da camada de Domain/Business logic layer acima dela, conforme indicado pela seta em vermelho para cima. Fonte: “Learning Domain-Driven Design” Chapter 8.</figcaption></figure><p>Se o desenvolvedor optar por adicionar uma camada de <strong>Application </strong><em>(opcional) </em>as dependências ficarão da seguinte forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b4fwKn695N-Li96x8l1NXg.png" /><figcaption>Dependências invertidas, com a inclusão de uma camada de Application (opcional). Fonte: “Learning Domain-Driven Design” Chapter 8.</figcaption></figure><p>Agora a camada de Domínio passa a não depender mais da camada de Infrastructure, nem de nenhuma outra camada. Com a inversão de dependência as outras camadas agora é que passam a depender da camada de Domínio.</p><p>Com a inclusão da camada de Application <em>(opcional)</em>, repare também que a camada de Infrastructure não depende mais diretamente da camada de Domain, ela depende da camada de Application, que por sua vez depende então da camada de Domain.</p><p>Dessa forma a camada de Domain passa a ocupar o centro da aplicação já que ela não depende de mais ninguém, enquanto as demais camadas ficam ao redor, da seguinte forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*dPX45DZcJUV3i8Gg3PVLUw.png" /><figcaption>Camada de Domain no centro. As setas coloridas de fora para dentro indicam o sentido da dependência de camadas mais externas com a próxima camada adjacente mais ao centro. Créditos: <a href="https://github.com/CodelyTV">https://github.com/CodelyTV</a></figcaption></figure><blockquote>Na Ports and Adapters as camadas exteriores devem depender somente da próxima camada mais interna, e assim por diante, até chegar a camada de Domínio no cento que por sua vez não deve depender de nenhuma outra camada.</blockquote><p>Se incluirmos na figura as <strong>Portas e Adaptadores</strong>, o desenho ficará da seguinte forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9XEVrYb6mxBfHeMMgAxqpw.png" /><figcaption>Fonte: “Learning Domain-Driven Design” Chapter 8.</figcaption></figure><h4>Na Arquitetura Ports and Adapters, o que exatamente é uma Porta?🤔</h4><p>Para explicar o conceito de Porta podemos fazer uma analogia com as conexões e portas atrás da sua TV.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*IF65_DS547X5GjZD.jpg" /><figcaption>As portas atrás da sua TV permitem que você conecte dispositivos a ela, como leitores de DVD, Blu-Ray ou videogames por exemplo.</figcaption></figure><p><em>A tecnologia vai evoluindo com o passar do tempo e eventualmente você pode querer substituir aquele seu leitor de DVDs antigo por um novo </em><a href="https://store.google.com/us/product/chromecast_google_tv"><em>Chromecast 4K HDR</em></a><em> super moderno para assistir </em><a href="https://www.netflix.com/in/title/70143822"><em>Two and a Half Men</em></a><em> na Netflix. Basta então você desconectar o seu leitor de DVD antigo da Porta HDMI atrás da sua TV e conectar o Chromecast 4K que você comprou na mesma porta onde estava conectado o seu antigo aparelho de DVD, e pronto. Você não precisou abrir a TV para fazer alterações internamente na parte eletrônica dela, nem comprar uma TV nova.</em></p><blockquote>No código, as Portas são definidas utilizando Interfaces da programação orientada a objetos, dentro da camada de Domínio.</blockquote><p>Ao utilizar Interfaces você poderá facilmente trocar a tecnologia de banco de dados de SQL para NoSQL por exemplo, trocar o RabbitMQ pelo Kafka, mudar o protocolo de comunicação de REST para gRPC, etc facilmente caso seja necessário, sem precisar reescrever toda a sua aplicação. Isso também facilita MUITO a criação <strong>Fakes</strong>, <strong>Stubs </strong>e <strong>Mocks </strong>ao implementar Testes Unitários.</p><pre>namespace App.BusinessLogicLayer // Na Camada de Domain<br>{<br>    public interface IMessaging<br>    {<br>        void Publish(Message payload);<br>        void Subscribe(Message type, Action callback);<br>    }<br>}<br><br>// Fonte: <br>// Khononov, Vlad. Learning Domain-Driven Design (p. 204). O&#39;Reilly Media. Edição do Kindle.</pre><blockquote>“Not every Interface is a Port.” — “The ideia of a Port fundamentally has something to do with we’re going to put different things there.” — <a href="https://www.youtube.com/live/AOIWUPjal60?si=-tevbR6HWczVDKH2&amp;t=1718">Alistair Cockburn, criador da Ports and Adapters</a>.</blockquote><p>Porém, nem toda e qualquer Interface no seu código pode ser chamada de Porta. Na Ports and Adapters uma Interface somente poderá ser chamada de Porta se ela foi criada com o intuito e a fim de de permitir a substituição de uma tecnologia <em>(de SQL para NoSQL por exemplo)</em> ou protocolo <em>(de REST para gRPC por exemplo)</em>. Esse é o principal objetivo da Ports and Adapters.</p><blockquote>Para resumir em palavras simples:<br>Interface na camada de Domain = Porta.</blockquote><h4>E o que exatamente é um Adapter?🤔</h4><p>O Adapter trata de traduzir um formato para outro. Um Objeto para JSON, um Objeto para XML ou um Objeto para o modelo relacional de linhas e colunas no banco de dados SQL por exemplo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*ssRPtjNa1phASd2uLBDYgw.png" /><figcaption>Adaptador de USB-C para conector de fones de ouvido de 3,5 mm da Apple. Assim como os Adapters da Ports and Adapters ele permite que você utilize fones de ouvidos mais antigos, com fio, em iPhones mais novos.</figcaption></figure><p>Em palavras simples, um <strong>Adapter </strong>é a implementação concreta na camada de Infrastructure da Interface de uma Porta que foi definida dentro da camada de Domínio.</p><pre>namespace App.Infrastructure.Adapters // Na Camada de Infrastructure<br>{<br>    public class SQSBus: IMessaging { <br>      // Os métodos Publish() e Subscribe() da interface IMessaging são implementados aqui.<br>      // Podemos utilizar o Apache Kafka, o AWS SQS ou RabbitMQ por exemplo para publicar e consumir mensagens<br>      // Os detalhes de implementação foram omitido para manter a simplicidade<br>      ...<br>    }<br>}<br><br>// Fonte: <br>// Khononov, Vlad. Learning Domain-Driven Design (p. 204). O&#39;Reilly Media. Edição do Kindle.</pre><blockquote>A implementação concreta da Interface das Portas deve ser feita na camada de Infrastructure.</blockquote><blockquote>Para resumir em palavras simples:<br>Implementação concreta da Interface dentro da camada de Infra = Adapter.</blockquote><h4>E onde entra o DDD na Ports and Adapters? Também é possível aplicar a Ports and Adapters sem o DDD?🤔</h4><p>A Ports and Adapters não te obriga a aplicar o DDD. Fica a cargo do desenvolvedor aplicar ou não os conceitos e patterns do DDD na Ports and Adapters. Porém, o mais comum no mercado é as duas coisas serem utilizadas juntas, aplicando o DDD dentro da camada de Domain, que fica no cento do Hexágono.</p><blockquote>“I don’t care. Not my business.” — Disse o Alistair Cockburn, criador da Ports and Adapters, ao ser questionado se o DDD deve ou não ser aplicado na Ports and Adapters. Fonte: <a href="https://www.youtube.com/watch?v=AOIWUPjal60&amp;t=1868s">https://www.youtube.com/watch?v=AOIWUPjal60&amp;t=1868s</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eo5vTIxazDuQjHoh" /><figcaption>Exemplo de aplicação Ports and Adapters complexa, com múltiplas Portas, Adapters e Camadas, aplicando também o DDD. Créditos: Herberto Graça — <a href="https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/">www.herbertograca.com</a></figcaption></figure><h4><strong>Onde posso aprender mais sobre a Ports and Adapters?</strong></h4><blockquote>&gt; Capítulo 8 do livro <a href="https://www.amazon.com/Learning-Domain-Driven-Design-Vlad-Khononov-ebook/dp/B09J2CMJZY/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=1701952787&amp;sr=1-1">Learning Domain-Driven Design: Aligning Software Architecture and Business Strategy</a> de Vlad Khononov, disponível na Amazon.<br>&gt; Hexagonal Me — <a href="https://jmgarridopaz.github.io/">https://jmgarridopaz.github.io/</a><br>&gt; DDD, Hexagonal, Onion, Clean, CQRS, … How I put it all together — <a href="https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/">https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/</a><br>&gt; Descomplicando “Arquitetura Hexagonal” com Elemar Jr. no canal da EximiaCo em <a href="https://www.youtube.com/watch?v=V7JnDDQY1m0">https://www.youtube.com/watch?v=V7JnDDQY1m0</a><br>&gt; Entrevista Hexagonal Architecture (Ports and Adapters) with Alistair Cockburn // Live #98 — Rodrigo Branas em <a href="https://www.youtube.com/watch?v=AOIWUPjal60">https://www.youtube.com/watch?v=AOIWUPjal60</a> <strong><br></strong>&gt; <a href="https://postech.fiap.com.br/curso/software-architecture/">Pós Tech em Software Architecture</a> da FIAP<br>&gt; Curso Full Cycle em <a href="https://fullcycle.com.br/">https://fullcycle.com.br/</a><br>&gt; Curso de Clean Code e Clean Architecture do Rodrigo Branas em <a href="https://www.branas.io/index.html">https://www.branas.io/</a></blockquote><h3>Clean Architecture (2012)</h3><blockquote>Data de publicação: 13 de agosto de 2012.<br>Visto pela primeira vez em: <a href="https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html">The Clean Code Blog</a>.<br>Autor: Robert C. Martin — Uncle Bob.</blockquote><p>A Clean Architecture foi baseada e fortemente inspirada na <a href="http://jeffreypalermo.com/blog/the-onion-architecture-part-1/">Onion Architecture</a>, publicada em 2008 por Jeffrey Palermo, e também na <a href="https://alistair.cockburn.us/hexagonal-architecture/">Hexagonal Architecture</a> <em>(Ports and Adapters)</em> do Alistair Cockburn.⁷⁰</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*iIvw-4oEpiovU7CK.png" /><figcaption>Robert C. Martin, o Uncle Bob, criador da Clean Architecture</figcaption></figure><p>Todas elas se baseiam nos mesmos princípios de design, possuem os mesmos componentes e possuem os mesmos relacionamentos entre os componentes.⁷¹ A única coisa que difere de uma pra outra basicamente é a terminologia.</p><figure><img alt="The Clean Architecture" src="https://cdn-images-1.medium.com/max/772/0*6rqkN-PzNQ1GWZ2S.jpg" /><figcaption>Os termos “Entities”, “Use Cases”, “Controllers”, “Presenters” e “Gateways” na figura acima indicam o conteúdo de cada camada.</figcaption></figure><p>Basicamente:</p><p>Application layer = service layer = use case layer⁷¹<br>Business logic layer = domain layer = core layer⁷¹</p><h4>Traduzindo os elementos da Arquitetura em Camadas tradicional para a terminologia da Clean Architecture</h4><ul><li>Classe de Application Service da camada de Application = Use Case na Clean Architecture⁷²</li><li>Repositories da camada de Infrastructure = Gateways na Clean Architecture⁷³</li><li>Controllers do MVC = Controllers na camada de Interface Adapters na Clean Architecture</li><li>View do MVC ou front-end em SPA = UI na camada de Frameworks &amp; Drivers na Clean Architecture</li></ul><p>Porém, as semelhanças vão só até a segunda página… Pois, a Clean Architecture é mais prescritiva.</p><h4>Mas, como assim a Clean Architecture é mais prescritiva?🤔</h4><p>Repare na quantidade de ✔️ <em>(check marks)</em> marcados para a Clean Architecture na tabela abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8zid5657ygLBnsRMGFWKDw.png" /></figure><p>Os demais Architectural Patterns não são tão prescritivos quanto a Clean Architecture, deixando o dev livre para optar por implementar <em>ou não</em> Testes, incluir <em>ou não</em> uma Camada de Application, aplicar <em>ou não</em> o DDD. Como é possível notar na tabela acima, a Clean Architecture é mais prescritiva ao tornar <strong>obrigatória </strong>a divisão da aplicação em Camadas⁷⁴, ao <strong>endossar</strong> a Screamimg Architecture⁷⁵ <em>(veja mais sobre a Screamimg Architecture no final do artigo)</em> e ao <strong>requerer </strong>a implementação de Testes como parte do sistema e parte da arquitetura.⁷⁶</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/978/1*O1cHxWVfLMkC1SnScaft5A.png" /><figcaption>Trecho do livro “Clean Architecture” do Uncle Bob.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*FcnsVG-fKo-d1Xe7V4GwEQ.jpeg" /><figcaption>O capítulo 22 do livro “<a href="https://www.amazon.com.br/Clean-Architecture-Craftsmans-Software-Structure-ebook/dp/B075LRM681/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a>” publicado pelo Uncle Bob em 2017 apresenta a Clean Architecture de forma bem didática e fácil de entender. O livro também está disponível em português na <a href="https://www.amazon.com.br/Arquitetura-Limpa-artes%C3%A3o-estrutura-software-ebook/dp/B085PP6Y8P/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Amazon</a>.</figcaption></figure><blockquote>Na Clean Architecture o nome das Camadas não é imposto. Portanto, fica a cargo do desenvolvedor dar nome as camadas. O mais comum é “UseCases”, “Domain” ou “Core” e “Infrastructure”.</blockquote><p>Na prática, alguns devs chamam as Entidades no centro de Camada de “<strong>Domain</strong>”, enquanto outros chamam a camada no centro de “<strong>Core</strong>”. Aqui não há certo ou errado, já que a Clean Architecture não prescreve exatamente qual deve ser o nome de cada camada ou pastinha dentro do seu projeto. <em>Na Clean Architecture você também pode incluir camadas adicionais se desejar.</em>⁷⁷</p><blockquote><em>🛈</em> Os Use Cases geralmente são colocados numa camada chamada “UseCases” porém, alguns devs optam por implementar os Use Cases como Application Services dentro de uma camada de Application na Clean Arch.</blockquote><blockquote>✏️ A Clean Architecture é o Architectural Pattern mais popular em 2024⁷⁸, ela vem sendo utilizada pelo mercado em aplicações modernas que estão nascendo hoje.</blockquote><h4>A Regra de Dependência</h4><figure><img alt="A Regra de Dependência da Clean Achitecture" src="https://cdn-images-1.medium.com/max/312/1*sQzksPUzuBKrt4FAd5E_8A.png" /></figure><p>Na Clean Architecture, assim como na Ports and Adapters, todas as dependências devem SEMPRE apontar para dentro⁷⁹, conforme indicado pelas setas pretas em direção ao centro na figura acima. Os círculos e camadas mais externas devem depender da próxima mais interna, até chegar no <strong>Core <em>(</em></strong><em>também chamado de </em><strong><em>Domínio)</em> </strong>no centro, onde vivem as Entidades. Na prática, assim como na Ports and Adapters, isso é feito usando Interfaces e Inversão de Dependência, com a ajuda de algum Framework de DI. As camadas mais internas definem Interfaces que as camadas e componentes mais externos implementam.</p><blockquote>🚧A Clean Architecture não é uma Relaxed Layered Architecture, portanto uma camada mais externa não pode “pular” a próxima camada adjacente mais interna e depender diretamente de outras mais ao centro. Não é permitido “pular” camadas na Regra de Dependência da Clean Architecture.⁷⁷</blockquote><h4>Eu também posso aplicar DDD na Clean Architecture?🤔</h4><p>SIM! O DDD e a Clean Architecture se complementam e costumam ser aplicados juntos! A camada de Domínio do DDD é o Core da Clean Architecture, localizando bem no centro, onde ficam as Entidades. Porém, apesar disso, a Clean Architecture não torna obrigatória a adoção do DDD.</p><h4>Quando usar a Clean Architecture?</h4><p>A Clean Architecture é uma arquitetura sofisticada, a primeira vista aparentemente um pouco complexa, portanto a complexidade extra da Regra de Dependência da clean arch pode não se justificar em projetos pequenos e acabar se tornando <a href="https://en.wikipedia.org/wiki/Overengineering">Over Engineering</a>, assim como também acontece com as outras Arquiteturas em Camadas. De acordo com o Uncle Bob, sistemas pequenos com menos de <strong>5 mil linhas</strong> de código não irão se beneficiar muito da Clean Architecture.</p><blockquote>“If I’m working on a small application that’s, you know, <strong>less than 5.000 lines of code</strong> I’m not applying Clean Architecture” — Uncle Bob em <a href="https://www.youtube.com/watch?v=ekBWizEpyvo&amp;t=506s">https://www.youtube.com/watch?v=ekBWizEpyvo&amp;t=506s</a></blockquote><blockquote>“Para alguns sistemas simples, dividir a aplicação em UI, regras de negócio e banco de dados é o suficiente.” — Fonte: <a href="https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a> pág. 299</blockquote><h4>Onde posso encontrar um modelo ou template de Clean Architecture para usar em meus projetos?🤔</h4><p>Você pode encontrar templates de aplicações baseadas na Clean Architecture no GitHub. Esses modelos podem ser utilizados como ponto de partida para os seus projetos.</p><p>&gt; C#<br>dotnet new install Amantinband.CleanArchitecture.Template<br>dotnet new clean-arch -o CleanArchitecture<br>Clean Architecture Solution Template by Amichai Mantinband em <a href="https://github.com/amantinband/clean-architecture">https://github.com/amantinband/clean-architecture</a></p><p>&gt; Java<br>clean-architecture-example em <a href="https://github.com/mattia-battiston/clean-architecture-example">https://github.com/mattia-battiston/clean-architecture-example</a></p><p>&gt; Node.js<br>node-api-boilerplate em <a href="https://github.com/talyssonoc/node-api-boilerplate">https://github.com/talyssonoc/node-api-boilerplate</a></p><h4><strong>Onde posso aprender mais sobre a Clean Architecture?</strong></h4><blockquote>&gt; Canal theWiseDev do Otavio Lemos no YouTube em <a href="https://www.youtube.com/@otaviolemos">https://www.youtube.com/@otaviolemos</a><br>&gt; Curso “Arquitetura Limpa na Prática” do Otavio Lemos, Microsoft MVP — <a href="https://www.otaviolemos.com.br/">https://www.otaviolemos.com.br/</a><br>&gt; Curso “Pragmatic Clean Architecture” por Milan Jovanovic (em inglês) — <a href="https://www.milanjovanovic.tech/pragmatic-clean-architecture">https://www.milanjovanovic.tech/pragmatic-clean-architecture</a><br>&gt; Curso “Deep Dive: Clean Architecture in .NET” <br>by Amichai Mantinband (em inglês) — <a href="https://dometrain.com/course/deep-dive-clean-architecture-in-dotnet/">https://dometrain.com/course/deep-dive-clean-architecture-in-dotnet/</a><br>&gt; Curso <a href="https://www.sympla.com.br/evento-online/clean-architecture-e-clean-code-com-net-na-pratica-e-on-line/2250352?referrer=www.vemcodar.com.br">Clean Architecture e Clean Code com .Net na Prática e On-Line</a> com Thamirys Gameiro e Angelo Belchior.<br>&gt; <a href="https://www.amazon.com.br/Clean-Architecture-Craftsmans-Software-Structure-ebook/dp/B075LRM681/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a> de Robert C. Martin, disponível na Amazon em <a href="https://www.amazon.com.br/Clean-Architecture-Craftsmans-Software-Structure-ebook/dp/B075LRM681/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">inglês </a>e em <a href="https://www.amazon.com.br/Arquitetura-Limpa-artes%C3%A3o-estrutura-software-ebook/dp/B085PP6Y8P/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">português</a>.<br>&gt; The Clean Code Blog do Uncle Bob em <a href="https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html">https://blog.cleancoder.com/</a><br>&gt; Capítulo 8 do livro <a href="https://www.amazon.com/Learning-Domain-Driven-Design-Vlad-Khononov-ebook/dp/B09J2CMJZY/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=1701952787&amp;sr=1-1">Learning Domain-Driven Design: Aligning Software Architecture and Business Strategy</a> de Vlad Khononov, disponível na Amazon.<br>&gt; <a href="https://www.amazon.com/Your-Hands-Dirty-Clean-Architecture-ebook/dp/B0CB74FW3J/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Get Your Hands Dirty on Clean Architecture: Build ‘clean’ applications with code examples in Java, 2nd Edition</a> de Tom Hombergs, disponível na Amazon.<br>&gt; <a href="https://postech.fiap.com.br/curso/software-architecture/">Pós Tech em Software Architecture</a> da FIAP<br>&gt; Curso Full Cycle em <a href="https://fullcycle.com.br/">https://fullcycle.com.br/</a><br>&gt; Curso de Clean Code e Clean Architecture do Rodrigo Branas em <a href="https://www.branas.io/index.html">https://www.branas.io/</a></blockquote><h3>Screaming Architecture (2011)</h3><blockquote>Data de publicação: 30 de setembro de 2011.<br>Visto pela primeira vez em: <a href="https://blog.cleancoder.com/uncle-bob/2011/09/30/Screaming-Architecture.html">The Clean Code Blog</a>.<br>Autor: Robert C. Martin — Uncle Bob.</blockquote><p>A Screaming Architecture não é um Layered Architectural Pattern, ou seja, ela não é uma Arquitetura em Camadas.</p><blockquote>O uso da Screaming Architecture é fortemente endossado pela Clean Architecture. Ambas foram propostas pelo Uncle Bob.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q12naK9AwTtdO88Tkiorag.png" /></figure><p>Na imagem acima, a primeira vista qual das duas arquiteturas comunica mais sobre a natureza do sistema? Podemos dizer que a arquitetura a direita “grita” que o sistema em questão se trata de um sistema de e-commerce. Dai vem o nome <strong>Screaming Architecture</strong>⁹⁰, ou Arquitetura Gritante em tradução livre.</p><p>Na Screaming Architecture a estrutura de pastas e arquivos <em>(e consequentemente também dos pacotes no Java e os namespaces no C#)</em> deve refletir <strong>conceitos do modelo de domínio</strong> como “Carrinho”, “Cliente”, “Pedido” e “Produto” e não conceitos puramente técnicos como “Entidades”, “ValueObjects” ou “Services”.</p><h4><strong>Onde posso aprender mais sobre a Screaming Architecture?</strong></h4><blockquote>&gt; The Clean Code Blog do Uncle Bob em <a href="https://blog.cleancoder.com/uncle-bob/2011/09/30/Screaming-Architecture.html">https://blog.cleancoder.com/</a><br>&gt; Screaming Architecture — Clean Code: Architecture, Episode 67 do Uncle Bob em <a href="https://cleancoders.com/episode/clean-code-episode-67">https://cleancoders.com/episode/clean-code-episode-67</a></blockquote><h3>Vertical Slice Architecture (2018)</h3><blockquote>Data de publicação: 19 de abril de 2018.<br>Visto pela primeira vez em: <a href="http://www.jimmybogard.com/">www.jimmybogard.com</a><br>Autor: Jimmy Bogard</blockquote><p>A Vertical Slice Architecture é a mais nova das Arquiteturas em Camadas, ela foi proposta em 2018 por Jimmy Bogard.</p><blockquote><em>🛈</em> Curiosidade: Jimmy Bogard é o criador das populares bibliotecas open-source <a href="https://github.com/jbogard/MediatR">MediatR</a> e <a href="https://automapper.org/">Automapper</a> do .NET e do C#</blockquote><p>A Vertical Slice Architecture veio para resolver uma das maiores dores das demais Arquiteturas em Camadas: A necessidade de procurar, abrir e mexer em todas as camadas ao adicionar novas features na aplicação.¹⁰⁰</p><blockquote>Na Vertical Slice Architecture não fazemos a divisão da aplicação em camadas de UI, Application, Domain e Infrastructure na horizontal.</blockquote><p>Na Vertical Slice Architecture todo código referente a uma determinada feature fica dentro da mesma camada (fatia), representada na vertical em verde na figura abaixo, <strong>minimizando o acoplamento entre fatias e maximizando o acoplamento em uma fatia.</strong>¹⁰⁰</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/581/0*G0ceC9lf4s2J07po.png" /><figcaption>Slice = Fatia em português. Fonte: <a href="https://www.jimmybogard.com/vertical-slice-architecture/">https://www.jimmybogard.com/vertical-slice-architecture/</a></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OR4gbeazV9BOU_-gHoK1zw.jpeg" /><figcaption>Créditos: Milan Jovanović — <a href="https://www.milanjovanovic.tech/">https://www.milanjovanovic.tech/</a></figcaption></figure><blockquote>Na prática, na Vertical Slice Architecture cada fatia é implementada como um package no Java, ou como um Projeto no C# — Fonte: <a href="https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure-ebook/dp/B075LRM681/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a> pág. 395</blockquote><p>Na Vertical Slice Architecture cada Slice pode ser implementada utilizando tecnologias e padrões de projeto diferentes.¹⁰⁰ No exemplo da figura abaixo, uma aplicação em .NET, uma fatia (representada agora na horizontal) utilizou o ORM EF Core e DTOs, a outra utilizou o micro ORM Dapper, a outra utilizou o padrão Repository com o Rich domain model do DDD e na última o EF Core do .NET, usando o método ExecuteDeleteAsync.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*I49Eab5qNq8q9aM2" /></figure><blockquote><em>💡</em>A Vertical Slice Architecture também pode ser implementada em conjunto com a Clean Architecture, criando o que alguns chamam informalmente de “Clean Vertical Slice Architecture”.</blockquote><p>A Vertical Slice Architecture vem ganhando popularidade nos últimos anos.</p><h4>Onde posso aprender mais sobre a Vertical Slice Architecture?</h4><blockquote>&gt; Artigo “Vertical Slice Architecture” de Jimmy Bogard em <a href="https://www.jimmybogard.com/vertical-slice-architecture/">https://www.jimmybogard.com/</a><br>&gt; “Vertical Slice Architecture” no canal <br>Pisani da ArcH no YouTube em <a href="https://www.youtube.com/watch?v=HOkt02QzoRc">https://www.youtube.com/watch?v=HOkt02QzoRc</a><br>&gt; Artigo “Vertical Slice Architecture” de Milan Jovanovic em <a href="https://www.milanjovanovic.tech/blog/vertical-slice-architecture">https://www.milanjovanovic.tech/blog/vertical-slice-architecture</a><br>&gt; Capítulo 34 do livro <a href="https://www.amazon.com.br/Clean-Architecture-Craftsmans-Software-Structure-ebook/dp/B075LRM681/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a> de Robert C. Martin, disponível na Amazon em <a href="https://www.amazon.com.br/Clean-Architecture-Craftsmans-Software-Structure-ebook/dp/B075LRM681/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">inglês </a>e em <a href="https://www.amazon.com.br/Arquitetura-Limpa-artes%C3%A3o-estrutura-software-ebook/dp/B085PP6Y8P/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">português</a>.</blockquote><h3>Conclusão</h3><p>Como podemos notar, as arquiteturas em camadas foram evoluindo com o passar do tempo…</p><p>A Clean Architecture do Uncle Bob pode ser considerada como uma “evolução” da Onion Architecture do Jeffrey Palermo e da Ports and Adapters do Alistair Cockburn, que por sua vez também foi uma “evolução” da Arquitetura em Camadas N-Layer tradicional de 2002 do Martin Fowler.</p><p>Tanto a Ports and Adapters como a Clean Architecture são consideradas arquiteturas <strong>domain-centric</strong>, pois ambas colocam o Domínio no centro da aplicação, isolando o domínio de detalhes externos como a UI e o banco de dados.</p><p>Independente de qual arquitetura em camadas você escolha utilizar no seu projeto de software, a camada de <strong>Domínio </strong>será sempre a mais importante, ela será o “coração” do software, como já dizia o Erick Evans no seu livro Domain-Driven Design.</p><h3>Considerações finais</h3><p>Para entender bem a Clean Architecture você precisa entender bem a Ports and Adapters. Para entender bem a Ports and Adapters você precisa entender bem antes a Arquitetura em Camadas “N-Layer” tradicional. Assim você será capaz de entender verdadeiramente bem o porquê da existência de cada uma, porquê elas foram criadas e que problemas elas resolvem.</p><p><em>O objetivo desse artigo é apresentar de forma simplista e bem resumida conceitos complexos de arquitetura de software. Alguns detalhes foram omitidos ou muito simplificados a fim de tornar o texto mais digerível para quem está tendo contato com os temas pela primeira vez.</em></p><p><em>Todas as informações apresentadas foram reproduzidas com base na literatura e/ou baseadas em declarações públicas dos autores, todas as fontes estão enumeradas abaixo.</em></p><figure><img alt="escrito por humano não por IA" src="https://cdn-images-1.medium.com/max/131/1*3p2RgKls_kN78apL9HBpUg@2x.png" /></figure><h3>Referências</h3><blockquote><strong>DDD</strong><br>¹Eric, Evans. Domain-Driven Design: Tackling Complexity in the Heart of Software (p. 500 — Conclusion). Pearson Education. Edição do Kindle.<br>²Khononov, Vlad. Learning Domain-Driven Design (p. 10 — Who Should Read This Book). O’Reilly Media. Edição do Kindle.<br>³Eric, Evans. Domain-Driven Design: Tackling Complexity in the Heart of Software (p. 413 — Project Risk Management). Pearson Education. Edição do Kindle.<br>⁴Khononov, Vlad. Learning Domain-Driven Design (p. 353 — Bounded Contexts). O’Reilly Media. Edição do Kindle.<br>⁵Khononov, Vlad. Learning Domain-Driven Design (p. 20 — Introduction). O’Reilly Media. Edição do Kindle.<br>⁶Martin, Fowler. Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series (Fowler)) (p. 17 — Chapter 1. Layering). Pearson Education. Edição do Kindle.<br>⁷Martin, Fowler. Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series (Fowler)) (p. 103 — Other Layering Schemes). Pearson Education. Edição do Kindle.<br>⁸Eric, Evans. Domain-Driven Design: Tackling Complexity in the Heart of Software (p. 68 — Layered Architecture). Pearson Education. Edição do Kindle.<br>⁹Eric, Evans. Domain-Driven Design: Tackling Complexity in the Heart of Software (p. 75 — The Domain Layer Is Where the Model Lives). Pearson Education. Edição do Kindle.<br><strong>Architectural Patterns</strong><br>¹⁰Architectural pattern — <a href="https://en.wikipedia.org/wiki/Architectural_pattern">https://en.wikipedia.org/wiki/Architectural_pattern</a><br>¹¹Martin, Fowler. Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series (Fowler)) (p. 17 — Chapter 1. Layering). Pearson Education. Edição do Kindle.<br>¹²Khononov, Vlad. Learning Domain-Driven Design (p. 195 — Layered Architecture). O’Reilly Media. Edição do Kindle.<br>¹³Traditional “N-Layer” architecture applications — <a href="https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures#traditional-n-layer-architecture-applications">https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures#traditional-n-layer-architecture-applications</a><br><strong>Arquitetura em Camadas N-Layer tradicional</strong><br>²⁰Khononov, Vlad. Learning Domain-Driven Design (p. 195 — Layered Architecture). O’Reilly Media. Edição do Kindle.<br>²¹Traditional “N-Layer” architecture applications — <a href="https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures#traditional-n-layer-architecture-applications">https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures#traditional-n-layer-architecture-applications</a><br>²²Khononov, Vlad. Learning Domain-Driven Design (p. 196 — Layered Architecture). O’Reilly Media. Edição do Kindle.<br>²³Khononov, Vlad. Learning Domain-Driven Design (p. 199 — Variation). O’Reilly Media. Edição do Kindle.<br>²⁴Martin, Fowler. Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series (Fowler)) (p. 31 — Service Layer). Pearson Education. Edição do Kindle.<br>²⁵Khononov, Vlad. Learning Domain-Driven Design (p. 202 — Variation). O’Reilly Media. Edição do Kindle.<br>²⁶Traditional “N-Layer” Architecture Layers — <a href="https://aspnetboilerplate.com/Pages/Documents/NLayer-Architecture#asp-net-boilerplate-application-architecture-model">https://aspnetboilerplate.com/Pages/Documents/NLayer-Architecture#asp-net-boilerplate-application-architecture-model</a><br>²⁷Khononov, Vlad. Learning Domain-Driven Design (p. 200 — Layered Architecture). O’Reilly Media. Edição do Kindle.<br>²⁸Khononov, Vlad. Learning Domain-Driven Design (p. 196 — Presentation Layer). O’Reilly Media. Edição do Kindle.<br>²⁹Khononov, Vlad. Learning Domain-Driven Design (p. 198 — Data Access Layer). O’Reilly Media. Edição do Kindle.<br>³⁰Khononov, Vlad. Learning Domain-Driven Design (p. 205 — Terminology). O’Reilly Media. Edição do Kindle.<br>³¹Eric, Evans. Domain-Driven Design: Tackling Complexity in the Heart of Software (p. 75 — The Domain Layer Is Where the Model Lives). Pearson Education. Edição do Kindle.<br>³²Khononov, Vlad. Learning Domain-Driven Design (p. 197 — Business Logic Layer). O’Reilly Media. Edição do Kindle.<br>³³Traditional “N-Layer” Architecture Layers — <a href="https://aspnetboilerplate.com/Pages/Documents/NLayer-Architecture#asp-net-boilerplate-application-architecture-model">https://aspnetboilerplate.com/Pages/Documents/NLayer-Architecture#asp-net-boilerplate-application-architecture-model</a><br><strong>N-Tier Architecture</strong><br>⁴⁰Martin, Fowler. Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series (Fowler)) (p. 19 - Chapter 1. Layering). Pearson Education. Edição do Kindle.<br>⁴¹N-tier architecture style — <a href="https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/n-tier">https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/n-tier</a><br>⁴²Khononov, Vlad. Learning Domain-Driven Design (p. 206). O’Reilly Media. Edição do Kindle.<br>⁴³What is three-tier architecture? — IBM em <a href="https://www.ibm.com/topics/three-tier-architecture">https://www.ibm.com/topics/three-tier-architecture</a><br>⁴⁴Martin, Fowler. Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series (Fowler)) (p. 19). Pearson Education. Edição do Kindle.<br><strong>Arquitetura Hexagonal/Ports and Adapters</strong><br>⁵⁰Khononov, Vlad. Learning Domain-Driven Design (p. 208 — Dependency Inversion Principle). O’Reilly Media. Edição do Kindle.<br>⁵¹Publicação de Vaughn Vernon no LinkedIn em <a href="https://www.linkedin.com/posts/vaughnvernon_hexagonal-architecture-common-pitfalls-activity-7157454786202685440-PH7x/">https://www.linkedin.com/posts/vaughnvernon_hexagonal-architecture-common-pitfalls-activity-7157454786202685440-PH7x/</a> em 28/01/2024<br>⁵²Hexagonal Architecture (Ports and Adapters) with Alistair Cockburn // Live #98 — Rodrigo Branas em <a href="https://www.youtube.com/watch?v=AOIWUPjal60">https://www.youtube.com/watch?v=AOIWUPjal60</a><br><strong>Clean Architecture</strong><br>⁷⁰The Clean Architecture — <a href="https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html">https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html</a><br>⁷¹Khononov, Vlad. Learning Domain-Driven Design (p. 212 — Variants). O’Reilly Media. Edição do Kindle.<br>⁷²Martin, Fowler. Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series (Fowler)) (p. 30 — Service Layer). Pearson Education. Edição do Kindle.<br>⁷³Martin, Fowler. Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series (Fowler)) (p. 465 — Chapter 18. Base Patterns). Pearson Education. Edição do Kindle.<br>⁷⁴Martin, Robert C.. Arquitetura Limpa: O guia do artesão para estrutura e design de software (Robert C. Martin) (Portuguese Edition) (p. 275 — Arquitetura Limpa). Alta Books. Edição do Kindle.<br>⁷⁵Martin, Robert C.. Arquitetura Limpa: O guia do artesão para estrutura e design de software (Robert C. Martin) (Portuguese Edition) (p. 268 — Arquitetura Gritante). Alta Books. Edição do Kindle.<br>⁷⁶Martin, Robert C.. Arquitetura Limpa: O guia do artesão para estrutura e design de software (Robert C. Martin) (Portuguese Edition) (p. 329 — O Limite Teste). Alta Books. Edição do Kindle.<br>⁷⁷Martin, Robert C.. Arquitetura Limpa: O guia do artesão para estrutura e design de software (Robert C. Martin) (Portuguese Edition) (p. 280 — Só Quatro Círculos?). Alta Books. Edição do Kindle.<br>⁷⁸Google Trends — <a href="https://trends.google.com.br/trends/explore?date=all&amp;q=Clean%20Architecture,Hexagonal%20Architecture,Ports%20and%20Adapters,Layered%20Architecture,N-Layer%20Architecture&amp;hl=pt">https://trends.google.com.br/trends/explore?date=all&amp;q=Clean%20Architecture,Hexagonal%20Architecture,Ports%20and%20Adapters,Layered%20Architecture,N-Layer%20Architecture&amp;hl=pt</a><br>⁷⁹Martin, Robert C.. Arquitetura Limpa: O guia do artesão para estrutura e design de software (Robert C. Martin) (Portuguese Edition) (p. 277 — A Regra da Dependência). Alta Books. Edição do Kindle.<br><strong>Screaming Architecture</strong><br>⁹⁰Martin, Robert C.. Arquitetura Limpa: O guia do artesão para estrutura e design de software (Robert C. Martin) (Portuguese Edition) (p. 268 — Arquitetura Gritante). Alta Books. Edição do Kindle.<br><strong>Vertical Slice Architecture</strong><br>¹⁰⁰Vertical Slice Architecture by Jimmy Bogard — <a href="https://www.jimmybogard.com/vertical-slice-architecture/">https://www.jimmybogard.com/vertical-slice-architecture/</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28cd7f910b3d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Quantos Repositories devo ter na camada de Infrastructure?]]></title>
            <link>https://medium.com/@dannevesdantas/quantos-repositories-eu-devo-ter-na-camada-de-infrastructure-3dff21ac2782?source=rss-c7861d094d51------2</link>
            <guid isPermaLink="false">https://medium.com/p/3dff21ac2782</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[repository-pattern]]></category>
            <dc:creator><![CDATA[Danilo Dantas]]></dc:creator>
            <pubDate>Fri, 10 Nov 2023 17:09:52 GMT</pubDate>
            <atom:updated>2024-06-09T01:16:39.485Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z3CiURyJ5wCpjrC9xobQhA.jpeg" /></figure><h3>Quantos Repositories devo ter na camada de Infrastructure? Um guia prático para identificar limites ao implementar o Repository Pattern</h3><p>Se você é Software Engineer, ao iniciar um novo projeto sempre surge aquela dúvida na hora de implementar a camada de Infrastructure: Quantos e quais Repositories devo criar? Qual a granularidade ideal? Aqui vai um guia prático para ajudar com o design dos seus Repositories.</p><h3>Vamos recapitular alguns conceitos básicos sobre os Building Blocks do Domain-Driven Design</h3><p>✏️<strong>Entidades: </strong>Uma entidade nada mais é do que, em palavras bem simples e resumidas, uma classe que <strong>possui um identificador - ou seja: um ID</strong>. Ela, ao contrário dos objetos transientes, possui um ciclo de vida mais longo e representam conceitos do modelo do domínio.</p><p>✏️<strong>Value Objects: </strong>Os Value Objects também representam conceitos do domínio, porém normalmente são objetos transientes que não precisam ser persistidos com um identificador (ID) e devem sempre ser <strong>imutáveis</strong>, devendo ser substituído por uma outra nova instância do Value Object caso o seu valor precise ser alterado. <em>Value Objects ajudam a combater a </em><a href="https://refactoring.guru/pt-br/smells/primitive-obsession"><em>Primitive Obsession</em></a><em>.</em></p><p>✏️<strong>Agregados:</strong> Em palavras simples Agregados são um conjunto de objetos, composto por uma (somente uma) Entidade Raiz <em>(também chamada de Entidade Root)</em> que pode possuir referência(s) para outra(s) Entidades ou Value Objects que precisam ser enxergados todos juntos como uma única unidade a fim de garantir a consistência e a invariância, ou seja, as regras de negócio e validações ao gravar e ler do banco de dados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rczl-w7c76d2uKd_3xRohw.jpeg" /><figcaption>Créditos: ByteByteGo.com</figcaption></figure><h3>A regra geral é: Crie um (no máximo um) Repository para cada Agregate Root presente na camada de Domínio.</h3><p>A regra de ouro é: Um Repository para cada Agregate Root. Agregados inteiros devem ser persistidos, lidos, alterados e excluídos de uma só vez, de maneira atômica, na mesma transação de banco de dados a fim de garantir a invariância <em>(ou seja, as regras de negócio e validações)</em> e a consistência de todos os objetos <em>(Entidades e Value Objects)</em> que compõem e fazem parte do Agregado.</p><blockquote>✏️Cada Agregado existente na camada de Domínio pode possuir o seu respectivo Repository implementado na camada de Infrastructure.<em>¹</em></blockquote><h3><strong>É importante saber</strong></h3><p>Entidades, que a princípio aparentemente não fazem parte de nenhum Agregado, mas que possuem referência(s), associação(ões) e travessia para outro(s) objeto(s) dentro dela <em>(sendo eles outras Entidade(s) ou Value Objects)</em> são entendidas como sendo raízes de um Agregado e, portanto, também pode ser criado um Repository para ela na camada de Infrastructure.</p><h3><strong>Dica</strong></h3><p>Se uma Entidade não for a raiz de um Agregado, não possuir nenhuma referência ou travessia para nenhum Value Object ou outra Entidade que a compõem, nem fizer parte de nenhum outro Agregado, também pode ser criado um Repository para ela na camada de Infrastructure, pois elas também são consideradas como sendo raízes de seu próprio Agregado.</p><blockquote>⚠️ATENÇÃO! Não se deve criar Repositories para acessar diretamente Entidades <em>(ou Value Objects)</em> que façam parte de Agregados — salvo os casos onde a Entidade for o Agregate Root do Agregado. Nesses casos elas devem ser acessadas somente através de travessia, partindo da Entidade root do Agregado do qual a Entidade faz parte.<em>¹</em></blockquote><p>💡Um Repository deve prover uma intention-revealing interface coesa para operações CRUD — Create, Read, Update, Delete mas pode também retornar uma contagem — COUNT() do SQL ou totais — usando a função SUM() do SQL por exemplo— de acordo com algum critério especificado pelo Client ou seja, pela classe que vai fazer uso do Repository.</p><p>Seguindo as regras acima fica bem mais fácil determinar quando, quantos e quais Repositories criar ao implementar a camada de Infrastruture na tradicional Arquitetura em Camadas N-Layer.</p><figure><img alt="escrito por humano não por IA" src="https://cdn-images-1.medium.com/max/131/1*3p2RgKls_kN78apL9HBpUg@2x.png" /></figure><h3>Referências</h3><blockquote><em>¹</em>Eric, Evans. Domain-Driven Design: Tackling Complexity in the Heart of Software (p. 147). Pearson Education. Edição do Kindle.<br><em>²</em>Série “DDD do Jeito Certo” no YouTube em <a href="https://youtu.be/FeqpZ9w-CRA?si=TZxeT42NVdBzWj3p">https://youtu.be/FeqpZ9w-CRA?si=TZxeT42NVdBzWj3p</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3dff21ac2782" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Onde estudar DDD em 2023?]]></title>
            <link>https://medium.com/@dannevesdantas/onde-estudar-ddd-em-2023-97a35d04ca2a?source=rss-c7861d094d51------2</link>
            <guid isPermaLink="false">https://medium.com/p/97a35d04ca2a</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <dc:creator><![CDATA[Danilo Dantas]]></dc:creator>
            <pubDate>Mon, 23 Oct 2023 16:09:34 GMT</pubDate>
            <atom:updated>2024-06-09T01:16:09.235Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_yxy7RdanqUjpFvePriDJA.jpeg" /></figure><p>O famoso livro de capa azul foi o primeiro publicado sobre o assunto em 2003 por <em>Erick Evans. </em>Apesar disso, o assunto já havia sido abordado de forma introdutória um ano antes por Martin Fowler no livro <em>Patterns of Enterprise Application Architecture</em> em 2002. Desde então mais de 20 anos se passaram e o assunto ainda é muito relevante nos dias atuais, e está em constante debate em eventos ao redor do mundo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3RsY0yZGTSyG-xdo.jpg" /><figcaption>Erick Evans, autor do DDD, no evento DDD Europe em 2019. Fonte: <a href="https://www.youtube.com/watch?v=pMuiVlnGqjk">Domain-Driven Design Europe on YouTube</a>.</figcaption></figure><h3><strong>Onde posso aprender mais sobre DDD?</strong></h3><p>A verdade cruel é: DDD é um assunto extenso que requer muito tempo de estudo para ser verdadeiramente bem compreendido. Não é possível aprender bem DDD lendo um artigo de 10 minutos, ou assistindo a um único vídeo de uma hora no YouTube🤯</p><p>Mas, aqui vão algumas dicas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*0IoswcfqX8foGems3bSU1A.jpeg" /><figcaption>Famoso livro da capa azul de Erick Evans, publicado em 2003.</figcaption></figure><blockquote>O livro original de capa azul de 2003 já possui 20 anos, é conhecido por ser muito denso, difícil de ler e de assimilar.</blockquote><p>O livro original do DDD, publicado por Erick Evans em 2003 está <a href="https://www.amazon.com.br/Domain-Driven-Design-Tackling-Complexity-Software-ebook/dp/B00794TAUG/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">disponível na Amazon</a> em versões impressa e digital no Kindle. Em 2016 foi publicada também a <a href="https://www.amazon.com.br/Domain-driven-design-atacando-complexidades-software/dp/8550800651/ref=asc_df_8550800651/?tag=googleshopp00-20&amp;linkCode=df0&amp;hvadid=379739109739&amp;hvpos=&amp;hvnetw=g&amp;hvrand=8563730458184171172&amp;hvpone=&amp;hvptwo=&amp;hvqmt=&amp;hvdev=c&amp;hvdvcmdl=&amp;hvlocint=&amp;hvlocphy=1031606&amp;hvtargid=pla-809277038576&amp;psc=1">3ª edição revisada do livro em português</a>, que está disponível somente na versão impressa. Infelzimente a versão em português possui ainda alguns erros de tradução em alguns trechos.</p><h4><strong>Learning Domain-Driven Design</strong></h4><p>Em 2021 o autor <em>Vlad Khononov</em> abordou o tema de forma mais objetiva e adaptada aos dias atuais no livro “<strong>Learning Domain-Driven Design: Aligning Software Architecture and Business Strategy</strong>” que está <a href="https://www.amazon.com.br/Learning-Domain-Driven-Design-English-Khononov-ebook/dp/B09J2CMJZY/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">disponível na Amazon</a> somente em inglês.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*8b9y6ZahF6nRafDwGI9cuQ.jpeg" /><figcaption>O livro “Learning Domain-Driven Design” publicado por Vlad Khononov em 2021 é mais didático.</figcaption></figure><blockquote>Se DDD é novidade para você, considere o livro de Vlad Khononov pois ele é MUITO mais didático que o livro original do Erick Evans, publicado em 2003.</blockquote><p>Além disso, ele aborda o tema de forma moderna, voltada para os dias atuais, aplicando o DDD com <strong>microsseviços</strong>, <strong>CQRS</strong>, <strong>mensageria</strong>,<strong> Arquitetura Hexagonal/Ports and Adapters</strong>,<strong> Clean Architecture </strong>e outras tecnologias que ainda não existiam ou não eram tão populares e disseminadas quando o livro de capa azul original foi publicado em 2003.</p><blockquote>⭐DICA: O livro “Learning Domain-Driven Design” de 2021 é dividido em 4 Partes. Se você estiver sem tempo, foque nas Partes I e II, pois essas duas partes são as mais importantes, elas cobrem tudo sobre DDD! Enquanto as Partes III e IV relacionam DDD com outros temas, como microsserviços por exemplo…</blockquote><blockquote><strong>Sem dúvidas o livro “Learning Domain-Driven Design” é simplesmente o melhor e mais completo material sobre DDD nos dias atuais!</strong>🚀</blockquote><p>O livro de Vlad Khononov apresenta também vários exemplos de código em C# que podem ser facilmente compreendidos por programadores que conhecem outras linguagens de programação.</p><h4>Outros livros</h4><p>Além dos dois livros citados acima, outros livros famosos sobre DDD são o famoso <em>livro da capa vermelha</em> “<strong>Implementing Domain-Driven Design</strong>” de Vaughn Vernon publicado em 2013 e o “<strong>Domain-Driven Design Distilled</strong>” de capa verde publicado em 2016.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*b7g3On2YaUEzQ29t" /><figcaption>Créditos: <a href="https://ddd.mikaelvesavuori.se/">https://ddd.mikaelvesavuori.se/</a></figcaption></figure><p>O livro “<strong>Implementing Domain-Driven Design</strong>” de 2013 foca um pouco mais na parte prática, em como aplicar o DDD, contendo vários exemplos de código em Java. Ele aborda também tópicos e tecnologias mais modernas como por exemplo Bancos de Dados <strong>NoSQL</strong>, <strong>Event-Driven Architecture</strong> e <strong>APIs REST</strong>.</p><p>O último, “<strong>Domain-Driven Design Distilled</strong>” de 2016 é basicamente um resumo sobre o assunto.</p><h4>DDD do jeito certo no YouTube</h4><p>Se você prefere consumir conteúdo em vídeo, o Microsoft MVP Elemar Jr. é especialista no assunto e possui uma playlist “DDD do jeito certo” no YouTube em <a href="https://www.youtube.com/watch?v=2X9Q97u4tUg&amp;list=PLkpjQs-GfEMN8CHp7tIQqg6JFowrIX9ve">https://www.youtube.com/watch?v=2X9Q97u4tUg&amp;list=PLkpjQs-GfEMN8CHp7tIQqg6JFowrIX9ve</a> com mais de 3 horas de duração.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*t-W12rutRmf5YzLu.jpg" /></figure><p>Ele também possui um excelente grupo de estudos fechado (pago) sobre o assunto, com aulas quinzenais.<br><a href="https://elemarjr.com/clube-de-estudos/ddd-do-jeito-certo/">https://elemarjr.com/clube-de-estudos/ddd-do-jeito-certo/</a></p><h4>Curso Full Cycle</h4><p>O curso e o MBA <strong>Full Cycle</strong> ministrado pelo Wesley Willians, Microsoft MVP, também aborda o assunto em <a href="https://fullcycle.com.br/">https://fullcycle.com.br/</a> de forma prática e objetiva.</p><h4>Pós Tech em Software Architecture da FIAP</h4><p>A <a href="https://postech.fiap.com.br/curso/software-architecture/">Pós Tech em Software Architecture da FIAP</a> também aborda o tema de forma prática. Como metodologia de aprendizagem a Pós Tech da FIAP adota o Project Based Learning (PBL). As disciplinas do curso estão dispostas em uma jornada de 5 fases de um projeto completo que soluciona problemas reais do mercado. A Pós Graduação possui 10 meses de duração.</p><p>Pós Tech em Software Architecture da FIAP<br><a href="https://postech.fiap.com.br/curso/software-architecture/">https://postech.fiap.com.br/curso/software-architecture/</a></p><figure><img alt="escrito por humano não por IA" src="https://cdn-images-1.medium.com/max/131/1*3p2RgKls_kN78apL9HBpUg@2x.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=97a35d04ca2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Afinal de contas, qual é exatamente a diferença entre Regra de Negócio e Lógica de Negócio?]]></title>
            <link>https://medium.com/@dannevesdantas/qual-%C3%A9-a-diferen%C3%A7a-entre-regra-de-neg%C3%B3cio-e-l%C3%B3gica-de-neg%C3%B3cio-e6799e4a7b72?source=rss-c7861d094d51------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6799e4a7b72</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Danilo Dantas]]></dc:creator>
            <pubDate>Mon, 16 Oct 2023 20:03:43 GMT</pubDate>
            <atom:updated>2024-06-09T01:17:33.423Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q7VUmR8luqTY_yhNDqDIyg.jpeg" /></figure><p>Os termos “Regra de Negócio” e “Lógica de Negócio” não raramente são confundidos e usados intercambiavelmente. Você sabe exatamente qual é o significado desses termos? Vamos abordar cada um deles de forma bem clara, didática, com palavras bem simples e objetivas.</p><h3>O que exatamente significa o termo “Regra de Negócio”?🤔</h3><p>As Regras de Negócio são, em palavras bem simples, os “IFs” da sua aplicação.¹</p><p>Por exemplo:</p><ul><li>“Somente alunos com idade <strong><em>≥ 18</em></strong> anos podem se matricular para obter uma CNH”;</li><li>“Caso haja faturas em aberto com <strong><em>mais de 3 meses</em></strong><em> </em>de atraso, o acesso deverá ser bloqueado”;</li><li>“O usuário pode incluir <strong><em>no máximo 6 unidades</em></strong> do mesmo item no carrinho”;</li><li>“O tomador precisa ter score <strong><em>≥ 500 </em></strong>para ter acesso as linhas de crédito”.</li></ul><blockquote><em>No DDD os “IFs” das Regras de Negócio ficam dentro das classes de Entidades, ou dentro das Domain Services quando não pertencem a nenhuma Entidade em específico ou quando pertencem a mais de uma Entidade ao mesmo tempo</em>¹<em>.</em></blockquote><h3>E o que exatamente significa o termo “Lógica de Negócio”?🤔</h3><p>A Lógica de Negócio (as vezes também chamada de lógica de domínio ou lógica do negócio, ou também de “regra de negócio”) é, em palavras simples, uma sequência ordenada de passos <em>(ou seja, um algoritmo!)</em> necessários para executar um processo de negócio na empresa.²</p><p>Por exemplo, para fazer a criação de um pedido num e-commerce é necessário:</p><p>1º) Checar se há estoque do produto desejado;<br>2º) Calcular o valor do frete;<br>3º) Gravar o pedido no banco de dados;<br>4º) Enviar o pedido para o WMS — Warehouse Management System para separação no Centro de Distribuição;<br>5º) Fazer a emissão da NF;<br>6º) Entregar o pedido a transportadora;<br>e assim por diante…</p><blockquote><em>Na prática, a Lógica de Negócio é geralmente implementada como métodos públicos nas classes de Entidades, ou nas classes de Domain Services do DDD</em>²<em>.</em></blockquote><p>Dentro do código da lógica de negócio são implementados os “IFs” das regras de negócio¹.</p><blockquote>⚠️Alguns livros, como o “Clean Architecture” do Uncle Bob por exemplo, usam o termo “regra de negócio” para se referir a lógica de negócio, e vice-versa. Intercambiavelmente.⁵</blockquote><h4>Tornando as Regras de Negócio explicitas</h4><p>O Design Pattern <strong>Specification</strong> pode ajudar a tornar as regras de negócio mais explicitas¹, evitando múltiplos IFs espelhados pelo código.</p><p>No exemplo abaixo, retirado do livro <em>Domain-Driven Design</em>, a regra de negócio que verifica a idade de uma Person foi movida para uma classe separada, chamada MinimumAgeSpecification.</p><pre>public class MinimumAgeSpecification {<br>  int threshold;<br><br>public MinimumAgeSpecification(int minAge) {<br>  threshold = minAge;<br>}<br><br>public boolean isSatisfiedBy(Person candidate) {<br>  return candidate.getAge() &gt;= threshold;<br>}</pre><p>Agora, basta conferir se Person está de acordo com a regra de negócio especificada pela classe MinimumAgeSpecification.</p><pre>drivingAgeSpecification = new MinimumAgeSpecification(18);<br><br>public boolean canDrive(Person candidate) {<br>  return drivingAgeSpecification.isSatisfiedBy(candidate);<br>}</pre><p>O Design Pattern Specification também facilita a alteração ou atualização da Regra de Negócio, quando ocorrem alterações na legislação vigente por exemplo.</p><blockquote>Você pode aprender mais sobre o Specification Pattern assistindo à Parte 08 da série “DDD do jeito certo” no YouTube em <a href="https://youtu.be/dCdOG_RZpxU?si=F84fpl-dDZp2V4aM">https://youtu.be/dCdOG_RZpxU?si=F84fpl-dDZp2V4aM</a></blockquote><figure><img alt="escrito por humano não por IA" src="https://cdn-images-1.medium.com/max/131/1*3p2RgKls_kN78apL9HBpUg@2x.png" /></figure><h3>Referências</h3><blockquote>¹Eric, Evans. <a href="https://www.amazon.com.br/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215/ref=tmm_hrd_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Domain-Driven Design: Tackling Complexity in the Heart of Software</a> (pág. 18). Pearson Education.<br>²Khononov, Vlad. <a href="https://www.amazon.com.br/Learning-Domain-Driven-Design-English-Khononov-ebook/dp/B09J2CMJZY/ref=tmm_kin_swatch_0?_encoding=UTF8&amp;qid=&amp;sr=">Learning Domain-Driven Design</a> (p. 8). O’Reilly Media. Edição do Kindle.<br>³What are business rules? — IBM em <a href="https://www.ibm.com/topics/business-rules">https://www.ibm.com/topics/business-rules</a><br>Khononov, Vlad. <a href="https://www.amazon.com/Learning-Domain-Driven-Design-Aligning-Architecture/dp/1098100131">Learning Domain-Driven Design</a>. O’Reilly Media.<br>⁴Business Logic Definition — WikiWikiWeb em <a href="https://wiki.c2.com/?BusinessLogicDefinition">https://wiki.c2.com/?BusinessLogicDefinition</a><br>⁵Martin, Robert C.. <a href="https://www.amazon.com.br/Arquitetura-Limpa-Artes%C3%A3o-Estrutura-Software/dp/8550804606">Arquitetura Limpa: O guia do artesão para estrutura e design de software</a> (Robert C. Martin) (Portuguese Edition) (p. 260). Alta Books. Edição do Kindle.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6799e4a7b72" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Resumo do livro Software Engineering at Google: Lessons Learned from Programming Over Time]]></title>
            <link>https://medium.com/@dannevesdantas/resumo-do-livro-software-engineering-at-google-lessons-learned-from-programming-over-time-62c3e7ac1de?source=rss-c7861d094d51------2</link>
            <guid isPermaLink="false">https://medium.com/p/62c3e7ac1de</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[google]]></category>
            <dc:creator><![CDATA[Danilo Dantas]]></dc:creator>
            <pubDate>Sat, 19 Aug 2023 22:54:20 GMT</pubDate>
            <atom:updated>2024-06-09T01:18:02.719Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*h9UDdoHGhPoyPuxYeCM7qw.jpeg" /><figcaption>Complexo de edifícios que formam a sede do Google na cidade de Mountain View, Califórnia</figcaption></figure><p>Se você, assim como eu, gosta ou trabalha com tecnologia já deve ter visto o filme <a href="https://www.adorocinema.com/filmes/filme-206149/"><strong>Os Estagiários</strong></a><strong>, </strong>de 2013, com os atores <em>Owen Wilson</em> e <em>Vince Vaungh</em>. O filme conta a história de dois amigos que após perderem o emprego conseguem uma entrevista para estágio no Google.</p><p>Na vida real, o Google é considerado a <a href="https://www.humanresourcesonline.net/world-s-most-attractive-employers-2021-google-microsoft-apple-and-more">empresa mais atrativa do mundo para se trabalhar</a> em 2021. Parte disso se deve a política interna de comida grátis, ambientes inovadores, equipe talentosa, entre vários outros incentivos a fim de atrair os melhores talentos.</p><p>Em 2020 os engenheiros Titus Winters, Hyrum Wright e Tom Manshreck do Google publicaram o livro <strong>Software Engineering at Google: Lessons Learned from Programming Over Time</strong> compartilhando mais detalhes sobre a <strong>Cultura</strong>, os <strong>Processos </strong>e as <strong>Ferramentas </strong>utilizadas pelo Google no dia-a-dia no desenvolvimento de produtos que impactam diariamente a vida de milhões de pessoas ao redor do mundo.</p><p>O livro é bem grande e possui 999 páginas no Kindle. O livro apresenta vários cases e problemas reais enfrentados pelo Google ao longo dos últimos 20 anos para conseguir escalar as suas aplicações de forma sustentável.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*_8-8iBjCvevkzrZlu7hMOQ.jpeg" /></figure><p>Aqui vão algumas highlights e curiosidades sobre as práticas de Engenharia de Software na empresa mais atrativa do mundo:</p><p>📕A palavra humildade (<em>humility</em>) aparece 32 vezes no livro. A palavra “<em>ego</em>” aparece 23 vezes e a palavra puxa-saco (<em>pushover</em>) aparece 10 vezes.</p><p>🤓Todo Tech Manager no Google deve possuir conhecimento técnico.</p><p>🏫O Google procura contratar pessoas que possuem excelente desempenho acadêmico.</p><p>👨‍💻O Google versiona seu monorepo com base na <strong>Trunk Based Development</strong> utilizando uma ferramenta de VCS — Version Control System desenvolvida in-house chamada <strong>Piper</strong>. Eles já tentaram mudar pro Git pra facilitar a vida dos Nooglers (novos Googlers) mas não conseguiram.</p><p>💣Se algo quebrar em produção após um deploy, a “culpa” não é de quem fez o deploy, mas sim da equipe que falhou ao deixar de escrever testes para o cenário que foi afetado. Eles chamam essa regra de <strong>Beyoncé Rule: <em>“If you liked it, you should have put a CI test on it”</em></strong> em alusão a música Single Ladies da Beyoncé.</p><p>👨‍💻As linguagens mais utilizadas no back-end do Google até 2020 eram <strong>C++</strong>, <strong>Java</strong>, <strong>Python </strong>e <strong>Go</strong>.</p><p>🚫O Google evita o uso de <strong>Mocks</strong>. Eles colaram avisos nas portas dos banheiros para alertar os devs dos perigos do uso excessivo de Mocks e até criaram uma anotação <strong>@DoNotMock</strong> no Java. Alguns devs não gostaram muito da ideia dos cartazes colados nos banheiros.</p><p>📝Escrever <strong>documentação </strong>clara e objetiva deve fazer parte do trabalho e do dia-a-dia dos devs. No Google, toda documentação tem um ou mais OWNERS que tem obrigação de mantê-la atualizada, versionada junto ao código fonte da aplicação a qual ela se refere, em formato <strong>Markdown</strong>. A documentação também passa pelo processo de Code Review. A conclusão deles foi que a documentação aumentou a produtividade dos Googlers.</p><p>🙋Qualquer diretiva, regra ou recomendação técnica pode ser rediscutida livremente com os demais devs a qualquer momento, por e-mail, caso alguém acredite que ela não faz mais sentido.</p><p>👌O Google é extremamente rígido quanto a legibilidade de código. Tudo deve ser MUITO bem escrito a fim de facilitar a leitura, <strong>manutenibilidade </strong>e reduzir o esforço cognitivo para os demais devs.</p><p>🌎O Google possuía cerca de <strong>50 mil devs</strong> espalhados ao redor do mundo em <strong>1 mil squads</strong> em 2020.</p><p>👨‍💻Cerca de <strong>60 a 70 mil commits</strong> são feitos diariamente no monorepo do Google, que contém o código do Google Search, Gmail, Google Ads e GCP. Mais de <strong>50 mil changes</strong> (PRs) são abertas por dia.</p><p>🧪O canal <a href="https://www.youtube.com/channel/UCsLiV4WJfkTEHH0b9PmRklw">Webdriver Torso</a> no YouTube é utilizado pelo <strong>Selenium WebDriver</strong> da suíte de testes do Google para testes end-to-end de upload e processamento de vídeos em produção.</p><p>💽O monorepo do Google, conhecido internamente por google3, possui mais de <strong>2 bilhões de linhas de código</strong> que ocupam cerca de 1.5 TB (lembrando que monorepo e monolito são coisas diferentes). A ferramenta de controle de código fonte centralizada do Google consegue “clonar” partes do código do monorepo sem precisar baixar o repositório inteiro como acontece no Git.</p><p>📦O Blaze, Build System criado pelo Google, executa <strong>milhões de builds por dia</strong>.</p><p>🧪O TAP — Test Automation Platform do Google executa mais de <strong>4 milhões de casos de teste por dia</strong>, sem contar os testes unitários que são executados antes da integração, na fase de presubmit.</p><p>⚠️O Blaze, Build System do Google, não baixa dependências transientes automaticamente (dependências de dependências) e todos os projetos devem usar a mesma versão de uma dependência para evitar problemas de diamond dependency. Eles chamam essa regra de <strong>One-Version Rule</strong>.</p><p>✋O compilador Go do Google foi customizado para ser mais rígido e apontar variáveis e imports sem uso como erros.</p><p>⏳A execução de todos os milhares de testes presentes no monorepo do Google leva cerca de <strong>6 horas</strong>.</p><p>⚠️O Google evita usar linguagens dinamicamente tipadas como Python, Ruby, e JavaScript em projetos que vão ter vida útil longa porque essas linguagens, apesar de serem focadas na produtividade do desenvolvedor, tende a serem mais difíceis de manter e executar Large-Scale Changes.</p><p>🐍O <strong>YouTube </strong>foi escrito em <strong>Python</strong>.</p><p>☸️O <strong>Borg</strong>, plataforma de containers do Google similar ao Kubernetes, é a plataforma por trás das VMs e do AppEngine no Google Cloud.</p><p>O livro está disponível em versões físicas e digitais na Amazon em <a href="https://www.amazon.com/Software-Engineering-Google-Titus-Winters/dp/1492082791"><em>https://www.amazon.com/Software-Engineering-Google-Titus-Winters/dp/1492082791</em></a></p><figure><img alt="escrito por humano não por IA" src="https://cdn-images-1.medium.com/max/131/1*3p2RgKls_kN78apL9HBpUg@2x.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62c3e7ac1de" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O que aprendi estudando Inovação no MIT xPRO]]></title>
            <link>https://medium.com/@dannevesdantas/o-que-aprendi-estudando-inova%C3%A7%C3%A3o-no-mit-xpro-3f2b4ed46850?source=rss-c7861d094d51------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f2b4ed46850</guid>
            <category><![CDATA[innovation]]></category>
            <dc:creator><![CDATA[Danilo Dantas]]></dc:creator>
            <pubDate>Thu, 27 Jul 2023 04:47:59 GMT</pubDate>
            <atom:updated>2024-06-09T01:18:33.172Z</atom:updated>
            <content:encoded><![CDATA[<p>Após passar pelo Microsoft Innovation Center como estagiário alguns anos atrás comecei a me interessar bastante pelo tema e agora resolvi me especializar um pouquinho mais no assunto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*aFkrQHR97NdgKslpekbHwg.jpeg" /><figcaption>Campus do Massachusetts Institute of Technology (MIT) (Foto: Massachusetts Institute of Technology (MIT)/Reprodução)</figcaption></figure><p>Foi no MIT que nasceu o conceito de <em>Lean Innovation</em>, lá também estudaram os fundadores de muitas empresas inovadoras como o <em>DropBox</em>, <em>Intel</em>, <em>LinkedIn</em>, <em>Coursera </em>e <em>HubSpot</em>.</p><p>O curso tem uma pegada bem objetiva e didática, baseada em cases práticos bem atuais. O curso é bem soft e a didática do professor Sanjay Sarma do MIT é sensacional. As aulas são gravadas, editadas, legendadas em português e disponibilizadas na plataforma para que possam ser assistidas de forma assíncrona.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IlyN-NyOUxZYoiO7wzQ6Xg.png" /><figcaption>Brochura do curso de Inovação Tecnológica: da Estratégia à Aplicação do MIT xPRO</figcaption></figure><h3>Algumas das coisas mais valiosas que aprendi foram:</h3><p>🧪 Invenção e Inovação são coisas diferentes.</p><p>💡 Existem diferentes metodologias para a inovação: <strong>Inovação disruptiva</strong>, <strong>destruição criativa</strong>, <strong>usuário líder</strong>, <strong>Design Thinking</strong>, <strong>Growth Hacking</strong>, <strong>Open Innovation</strong> e <strong>Storytelling</strong> são algumas delas.</p><p>🚚 Não é necessário caminhõõões de dinheiro para inovar. Só uma equipe talentosa, gestão capacitada a altura, <strong>CULTURA</strong> (principalmente cultura!) e ambientes adequados. As organizações mais inovadoras do mundo não são as que mais gastam.</p><p>💀 Se sua organização não inova, ou se inova tarde demais e perde o timming, alguém vai inovar em outro lugar e fazer você desaparecer, simples assim! Inovação não é mais uma atividade secundária e sim uma questão de sobrevivência.</p><p>🌎 A inovação não está mais restrita somente a países ricos e desenvolvidos, apesar desses ainda serem os mais inovadores.</p><p>🕒 Pode parecer cruel mas na grande maioria das vezes o inventor não é quem gera valor e ganha dinheiro, mas sim quem soube aplicar a invenção de outra pessoa no lugar certo, do jeito certo e no momento certo.</p><p>🤖 Nem toda inovação é baseada em tecnologia.</p><p>🖥️ Para nós desenvolvedores de software, a <strong>XP — Extreme Programming</strong> e o <strong>Pair Programming</strong> são aliados que podem contribuir bastante para melhores escolhas arquiteturais, resultando em softwares mais bem escritos, mais fáceis e rápidos de evoluir e de iterar nas metodologias Ágeis.</p><p>💣O Debito Técnico excessivo corrói a capacidade de adaptação rápida da estratégia a inovações disruptivas emergentes no timming adequado.</p><p>💲Novos modelos de negócio como por exemplo a <strong>Economia Compartilhada</strong> ou <strong>Direto ao Consumidor</strong> também são classificados como inovações.</p><p>🏭 Uma melhoria num processo interno também é inovação.</p><p>💪 A motivação intrínseca geralmente é mais poderosa do que a motivação extrínseca.</p><p>🦖 Não são somente as startups que inovam, é possível inovar também dentro de grandes organizações e através do intraempreendedoríssimo.</p><p>👨‍💼 Não são somente os gerentes e diretores que tem capacidade intelectual para inovar. Empresas altamente inovadoras como Google e Tesla estimulam a inovação em <strong>todos os níveis</strong>!</p><p>🥷 Alguns inovadores em série como o Elon Musk foram capazes de inovar de forma bem sucedida em setores muito diferentes, isso indica que inovação é uma skill que pode ser aprendida e aplicada em vários contextos diferentes.</p><p>Se você, assim como eu, está diretamente envolvido no desenvolvimento de produtos e serviços inovadores e também se interessou em aprender mais sobre Inovação e como aplicá-la, a <a href="https://educacao-executiva.fgv.br/cursos/online/curta-media-duracao-online/inovacao-estrategica-1?oferta=104016">FGV</a> e a <a href="https://www.alura.com.br/escola-inovacao-gestao">Alura</a> também possuem bons cursos livres sobre <strong>Inovação</strong>, <strong>Estratégia</strong> e <strong>Gestão</strong>.</p><p>Mais informações sobre o curso de <strong>Inovação Tecnológica: da Estratégia à Aplicação</strong> do <strong>MIT xPRO</strong> em português estão disponíveis em <a href="https://globalalumni.xpro.mit.edu/pt-pt/inovacao-tecnologica/">https://globalalumni.xpro.mit.edu/pt-pt/inovacao-tecnologica/</a></p><figure><img alt="escrito por humano não por IA" src="https://cdn-images-1.medium.com/max/131/1*3p2RgKls_kN78apL9HBpUg@2x.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f2b4ed46850" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to connect to AKS clusters after Kubernetes v1.26 update]]></title>
            <link>https://medium.com/@dannevesdantas/how-to-connect-to-aks-clusters-after-kubernetes-v1-26-update-cc27d87ab186?source=rss-c7861d094d51------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc27d87ab186</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Danilo Dantas]]></dc:creator>
            <pubDate>Tue, 28 Feb 2023 01:48:59 GMT</pubDate>
            <atom:updated>2024-06-09T01:19:41.245Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9YL1Y_Xv83mcUUfarKQUzA.jpeg" /></figure><p>Learn how to use the new Azure kubelogin tool to autheticate to your AKS cluster through Azure AD — Now Microsoft Entra ID</p><p>Kubernetes v1.24 introduced some important changes in the way we used to connect to Azure Kubernetes Service — AKS clusters. With the arrival of v1.26 on January 18, 2023 Kubernetes was dropped the built-in support for gcp and azure auth plugins that until then came inside kubectl.</p><p>Now, each cloud provider should provide a cloud-specific replacement for the auth plug-in that was dropped from kubectl in v1.26</p><p>The first thing to do is to download and install the latest version of Azure CLI. If you don’t have it yet, you can download it for Windows, macOS and Linux at <a href="https://learn.microsoft.com/en-us/cli/azure/install-azure-cli">https://learn.microsoft.com/en-us/cli/azure/install-azure-cli</a></p><p>After downloading and installing Azure CLI, open a PowerShell terminal and type:</p><pre>az login</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*izGSV8uLHUb5sJypwOZ0fg.png" /><figcaption>az login</figcaption></figure><p>You will be prompted to log in with your work (or personal) Microsoft account, as usual.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*wQT8WpCt7rDkc1TkNRa9cw.png" /></figure><blockquote>If your tenant have more than one subscription, use the az account set --subscription command to switch to the subscription where your AKS cluster resides.</blockquote><pre># Show all subscriptions in my tenant<br>az account subscription list<br><br># Switch to a different subscription<br>az account set --subscription &lt;subscription-id&gt;<br><br># Don&#39;t forget to replace &lt;subscription-id&gt; above with your subscription name or id.</pre><p>After logging in using your Microsoft Account, use the Azure CLI’s az aks get-credentials command to populate your local kubeconfig file with your AKS cluster credentials, as usual.</p><pre>az aks get-credentials --resource-group my-rg-name --name my-aks-cluster-name<br><br># Don&#39;t forget to replace my-rg-name and my-aks-cluster-name above with your Resource Group and AKS Cluster names.</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/933/1*pwt_RtMEM7B6x8IHLiii4g.png" /><figcaption>az aks get-credentials</figcaption></figure><p>Now, you need to install <strong>azure-kubelogin</strong>. It is now responsible for implementing and performing the authentication. To do this, use the command bellow:</p><pre>az aks install-cli</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kRZh2LsAJBCWo1F1ofApOg.png" /><figcaption>az aks install-cli</figcaption></figure><p>az aks install-cli will download and install the latest version of kubectl and azure-kubelogin that is now needed to perform authentication on AKS clusters through Azure AD — now Microsoft Entra ID.</p><blockquote>In some cases, after running az aks install-cli Azure CLI may ask you to add kubelogin.exe to your PATH environment variable manually. If it asks you to, go to Control Panel -&gt; System -&gt; Advanced -&gt; Environment Variables and include the provided path for kubelogin.exe (and kubectl.exe if you already don’t have it) to the list.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/859/1*tR1jwbsLnLo4tRNSeZCE5A.png" /><figcaption>Instructions to include kubelogin.exe to the PATH environment variable manually</figcaption></figure><blockquote>⚠️After the installation, close PowerShell and open it again. Otherwise, kubelogin will not be recognized.</blockquote><p>Now, use Kubelogin to convert your kubeconfig and populate it with the AAD tokens. To do so, type the following command on your PowerShell terminal:</p><pre>kubelogin convert-kubeconfig</pre><p>Now you will be able to use kubectl as usual.</p><pre># List all my k8s Deployments<br>kubectl get deployments - all-namespaces=true</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SffsbfmrcpBbyUvFTWR2PA.png" /><figcaption>kubectl get deployments</figcaption></figure><p>And you will be able to access you cluster using <a href="https://k8slens.dev/">Lens</a> also if you want.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dzsGZgTCNvd2mlLuXC_Dbw.png" /><figcaption>Lens Desktop</figcaption></figure><p>If you have any trouble with Lens, don’t forget to quit Lens and open it again before trying to connect to AKS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/374/1*IVo-_AM4CHe2pBPyPd3lUA.png" /><figcaption>Quit Lens</figcaption></figure><blockquote>See the Kuberentes v1.26.0 changelog deprecation notice at <a href="https://gist.github.com/superbrothers/7409b6f4df10501304e7a85e137d7269#deprecation">https://gist.github.com/superbrothers/7409b6f4df10501304e7a85e137d7269#deprecation</a></blockquote><figure><img alt="written by human not by AI" src="https://cdn-images-1.medium.com/max/131/1*Cq1aKyuOPDBErrfZDfz0lQ@2x.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc27d87ab186" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>