<?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[Let&#39;s Grow - Medium]]></title>
        <description><![CDATA[Let&#39;s Grow Sistemas Inteligentes - Medium]]></description>
        <link>https://medium.com/lets-grow?source=rss----870adf3ca100---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Let&amp;#39;s Grow - Medium</title>
            <link>https://medium.com/lets-grow?source=rss----870adf3ca100---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 14:58:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/lets-grow" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Clean Code #2: capriche em sua funções]]></title>
            <link>https://medium.com/lets-grow/clean-code-2-capriche-em-sua-fun%C3%A7%C3%B5es-d17339e8a0a6?source=rss----870adf3ca100---4</link>
            <guid isPermaLink="false">https://medium.com/p/d17339e8a0a6</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[clean-code]]></category>
            <dc:creator><![CDATA[Vinícius Alonso]]></dc:creator>
            <pubDate>Sat, 04 Mar 2017 14:37:25 GMT</pubDate>
            <atom:updated>2017-03-04T13:46:43.302Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/716/1*q-j5STEfVVd1bJGtlXuTUg.jpeg" /><figcaption>Fonte: <a href="https://www.butterfly.com.au/blog/website-development/clean-high-quality-code-a-guide-on-how-to-become-a-better-programmer">https://www.butterfly.com.au/blog/website-development/clean-high-quality-code-a-guide-on-how-to-become-a-better-programmer</a></figcaption></figure><p>No post <a href="https://medium.com/lets-grow/clean-code-1-a-import%C3%A2ncia-dos-nomes-1203b2f3300b#.1zfwnvo10">anterior</a> foi abordado a importância de escolher bem os nomes, nesse post o assunto trabalhado serão as funções. O <a href="https://www.amazon.com.br/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882">Clean Code</a> estabelece alguns conceitos para determinar se uma função está bem escrita.</p><h4>As funções devem ser pequenas!</h4><p>Funções com muitas linhas são difíceis de serem lidas e entendidas. Por essa razão é muito importante mantê-las pequenas, abaixo um exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/604c02f408bb62991a2ffc702f2276a2/href">https://medium.com/media/604c02f408bb62991a2ffc702f2276a2/href</a></iframe><p>O algoritmo acima faz o cálculo da fórmula de <a href="https://educacao.uol.com.br/matematica/bhaskara.jhtm">Bhaskara</a>, olhando para ele podemos notar que faz coisas demais e poderia ser dividido por responsabilidades para ficar menor e mais legível. Abaixo a versão refatorada da função:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d7e43903dd879d5584402c5cd482a3e7/href">https://medium.com/media/d7e43903dd879d5584402c5cd482a3e7/href</a></iframe><p>A função acima ganhou mais linhas que sua versão original, então quais as vantagens?</p><p>Agora cada função faz apenas uma coisa. Essa é uma premissa do Clean Code, cada função deve fazer apenas uma coisa e fazer isso bem feito. Temos partes que podem ser reutilizadas tornando nosso código mais modular. Note que as funções, <em>is_zero</em>, <em>is_greater_than_zero</em>, entre outras, podem ser utilizadas em outras partes da aplicação seguindo o princípio do <a href="http://deviq.com/don-t-repeat-yourself/">DRY</a> (Don&#39;t Repeat Yourself).</p><p><strong>Facilite a leitura de seu código</strong></p><p>Observe o código abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/11065c41ac6d12f749a694193536e374/href">https://medium.com/media/11065c41ac6d12f749a694193536e374/href</a></iframe><p>Note que a segunda opção é mais fácil de ser lida, isso porque lê-se &quot;se $a for zero, calcule a raiz simples&quot;.</p><p><strong>Utilize poucos níveis de indentação</strong></p><p>Cada função deve ter um ou dois níveis de indentação e nada mais que isso. Estabelecer esse padrão e segui-lo à risca é importante para garantir que códigos como o do Haduken não sejam mais escritos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*sJ-qbjU__iV_H6c5DXuUkA.png" /><figcaption>Fonte: <a href="http://imgur.com/gallery/FT1vYUY">http://imgur.com/gallery/FT1vYUY</a></figcaption></figure><p><strong>Não utilize else</strong></p><p>Pesquisando em outras regras de boas práticas, encontrei o <a href="http://williamdurand.fr/2013/06/03/object-calisthenics/">Object Calisthenics</a> e, uma das regras diz &quot;não use a palavra reservada else&quot;. A parte interessante de remover o else de nossos códigos, é que diminuímos os fluxos de execução, diminuindo por sua vez a <a href="https://www.tutorialspoint.com/software_testing_dictionary/cyclomatic_complexity.htm">complexidade ciclomática</a>.</p><h3>Conclusão</h3><p>Embora o código refatorado ainda tenha vários problemas, é possível notar uma melhora da versão original. Porém, o foco desse post era mostrar alguns detalhes voltados as funções.</p><p>Manter nossos códigos limpos e bem escritos é fundamental para que um sistema cresça sem se tornar uma bagunça. E esse cuidado começa nos pequenos detalhes.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d17339e8a0a6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-grow/clean-code-2-capriche-em-sua-fun%C3%A7%C3%B5es-d17339e8a0a6">Clean Code #2: capriche em sua funções</a> was originally published in <a href="https://medium.com/lets-grow">Let&#39;s Grow</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Conhecendo Ember-Electron]]></title>
            <link>https://medium.com/lets-grow/conhecendo-ember-electron-a229e38f9150?source=rss----870adf3ca100---4</link>
            <guid isPermaLink="false">https://medium.com/p/a229e38f9150</guid>
            <category><![CDATA[ember]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[electron]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Guilherme Freire Hack]]></dc:creator>
            <pubDate>Sat, 18 Feb 2017 11:56:53 GMT</pubDate>
            <atom:updated>2017-02-18T11:57:45.522Z</atom:updated>
            <content:encoded><![CDATA[<h4>Escreva menos código, vincule dados com a página, separe em componentes reutilizáveis.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*mRjoWn8aKMeLSEw0y-iFeQ.png" /><figcaption>“Podem falar o que quiserem, mas o Ember tem a melhor logo.” <a href="https://medium.com/u/1bd77469095">Vinícius Alonso</a></figcaption></figure><p>Ember é um framework JavaScript. Você tem disponível <em>handlebars</em>, <em>compoments</em>, <em>routes</em> e <em>controllers</em>, além do <em>data-bind</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d167df4ddf16d6ca5e4cf59f841754ce/href">https://medium.com/media/d167df4ddf16d6ca5e4cf59f841754ce/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/185/1*GM4VkM27zyxKj4nQIO38bg.png" /><figcaption>“Talvez você já esteja rodando uma aplicação Electron.” <a href="https://medium.com/u/23626b04abce">Felix Rieseberg</a></figcaption></figure><p><a href="https://medium.com/lets-grow/conhecendo-electron-e4dd5019ab75">Conhecendo Electron</a></p><h3>Tutorial Ember-Electron</h3><h4>Instalar globalmente o Ember-Cli</h4><blockquote>npm install -g ember-cli</blockquote><h4>Criar aplicação Ember</h4><blockquote>ember new test-app</blockquote><h4>Rodar o Ember no navegador</h4><blockquote>ember server</blockquote><h4>Instalar o Electron na aplicação Ember</h4><blockquote>ember install ember-electron</blockquote><h4>Gerar Electron na aplicação</h4><blockquote>ember g ember-electron</blockquote><h4>No arquivo config/environment.js</h4><blockquote>locationType: process.env.EMBER_CLI_ELECTRON ? &#39;hash&#39; : &#39;auto&#39;,</blockquote><h4>Rodar aplicação no Electron</h4><blockquote>ember electron</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*bhq3RuLRUdLphYIA8KTqFA.png" /><figcaption>TestApp rodando com o exemplo do Ember</figcaption></figure><h3>Conversando com o Electron</h3><p>O Electron disponibiliza o <strong>ipc</strong>, um módulo que lida com mensagens síncronas e assíncronas, enviadas de um processo <strong>renderer</strong>. Abaixo, é recebido uma mensagem e retornado uma resposta assíncrona.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eeb8ba8f1425114afd53c0ec31890d8d/href">https://medium.com/media/eeb8ba8f1425114afd53c0ec31890d8d/href</a></iframe><p>Abaixo, é enviado uma mensagem e recebemos uma resposta assíncrona do processo principal, Electron.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7f366b5ff1985d1a526b636c737f4e42/href">https://medium.com/media/7f366b5ff1985d1a526b636c737f4e42/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/797/1*gGuruLwFh-ZgkeL7Jl0KWA.png" /><figcaption>Esse é o resultado dos códigos apresentados acima</figcaption></figure><p>Isso abre possibilidades, principalmente ao considerar que é possível criar processos sem renderizá-los em janela, múltiplos processos conversando de forma assíncrona é possível no Electron.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a229e38f9150" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-grow/conhecendo-ember-electron-a229e38f9150">Conhecendo Ember-Electron</a> was originally published in <a href="https://medium.com/lets-grow">Let&#39;s Grow</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O Básico Sobre Expressões Regulares]]></title>
            <link>https://medium.com/lets-grow/o-b%C3%A1sico-sobre-express%C3%B5es-regulares-9dca27d3411?source=rss----870adf3ca100---4</link>
            <guid isPermaLink="false">https://medium.com/p/9dca27d3411</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[desenvolvimento]]></category>
            <category><![CDATA[expressões-regulares]]></category>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[produtividade]]></category>
            <dc:creator><![CDATA[Danilo Pinotti]]></dc:creator>
            <pubDate>Mon, 06 Feb 2017 12:26:06 GMT</pubDate>
            <atom:updated>2017-02-06T12:32:10.618Z</atom:updated>
            <content:encoded><![CDATA[<p>O que são? Pra que servem? Podem mesmo me ajudar ?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*C-Pur9deSupwOkmRmt8DwA.jpeg" /></figure><h3>O que são?</h3><p>Expressão regular é uma forma de representar palavras, frases ou até parágrafos através de uma única notação. Ainda não entendeu? Vamos a alguns exemplos:</p><ul><li>Imagine no desenvolvimento de um sistema ao qual é repleto em validações em textos. Como será validado um campo de e-mail, por exemplo? Percorrerá caractere por caractere a fim de buscar os padrões de um campo de e-mail ?</li><li>Imagine na escrita de um texto ao qual você quer buscar todas as palavras escritas duas vezes seguidas, exemplo “Usar expressões regulares <strong>para para</strong> resolver (…)”. Além de buscá-las você também quer arrumá-las automaticamente.</li><li>Substituir todas as ocorrências da palavra ‘carro’ por ‘automóvel’.</li></ul><p>A aplicação de expressões regulares é praticamente infinita, basta encontrar os momentos certos para usá-las.</p><h3>Conceitos básicos</h3><p>Antes de começar a explicar como criar e ler uma expressão regular, é importante ter em mente o significado da palavra <em>match</em>. A tradução literal da palavra é “corresponder’” porém, neste contexto, a palavra será utilizada para dizer que uma expressão regular “casou” com uma palavra, frase ou parágrafo, ou seja, quando uma expressão regular conseguir representar o que foi planejado.</p><p>Outra ideia que deve sempre estar em mente é que uma expressão regular é lida como uma palavra onde cada parte dela representa, inicialmente, apenas um caractere. Mais para frente, neste artigo, será mostrado isso.</p><p>Uma expressão regular é formada de vários metacaracteres e caracteres literais. São chamados metacaracteres os caracteres que servem para representarem outros caracteres, neste artigo não serão explicados todos. São eles: <strong>. ? * + ^ $ | [ ] { } ( ) \</strong></p><p>Para tornar um metacaractere um caractere literal, usa-se o escape (\). Por exemplo, para usar o ponto como caractere literal: \.</p><p>Um exemplo simples de expressão regular:</p><pre>[0-9]{5}-[0-9]{3}</pre><p>A expressão acima foi escrita para “casar” com um CEP (código de endereçamento postal) onde possui 5 dígitos numéricos, um traço e logo após, mais 3 dígitos numéricos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/596/1*WFYM0FVrZXP3geL4lZCzdQ.png" /></figure><h3>Componentes básicos</h3><p>Nesta parte do artigo serão explicados separadamente alguns dos componentes que formam uma expressão regular.</p><p>Existem ferramentas online para testar, em tempo real, as expressões regulares criadas. É interessante você acompanhar a leitura do artigo e ir fazendo seus próprios testes. Uma ferramenta interessante é o <a href="https://regex101.com/">regex101</a>.</p><h3>Lista [ … ]</h3><p>A lista é um dos componentes mais utilizados. Ela permite você escolher quais caracteres poderão aparecer no lugar em que ela foi colocada. Exemplo:</p><pre>[ab]c</pre><p>Neste caso, a expressão regular casará com as seguintes informações:</p><pre>ac<br>bc</pre><p>Uma lista representa apenas um caractere.</p><p>Dentro da lista todos os caracteres são literais, com exceção do traço (-), do acento circunflexo (^) e, caso não seja o primeiro ítem da lista, o colchete de fechar (]).</p><p>É possível utilizar um conjunto de dados dentro da listas, desta forma, facilitando filtrar caracteres. Exemplo:</p><pre>[0-2]c</pre><p>Que casará com:</p><pre>0c<br>1c<br>2c</pre><p>Como conjuntos dentro de listas você pode utilizar:</p><pre>a-z<br>A-Z<br>A-z<br>0-9</pre><h3>Lista negada [^ … ]</h3><p>A lista negada têm a mesma finalidade da lista comum, porêm, os caracteres dentro dela são ignorados no momento de casar. A lista negada é uma lista convencional a qual o primeiro ítem é o circunflexo: [^ … ]. Em outras palavras, ela permite representar qualquer outro caractere, exceto os que estão dentro dela.</p><p>Exemplos de utilização:</p><pre>pat[^a]</pre><p>A expressão regular acima consegue se casar com a palavra ‘pato’ porém, não consegue se casar com ‘pata’ por causa da lista negada que “proíbe” o aparecimento a letra “a” no final da palavra.</p><h3>Ponto .</h3><p>O ponto ( . ) é um metacaractere que se casa com qualquer outro caractere, ou seja, ele é um curinga.</p><p>Exemplos de utilização:</p><pre>.[a-z]</pre><p>A expressão regular acima se casa com qualquer conjunto ao qual começa com qualquer caractere e, em seguida, uma letra minúscula:</p><pre>1a, rb, (z, pw, 8z, etc.</pre><h3>Metacaracteres quantificadores</h3><p>Pense que agora que você já fez a lista de caracteres desejados, você quer buscar todas as palavras que começam com eles. Você pode fazer de algumas formas.</p><h4>Primeira forma: Limitar a quantidade exata de vezes que aquele elemento aparecerá.</h4><p>Tendo uma lista com os elementos escolhidos, você pode escolher quantas vezes ela poderá se repetir com a utilização do metacaractere de chaves ( {} ) com a quantidade de vezes que o elemento anterior poderá se repetir, ou seja: [a-b]{3} é o mesmo que [a-b][a-b][a-b]</p><p>Utilização:</p><pre>[a-b]{2}</pre><p>Neste caso “falamos” que a expressão regular se casará com qualquer palavra/termo de duas letras em que cada uma poderá ser ‘a’ ou ‘b’.</p><p>Outro exemplo:</p><pre>[a-z]{5}</pre><p>Neste segundo caso podemos dizer que a expressão regular irá casar com qualquer palavra, toda minúscula, de 5 letras.</p><h4>Segunda forma: Definir um limite mínimo e máximo de vezes que o elemento poderá aparecer.</h4><p>Semelhante ao primeiro caso, esta limitação é feita usando os metacaracteres de chaves, porém, com dois valores dentro que representam, respectivamente, valor mínimo e valor máximo.</p><p>Utilização</p><pre>[a-z]{3,5}</pre><p>No exemplo acima, a expressão regular casará com qualquer palavra, toda minúscula, de 3 até 5 letras.</p><p><strong>Metacaractere: ?</strong></p><p>Este metacaractere permite tornar opcional a ocorrência do elemento ao seu lado, ou seja:</p><pre>[a-z]? </pre><pre>é o equivalente a:</pre><pre>[a-z]{0,1}</pre><h4>Terceira forma: Não limitar a quantidade de vezes que ele poderá aparecer.</h4><p>Para isso podemos utilizar dois metacaracteres diferentes, o asterisco (*) e o mais (+).</p><p>A diferença é simples, o asterisco permite casar o elemento nenhuma vez ou infinitas vezes, enquanto o (+) permite casar o elemento pelo menos uma vez ou infinitas vezes.</p><p>Exemplos:</p><pre>[a-z]*</pre><p>Permite casar qualquer palavra minúscula ou nenhuma palavra.</p><pre>[a-z]+</pre><p>Permite casar uma única letra ou qualquer palavra minúscula.</p><h3>Âncoras</h3><p>Metacaracteres chamados de âncoras são aqueles que permite você “posicionar” sua expressão regular, indicando inicio ou fim de linhas e parágrafos:</p><p>São eles:</p><p>^ : Circunflexo. Indica o início de uma linha</p><p>$ : Cifrão. Indica o final de uma linha</p><p>\b : Borda. Indica as bordas de uma palavra, ou seja, inicio ou fim de uma palavra.</p><p>Exemplos de uso:</p><pre>^hoje$</pre><p>Se casará apenas com a linha que só tenha a palavra “hoje”.</p><pre>^hoje o \b[A-Za-z]+\b estará maravilhoso$</pre><p>Se casará com qualquer linha que seja:</p><pre>hoje o dia estará maravilhoso<br>hoje o sol estará maravilhoso<br>hoje o (qualquer termo sem espaços aqui) estará maravilhoso</pre><h3>Aplicações gerais</h3><p>Como dito no início do artigo, a aplicação de expressões regulares tende ao infinito. Você consegue, além de abrir o leque de opções em suas buscas, usá-las em validações e substituições (não explicado no artigo). Abaixo mais alguns exemplos de utilização:</p><pre>\([0-9]{2}\)[0-9]?[0-9]{4}-[0-9]{4}</pre><p>Casará com números de telefone que contenham o DDD de dois dígitos numéricos e possuam ou não o nono dígito: (99)98888–8888 ou (99)8888–8888</p><pre>[a-z0-9_]+@[a-z0-9]+(\.[a-z0-9]+)+</pre><p>Casará com emails.</p><p>Entre outras…</p><h3>Conclusão</h3><p>A partir do momento em que você aprender como usar expressões regulares e ver as aplicações, verá o quanto irá facilitar em atividades do dia-a-dia, principalmente para quem é da área de informática.</p><p>No meu caso, enquanto escrevia minha monografia da faculdade, consegui identificar vários deslizes de escrita como: palavras escritas duas vezes, parágrafo iniciando com letra minúscula, falta de espaço depois da vírgula, etc.</p><p>O seguinte livro, que será deixado como referência, possui vários exemplos de aplicações de expressões regulares.</p><h3>Referência</h3><p>Apesar de existirem diversos lugares que ensinam a usar expressões regulares irei indicar o lugar em que aprendi, onde está explicado de forma simples e divertida.</p><p>Livro:<a href="https://books.google.com.br/books?id=MNCCCwAAQBAJ&amp;hl=pt-BR&amp;source=gbs_navlinks_s"> Expressões Regulares: Uma abordagem divertida</a></p><p>Endereço eletrônico: <a href="http://aurelio.net/regex/guia/">http://aurelio.net/regex/guia/</a></p><p>Originalmente publicado no blog <a href="http://danilopinotti.com.br/blog/o-basico-sobre-expressoes-regulares/">Danilo Pinotti</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9dca27d3411" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-grow/o-b%C3%A1sico-sobre-express%C3%B5es-regulares-9dca27d3411">O Básico Sobre Expressões Regulares</a> was originally published in <a href="https://medium.com/lets-grow">Let&#39;s Grow</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Clean Code #1: a importância dos nomes]]></title>
            <link>https://medium.com/lets-grow/clean-code-1-a-import%C3%A2ncia-dos-nomes-1203b2f3300b?source=rss----870adf3ca100---4</link>
            <guid isPermaLink="false">https://medium.com/p/1203b2f3300b</guid>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[boas-práticas]]></category>
            <dc:creator><![CDATA[Vinícius Alonso]]></dc:creator>
            <pubDate>Tue, 17 Jan 2017 16:32:58 GMT</pubDate>
            <atom:updated>2017-01-17T16:31:19.595Z</atom:updated>
            <content:encoded><![CDATA[<h4>Escrever um código para um computador entender é fácil, o difícil é escrever um código que os serem humanos entendam.</h4><p>Quem nunca suou frio quando recebeu a notícia de que teria que fazer uma alteração em um projeto legado? Quem nunca escreveu um código ruim e depois justificou com &quot;Não tinha muito tempo&quot;? Será que os programadores que desenvolveram aquele projeto legado, pensaram em boas práticas ou apenas foram na onda do “faz funcionar”?</p><p>Manter um sistema é mais complicado do que fazer um do zero. Por isso, é importante ter em mente de que a qualidade do código é importante. Os programadores passam mais tempo lendo código ao invés de escrever, logo, devemos deixa-los fáceis de serem compreendidos por outros programadores.</p><h3>Mas afinal de contas, o que é um código limpo ?</h3><p>Existem diversas definições legais sobre isso no livro Clean Code, porém, gostaria de deixar aqui a minha definição pessoal baseada na experiência que possuo:</p><blockquote>Um código limpo é fácil de ser entendido por expressar bem sua intenção, fazendo o que se propõem e nada mais. Utiliza corretamente os recursos da linguagem e framework no qual foi implementado.</blockquote><p>O objetivo deste post é falar sobre um tópico muito específico nesse universo do Clean Code, a importância dos nomes. Nomeamos arquivos, variáveis, classes, métodos e assim por diante. Mas afinal de contas, por que a nomenclatura é tão importante? Vamos a um exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/57ac357f37e3615649e368ab2dbd6fc4/href">https://medium.com/media/57ac357f37e3615649e368ab2dbd6fc4/href</a></iframe><p>Quando se lê <em>calc </em>o que lhe vem à mente? O nome dessa função é muito vaga e não expressa a real intenção do que ela faz. E quanto as variáveis <em>x</em> e <em>y</em>, quando se lê seus nomes não se sabe dizer exatamente o que são, com isso, deve-se ler a função toda para compreender seu propósito.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/63a78958310f5a72801e34a8c8a53131/href">https://medium.com/media/63a78958310f5a72801e34a8c8a53131/href</a></iframe><p>Agora pode-se notar uma melhora na versão refatorada, quando se lê o nome da função já se sabe o que ela faz. E o que se espera de cada variável também ficou muito mais claro: dividendo e divisor.</p><p>É muito importante que todos os nomes façam sentido no contexto ao qual são empregados. À seguir temos outro exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/49d847e8712210d9e6f4f34f7417c112/href">https://medium.com/media/49d847e8712210d9e6f4f34f7417c112/href</a></iframe><p>Apenas lendo o código o que se consegue extrair dele? A classe acima deve calcular o valor a ser pago a um programador freelancer. Se olharmos para o nome da classe já vemos um problema <em>ProgrammerFL</em>. Mas afinal, o que esse FL significa? Talvez alguns tenham entendido, talvez outros tenham demorado mais ou não entendido. Mas o fato é, siglas devem ser utilizas quando a equipe toda sabe seu significado ou quando faz parte da regra de negócio, por exemplo, tabela periódica, etc.</p><p>Outro problema são os atributos <em>h </em>e <em>v</em>. Quando são lidos, não se pode afirmar com certeza o que são. E finalmente o método <em>pay</em>, o qual diz apenas &quot;pagar&quot;, porém, na prática apenas calcula o valor a ser pago. O método diz uma coisa e faz outra isso é um problema grave.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fa49c0ec94614d08588455863405ab7a/href">https://medium.com/media/fa49c0ec94614d08588455863405ab7a/href</a></iframe><p>Após refatorar a classe, pode-se notar que ela ficou muito mais expressiva. Não há siglas para deixar o leitor em dúvida, o nome da classe expressa o que ela faz. Os atributos agora são claros, horas trabalhadas e valor da hora. E o método nos diz que calcula o valor total do trabalho e realmente faz isso.</p><h3>Algumas dicas para escolher bem os nomes</h3><p>Use nomes de fácil pronuncia:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/04858328dfc4290ced336581f7c5e020/href">https://medium.com/media/04858328dfc4290ced336581f7c5e020/href</a></iframe><p>Use substantivos em nomes de classes: Ex: Address, Customer, Programmer.</p><p>Use verbos em nomes de métodos: Ex: playGuitar, addItem, removeFirst.</p><p>Deixe explícito caso use algum design pattern, exemplo, CalculatorStrategy, CustomerFactory.</p><h3>Conclusão</h3><p>Nomear as coisas de forma correta é mais complicado do que parece, porém, deve ser algo que todo desenvolvedor deve ter em mente. É muito importante pensar bem nos nomes para que outros desenvolvedores consigam entender sua lógica. Lembre-se sempre, escrevemos códigos para os outros não para nós mesmos.</p><p>Caso tenha gostado do assunto, saiba mais lendo a obra completa de Robert C. Martin (Uncle Bob) Clean Code, há um capítulo inteiro falando apenas sobre esse assunto no qual essa publicação se baseou.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1203b2f3300b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-grow/clean-code-1-a-import%C3%A2ncia-dos-nomes-1203b2f3300b">Clean Code #1: a importância dos nomes</a> was originally published in <a href="https://medium.com/lets-grow">Let&#39;s Grow</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Primeiros passos com Docker]]></title>
            <link>https://medium.com/lets-grow/primeiros-passos-com-docker-2413ef6759a6?source=rss----870adf3ca100---4</link>
            <guid isPermaLink="false">https://medium.com/p/2413ef6759a6</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[brasil]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[tecnologia]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <dc:creator><![CDATA[Danilo Pinotti]]></dc:creator>
            <pubDate>Mon, 09 Jan 2017 11:22:40 GMT</pubDate>
            <atom:updated>2017-01-08T00:56:20.083Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/660/0*mfvp5Fp-I84bNOev.png" /></figure><p>O principal objetivo desta postagem não é aprofundar no funcionamento interno do Docker, quem sabe numa postagem futura, e sim nas definições básicas e nos passos iniciais para utilizá-lo.</p><h4>Sobre o Docker</h4><blockquote>“Docker containers wrap a piece of software in a complete filesystem that contains everything needed to run: code, runtime, system tools, system libraries — anything that can be installed on a server. This guarantees that the software will always run the same, regardless of its environment.”</blockquote><p>“Os contêineres do Docker envolvem um pedaço de software em um sistema de arquivos completo ao qual contém o necessário para executar: códigos, ferramentas do sistema, bibliotecas — qualquer coisa que possa ser instalado em um servidor. Isso garante que o software sempre será executado da mesma forma, independentemente do seu ambiente.”</p><p>Em outras palavras, o Docker permite você criar ambientes isolados de seu sistema raiz, através do uso de contêineres, de forma que fiquem independentes.</p><p>A instalação do Docker é feita de forma diferente em cada sistema operacional. Será apresentado os passos de como instalar em um sistema operacional Linux baseado em Debian (<em>Debian-like</em>) e, logo em seguida, o link para instalação nos demais sistemas.</p><h4>Instalação do Docker em um sistema operacional Linux baseado em Debian</h4><p>A instalação é simples, basta inserir os seguintes comandos no terminal do seu linux:</p><pre># apt-get install curl<br>$ curl -fsSL <a href="https://get.docker.com/">https://get.docker.com/</a> | sh</pre><p>Obs: O símbolo ‘#’ diz que o comando deve ser executado com permissões de super-administrador (root), e o símbolo ‘$’ diz que pode ser executado como usuário padrão do sistema.</p><p>Desta forma, sempre que for usar o Docker, terá que logar no sistema como root ou usar o ‘sudo’ antes de cada comando e isto não é muito prático. Para resolver é necessário adicionar o seu usuário do sistema ao grupo ‘docker’, que possui privilégios root, através do seguinte comando:</p><pre>$ sudo usermod -aG docker $USER</pre><p>Feito isto, é possível utilizar o comando ‘docker’ sem colocar ‘sudo’ antes, ou estar logado como root.</p><h4><a href="https://docs.docker.com/engine/installation/">Instalação do Docker nos demais sistemas operacionais (link para documentação oficial)</a></h4><h4>Imagens Docker e Docker Hub</h4><p>Para a criação de um contêiner Docker é necessário ter uma imagem base, ela pode ter sido criada por você ou ser baixada da central de imagens do Docker, o <a href="https://hub.docker.com/">Docker Hub</a>.</p><p>Atualmente existem milhares de imagens criadas e pré-configuradas para as mais diversas finalidades. Por exemplo: imagem com um servidor Apache ou DNS já instalados e prontos para serem colocados em funcionamento.</p><p>As imagens possuem uma nomenclatura padrão definida pela própria equipe de desenvolvimento:</p><pre>nome_do_usuario/nome_da_imagem:versão</pre><p>Exemplo:</p><pre>danilopinotti/apache:2.4</pre><p>Endereço para o Docker Hub: <a href="https://hub.docker.com/">https://hub.docker.com/</a></p><p>Ao encontrar uma imagem, é importante ler a documentação para ver como usá-la de maneira correta. Para ter uma cópia dela, ou de alguma versão específica, em sua máquina local basta digitar:</p><pre>$ docker pull nome_imagem</pre><pre>$ docker pull nome_imagem:versão</pre><h4>Comandos básicos</h4><p>Ver versão do Docker instalada:</p><pre>$ docker version</pre><p>Ver as imagens disponíveis no Docker:</p><pre>$ docker images</pre><p>Ver todos os contêineres instanciados:</p><pre>$ docker ps -a</pre><p>O parâmetro ‘-a’ faz com que exiba todos os contêineres instanciados. Sem ele, será mostrado apenas os contêineres em execução.</p><p>Executar/instanciar um contêiner (básico):</p><pre>$ docker run -ti --name &lt;nome_container&gt; &lt;nome_imagem&gt;</pre><p>Abaixo a explicação dos parâmetros do comando</p><p>“-ti”: Permite assumir o <em>bash</em> do contêiner logo após instanciá-lo</p><p>“-d”: Usado no lugar do ‘-ti’. Instancia e inicia o contêiner em background</p><p>“ — name &lt;nome_container&gt;”: Permite dar um nome ao contêiner. Recomendável para que possa tratá-lo por um nome ao invés de seu ID sha1.</p><p>“&lt;nome_imagem&gt;”: Imagem de base para o contêiner.</p><p>Exemplo de uso:</p><pre>$ docker run -ti --name meu_primeiro_container ubuntu:14.04</pre><p>O Docker isola o ambiente dentro do contêiner de forma que não acesse nada da máquina hospedeira, em alguns casos isso complica na utilização deles. Por exemplo, os códigos da aplicação estão armazenados na máquina hospedeira, enquanto o ambiente de desenvolvimento está isolado no contêiner, para isso existem formas de “conversar” com a máquina hospedeira.</p><p>Uma forma é executar/instanciar um contêiner montando (ou <em>linkando</em>) uma pasta da máquina hospedeira para dentro do ambiente isolado:</p><pre>$ docker run -v /home/pasta/host:/pasta/no/container --name &lt;nome_container&gt; &lt;nome_imagem&gt;</pre><p>Outra é Executar/instanciar um contêiner redirecionando (ou <em>linkando</em>) uma porta da máquina hospedeira para o ambiente isolado:</p><pre>$ docker run -p porta_host:porta_container --name &lt;nome_container&gt; &lt;nome_imagem&gt;</pre><p>Além dessas formas apresentadas, existem outras mais complexas.</p><p>Para sair do contêiner é recomendado usar ‘ctrl + p/q’ para que, desta forma, não finalize ele.</p><p>Parar um contêiner (pode ser iniciado usando o seu ID sha1 ou o nome do contêiner):</p><pre>$ docker stop &lt;ID sha1 / nome_do_contêiner&gt;</pre><p>Iniciar um contêiner :</p><pre>$ docker start &lt;ID sha1 / nome_do_contêiner&gt;</pre><p>Executar um comando em um contêiner em execução. Para funcionar, o contêiner deve inicializado (<em>started</em>):</p><pre>$ docker exec -it &lt;nome_contêiner&gt; /bin/bash</pre><p>‘/bin/bash’ será o comando executado dentro do contêiner</p><h3>Comandos úteis</h3><p>Abaixo serão apresentados comandos úteis para a utilização do Docker.</p><h4>Remover contêineres</h4><p>Um em específico:</p><pre>$ docker rm -f &lt;nome|id&gt;</pre><p>Todos:</p><pre>$ docker rm -f $(docker ps -a -q)</pre><h4>Remover imagem</h4><p>Uma imagem específica:</p><pre>$ docker rmi -f &lt;nome_da_imagem&gt;</pre><p>Todas as imagens:</p><pre>$ docker rmi $(docker images -q)</pre><p>A maioria dos comandos apresentados nesta postagem possuem mais parâmetros que não foram abordados devida à complexidade que foi evitada. Em futuras postagens serão mostradas mais opções para utilização dos contêineres.</p><h3>Temas para as próximas postagens sobre Docker:</h3><ul><li>Salvar instância do contêiner como imagem;</li><li>Importar/exportar contêineres e imagens;</li><li>Enviar imagem para o Docker Hub;</li><li>Dockerfile.</li></ul><h3>Referências</h3><ul><li><a href="https://www.ricardomartins.com.br/2014/09/11/docker-tutorial-mao-na-massa/">Blog pessoal de Ricardo Martins</a></li><li><a href="http://danilopinotti.com.br/blog/primeiros-passos-com-docker/">Meu blog pessoal</a></li><li><a href="https://docs.docker.com/">Documentação oficial Docker</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2413ef6759a6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-grow/primeiros-passos-com-docker-2413ef6759a6">Primeiros passos com Docker</a> was originally published in <a href="https://medium.com/lets-grow">Let&#39;s Grow</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Conhecendo Electron]]></title>
            <link>https://medium.com/lets-grow/conhecendo-electron-e4dd5019ab75?source=rss----870adf3ca100---4</link>
            <guid isPermaLink="false">https://medium.com/p/e4dd5019ab75</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[electron]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[introduction]]></category>
            <dc:creator><![CDATA[Guilherme Freire Hack]]></dc:creator>
            <pubDate>Tue, 27 Dec 2016 00:39:09 GMT</pubDate>
            <atom:updated>2017-01-07T13:40:05.673Z</atom:updated>
            <content:encoded><![CDATA[<h4>Se você consegue criar uma aplicação Web, você consegue criar uma aplicação Desktop.</h4><p>Desenvolvido pela equipe do GitHub, aberto a comunidade em 2014, Electron é um framework para criação de aplicações Desktop usando tecnologias Web como HTML 5, CSS e JavaScript. Com <a href="http://electron.atom.io/">Electron</a>, <a href="https://nodejs.org/en/">NodeJS</a>, <a href="https://www.chromium.org/">Chromium</a> e <a href="https://developers.google.com/v8/">V8 JavaScript Engine</a>, você pode:</p><ul><li>Exportar para Windows, MacOS e Linux</li><li>Distribuir pela Windows Store e Apple Store</li><li>Acessar o sistema de arquivos</li><li>Usar o ambiente do sistema operacional</li></ul><h3>Primeiro Contato</h3><p>No <a href="http://electron.atom.io/">site oficial</a> faça o download do <a href="https://electron-api-demos.githubapp.com/updates/electron-api-demos-linux.zip">Electron API Demo</a> e veja algumas possibilidades que o Electron oferece, o <a href="https://github.com/electron/electron-quick-start">Quick Start</a> é um começo rápido para o desenvolvimento. Verifique a versão do NodeJS requerida pelo Electron.</p><p>No <a href="https://docs.nodejitsu.com/articles/getting-started/npm/what-is-the-file-package-json/">package.json</a> é definido o main.js como o processo principal da sua aplicação, nele será carregado o Electron e onde está definida a criação da janela principal da aplicação.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f70c52958edcb797a389852e1f52b49c/href">https://medium.com/media/f70c52958edcb797a389852e1f52b49c/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/54bf94792df42ffef4c47981d7d04159/href">https://medium.com/media/54bf94792df42ffef4c47981d7d04159/href</a></iframe><p>Temos a definição das constantes <strong>app</strong> e <strong>BrowserWindow</strong>, respectivamente a aplicação e o responsável pela criação das janelas. Logo em seguida a declaração global da janela principal da aplicação e da função responsável pela criação da mesma. Em seguida é definido que assim que a aplicação fique pronta a função de criação da janela principal deve ser chamada. As duas funções seguintes são em relação ao OS X, para finalizar a aplicação quando todas as janelas estão fechadas e para quando iniciar a aplicação não recriar a última janela e sim criar a partir da janela principal.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/04de8221dbef79f56710af6587b4ab4a/href">https://medium.com/media/04de8221dbef79f56710af6587b4ab4a/href</a></iframe><p>Página em HTML 5 onde está o nosso “Hello World!”. Com isso basta no terminal, dentro da pasta da aplicação, dar o comando <strong><em>npm install</em></strong> para<em> </em>instalar as dependências e <strong><em>npm start</em></strong> para rodar o Electron.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/818/1*EbTuOR47V44tXUi6JLmd-Q.png" /></figure><h3>Nos próximos episódios…</h3><ul><li>Usando o sistema de arquivos</li><li>Ember</li><li>Banco de Dados</li></ul><p><a href="http://electron.atom.io/apps/">Explore aqui aplicação desenvolvidas com Electron!</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4dd5019ab75" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-grow/conhecendo-electron-e4dd5019ab75">Conhecendo Electron</a> was originally published in <a href="https://medium.com/lets-grow">Let&#39;s Grow</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Aplicando a Lei de Demeter em nossos códigos]]></title>
            <link>https://medium.com/lets-grow/aplicando-a-lei-de-demeter-em-nossos-c%C3%B3digos-5e2c0d70efd4?source=rss----870adf3ca100---4</link>
            <guid isPermaLink="false">https://medium.com/p/5e2c0d70efd4</guid>
            <category><![CDATA[lei-de-demeter]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[boas-práticas-programação]]></category>
            <dc:creator><![CDATA[Vinícius Alonso]]></dc:creator>
            <pubDate>Mon, 19 Dec 2016 11:33:07 GMT</pubDate>
            <atom:updated>2016-12-17T15:02:57.549Z</atom:updated>
            <content:encoded><![CDATA[<p>Quando estamos na universidade aprendemos sobre classes, objetos, atributos, métodos, herança, polimorfismo, etc. A ideia principal por trás da orientação a objetos é olhar para o problema que queremos resolver, abstrair as informações necessárias e montar um &quot;quebra-cabeça&quot; que vai solucionar nosso problema.</p><p>Esse quebra-cabeça é composto por nossos objetos que devem trocar mensagens entre si para chegar a uma solução. Quando estamos escrevendo nossos códigos, devemos sempre nos perguntar. &quot;O próximo desenvolvedor que olhar para esse código vai entende-lo com facilidade?&quot;, &quot;Há alguma classe que faz coisas demais?&quot;, etc. Como o processo de codificar é algo muito abstrato e varia de desenvolvedor para desenvolvedor, devemos seguir algumas regras para programar da melhor forma possível.</p><p>Existem diversos guias para nos auxiliar nessa jornada, Clean Code, princípios SOLID, entre outros. Porém, nesse post, falarei sobre a Lei de Demeter. Veremos como essa lei funciona com um exemplo prático.</p><p>Nesse exemplo, somamos todos os itens de um carrinho de compras, para isso existe a classe <strong>Product</strong> que representa um produto contendo seu nome e valor. Há também a classe <strong>Item</strong> responsável por compor os itens do carrinho de compras, ela guarda o produto e a quantidade. Por fim, temos a classe <strong>Cart</strong> que representa o carrinho de compras, responsável por somar o valor de todos os itens.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bbb9a52d15e90fb204397da71e50b4bc/href">https://medium.com/media/bbb9a52d15e90fb204397da71e50b4bc/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/61cf0c9f07efcd13e48aedb045df7202/href">https://medium.com/media/61cf0c9f07efcd13e48aedb045df7202/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/12f4bccfde7e7e7a387d6760c65bf99d/href">https://medium.com/media/12f4bccfde7e7e7a387d6760c65bf99d/href</a></iframe><p>Embora o código acima parece simples e inofensivo ele apresenta um problema de encapsulamento. Olhando para o método <em>totalValueOfItems</em>, vamos notar que na linha 14 é chamado o produto do item para então chamar seu valor.</p><p>Isso é um problema, porque caso a classe <strong>Item</strong> mude, o código desse método irá quebrar, e se o projeto não tiver testes para detectar isso? E se códigos assim estiverem espalhados por toda nossa aplicação? É certo o próximo desenvolvedor tem que usar ctrl + F para saber onde deve mudar?</p><p>Evitar esses problemas é simples, apenas devemos deixar os donos da informação manipulá-la, para isso vamos refatorar as classes.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3840a384466ca654e32ff425ce6ecbb8/href">https://medium.com/media/3840a384466ca654e32ff425ce6ecbb8/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1afd8001ffc1f7957e86deeee70ef1ba/href">https://medium.com/media/1afd8001ffc1f7957e86deeee70ef1ba/href</a></iframe><p>O que mudou com essa pequena alteração ? Agora, está melhor encapsulado porque a classe que conhece o produto e a quantidade está fazendo essa soma e a classe <strong>Cart</strong> que conhece todos os itens está acumulando o valor para retornar o total no carrinho.</p><blockquote>Quando vamos utilizar métodos de outras classes devemos saber sempre o que o método faz e nunca como ele faz. Seguindo isso, evitamos o <a href="http://martinfowler.com/bliki/CodeSmell.html"><strong>bad smel</strong></a><strong>l</strong> chamado <a href="https://sourcemaking.com/refactoring/smells/feature-envy"><strong>Feature Envy</strong></a><strong>.</strong></blockquote><h3>Explicando melhor a Lei de Demeter</h3><p>Foi proposta por <a href="http://www.ccs.neu.edu/research/demeter/holland/">Ian Holland</a> em 1987, leva esse nome porque foi descoberta durante o desenvolvimento do <a href="http://www.ccs.neu.edu/research/demeter/">The Demeter Project</a> na Northeastern University.</p><p>A ideia dela é <a href="http://www.ccs.neu.edu/home/lieber/LoD.html">&quot;Converse apenas com seus amigos&quot;,</a> levando isso em consideração temos na classe <strong>Item</strong> o método <em>totalValue</em> que trabalha com o valor do produto apenas porque ele conhece a classe do produto por isso pode pedir seu valor.</p><p>Para saber mais sobre a Lei de Demeter, recomendo a leitura do <a href="http://The Paperboy, The Wallet, and The Law Of Demeter">The Paperboy, The Wallet, and The Law Of Demeter</a> e também o livro <a href="https://www.amazon.com.br/Pragmatic-Programmer-Journeyman-Master-ebook/dp/B003GCTQAE/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1481980918&amp;sr=1-1&amp;keywords=pragmatic+programmer">Pragmatic Programmer</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e2c0d70efd4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-grow/aplicando-a-lei-de-demeter-em-nossos-c%C3%B3digos-5e2c0d70efd4">Aplicando a Lei de Demeter em nossos códigos</a> was originally published in <a href="https://medium.com/lets-grow">Let&#39;s Grow</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Que os jogos comecem]]></title>
            <link>https://medium.com/lets-grow/que-os-jogos-comecem-c47e56d119de?source=rss----870adf3ca100---4</link>
            <guid isPermaLink="false">https://medium.com/p/c47e56d119de</guid>
            <dc:creator><![CDATA[Guilherme Mazur]]></dc:creator>
            <pubDate>Tue, 18 Oct 2016 00:50:06 GMT</pubDate>
            <atom:updated>2016-10-18T00:50:05.903Z</atom:updated>
            <content:encoded><![CDATA[<p>First story :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c47e56d119de" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-grow/que-os-jogos-comecem-c47e56d119de">Que os jogos comecem</a> was originally published in <a href="https://medium.com/lets-grow">Let&#39;s Grow</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>