<?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 Anderson Badari on Medium]]></title>
        <description><![CDATA[Stories by Anderson Badari on Medium]]></description>
        <link>https://medium.com/@anderson.badari?source=rss-534201524a79------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*K2grQZbKPpgm_oaL.</url>
            <title>Stories by Anderson Badari on Medium</title>
            <link>https://medium.com/@anderson.badari?source=rss-534201524a79------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 08:55:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@anderson.badari/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[Android — MVVM e Databinding]]></title>
            <link>https://medium.com/@anderson.badari/android-mvvm-e-databinding-fd4595e271c9?source=rss-534201524a79------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd4595e271c9</guid>
            <category><![CDATA[mvvm]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[data-binding]]></category>
            <dc:creator><![CDATA[Anderson Badari]]></dc:creator>
            <pubDate>Thu, 11 Jan 2018 12:57:48 GMT</pubDate>
            <atom:updated>2018-03-14T01:38:35.045Z</atom:updated>
            <content:encoded><![CDATA[<p>Facilite sua vida com este incrível padrão</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*KF40wMQ7hlfh988fR9gn_g.png" /></figure><h4><strong>O que é?</strong></h4><p>Resumidamente, é um jeito de apresentar os dados às views. Em outras palavras, é ‘jeito’ específico de apresentar os dados na tela do seu aplicativo.</p><h4>Porque usar?</h4><p>O MVVM (sigla para <strong>M</strong>odel-<strong>V</strong>iew-<strong>V</strong>iew<strong>M</strong>odel) é um ‘padrão’ de apresentação, na qual seu programa vai ser dividido em três camadas — no que diz respeito a apresentação dos dados, já que MVVM, MVC e MVP não são arquiteturas, como expliquei em um <a href="https://medium.com/brq-techblog/are-mv-something-really-architectural-patterns-abc36c1ed821">outro artigo</a>.</p><p>A primeira, a View, é a sua activity. Ela simplesmente ‘recebe’ dados de ‘algum lugar’ (veremos mais adiante) e os exibe. Ponto final. Coisas como animações e especificidades do framework Android, como GPS ou permissões, fazem parte dessa camada.</p><p>A segunda camada, a Model, simplesmente é a origem dos seus dados que vão ser exibidos na activity/fragment/custom view. Por exemplo, pode ser classes de banco de dados local ou externo, um sharedPrefs ou até dados mockados. As entidades do programa, suas classes base (por exemplo a classe Pessoa), são parte também da camada Model. Então, como já dito, a Model é a camada da ‘origem’ dos seus dados, a camada que vai prover ou ceder os dados à sua aplicação.</p><p>A terceira e última camada, a ViewModel, nada mais é que a abstração da sua view. Por exemplo, supondo que você tem uma Activity chamada ‘ActivityLogin’, você terá uma classe LoginViewModel para esse login. Nessa classe, você terá de abstrair o comportamento que a activity está representando. Supondo que a ActivityLogin contenha dois campos de input (nome e email), um botão de confirmar e um dialog de loading, então sua LoginViewModel irá conter duas strings para representar o nome e o email e uma variável booleana para representar o estado do dialog de loading (porque o loading está ‘on’ ou ‘off’). O comportamento do botão, por se tratar de uma ‘ação’, será representado por um método.</p><p>O ViewModel conterá, além disso, uma ou mais referências a camada Model. Por exemplo, seu LoginViewModel conterá um objeto do tipo LoginDatabase para você buscar os dados que irá apresentar na tela.</p><p>Por fim, vincularemos a View ao ViewModel de tal forma que, quaisquer mudanças que ocorram na camada Model, sua View ficará ciente disso e renderizará os dados.</p><h4>O que é e porque usar Databinding?</h4><p>Databinding, em tradução livre, significa ‘vinculação de dados’. No mundo android, significa que a sua camada View ficará ‘observando’ a camada ViewModel (ficará observando o comportamento abstraído na forma de variáveis) em mão dupla e, caso o valor de uma variável mude, a View automaticamente irá renderizar as mudanças. Por exemplo, uma string que tenha seu valor alterado via código, automaticamente irá apresentar seu novo valor na tela do seu aplicativo. O mesmo serve para caso a View mude o valor de, por exemplo, um campo de texto. A variável correspondente a esse campo de texto, que está na ViewModel, será notificada da mudança e terá seu valor automaticamente alterado.</p><p>Abaixo, um exemplo gráfico da interação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xylQdPwpTzf2mCmwa1awgQ.png" /></figure><p>Na imagem acima, a camada View vincula (ou mapeia) os componentes visuais no seu respectivo ViewModel. A vinculação de dados ocorre em mão-única (a view somente envia os valores/interações para a viewModel) ou em mão-dupla (a view envia valores e interações e recebe valores da viewModel).</p><p>A viewModel, por sua vez, requisita valores para a camada model e aguarda a resposta. Assim que o valor chega para a viewModel, seus valores são automaticamente exibidos na camada view.</p><h4>Vantagens</h4><ul><li>Programar se torna mais ‘orgânico’ e ‘simples’, já que não há um ‘controlador’ ou um ‘gerente’ de dados, uma vez que são as views que ‘solicitam’ os dados que elas precisam apresentar;</li><li>Lógica de exibição fica restrita às views;</li><li>Código mais organizado e clean;</li><li>Facilidade para leitura e manutenção do código;</li><li>Reusabilidade dos seus viewsModels;</li><li>Testabilidade do seu projeto.</li><li>Em conjunto com <a href="https://medium.com/@anderson.badari/android-facilite-ainda-mais-sua-vida-com-os-bindingadapters-d87d9f73aaea">bindingAdapters</a>, tudo fica mais fácil ainda.</li></ul><h4>Pontos interessantes</h4><p>O ViewModel é DESACOPLADO da View. Em outras palavras, o ViewModel (a camada um ‘nível’, digamos assim, mais interna que a View) jamais sabe QUEM o está utilizando. Dessa forma, você pode REUTILIZAR e TESTAR facilmente sua classe ViewModel. Essa é a razão principal para utilizar o MVVM.</p><p>Da mesma forma, é boa prática você depender de abstrações e não de implementações no que diz respeito à ao acesso ao banco de dados. Por exemplo, sua ViewModel conterá um objeto para você ter acesso aos dados (o objeto que representa seu banco). Entretanto, é boa prática fazer uso de uma ‘interface’ na hora de criar uma referência ao banco de dados (isso se chama inversão de dependência, que é um tipo de injeção de dependência).</p><h4>Exemplos de caso de uso onde programar usando MVVM + databinding se torna uma tarefa muito menos árdua:</h4><ul><li>Validação de campos acontecendo em tempo real (os campos são validados conforme o usuário os digita).</li><li>Captação de valores de campos de texto de um modo geral, uma vez que há a possibilidade de vinculação em mão-dupla (two-way datadinding).</li><li>Exibir listas se torna um trabalho muito simples com <a href="https://medium.com/@anderson.badari/android-mvvm-e-databinding-fd4595e271c9">BindingAdapter</a>, porque basta usar um bindindAdapter como um atributo de um recyclerView (e fazer seu recyclerView ‘observar’ um arrayList na sua ViewModel) que você terá uma lista com poucas (ou nenhuma) linhas de código (claro, desde que você REUSE o seu bindingAdapter).<br>-</li></ul><h4>Como usar?</h4><p>Primeiramente, devemos ativar o databinding no build.gradle</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/856/1*_yhVubRlljUbzEiCYqy5fQ.png" /></figure><p>Agora, criaremos uma classe chamada LoginActivity e seu respectivo layout xml, chamado activity_login.xml</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/616/1*RpfN6e7Kiu0qnV5P5Skz0Q.png" /></figure><p>Note que, ao invés de declarar um relative ou linear como base, declararemos um ‘layout’ apenas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/616/1*2i4QzqRUMz8_ekkXV3UK3Q.png" /></figure><p>Em seguida, criaremos uma classe chamada LoginViewModel, que será o seu view model e, dentro dele, declararemos a <em>abstração</em> da sua tela de login.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/1*n0FgaJ1O90_P9ILCTA1sEg.png" /></figure><p>Note que são campos do tipo <em>Observable</em>. Esses campos serão observados pela sua view. Eles devem ser <em>public</em>.</p><p>Agora, declararemos os componentes visuais <strong>dentro</strong> dos limites do componente base, o layout.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*JjOJ2QVaGefO5RjZx1hLYQ.png" /></figure><p>Como já criamos o nosso viewModel, o vincularemos a nossa view através do nosso xml. Usaremos o campo data para declarar variáveis dentro do nosso xml.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*tZOfrQGHY8rd7JtT9D1agQ.png" /></figure><p>Agora, o passo mais importante. Vincularemos a variável pública que está dentro do LoginViewModel ao componente visual equivalente. Por exemplo, Abaixo temos os dois campos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*U3A-f-wnCeiL9NAxhm2AXg.png" /><figcaption>Email</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/522/1*-QRxmoeti4ct7xUzbxw48w.png" /><figcaption>Password</figcaption></figure><p>O botão de login será um mero onClick</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/474/1*KxhDsbuP2OkzNg1q0Z2zsw.png" /><figcaption>Login</figcaption></figure><p>Seu método, que está na activity, evocará um método que está dentro do LoginViewModel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/391/1*2gHxVcv-yAaog4HmIX048w.png" /></figure><p>Em seguida, configuraremos o que o aplicativo irá fazer assim que o login for clicado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/469/1*KI0OVFLbmpQjnvUKaIYaKg.png" /></figure><p>Basicamente, ele irá validar se os textos não estão vazios e, caso não esteja, irá ativar um diálogo de loading por 1.5 segundos.</p><p>Em alguns casos especiais, como o demonstrado abaixo, devemos vincular manualmente via código o comportamento da view na variável que está dentro do view model.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/905/1*cXOFBdHss6my_igsOrx2uA.png" /></figure><p>O trecho acima vincula um ouvinte que escuta qualquer mudança na variável chamada loadingState que está dentro do view model.</p><p>Por fim, o passo mais importante: vamos vincular de fato a nossa view (activity) ao nosso view model. Note que o objeto <em>binding</em>, do tipo ActivityLoginBinding, é gerado automaticamente pelo Android Studio. O nome dele é gerado com base no nome do seu layout xml (<em>activity_login</em> se torna <em>ActivityLoginBinding</em>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/778/1*a1uUzpI7emHD3qDRtywAWQ.png" /></figure><p>Depois, basta executar seu projeto, que se encontra <a href="https://github.com/andersonbadari/Android-BindingAdapterDemo">neste repositório do Github</a>, e verá os resultados.</p><h4>Finalizando</h4><p>Num primeiro momento, parece um esforço desnecessário utilizar esse padrão de apresentação para apenas validar dois simples campos. Entretanto, um aplicativo moderno <strong>não</strong> faz apena isso. Pensando no mesmo login: um aplicativo moderno valida os campos em tempo real conforme o usuário digita; um aplicativo moderno exibe mensagens (toast, snackbar ou até mesmo views customizadas) diferentes para cada resultado do login (sucesso, erro, sem rede, etc); um aplicativo moderno apresenta animações de transições de fragmentos ou views para cada interação do usuário; um aplicativo moderno salva os dados de login (criptografados, ainda) em bancos de dados locais, por exemplo, ao clicar de um botão do usuário; enfim, um aplicativo moderno faz muitas coisas numa mera tela de login.</p><p>Agora, imagine um aplicativo com vários fragmentos, listas, mensagens de erros, estados possíveis de telas, etc. Tudo isso fica muito mais fácil e simples de se fazer utilizando MVVM e Databinding.</p><p>O projeto se encontra nesse <a href="https://github.com/andersonbadari/Android-BindingAdapterDemo">repositório do github</a>.</p><h4>Leituras recomendadas</h4><ul><li><a href="https://medium.com/@anderson.badari/android-facilite-ainda-mais-sua-vida-com-os-bindingadapters-d87d9f73aaea">Binding Adapters</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd4595e271c9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android — Facilite ainda mais sua vida com os BindingAdapters]]></title>
            <link>https://medium.com/@anderson.badari/android-facilite-ainda-mais-sua-vida-com-os-bindingadapters-d87d9f73aaea?source=rss-534201524a79------2</link>
            <guid isPermaLink="false">https://medium.com/p/d87d9f73aaea</guid>
            <category><![CDATA[bindingadapter]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[data-binding]]></category>
            <category><![CDATA[mvvm]]></category>
            <dc:creator><![CDATA[Anderson Badari]]></dc:creator>
            <pubDate>Wed, 10 Jan 2018 17:55:00 GMT</pubDate>
            <atom:updated>2018-01-11T16:38:17.222Z</atom:updated>
            <content:encoded><![CDATA[<p>Tenha um código mais limpo com esta ferramenta</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/523/1*dXmQITHGz78tozDgqkJl_w.png" /></figure><h4>Antes de mais nada</h4><p>Esse texto parte do pressuposto de que você já utilizou MVVM no android e conhece pelo menos os princípios desse padrão de apresentação. <a href="https://medium.com/@anderson.badari/android-mvvm-e-databinding-fd4595e271c9">Em outro post, explico mais MVVM e Databinding no Android. Confira!</a></p><h4>Vamos lá!</h4><p>Suponha que você precise exibir uma imagem que está numa URL em um imageView. Mas, todos sabemos que uma URL é uma mera string (que estará no viewModel), e uma imageView é um componente visual (que está na view) que somente aceita um drawable ou um resource do android como parâmetro.</p><p>Como faremos essa ‘ponte’, ou esse ‘adaptador’, para transformar a string do viewModel para exibir a imagem no imageView?</p><p>Exatamente! Usaremos o<strong> bindingAdapter</strong>.</p><p>Binding adapters são métodos onde você consegue criar comportamentos específicos às suas Views sem precisar criar subclasses.</p><p>Antes de mais nada, você precisa ativar a biblioteca <a href="https://developer.android.com/topic/libraries/data-binding/index.html?hl=pt-br">Databinding do android</a>.</p><p>Primeiramente, basta criar um método estático com a annotation<strong> @BindingAdapter</strong> para fazer seu método ser ‘visto’ pelo layout xml.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/1*VCrlK9DPnjT27uPNxeiuJg.png" /></figure><p>Como implementaremos um bindingAdapter numa ImageView, então obrigatoriamente o primeiro parâmetro do método é uma ImageView. O segundo parâmetro é o valor que será vinculado e que está lá no viewModel (que é uma URL — uma string).</p><p>A annotation recebe um parâmetro que será o nome do atributo que você utilizará no layout xml (e seus respectivos parâmetros).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*58ULVn8Ki5GcM4N_n6BS_g.png" /></figure><p>Em segundo lugar, basta, agora, criar o principal: vincular sua URL ao seu ImageView. Usarei, nesse exemplo, a biblioteca Glide.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/662/1*H1LZN436pUxyKfPffupf3Q.png" /></figure><p>O Glide precisa de contexto. Então, pegaremos o contexto da própria ImageView. A URL será o parâmetro enviado, e usaremos ele para carregar a imagem na ImageView.</p><p>Por fim, basta ir no seu layout xml e declarar o atributo e passar seus parâmetros que você precisou. Pode, inclusive, ser mais de um.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/724/1*EygI-CsKklNOQyAXKkpFaA.png" /></figure><p>Da mesma forma, você pode ainda criar bindingAdapters para validar em tempo real seus campos de texto ou para exibir mensagens de erro — lembrando que um método de bindingAdapter pode receber mais de um parâmetro. Portanto, use e abuse da sua criatividade!</p><p>O projeto pode ser encontrado no <a href="https://github.com/andersonbadari/Android-BindingAdapterDemo">Github</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d87d9f73aaea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Are MVC, MVP and MVVM really architectural patterns?]]></title>
            <link>https://medium.com/@anderson.badari/are-mv-something-really-architectural-patterns-abc36c1ed821?source=rss-534201524a79------2</link>
            <guid isPermaLink="false">https://medium.com/p/abc36c1ed821</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[mvp]]></category>
            <dc:creator><![CDATA[Anderson Badari]]></dc:creator>
            <pubDate>Mon, 16 Oct 2017 22:38:51 GMT</pubDate>
            <atom:updated>2017-12-22T19:28:57.732Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*3hKkeAXcf3QRiVORhfFSGw.jpeg" /></figure><h4>Short answer: no.</h4><h4>Behind the scenes</h4><p>Once, we were discousing at company about mobile architecture, such as MVC, MVP and MVVM, and a colleague, <a href="https://medium.com/u/3e2dffff1683">Victor Caldas</a>, said that they weren’t architectural patterns. Of course, I laughed at first, and then I made a polling with some mobile developers friends of ours and, of course, we win by far. Everyone said that MVC, MVP and MVVM were, undoubtedly, architectural patterns.</p><p>Some time after, I was working at a huge project which I was creating from scratch and I faced some situations that I tought that those ‘architectural patterns’ weren’t working nicely. This led me to think and I made some discoveries in my journey through the internet.</p><h4>Why it’s not?</h4><p>You , probably, will not find in the internet a reference to a blog or book that says MVC, MVP or MVVM are not architectural pattern (except for <a href="https://antonioleiva.com/mvp-android/">this</a> post of Antonio Leiva); it’s the opposite: you will find everywhere in the internet that MV(something) is an architectural pattern and, whoever play with one of those, is an software architect. You, of course, will accept that, because it’s everywhere. It’s absolutely normal, and it’s not a critical mistake; but, it’s not the truth.</p><p>An architectural pattern is much more than a mere presentation-pattern , which is what MV(something) really is. Also, it’s not a ‘structure’ of the project, or whatever you call it. An architectural pattern include much more relevant and critical things than a presentation-pattern (the way you send your data to the views — be an activity or a fragment).</p><h4>Thinking in the MVP world</h4><p>For instance, let’s think about MVP pattern: you have a ‘model’ layer, a ‘view’ layer and a ‘presenter’ layer. In your ‘view’ package, you will have activities, fragments and adapters. In your presenter layer, you will have your presenters, of course. But, in your model layer, what will you have?</p><p>Short answer is: it depends.</p><p>You, of course, will have your entities classes. Maybe dozens of then. But that’s not enough on a modern application. You may have a class that manage if you have internet connection and fetch data from local database if you aren’t connected to the internet. You may have a class that cache data and a class that upload data to a server when the internet is back, or download data when the app open. That’s already A LOT of classes and callbacks and interactions between then and…</p><p>But, it’s not over.</p><p>You may have classes that not belong to model layer (dont belong to anything in MV(something) world), but, in some way, interacts directly with models, which are classes like a gpsManager, permissionsManager,sensorsManager,… and all the data they emmit will be sent to the model layer through the presenter, which, after, will store God knows where those data.</p><p>What I really want to say is that the ‘model’ layer is much more complex than it is threated when you simply say ‘I’am using MVP architectural pattern’. That’s not enough to describe what REALLY you is using in your app, once the ‘model’ layer is, sometimes, more complex than the presentation layer.<br>On the other hand, a presenter is simply a presenter: it format and presents data (which was received by model layer) to the view. The presenter have not enough responsability to someone say that this is an architectural pattern.</p><h4>A new approach</h4><p>I, humbly, propose a new separation of concerns on this topic, which is to split design patterns into three distinct groups.</p><p>First, we have design patterns that act on the very logic of the software (e.g. singleton, façade, builder, strategy etc). These, I call logical-patterns. They just receive data and process them. They can emmit or not data; it will depends on what pattern you is using.</p><p>Second, we have architectural patterns, which describes the software architecture that you are using. They are ideas to be implemented and not code templates like logical-patterns.</p><p>Third, we have patterns that act on the presentation of data of a software, like MVC, MVP and MVVM. These, I call presentation-patterns. They receive data from the model layer and format it in order to send to the view.</p><p>Some of you may disagree with my new proposition, and that’s ok. But, take a look at the definition of a design pattern, provided by wiki:</p><p><em>“…a software design pattern is a general reusable solution to</em><strong><em> </em></strong><em>a commonly occurring problem within a given context in software design. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns are formalized best practices that the programmer can use to solve common problems when designing an application or system</em>”</p><p>This description fits perfectly on what I’m proposing here, which is to split design patterns into three groups, and include the patterns know as ‘architecture’ (MVC, MVP and MVVM) into one of them.</p><p>In this context, you may ask which solution MVP, for instance, try to solve? It tries to solve organization and testability of the object that presents data, which is the presenter (which is hard to do on an activity, for instance). It has it’s own responsability, and it’s not to architect the whole project.</p><h4>Conclusion</h4><p>Some of you, dear readers, may be asking something like this:</p><p>“Wait. So, are you saying that those &#39;presentation patterns&#39; aren’t architectural patterns? What are architectural patterns, so? Where are they?”</p><p>Of course there are architectural patterns. One of them is the well know <a href="https://8thlight.com/blog/uncle-bob/2012/08/13/the-clean-architecture.html">Clean architecture</a>.</p><p>Below there’s a list of some of them (this list can be found on Clean Architecture article right above):</p><ul><li><a href="http://alistair.cockburn.us/Hexagonal+architecture">Hexagonal Architecture</a>(a.k.a. Ports and Adapters) by Alistair Cockburn and adopted by Steve Freeman, and Nat Pryce in their wonderful book <a href="http://googleweblight.com/?lite_url=http://www.amazon.com/Growing-Object-Oriented-Software-Guided-Tests/dp/0321503627&amp;lc=pt-BR&amp;s=1&amp;m=254&amp;host=www.google.com.br&amp;ts=1508195751&amp;sig=ANTY_L0W--MiFtBanUBEhUhL6Y_EdASa2g">Growing Object Oriented Software</a></li><li><a href="http://googleweblight.com/?lite_url=http://jeffreypalermo.com/blog/the-onion-architecture-part-1/&amp;lc=pt-BR&amp;s=1&amp;m=254&amp;host=www.google.com.br&amp;ts=1508195751&amp;sig=ANTY_L1Z-P3ylTjdHozBVo3JFLHY8ZCmeg">Onion Architecture</a> by Jeffrey Palermo</li><li><a href="https://googleweblight.com/?lite_url=https://8thlight.com/blog/uncle-bob/2011/09/30/Screaming-Architecture.html&amp;lc=pt-BR&amp;s=1&amp;m=254&amp;host=www.google.com.br&amp;ts=1508195751&amp;sig=ANTY_L204n5vzXQG5igqVwtVgHJpyj7YzA">Screaming Architecture</a> from a blog of mine last year</li><li><a href="http://googleweblight.com/?lite_url=http://www.amazon.com/Lean-Architecture-Agile-Software-Development/dp/0470684208/&amp;lc=pt-BR&amp;s=1&amp;m=254&amp;host=www.google.com.br&amp;ts=1508195751&amp;sig=ANTY_L3oBFMuAOPiCVenFN6EBbabj_3TPA">DCI</a> from James Coplien, and Trygve Reenskaug.</li><li><a href="http://googleweblight.com/?lite_url=http://www.amazon.com/Object-Oriented-Software-Engineering-Approach/dp/0201544350&amp;lc=pt-BR&amp;s=1&amp;m=254&amp;host=www.google.com.br&amp;ts=1508195751&amp;sig=ANTY_L0V5xu-BqvRfK39UsuEtTh2NZWOSA">BCE</a> by Ivar Jacobson from his book Object Oriented Software Engineering: A Use-Case Driven Approach</li></ul><p>If you are using one of those architectures, you can still use MVP or MVVM to present your data to the view, because they are (presentation)patterns, which make ‘smaller’ things and are ‘less important’, in the whole context, than an architecture. The fact is that an architecture theorize much more layers and responsabilies than a simple presentation-pattern, such as MVC, MVP or MVVM.</p><p>Thank you for reading and feel free to share your thoughts with the community!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=abc36c1ed821" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>