<?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 Júnior Garcia on Medium]]></title>
        <description><![CDATA[Stories by Júnior Garcia on Medium]]></description>
        <link>https://medium.com/@itamarjunior?source=rss-80b7cbd58a4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*_J5-ur3Fqf4LxgNQBxVh1A.png</url>
            <title>Stories by Júnior Garcia on Medium</title>
            <link>https://medium.com/@itamarjunior?source=rss-80b7cbd58a4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 10:39:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@itamarjunior/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[Eu desisti do Linux há alguns anos e aqui estão as principais razões]]></title>
            <link>https://itamarjunior.medium.com/eu-desisti-do-linux-h%C3%A1-alguns-anos-e-aqui-est%C3%A3o-as-principais-raz%C3%B5es-744fc70a5872?source=rss-80b7cbd58a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/744fc70a5872</guid>
            <category><![CDATA[apple]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[macos]]></category>
            <category><![CDATA[it]]></category>
            <category><![CDATA[os-x]]></category>
            <dc:creator><![CDATA[Júnior Garcia]]></dc:creator>
            <pubDate>Tue, 07 Jan 2020 12:30:18 GMT</pubDate>
            <atom:updated>2020-01-07T12:30:18.459Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MY2GS_LMdkchJKcjCngCVQ.jpeg" /><figcaption>Créditos: <a href="https://unsplash.com/@teodor">Teodor Bjerrang</a></figcaption></figure><p>O Linux tem sido há muitos anos um sistema operacional de sucesso estrondoso, mesmo que não nos desktops que foi seu objetivo principal. Servidores, computadores de instituições governamentais e de mercado privado e, claro, seu celular Android são apenas <em>alguns</em> <em>cases</em> de sucesso do SO. Mas depois de utilizar diariamente o macOS desde 2014 deixei o Linux de lado e mais a frente vocês saberão os motivos, mas primeiro é importante um disclaimer.</p><h4>Aos exaltados, eis a minha proposta nesse artigo</h4><p>Antes de continuar, você precisa se despir de qualquer preconceito que tenha com relação à Apple, já que tem muito disso principalmente em meio a profissionais de TI mais radicais, muitos dos quais conheci durante todos esses anos de profissão.</p><p>Como sei da existência desses donos da razão e dos puristas que acham que fazer tudo no terminal torna-os espiritualmente superiores, peço que antes de gastar seus poderes de <em>sudo</em> comentando coisas como “não é programador de verdade” ou “reclama porque não sabe usar”, nem se dê ao trabalho.</p><p>Essa análise é <em>puramente</em> pessoal e <em>não</em> terá detalhes técnicos <em>profundos</em>, apenas o que me levou a não usar mais o Linux. Tudo o que vou falar aqui vai ser do ponto de vista de um usuário-programador que não quer converter ninguém bem como ser convertido. Não tente falar coisas como “está errado” no tocante a opinião. Também <em>não</em> quero dar a ideia de que característica &quot;A&quot; ou &quot;B&quot; ou a falta delas é <em>culpa</em> do Linux.</p><h4>Uma breve história pessoal com o Linux</h4><p>Usei a distribuição brasileira Kurumin (feita pelo Clube do Hardware) pela primeira vez em 2007, e me apaixonei. Naquele tempo eu era só uma criança com 16 anos. Não sabia escrever sequer uma linha de código, estava apenas me aventurando. Sempre gosto de repensar o que e como faço as coisas para validar se ainda faz sentido. Isso me permite evoluir na vida profissional e pessoal.</p><p>A partir de 2011, quando comecei a trabalhar na área, decidi que o Linux seria meu principal SO<em> em casa</em>, já que no trabalho desenvolvia aplicativos para Windows. Nesse ponto da vida aprendi duas lições que levo até hoje:</p><ol><li>Usaria Linux sempre que possível;</li><li>Windows como sistema operacional é um ótimo <em>videogame</em>.</li></ol><p>Minha paixão pelo Linux foi tanta que em 2017 decidi estudar para conseguir a certificação LPIC-1 e consegui.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q_cN9n6vFhpjQ59TltRNnQ.png" /></figure><p>Porém, essa relação durou até 2014, quando comprei um Macbook. Depois de utilizar o sistema com frequência, as minhas opiniões começaram a mudar. Eis algumas coisas que considero problemas hoje no mundo do Linux.</p><h4>Muitas variantes (distros) não ajudam</h4><p>Aprendi que quanto mais opções temos, mais tempo demoramos para escolher, quando conseguimos escolher. Isso torna a experiência ruim e exaustiva que pode nos levar a abraçar uma alternativa que não será ideal.</p><p>Aconteceu comigo quando estive perante uma prateleira com pelo menos 37 opções de cápsulas de bebidas que podem ser preparadas na cafeteira gourmet com backup cardíaco. Ainda bem que ganhei-a num sorteio, para não me arrepender do processo que é abastecê-la, além de escolher um modelo da marca, que atualmente está na casa dos 20.</p><p>Infelizmente escolher uma distro <em>não</em> é uma tarefa tão simples e rápida como escolher um sabor de bebida. Existem muitas características que só o uso por algum tempo pode dizer se ela foi uma boa escolha.</p><p>O <a href="https://www.linux.org/pages/download">site do Linux</a> tem uma listagem de apenas <em>algumas</em> distros disponíveis, que enquanto escrevo chegam a 25. São tantas distros que <a href="https://distrowatch.com/">existe um site famoso</a> dedicado ao assunto. No sidebar<em> </em>dele você pode ver o ranking<em> </em>das top<em> 100</em>. Existe até um <em>prático</em> botão para obter uma distribuição aleatória.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/224/1*BkRJ8wk6zomDuaFwjUSNUQ.png" /></figure><p>Se isso resolver o problema de tantas variantes, espero ver um botão desses nas prateleiras de cápsulas de café. Você pode conferir <a href="https://distrowatch.com/dwres.php?resource=popularity">aqui</a> o <em>ranking</em> total que enquanto escrevo está com <em>277</em> variantes.</p><h4>Não existe um designer que cuida do projeto</h4><p>Com tantos ambientes de desktop diferentes o controle de UI/UX é impraticável. Alguns ambientes focam em computadores menos poderosos, logo tem de abrir mão de firulas e funcionalidades que podem ajudar o usuário ou deixar a interação mais suave e agradável.</p><p>Ambientes como Gnome 3 ou KDE, tem abordagens diferentes entre eles, desde gerenciador de arquivos até identidade visual e usabilidade. Geralmente eles proporcionam experiências e configurações diferentes, podendo tornar a migração entre os dois ambientes um processo não muito agradável, se é que possível.</p><h4>Adobe não está por lá</h4><p>Não existe muito o que explicar aqui. A falta da Adobe é um problema de adoção para mim e para muitos profissionais que, mesmo não trabalhando como designers, precisam dos apps para abrir seus arquivos. Há quem recomende o Gimp como alternativa ao Photoshop. Sempre acho que essas pessoas nunca trabalharam com psds por lá para sugerirem tal coisa. Além da sua usabilidade muito diferente, abrir um arquivo psd nele pode gerar resultados <em>bastante</em> diferentes do que foi criado originalmente. Tentei utilizar o Gimp por algum tempo mas sempre existiam discrepâncias consideráveis quando comparávamos psds abertos nele e no Photoshop. Isso certamente é algo que afasta quem precisa dessas ferramentas no Linux.</p><h4>A renderização da fonte é lamentável</h4><p>Se você esqueceu do que leu lá em cima sobre esse artigo ser uma <em>opinião pessoal</em> e já está pensando em me xingar nos comentários porque isso é frescura, respire.</p><p>Interface é um aspecto que pesa muito para mim, principalmente depois de ficar tão inserido em <em>frontend</em> e UX. A renderização de fonte do Linux é uma coisa triste. Veja uma comparação que fiz utilizando a fonte <a href="https://github.com/tonsky/FiraCode">Fira Code</a>. Configurei dois terminais para utilizarem essa mesma fonte, com <em>mesma configuração</em> de cor e tamanho:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/634/1*G4kwbrIb2SYKv78gfzgiTA.png" /><figcaption>À esquerda o terminal do macOS, à direita do Ubuntu</figcaption></figure><p>Nota a diferença? A fonte renderizada do Linux parece mais fina enquanto a do macOS é mais encorpada e agradável. Vale lembrar que esse problema acontece no sistema inteiro, não somente no terminal. Você pode até dizer que existem tutoriais como <a href="https://blog.aktsbot.in/better-font-rendering-linux.html">esse</a> para melhorar a renderização, mas voltamos ao ponto em que eu defendo que isso não é para ser preocupação do usuário. Se quiser entender mais sobre esse problema, veja <a href="https://pandasauce.org/post/linux-fonts/">aqui</a>.</p><h4>A falta de ecossistema</h4><p>Esse calo é um dos que mais doem. Só quem já comprou algo da Apple sabe da facilidade que é ter tudo sincronizado. Suas fotos, configurações, senhas, aplicativos, calendário, contatos e arquivos todos girando em torno de uma conta que está só esperando ser logada para sincronizar o que você precisa ou de um HD qualquer que você pode utilizar para backup (mais adiante).</p><p>Seus dispositivos também podem ser ligados e conversar uns com os outros de forma harmoniosa. A Apple faz esse tipo de coisa com maestria.</p><p>Se comprar uma Apple TV e tiver um iPhone, a única coisa que precisa para ativá-la é chegar com o iPhone perto e pronto. Funciona como mágica. Tudo será configurado e sincronizado sem uma batalha ou sem a necessidade de ler um manual.</p><p>O Linux não produz hardware, claro. Mas a falta dessa facilidade me incomoda.</p><h4>Backup e sincronização</h4><p>Teve que reparar o Mac ou decidiu instalar um SO limpo? Sem problemas! Basta restaurar um backup feito pela Time Machine ou simplesmente logar na conta do iCloud e marcar o que você quer sincronizar. Verdade seja dita: o iCloud não sincroniza todo o sistema, mas apenas algumas coisas mais pessoais como contatos, fotos, senhas, etc. Por isso prefiro ter um HD externo e utilizar a Time Machine para restaurar o sistema por completo. Sei da existência de ferramentas no Linux que internamente utilizam rsync ou de alternativas como Cronopete, mas usá-las é uma coisa tediosa, complicada ou sem muitos recursos mais polidos.</p><p>A Time Machine me permite uma visualização por data dos meus arquivos ao longo dos backups feitos, e esse é um recurso fantástico e intuitivo. Posso fazer coisas como restaurar apenas um arquivo de um certo dia de forma simples e rápida e o melhor: sem precisar ler a documentação no terminal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OyTh8gQ2pn8ZbV3nW67aag.png" /></figure><h3>Conclusão</h3><p>Essas opiniões sobre o Linux se deram depois de amadurecimento profissional e pessoal. Precisei abandonar esse preciosismo de querer fazer tudo no terminal ou de maneira menos intuitiva a fim de inflar meu ego. Acho <em>fantástico</em> utilizar o terminal para as tarefas técnicas do meu dia-a-dia e certamente será um costume que <em>nunca</em> abandonarei, mas depois de tantos anos na área e consumindo diariamente conteúdo sobre agilismo, empreendedorismo e programação, percebi que devemos <em>sempre</em> solucionar as coisas da <em>melhor maneira possível </em>(claro que isso é relativo). Praticar esse conceito muitas vezes significa abandonar uma maneira <em>cool</em> de executar uma tarefa em prol de uma alternativa que vai resolver o problema de forma eficaz. A maior vantagem de seguir esse modelo é que <em>posso focar no que realmente importa</em>.</p><p>Desde 2018 tenho sido frontend integralmente depois de uma temporada como fullstack, e consumir conteúdo semanal de newsletters sobre o assunto me fez perceber o quanto estamos sobrecarregados. JavaScript é uma linguagem que só cresce, e sempre tem alguma library ou framework para resolver algum problema. A necessidade de atualização de profissionais de TI é muito alta e está ficando cada vez maior. Já sofremos tanto com uma grande quantidade de escolhas técnicas que temos que fazer, então por que não nos dedicarmos apenas a essas escolhas técnicas enquanto nosso workflow fica mais simples?</p><p>Minha paixão por Clojure é devido ela ser uma linguagem bonita, elegante, simples e robusta. <em>Quase</em> sem sintaxe. No final o que deve importar é a <strong><em>qualidade e arquitetura do seu código</em></strong>.</p><p>Já ouviu falar do <a href="https://medium.com/devane-io/bundlers-configura%C3%A7%C3%A3o-zero-com-parcel-35f75db2b8f8">Parcel Bundler</a>? A proposta dele é configuração zero. Sabe o motivo? Simples: <em>seu produto final é o que importa de verdade</em>. Uma configuração elegante no pipeline de assets <strong>não</strong> é o que vai botar dinheiro no seu bolso ou gerar renda para a empresa que você trabalha.</p><blockquote>A capacidade de tornar algo simples significa eliminar o desnecessário para que o necessário possa falar — Hans Hofmann</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=744fc70a5872" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Clojure: minha primeira experiência com programação puramente funcional]]></title>
            <link>https://itamarjunior.medium.com/clojure-minha-primeira-experi%C3%AAncia-com-programa%C3%A7%C3%A3o-puramente-funcional-ed1badb23ea9?source=rss-80b7cbd58a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed1badb23ea9</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[it]]></category>
            <category><![CDATA[clojure]]></category>
            <category><![CDATA[programming-languages]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Júnior Garcia]]></dc:creator>
            <pubDate>Mon, 28 Oct 2019 15:56:46 GMT</pubDate>
            <atom:updated>2019-10-28T15:56:46.762Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ahjtevtsKMLsys-qo_snHA.png" /><figcaption>Logo da linguagem</figcaption></figure><p>Lembro que estava ouvindo o <a href="https://hipsters.tech/tecnologias-no-nubank-hipsters-01/?utm_source=medium&amp;utm_medium=article">primeiro episódio do podcast hipsters.tech</a> em julho de 2016 sobre as tecnologias do Nubank quando me deparei com Clojure.</p><p>De tempos em tempos eu ouvia e lia sobre programação funcional e percebi que esse termo ganhava cada vez mais visibilidade. Foi aí que decidi brincar com essa linguagem por diversão e para entender um pouco mais sobre esse <em>buzz</em> em cima desse paradigma. Considere esse artigo como um pequeno <em>overview</em> da linguagem e de algumas das suas características.</p><h3>O que é programação funcional?</h3><p>Porque não utilizar a Wikipedia?</p><blockquote>[…]programação funcional é um paradigma de programação que trata a computação como uma avaliação de funções matemáticas e que evita estados ou dados mutáveis. Ela enfatiza a aplicação de funções, em contraste da programação imperativa, que enfatiza mudanças no estado do programa.</blockquote><p>A verdade é que se você já programou em JavaScript, provavelmente já deu de cara com algum bloco de programação funcional. Veja o exemplo abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e8bae1cd9ee07d3abd309e12879c136e/href">https://medium.com/media/e8bae1cd9ee07d3abd309e12879c136e/href</a></iframe><p>Na linha 2 declaramos uma variável e a ela atribuímos uma <em>closure</em> (soa familiar?), ou função anônima para processar os dados e retorná-los. Seria fácil utilizar writeAllNames para compor outras funções.</p><h4>Funções puras</h4><p>As funções puras devem cumprir os seguintes requisitos:</p><ol><li>Não devem depender de valores externos à ela mesma como IO, acesso à banco de dados<em>, networking</em>, etc;</li><li>Dado um mesmo <em>input</em>, elas devem retornar o mesmo <em>output;</em></li><li>Não deve alterar o valor dos seus <em>inputs</em>.</li></ol><p>Ao cumprir esses requisitos é dito <em>também</em> que a função não tem efeitos colaterais, ou <em>side-effects</em>.</p><p>Por mais que possa parecer estranho cumprir os passos acima, isso torna a depuração muito mais fácil.</p><blockquote><em>Disclaimer: Numa aplicação do mundo real, é bastante improvável que todas as funções sejam puras, isso porque uma hora ou outra precisaremos interagir com </em>network<em>, banco de dados, arquivos, etc. </em><strong><em>Sempre que possível, escreva funções puras.</em></strong></blockquote><h3>Um pouco sobre Clojure</h3><p>A primeira coisa interessante que notei é que ela roda na JVM e é interoperável com Java, o que quer dizer basicamente que qualquer biblioteca escrita em Java pode ser utilizada no Clojure. E esse é um ponto muito forte, afinal, o Java tem uma lista gigantesca de bibliotecas disponíveis incluindo a sua biblioteca interna e é uma linguagem muito sólida.</p><p>A segunda coisa me deixou um pouco assustado <em>de início</em>: a sintaxe era diferente de tudo o que eu já tinha visto, isso porque Clojure é um dialeto de LISP e não de Java ou C++, como é de se esperar de muitas linguagens populares.</p><p>Vamos comparar o exemplo acima com outro escrito em Clojure:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/51e4241e0ecab41fbdc5ec08ef4dff1c/href">https://medium.com/media/51e4241e0ecab41fbdc5ec08ef4dff1c/href</a></iframe><p>É diferente do que você já viu ou não é? Ainda assim, muito simples de se entender. Não se deixe intimidar pelos parênteses. Você só precisa de um pouco de tempo para assimilá-los.</p><p>Na primeira linha nós importamos <em>apenas</em> (:only) a função join da biblioteca clojure.string. Então, declaramos um <em>array</em> de nomes utilizando def que serve para declarar valores. defn cria uma função e seus parâmetros de entrada são passados nos colchetes separados por espaço. Você também vai perceber que não existe uma declaração (<em>statement</em>) de retorno, como o return que encontramos em outras linguagens. Isso porque Clojure é uma linguagem baseada em expressões, logo, o resultado da última expressão será o retorno da função.</p><h4>Funções como first-class objects</h4><p>Com Clojure você tem funções como <em>first-class objects</em>, o que significa que é possível atribuir uma função a uma variável ou utilizar essa função como <em>callback</em>. Vale ressaltar que isso é uma característica comum em linguagens funcionais. Vejamos um exemplo simples mas esclarecedor.</p><p>Primeiro, temos uma função count-chars que recebe uma string e retorna outra string com a palavra informada e a contagem de caracteres dela:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e53effda96f9d31399f2f9717bd0613e/href">https://medium.com/media/e53effda96f9d31399f2f9717bd0613e/href</a></iframe><p>Se queremos processar o tamanho das <em>strings</em> de uma coleção, podemos utilizar a referência da função que criamos em um map (bem comum em outras linguagens) para demonstrarmos que funções são <em>first-class objects</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2a8d74534b89fbd882b500e119f8b723/href">https://medium.com/media/2a8d74534b89fbd882b500e119f8b723/href</a></iframe><h4>O Design da Linguagem</h4><p>Clojure foi uma linguagem que teve um bom processo de design. O código é coerente. A coerção de tipos é coerente. As convenções da linguagem são coerentes. Há um contraste muito grande aqui se compararmos com, digamos, JavaScript, que teve seu processo de criação confuso e sem uma boa fase de design.</p><h4>É imutável</h4><p>Valores definidos em Clojure não mudam. Eles passam por transformação. Quando você aplica função para &quot;remover&quot; um item de um <em>array</em>, o <em>array</em> original não é mudado. Ao invés disso um novo valor é retornado com a modificação proposta pela função aplicada a ele. Esse princípio de programação puramente funcional, como dito anteriormente, deixa o código mais fácil de depurar, já que valores não serão mudados por funções.</p><h4>Preparada para programação assíncrona</h4><p>Clojure possui uma biblioteca oficial para trabalhar com programação assíncrona (core.async). O modelo de concorrência utilizado na linguagem é similar ao utilizado em Go, chamado CSP ou <em>Communicating Sequential Processes</em> e utiliza todo o poder da JVM para tal. Isso torna Clojure uma linguagem muito boa para trabalhar com concorrência.</p><h4>Pode ser utilizada na web</h4><p>Um ponto muito forte é que você pode utilizar código Clojure para programar para a web. Isso é feito utilizando ClojureScript que compila para JavaScript. Dessa forma seu código fica mais conciso e bem menos propenso a erros e você tem acesso à API nativa como teria se utilizando JavaScript.</p><h4>Possui REPL</h4><p>Ter um REPL faz toda a diferença na linguagem. Você programa de forma muito interativa com um feedback rápido.</p><h4>Leiningen como ferramenta a nível de projeto</h4><p>O Leiningen é uma ferramenta que auxilia muito no gerenciamento dos projetos. Dentre outras coisas, ele pode:</p><ol><li>Gerenciar suas dependências</li><li>Rodar seus testes</li><li>Compilar sua aplicação</li><li>Criar projetos baseados em templates</li><li>Rodar um REPL contextualizado, onde você pode executar o código do seu projeto, utilizando até mesmo o código das dependências que você instalou.</li></ol><h3>Considerações finais</h3><p>A experiência inicial com Clojure pode ser um pouco intimidadora, mas você não deve desistir se realmente quiser aprender. Isso se dá principalmente porque você está combinando uma linguagem nova com um paradigma puramente funcional. Você precisa aprender a como fazer <em>X</em> de forma funcional e isso pode dar um nó na cabeça, mas a internet está cheia de exemplos para você. Fato é que programar de forma puramente funcional te ensina a resolver problemas de maneiras diferentes e mais limpas.</p><h4>Sites úteis</h4><ul><li><a href="https://exercism.io/">exercism.io</a>: Possui um <a href="https://exercism.io/tracks/clojure">track de Clojure</a> onde você pode estudar enquanto auxiliado por um mentor sem pagar nada — isso mesmo que você ouviu. De forma geral, recomendo o exercism.io para aprender qualquer linguagem de programação de forma assistida. Nada melhor que receber dicas de pessoas experientes.</li><li><a href="http://www.4clojure.com/">4clojure.com</a>: É um site focado em Clojure com uma lista imensa de exercícios de todos os níveis para que você possa praticar a linguagem.</li><li><a href="https://www.braveclojure.com/">braveclojure.com</a>: É o site de um livro muito famoso de Clojure o qual você <a href="https://www.braveclojure.com/clojure-for-the-brave-and-true/">pode ler online e grátis</a> para aprender. É bastante didático e aborda tópicos como core.async, <em>protocols,</em> gerenciamento de projetos e muitas outras coisas interessantes.</li></ul><p>Quando estiver resolvendo exercícios propostos por sites, você certamente buscará as soluções para comparar às suas. Não se sinta mal se a sua solução é menos elegante (o que quer que isso signifique) ou se não usa de forma aprimorada os recursos da linguagem. Lembre-se que você está aprendendo uma linguagem e um paradigma novo, e chegar à excelência leva tempo.</p><p>Tem alguma consideração? Deixa um comentário que ficarei feliz em responder.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed1badb23ea9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introdução a programação funcional com JavaScript]]></title>
            <link>https://medium.com/devane-io/introducao-a-programacao-funcional-com-javascript-67d659a5b558?source=rss-80b7cbd58a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/67d659a5b558</guid>
            <category><![CDATA[tooling]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Júnior Garcia]]></dc:creator>
            <pubDate>Fri, 28 Jun 2019 13:31:01 GMT</pubDate>
            <atom:updated>2019-06-28T13:31:01.196Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introdução à programação funcional com JavaScript</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aN-OH0yWRTjoagiCGQblQA.png" /></figure><p>Muitos de nós estamos acostumados a fazer código de forma<strong> imperativa</strong>, cuja estrutura dá uma ideia de ordem: sayHello() , doubleValue(x) , etc. O “o quê” e “como” fazer são importantes e característicos desse tipo de paradigma.</p><p>Apesar da sua grande base de usuários e linguagens que a adotam, a programação imperativa<strong> </strong>não é a única por aí. Se você explora o mundo da TI, certamente já ouviu falar de <strong>programação funcional</strong> que está em alta há um tempo e que é suportada nativamente pelo JavaScript!</p><h4>O que é programação funcional?</h4><p>Na programação funcional, a computação dos dados é feita como uma avaliação de funções matemáticas. Linguagens que suportam esse paradigma normalmente tratam funções como membros de primeira importância (também conhecido como <em>first-class object</em> ou <em>first-class member</em>), o que significa que funções têm métodos internos, propriedade e que podem ser passadas como parâmetros para outras funções ou atribuídas à variáveis e constantes.</p><h4>Aplicação de programação funcional no JavaScript</h4><p>JavaScript é uma linguagem muito flexível (às vezes até em demasia) e suporta ambos os paradigmas: funcional e imperativo. Você pode nem ter percebido, mas sempre que usa um forEach , reduce ou map, você põe em prática conceitos de programação funcional, já que as funções passadas como parâmetro recebem um valor de <em>input</em> e realizam cálculos baseados nele. Vejamos um exemplo simples:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d95f2c45cd0f962c9764751492f00868/href">https://medium.com/media/d95f2c45cd0f962c9764751492f00868/href</a></iframe><p>Apesar de simples, esse exemplo é muito esclarecedor. Lembra que falamos anteriormente que linguagens que suportam o paradigma funcional tratam funções como <em>first-class members</em>? Perceba que eu atribui à doubleValue uma função (<em>arrow function</em> para ser mais específico) que recebe um parâmetro x e multiplica o valor dele por 2. Ao passar a função doubleValue para map eu aplico o resultado de doubleValue para cada item do <em>array</em> numbers, obtendo o resultado esperado: [2, 10, 20].</p><p>Perceba uma característica <strong>importante</strong> desse exemplo: o valor original de numbers <strong>não</strong> é alterado:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c34d0207aa593403926879029fa9e3b5/href">https://medium.com/media/c34d0207aa593403926879029fa9e3b5/href</a></iframe><p>Isso não é obrigatório, mas é muito bom porque ajuda na depuração do código e não muda o valor original do parâmetro processado, podendo afetar o funcionamento de outros componentes do seu código que dependem do valor de numbers.</p><p>Nesse caso, podemos dizer que doubleValue é uma função <strong>pura</strong>.</p><h4>Funções puras</h4><p>Uma função pura (<em>pure function</em>) tem as seguintes características:</p><ol><li>Dado o mesmo input, sempre será retornado o mesmo output;</li><li>Não possui efeitos colaterais como: dependências externas — conexão com APIs, banco de dados, escrita em sistema de arquivos — ou mudança de estado compartilhado.</li></ol><p>Funções puras são fáceis de testar, consistentes e não quebram o comportamento externo, o que deixa seu código menos suscetível a erros. Elas são <strong>ideais</strong> para programação funcional.</p><p>Claro que, não é muito realístico uma aplicação completa composta apenas de funções puras, afinal você vai ter que acessar uma API ou um banco de dados uma hora ou outra. <strong>Lembre-se de usá-las sempre que possível</strong>.</p><h4>Conclusão</h4><p>Programação funcional tem sido <em>trend</em> por um tempo, contudo talvez ainda não seja tão explorada quanto deveria. Aplique o paradigma funcional no seu código sempre que puder. Isso garante menos probabilidade de erro, menos <strong>dependência de valores externos</strong>.</p><p>Explore, também, linguagens puramente funcionais como <a href="https://clojure.org/">Clojure</a>, <a href="http://elixir-lang.org/">Elixir</a> ou <a href="https://elm-lang.org/">Elm</a> que compila para JavaScript. Isso pode dar uma visão diferente na hora de construir seu código.</p><h4>Referências</h4><ol><li><a href="https://medium.com/javascript-scene/master-the-javascript-interview-what-is-functional-programming-7f218c68b3a0">Master the JavaScript Interview: What is Functional Programming?</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67d659a5b558" width="1" height="1" alt=""><hr><p><a href="https://medium.com/devane-io/introducao-a-programacao-funcional-com-javascript-67d659a5b558">Introdução a programação funcional com JavaScript</a> was originally published in <a href="https://medium.com/devane-io">devane.io</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bundlers — Configuração zero com Parcel]]></title>
            <link>https://medium.com/devane-io/bundlers-configura%C3%A7%C3%A3o-zero-com-parcel-35f75db2b8f8?source=rss-80b7cbd58a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/35f75db2b8f8</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[tooling]]></category>
            <category><![CDATA[webpack]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Júnior Garcia]]></dc:creator>
            <pubDate>Thu, 14 Feb 2019 14:01:10 GMT</pubDate>
            <atom:updated>2019-02-15T12:57:57.597Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bundlers — Configuração zero com Parcel</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*36ZLO3-292Ylj4Pq8F1FyA.jpeg" /></figure><p>Desde a ascensão da internet muita coisa mudou. Há alguns anos precisávamos de imagens para simular bordas arredondadas. Isso vai soar absurdo para vocês, mas funcionava desse jeito mesmo.</p><p>Nesses mesmos tempos sombrios em que não existia border-radius, nós não fazíamos muitos trabalhos relacionados aos nossos <em>assets</em>, como CSS, JavaScript (JS) ou imagens. Talvez minimizá-los. Mas hoje a web está muito mais exigente e fragmentada: diferentes dispositivos e variantes deles, vários <em>browsers</em>, poder de processamento que varia muito entre dispositivos, armazenamento e velocidade de conexão, muitas linguagens e ferramental que podemos usar para melhorar nossa produtividade e qualidade de código.</p><p>Hoje dificilmente utilizamos JS ou CSS planos em projetos de médio a grande porte. Precisamos compilar linguagens que se transformam em CSS e talvez outras que se transformam em JavaScript, ou até mesmo transpilar JavaScript para uma versão mais compatível com <em>browsers </em>que não aceitam alguns recursos, além de uma série de outros trabalhos que tornam nossos sites e aplicações mais eficientes<em>. </em>Gerir todos esses novos recursos não é fácil. São muitas tarefas que têm de entrar em sintonia para termos um bom produto. Aí entra uma peça fundamental no desenvolvimento <em>web</em> moderno: o <em>bundler</em>, ou empacotador.</p><h3><strong>O que é o bundler?</strong></h3><p>O <em>bundler</em> é uma ferramenta que organiza os <em>assets</em> do seu produto web de forma inteligente, otimizada e compatível com os <em>browsers</em>. Como um exemplo, <em>browsers</em> não tem suporte à TypeScript, mas o <em>bundler</em> trata de compilá-lo para JavaScript compatível para que as pessoas consigam usar seu produto sem nenhum problema.</p><p>Um <em>bundler</em> muito famoso hoje em dia é o Webpack. Você provavelmente já ouviu falar sobre ele antes e é sua popularidade que me fez escrever sobre Parcel (você vai entender em breve).</p><h3>A parte chata do Webpack</h3><p>Partindo do pressuposto que você já utilizou ou pelo menos viu uma configuração do Webpack, você sabe que não é a coisa mais didática ou produtiva do mundo. É preciso se importar com muitos detalhes: instalar <em>loader</em>(s) para transpilação de código, para os seus estilos que mudam de acordo com a linguagem que você usa, e mais outro se você quiser utilizar <em>templates</em> ou apenas HTML no seu projeto, dentre muitas outras possibilidades. Cada um desses <em>loaders</em> possui configurações que necessitam de consulta para entendimento e aplicação e esse processo pode ser difícil dependendo do tamanho do seu projeto, além do que o <em>debug</em> do seu <em>setup</em> é tedioso e pode requerer muitos ajustes até que fique pronto, causando ruído no processo de desenvolvimento.</p><h3>A proposta do Parcel</h3><p>Ao meu ver o Parcel tem duas propostas principais: pouca ou nenhuma configuração necessária e velocidade.</p><h4>A configuração</h4><p>Ele não exige que você configure absolutamente nada na maioria dos casos para que seu código funcione. Em vez disso, você segue convenções ou utiliza arquivos de configuração específico dos módulos que o Parcel utiliza, como .babelrc, .postcssrc. Enquanto esse artigo está sendo escrito, o Parcel já possui integração com os seguintes formatos e mais formatos virão com o tempo:</p><ol><li>CoffeeScript</li><li>CSS</li><li>GraphQL</li><li>HTML</li><li>Javascript</li><li>JSON</li><li>LESS</li><li>OpenGL</li><li>Pug</li><li>ReasonML</li><li>Rust</li><li>SCSS</li><li>Stylus</li><li>TOML</li><li>TypeScript</li><li>Vue</li><li>WebAssembly</li><li>WebManifest</li><li>YAML</li></ol><p>Isso significa que com pouca ou nenhuma configuração você pode utilizá-los no seu projeto <em>out-of-the-box.</em></p><h4>Velocidade</h4><p>O Parcel utiliza <em>multi-thread</em> para compilar os módulos, tornando a experiência de desenvolvimento muito mais fluida</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ea2af6a14915f97ab6568fd4c252bf2e/href">https://medium.com/media/ea2af6a14915f97ab6568fd4c252bf2e/href</a></iframe><h3>OK, e agora, podemos passar a usá-lo em <em>tudo</em>?</h3><p>Depois desse breve sumário sobre o Parcel, temos alguns detalhes a discutir. Embora dissemos mais acima que a configuração do Webpack é mais cansativa e burocrática, uma característica inegável é que com ela podemos fazer ajustes finos que talvez no Parcel não sejam possíveis. Sendo assim, não credito o Parcel como viável para todo e qualquer projeto, isso depende muito do tamanho do projeto, dos recursos que ele utiliza e da necessidade desses ajustes finos na etapa de compilação.</p><p>Independente de qualquer coisa, nem o Webpack nem o Parcel irão a lugar nenhum por terem fins iguais, porém diferentes propostas para projetos. Mas, e você? Qual sua opinião sobre esses bundlers?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35f75db2b8f8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/devane-io/bundlers-configura%C3%A7%C3%A3o-zero-com-parcel-35f75db2b8f8">Bundlers — Configuração zero com Parcel</a> was originally published in <a href="https://medium.com/devane-io">devane.io</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Injeção de dependência básica com Laravel 5]]></title>
            <link>https://itamarjunior.medium.com/inje%C3%A7%C3%A3o-de-depend%C3%AAncia-b%C3%A1sica-com-laravel-5-a1303bde854c?source=rss-80b7cbd58a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/a1303bde854c</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[laravel]]></category>
            <dc:creator><![CDATA[Júnior Garcia]]></dc:creator>
            <pubDate>Mon, 30 Jul 2018 23:07:32 GMT</pubDate>
            <atom:updated>2019-01-23T11:54:52.825Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você programou <em>antes</em> de <em>frameworks</em> modernos tomarem conta do mercado, devem lembrar-se da sensação que é a repetição para conseguir um tipo de objeto e utilizá-lo ao longo da sua aplicação. Esse objeto era, muitas vezes (senão todas) inicializado da mesma forma, mas ainda assim, isso dava brecha para erros que você poderia evitar.</p><p>Então você conhece uma técnica chamada “<em>singleton</em>” e fica feliz porque finalmente vai poder abrir mão das repetições para se obter um objeto inicializado, mas como tudo o que é bom dura pouco, você descobre que <em>singletons </em>são difíceis de depurar porque podem ser alterados de literalmente qualquer lugar, propagando essas mudanças em todo o seu projeto. Quando você menos percebe está no meio de um <em>dependency hell</em>.</p><p>Esse artigo é para pessoas que <em>tem conhecimento básico no Laravel</em>. Se você nunca o utilizou, talvez injeção de dependência nem seja um problema que você está enfrentando agora.</p><h3>O que é injeção de dependência?</h3><p>É uma técnica onde, basicamente, se provê os objetos (dependências) necessárias que as partes da aplicação precisam para funcionarem corretamente.</p><p>Esse é um conceito <em>framework-agnostic</em>, o que significa que, independente de <em>framework</em> ou até mesmo linguagem, seu significado é o mesmo. O que muda é a forma de implementação. Hoje vamos entender como funciona a injeção de dependência básica no Laravel.</p><h3>O <em>Service Container</em></h3><p>O Laravel possui internamente um <em>container</em> de serviços. Nele são registrados serviços que indicam ao <em>framework</em> as dependências utilizadas pela sua aplicação e como elas devem ser inicializadas. Por exemplo: você tem um provider chamado Illuminate\View\ViewServiceProvider que inicializa os serviços de templates (Blade) e views. Em termos de semântica, cada <em>service provider</em> configura as dependências para uma parte da sua aplicação, como autenticação, cache, acesso à base de dados, dentre outros.</p><p>É criado automaticamente um <em>service provider</em> genérico que fica em app/Providers/AppServiceProvider.php . Como nem sempre vale a pena projetar a aplicação focando nos <em>service providers</em>, esse arquivo pode ser o suficiente para registrar todos os <em>providers</em> para a sua aplicação. Mas, como estamos aqui para aprender, vamos ignorá-lo e criar o nosso próprio <em>service provider.</em></p><h3>O problema</h3><p>Esse problema pode passar longe de uma necessidade real, mas lembre que estamos fazendo isso para ilustração.</p><p>Primeiramente vou explicar o que vamos resolver:</p><p>Imagine que temos que fazer requisições de dentro da nossa aplicação para obtermos informações de uma API externa. Sendo assim, temos que configurar um cliente em PHP e criar uma classe de controle para que sempre que a utilizarmos, o cliente HTTP seja instanciado automaticamente e de forma apropriada pelo <em>service container</em>. Vamos seguir os passos abaixo para utilizar injeção de dependência ao estilo Laravel:</p><h4>Instalando as dependências necessárias</h4><p>Instale o Guzzle para efetuar as requisições a partir dele. Com o terminal aberto no projeto, execute o seguinte comando para adicionar o Guzzle nas suas dependências:<br>composer require guzzlehttp/guzzle:~6.0</p><h4>Adicionando a configuração necessária</h4><p>Insira o seguinte valor no arquivo .env com a URL base da API: TEST_API_URL=https://reqres.in</p><p>Após, abra o arquivo config/app.php e inclua a chave que conterá a URL base da API:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/04ee1367e8d3ccbe4a70fa3a260546f1/href">https://medium.com/media/04ee1367e8d3ccbe4a70fa3a260546f1/href</a></iframe><h4>Configurando a interface</h4><p>Essa interface <em>poderia</em> ser dispensada e, ao invés, poderíamos criar uma classe, contudo programar orientado a interface é uma boa prática que ajuda em uma possível refatoração e até mesmo na própria injeção de dependência. Vamos criar uma interface chamada ExternalDataInterface que conterá os métodos para obter os dados de uma API externa:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/509fd6673939dbd21ccb81ed55e46a7b/href">https://medium.com/media/509fd6673939dbd21ccb81ed55e46a7b/href</a></iframe><h4>Criando um service provider para o client do Guzzle</h4><p>Agora, precisamos dizer ao Laravel como criar uma instância do cliente do Guzzle para utilizarmos na próxima etapa. Digite no terminal:</p><pre>php artisan make:provider GuzzleClientServiceProvider</pre><p>O Artisan criará um <em>scaffold</em> de <em>service provider</em> que estará no arquivo app/Providers/GuzzleClientServiceProvider.php. Abra esse arquivo. Todo <em>service provider</em> herda da classe abstrata Illuminate\Support\ServiceProvider. Esse esboço contém os métodos boot e register . Vamos focar no método register . Deixe seu arquivo como o seguinte:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f57b3c3cc02340b3390b30009ddb7a87/href">https://medium.com/media/f57b3c3cc02340b3390b30009ddb7a87/href</a></iframe><p>O método register, como o próprio nome já diz, serve para registrar serviços no <em>service container</em>. Acessamos a aplicação dentro desse método através de $this-&gt;app. Chamamos a função bind e passamos como primeiro parâmetro o <em>alias</em> que será utilizado pelo <em>service container</em> para instanciar itens com esse <em>alias</em>, seguido de uma closure que criará a instância do cliente do Guzzle que queremos para requisitar os dados da API externa e retornará esse cliente no final. Esse <em>alias</em> fala em outras palavras que: sempre que alguém depender de GuzzleHttp\Client, o <em>service container</em> vai instanciá-lo e entregá-lo pronto para uso a seus dependentes.</p><p>Nessa closure, temos acesso ao argumento $app que é o mesmo que $this-&gt;app (a nossa aplicação, logo o service container).</p><p>Utilizamos o <em>service container</em> dentro dele próprio ao pedirmos uma instância de config para acessar a URL que salvamos em config/app.php (linha 18) e então, retornamos o client Http com seu base_uri configurada. Lembrando que poderíamos configurar o que quiséssemos nessa parte. Mudamos apenas a base_uri apenas para exemplificar.</p><h4>Dizendo para o Laravel utilizar nosso service provider</h4><p>Após configurar seu <em>service provider</em> é necessário dizer ao Laravel para utilizá-lo. Abra o arquivo config/app.php e na chave providers <em>adicione</em> seu <em>service provider</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/481efc586dc59d9eac16183c88b3f5d0/href">https://medium.com/media/481efc586dc59d9eac16183c88b3f5d0/href</a></iframe><p>A título de informação, <em>sempre</em> que você criar um service provider, deve colocá-lo no <em>array</em> do arquivo acima. Caso contrário, o Laravel não saberá encontrá-lo.</p><h4>Um teste rápido com dd</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7f79617b929c647c97e888ed89b4a604/href">https://medium.com/media/7f79617b929c647c97e888ed89b4a604/href</a></iframe><p>Agora abra a URL do seu projeto no navegador e você deverá ver o <em>dump</em> do seu <em>client</em> do Guzzle criado via <em>service container</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/296/1*R580DEtjkASt3hIM88XM_A.png" /><figcaption>O [provável] resultado do seu dd</figcaption></figure><h4>Criando a classe que recebe GuzzleClient como dependência</h4><p>Com o nosso client do Guzzle pronto, vamos criar uma classe que utilizará dele para obter os dados da API.</p><p>Crie um arquivo app/Services/UserDataService.php com o seguinte conteúdo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5c3000f9deb92e8ac64d9ca52e128a37/href">https://medium.com/media/5c3000f9deb92e8ac64d9ca52e128a37/href</a></iframe><p>Aqui nós criamos uma classe que implementa a interface base para requisitar. No construtor dessa classe temos um único parâmetro $client, mas como o Laravel vai injetá-lo aí? Criaremos outro <em>service provider</em> para essa classe, só que utilizaremos a sua <em>interface</em> para deixarmos a aplicação menos acoplada: rode php artisan make:provider UserDataServiceProvider e adicione o conteúdo seguinte no arquivo app/Providers/UserDataServiceProvider.php :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bed01ac0f59abde3f46fee575a3533ee/href">https://medium.com/media/bed01ac0f59abde3f46fee575a3533ee/href</a></iframe><p>Após, adicione esse provider em config/app.php:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/59f621d9b740acc39d23e542cf2fc61d/href">https://medium.com/media/59f621d9b740acc39d23e542cf2fc61d/href</a></iframe><p>Agora, crie uma rota para fazer o teste do seu <em>provider</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0103fa620215ed71019a6c7449932c22/href">https://medium.com/media/0103fa620215ed71019a6c7449932c22/href</a></iframe><p>Abra a página inicial do seu projeto e você verá impressa a resposta do JSON retornado pela API externa e obtida com o provider que configuramos.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F12NUbkX6p4xOO4%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F12NUbkX6p4xOO4%2Fgiphy.gif&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2F12NUbkX6p4xOO4%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="398" frameborder="0" scrolling="no"><a href="https://medium.com/media/c6d57f4067e20f622abd783ff7bfe8e2/href">https://medium.com/media/c6d57f4067e20f622abd783ff7bfe8e2/href</a></iframe><p>Há vários outros métodos que podem ser utilizados para vincular coisas no <em>service container</em>:</p><p>Vinculando uma instância singleton</p><pre>$this-&gt;app-&gt;singleton(&#39;GuzzleHttp\Client&#39;, function ($app) {<br>  return new \GuzzleHttp\Client([<br>    &#39;base_uri&#39; =&gt; $app-&gt;make(&#39;config&#39;)-&gt;get(&#39;app.external_api&#39;)<br>  ]);<br>});</pre><p>Vinculando uma instância de objeto já criada</p><pre>$foo = new Foo(/* alguns parâmetros */);<br><br>$this-&gt;app-&gt;instance(&#39;FooObject&#39;, $foo);</pre><p>Veja mais na <a href="https://laravel.com/docs/5.6/container">documentação do service container do Laravel</a>.</p><p>Todo o código-fonte para essa parte pode ser encontrado na branch service-container-basico <a href="https://github.com/juniorgarcia/laravel-articles/tree/service-container-basico">desse repositório</a>. Lembre-se de rodar composer install.</p><p>Abraços e sintam-se à vontade para fazer perguntas nos comentários.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1303bde854c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Porque PHP é considerado ruim por muitos?]]></title>
            <link>https://itamarjunior.medium.com/porque-php-%C3%A9-considerado-ruim-por-muitos-64ce68471eec?source=rss-80b7cbd58a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/64ce68471eec</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[programming-languages]]></category>
            <category><![CDATA[it]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Júnior Garcia]]></dc:creator>
            <pubDate>Mon, 25 Jun 2018 13:01:05 GMT</pubDate>
            <atom:updated>2018-06-25T13:01:05.634Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hEhkPo4cAOO7chpkPgCNxg.jpeg" /></figure><p>Desde que comecei na web utilizo PHP por ter sido sempre a alternativa mais acessível em todos os sentidos e desde sempre vejo comentários falando que programadores que a utilizam são ruins em metodologia e/ou código ou que a própria linguagem é ruim. Não é incomum ver <em>flamewars</em> na internet quando se trata de tecnologia. Para muitos usuários, Java é lenta, Ruby não escala, JavaScript não tem sentido e PHP é banhado a código ruim.</p><p>A pergunta é: porque as pessoas tem essa opinião tão forte e ruim sobre PHP?</p><h4>Entendendo porque o PHP é como é</h4><p>O PHP chegou entre nós em 1995 (mesmo ano do Java), mais de 20 anos atrás, 4 anos depois do <em>primeiro</em> servidor de internet. Na sua concepção, não era para ser uma grande linguagem, mesmo porque Rasmus Lerdorf, seu criador, concebeu o PHP para ser utilizado em páginas pessoais, por isso antes seu acrônimo significava <strong>P</strong>ersonal <strong>H</strong>ome<strong> P</strong>age. O crescimento do PHP foi orgânico e Lerdorf não sabia o que fazer quando a linguagem estava ganhando proporção:</p><blockquote>Eu não sei como parar, nunca houve intenção de escrever uma linguagem de programação[…] Eu não tenho absolutamente nenhuma ideia de como escrever uma linguagem de programação, só continuo adicionando mais coisas que acho lógicas.</blockquote><p>Fonte: <a href="http://web.archive.org/web/20130729213507id_/http://itc.conversationsnetwork.org/shows/detail58.html">http://itc.conversationsnetwork.org/shows/detail58.html</a></p><p>Em suma, PHP não foi uma linguagem “pensada”, por assim dizer, mas foi uma linguagem que foi inchando com o tempo e com a necessidade de quem a adotava. Aparentemente não houve algo como um <em>brainstorm</em> propriamente dito porque o objetivo da linguagem era tecnicamente simples: ajudar a pessoas a programar para a <em>web</em> de forma mais fluida. Lerdorf diz em áudio que:</p><blockquote>Pessoas não tinham tempo nem habilidade para escrever C [para web].</blockquote><p>PHP é uma linguagem dinamicamente tipada em que &quot;1&quot; + 1 é igual a 2 e isso para “programadores clássicos” não faz sentido algum (e talvez eu também acha isso bem estranho). Seria como quebrar um mandamento da programação. Mas para pessoas que não sabiam ou não tinham tempo para escrever código C para web, essa abordagem era muito mais agradável do que saber manipular ponteiros, fazer <em>garbage collection</em> ou saber o tipo de variável que você teria que declarar. Isso fez o PHP bastante popular e com uma curva de aprendizado bem melhor que as linguagens da época.</p><h4>O problema são os programadores, não a linguagem</h4><p>Seres humanos não funcionam direito sem regras. O que eu digo sempre é que falta de bom senso é o princípio de todo mal da humanidade, e não é diferente em programação. Não é porque você pode fazer algo, que você o deve fazer.</p><p>A permissividade do PHP abre brecha para muito código mal feito. <strong>Só é preciso entender que código ruim não se escreve sozinho</strong>. A falta dos conceitos de programação bem como de material de estudo no tempo em que o PHP foi criado não poderia levar a outro caminho quando alguém decidia fazer sua aplicação sem nunca ter tocado noutra linguagem. A partir daí muitos ligaram o modo “se está funcionando, não tem problema”.</p><p>Quando as pessoas passavam a programar de qualquer jeito, desde que funcionasse, ia se gerando uma dívida técnica e fazendo o código cada vez mais feio. E normalmente isso não se corrige, apenas se deixa existindo, já que <em>ainda</em> funciona.</p><h4>Conclusão</h4><p><strong>Não podemos viver em um mundo onde Java sempre é lento, Ruby nunca escala e PHP é sempre ruim.</strong></p><p>Link:</p><ul><li><a href="http://origin.conversationsnetwork.org/Rasmus%20Lerdorf%20-%20PHP.mp3">Áudio (em inglês) de entrevista com Rasmus Lerdorf sobre a criação do PHP</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=64ce68471eec" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O Linux não foi a maior coisa impulsionada por Torvalds]]></title>
            <link>https://itamarjunior.medium.com/o-linux-n%C3%A3o-foi-a-maior-coisa-impulsionada-por-torvalds-a5217bdd1e40?source=rss-80b7cbd58a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5217bdd1e40</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[gnu]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Júnior Garcia]]></dc:creator>
            <pubDate>Sun, 24 Dec 2017 17:47:57 GMT</pubDate>
            <atom:updated>2017-12-24T17:47:57.813Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cM7Z6WD_itf-bW2mtwETWQ.jpeg" /></figure><p>Para os amantes do Linux (assim como eu), ouvir isso pode parecer uma afronta. Antes de continuar, precisamos de um pouco de história.</p><h4>Como Linus chegou aonde chegou</h4><p>Linus é finlandês e tinha uma família primariamente do mundo do jornalismo. O seu avô materno teve grande influência no que Linus se tornou, tendo dado seu primeiro computador de presente que foi um Commodore Vic 20, como o da foto abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XDM3_oGt5d803nwlX95oWw.jpeg" /><figcaption>By Cbmeeks / processed by Pixel8 (Original uploader was Cbmeeks at en.wikipedia) [GFDL (<a href="http://www.gnu.org/copyleft/fdl.html">http://www.gnu.org/copyleft/fdl.html</a>) or CC BY-SA 3.0 (<a href="https://creativecommons.org/licenses/by-sa/3.0">https://creativecommons.org/licenses/by-sa/3.0</a>)], via Wikimedia Commons</figcaption></figure><p>Em 1987 Torvald havia juntado dinheiro para comprar um Sinclair QL:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f6hMCYcrIZdAfom_RvAURg.jpeg" /><figcaption>By Working-Sinclair-QL.jpg: Telecarlos derivative work: Regi51 [CC BY 3.0 (<a href="http://creativecommons.org/licenses/by/3.0">http://creativecommons.org/licenses/by/3.0</a>)], via Wikimedia Commons</figcaption></figure><h4>A motivação para começar o Linux</h4><p>Como todo bom produto, o Linux veio de uma frustração: O Sinclair QL era limitado ao que vinha nele pelo fato de usar memória ROM (Read Only Memory). Sendo assim, Linus não podia reprogramá-lo.</p><p>Um ano depois, em 1988, ele ingressou na Universidade de Helsinki já como um programador habilidoso.</p><p>Em 1991 comprou um IBM-compatible que veio com o MS-DOS instalado, mas também se frustrara devido às limitações do sistema. Como ele estava acostumado com o Unix que utilizava na universidade, queria comprar uma licença do sistema para poder programar para ele. <em>Para a felicidade de todos nós</em>, uma licença básica custava cerca de 5,000 dólares. Ele não conseguia pagar por esse preço.</p><p>Depois de considerar o MINIX, clone do UNIX criado por Andrew Tanenbaum (certamente você que vê mais livros de TI já ouviu falar nele), Linus decidiu fazer seu próprio sistema, pois o MINIX ainda era muito limitado e tinha muita desvantagens, uma delas era que o código-fonte não estava disponível para o público.</p><h4>Começa a ser feito o coração do Linux</h4><p>Em 1991 Torvalds anunciou em um <em>mailing list</em> o seguinte:</p><blockquote>“[…] estou fazendo um sistema operacional (grátis) apenas como <em>hobby, não </em>será grande e profissional como o GNU) …”</blockquote><p>Em setembro do mesmo ano Torvalds anuncia que o sistema está minimamente utilizável, já com o GCC e com Bash rodando e que o “código completo do <em>kernel</em> estava disponível para todos […]”.</p><p>Depois disso o Linux só evoluiu com contribuições de desenvolvedores que analisavam e melhoravam seu código, mas isso só foi possível devido à maior coisa que Torvalds ajudou a impulsionar…</p><h3>A filosofia do Open Source</h3><p>É isso mesmo! O Open Source foi a maior coisa já impulsionada por Torvalds, mesmo que <strong>talvez</strong> sem querer. Na verdade eu duvido muito que o Linux cresceria tanto se não fosse por esse movimento.</p><p>Depois do lançamento do Linux em 1991, vários sistemas começaram a ser lançados utilizando o mesmo código-fonte como base, o que foi um tremendo <em>boom</em> para toda a comunidade de TI.</p><p>A verdade é que o Linux construiu a TI que conhecemos hoje. Sua força filosófica foi tão grande que muitas empresas e desenvolvedores autônomos começaram o ciclo de criar código, abrir esse código para o público e melhorar o código de terceiros que eles utilizavam.</p><p>Frameworks feitos por grandes empresas como <a href="https://github.com/facebook">Facebook,</a> <a href="https://github.com/google">Google</a> e <a href="https://github.com/twitter">Twitter,</a> ferramentas em linha de comando, e até mesmo <a href="https://github.com/collections/programming-languages">linguagens de programação</a> estão disponíveis de forma que desenvolvedores possam melhorar seu código abertamente bem como utilizá-lo em seus projetos sem custo.</p><p>O GitHub, uma plataforma de código aberto tem mais de 67 milhões de repositórios (<a href="https://github.com/torvalds/linux">incluindo o Linux</a>) e mais de 24 milhões de usuários.</p><p>Veja algumas estatísticas aqui: <a href="https://octoverse.github.com/">https://octoverse.github.com/</a></p><h3>O que o Open Source fez pela tecnologia?</h3><p>O Open Source move a TI como é hoje. A evolução que temos em muitos aspectos se deram devido à adoção desse movimento. Comercializar software não é errado de forma alguma, mas abri-lo para que alguém melhore enquanto você o monetiza de outra forma ou até mesmo o utiliza para fazer seu produto que é pago, é uma ótima moeda de troca.</p><p>Todo aplicativo atualmente, independente da plataforma, usa código aberto de algum repositório por mais que o código do próprio aplicativo seja fechado.</p><p>Essa grande rede de contribuição proporcionou e proporcionará uma tremenda evolução na nossa tecnologia por tornar códigos-fonte acessíveis e permitir que os programadores que os utilizam contribuam com eles.</p><p>Aproveitando a véspera de Natal, contribua com algum repositório que você usa 🎄</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5217bdd1e40" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introdução ao OAuth2]]></title>
            <link>https://itamarjunior.medium.com/introdu%C3%A7%C3%A3o-ao-oauth2-502311a14c82?source=rss-80b7cbd58a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/502311a14c82</guid>
            <category><![CDATA[it]]></category>
            <category><![CDATA[authentication]]></category>
            <category><![CDATA[oauth2]]></category>
            <category><![CDATA[oauth]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[Júnior Garcia]]></dc:creator>
            <pubDate>Sat, 19 Aug 2017 20:01:02 GMT</pubDate>
            <atom:updated>2021-04-20T13:31:09.192Z</atom:updated>
            <content:encoded><![CDATA[<p>Esse nome pode causar medo se você for apresentado a ele sem que antes tenha um entendimento de como ele funciona. <strong>Se você está a ponto de desenvolver uma aplicação e ela tem que usar OAuth2, leia esse artigo antes</strong>!</p><h4>Primeiramente, o problema:</h4><p>Quando você quer conceder acesso aos seus recursos para uma aplicação, você pode fazê-lo “facilmente” cedendo seu usuário e senha e a aplicação vai recuperar esses recursos, afinal, você deu o seu usuário e senha para ela. Isso resolve o problema inicial de ceder um certo recurso, mas oferece outros problemas muito maiores: <strong>a aplicação tem sua senha para usar na hora que quiser e eles podem, inclusive, alterá-la. Além do que, você não pode filtrar o acesso da aplicação, pois a senha é a “chave mestra” da sua conta!</strong></p><p>O OAuth2 <strong>pode</strong> resolver esse problema: conceder um recurso seu a uma aplicação, sem expor as credencias que você usa para logar. Dessa forma, posso usar um programa como o <a href="https://www.gitkraken.com/">GitKraken</a> e vinculá-lo à minha conta do GitHub, sem dar acesso à tudo, como ao meu painel de preferências, por exemplo. As vantagens são:</p><ol><li>Protejo meus dados: a aplicação não vai poder acessar dados sensíveis, como endereços, etc;</li><li>Não preciso mudar minha senha para que a aplicação pare de acessá-la (posso revogar o acesso quando quiser);</li><li>Se o meu servidor de autorização permitir, posso conceder permissões apenas a certo tipos de dados, protegendo-me ainda mais.</li></ol><blockquote>O OAuth2 só quer seu bem, mas pode ser uma relação difícil se vocês decidirem morar juntos depois do primeiro encontro.</blockquote><h4>Como funciona o fluxo?</h4><p>Considere a imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*TJfHKvNP52e9goS2_MGAIw.png" /><figcaption>Fluxo abstrato do protocolo OAuth2</figcaption></figure><p>Antes de prosseguir, vamos dar uma olhada nos termos, que estão em inglês porque facilitará uma possível pesquisa na internet:</p><ul><li><em>Client</em>: é quem quer consumir um recurso. Comumente uma aplicação;</li><li><em>Resource owner</em>: é a entidade que é dona de um recurso, dona dos dados. Normalmente um usuário.</li><li><em>Authorization server</em>: é o servidor que processa toda a autorização. Quando você conecta um aplicativo ao Facebook, temos um servidor de autorização que vai verificar se o <em>client</em> tem permissão para acessar o recurso.</li><li><em>Resource server</em>: é o servidor que pode ceder o recurso que um <em>resource owner</em> cedeu a um <em>client</em> mediante autorização que foi bem-sucedida.</li><li><em>Authorization grant</em>: é a concessão de autorização a um recurso. Você passa dessa fase quando o <em>resource owner</em> diz para o <em>authorization server</em> conceder permissões ao <em>client</em>.</li><li><em>Access token</em>: é um <em>token</em> que você recebe se a permissão for concedida pelo <em>authorization server</em>, e que será utilizado para requisitar os <em>resources</em> de um <em>resource owner</em>.</li><li><em>Grant type</em>: é o tipo de concessão que o <em>client</em> usará para requisitar o <em>access token</em> (veremos mais detalhes mais tarde).</li></ul><p>Os passos do protocolo OAuth2 são bastante simples de se entender [por incrível que pareça]:</p><ol><li>O <em>client</em> requisita autorização ao <em>resource owner</em>. A autorização pode ser feita diretamente para o <em>resource owner</em> (como mostrado), ou preferencialmente através de um <em>authorization server</em> como intermediário.</li><li>O <em>client</em> recebe a <em>authorization grant</em>, que é uma credencial representando a autorização do <em>resource owner</em>, expressada utilizando um de quatro tipos de concessão ou alguma tipo personalizado. O tipo de <em>authorization grant</em> depende do <em>grant type </em>utilizado que deve estar disponível no <em>authorization server</em>, que vamos explicar mais tarde.</li><li>O <em>client</em> requisita um <em>access token</em> autenticando com o <em>authorization server </em>e apresentando o <em>authorization code</em> recebido previamente.</li><li>O <em>authorization server </em>autentica o <em>client</em> e valida a concessão de autorização, que se válido, emite um access token.</li><li>O <em>client</em> requisita o recurso protegido do <em>resource server </em>utilizando o <em>access token</em> do passo anterior.</li><li>O servidor recebe o <em>access token</em> que, se válido, retorna o recurso.</li></ol><h3><em>Authorization grants</em></h3><p><em>Authorization grant</em> ou “concessão de autorização” é uma credencial que representa a permissão que o <em>resource owner</em> concedeu ao <em>client</em>. Com o <em>authorization grant</em> é possível pedir para o <em>authorization server</em> emitir <em>access tokens</em>, que serão chaves utilizadas para o <em>client</em> obter recursos do <em>resource owner</em>.</p><h4>Tipos de authorization grants:</h4><ul><li><strong><em>Authorization code</em></strong>: é um código de autorização emitido pelo <em>authorization server</em> como intermediário quando o <em>resource owner</em> aprova o acesso do <em>client</em>. Esse código será utilizado para emitir <em>access tokens</em> que darão acesso aos recursos do usuário. Para que o <em>resource owner</em> autorize o <em>client</em>, o <em>authorization server</em> vai pedir ao <em>resource owner</em> que faça login, se já não estiver logado para autorizar o <em>client</em>. Devido a esse intermédio do servidor de autorização, suas credenciais não serão compartilhadas com os <em>clients</em>.</li><li><strong><em>Implicit</em></strong>: É um fluxo simplificado e otimizado para aplicações que usam, por exemplo, JavaScript. Apesar de simplificado e otimizado como dito antes <strong>é mais inseguro</strong>. Ao invés de você receber um <em>authorization code</em> para pedir um <em>access token</em>, você recebe um <em>access token</em> diretamente através de uma URI de redirecionamento que você tem que providenciar na requisição. Esse método é chamado de <em>implicit</em> porque nenhuma credencial intermediária é emitida. Pese bem antes de implementar esse <em>authorization grant</em> porque, apesar de mais simples, ele expõe facilmente o <em>access token</em>.</li><li><strong><em>Resource owner password credentials</em></strong> (ou <em>username</em> e senha): permite emitir um <em>access token</em> utilizando <em>username</em> e senha do usuário. Utilize esse meio <strong>apenas</strong> quando houver um alto grau de confiança no <em>client</em> utilizado e quando outros tipos de <em>authorization grant</em> não estão disponíveis. Um ponto positivo é que o <em>client</em> não precisa armazenar as credenciais do usuário porque apenas utilizará o <em>access token</em> emitido para requisitar recursos e poderá obter um <em>long-lived access token</em> ou <em>refresh tokens </em>depois (veremos mais sobre eles adiante). <em>Long-lived access tokens</em> são <em>access tokens</em> que tem uma vida útil maior.</li><li><strong><em>Client credentials</em></strong>: É um <em>authorization grant</em> que deve ser utilizado apenas para <em>clients</em> secretos, isso porque a maneira de requisitar um <em>access token</em> é simples e o <em>range</em> de acesso pode ser maior. É bastante utilizado quando o <em>client</em> quer requisitar uma informação que está sob seu controle mas que não está necessariamente ligada ao <em>resource owner</em> atual.</li></ul><h3>Access token</h3><p>O <em>access token</em> é sua chave para obter recursos de um <em>resource server</em>. Geralmente ele não significa nada para o <em>client</em> mas pode conter informações sobre <em>scope</em> e validade legíveis para o <em>resource server</em> e/ou <em>authorization server</em>. A maneira como o access token é gerado está além do escopo desse artigo.</p><h3>Refresh token</h3><p>O <em>refresh token</em> é uma chave utilizada para obter um novo <em>access token</em> depois que ele expira ou para obter um <em>access token</em> adicional idêntico ao atual ou com <em>scope</em> mais restrito. Quando você efetua uma requisição de recurso no <em>resource server</em> e o <em>access token</em> utilizado expirou ou é inválido, você pode requisitar um novo <em>access token</em> utilizando o <em>refresh token</em> para continuar seu trabalho. Normalmente quando um <em>authorization server</em> utiliza <em>refresh tokens</em>, esse vem na requisição quando você emite um <em>access token</em>.</p><h3>Ilustração</h3><p>Digamos que você (<em>resource owner</em>)<em> </em>pede a um amigo seu (<em>client</em>) para ir ao banco (<em>authorization server</em>) e pegar algo seu que está no cofre (<em>resource server</em>). Para isso, você manda uma procuração (<em>authorization grant</em>) por ele para mostrar ao banco que ele tem autorização para acessar seus recursos. Ao chegar no banco você mostra a procuração ao responsável pelas autorizações. Se a procuração for válida, ele pode te dar uma chave (<em>access token</em>) e você pode ir no cofre (<em>resource server</em>), pegar o que quer (<em>resource</em>), e voltar para casa.</p><h3>Considerações finais</h3><p>Acredito que essa explanação inicial não-técnica seja valiosa pra quem ainda não tem um entendimento sobre o OAuth2. Já já sai algo um pouco mais técnico sobre o protocolo.</p><p><strong>Referências:</strong></p><ul><li>RFC 6749: <a href="https://tools.ietf.org/html/rfc6749#section-1.2">https://tools.ietf.org/html/rfc6749</a></li><li>OAuth Lib: <a href="http://oauthlib.readthedocs.io/en/latest/oauth2/grants/credentials.html">http://oauthlib.readthedocs.io/en/latest/oauth2/grants/credentials.html</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=502311a14c82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tenha medo de desenvolvimento barato]]></title>
            <link>https://itamarjunior.medium.com/tenha-medo-de-desenvolvimento-barato-d0c68d7ad10?source=rss-80b7cbd58a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0c68d7ad10</guid>
            <category><![CDATA[it-support]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Júnior Garcia]]></dc:creator>
            <pubDate>Sun, 05 Feb 2017 17:15:29 GMT</pubDate>
            <atom:updated>2017-02-05T17:18:19.123Z</atom:updated>
            <content:encoded><![CDATA[<p>Desde que comecei a trabalhar com desenvolvimento <em>web</em> tenho me deparado com inúmeros projetos que começam a ser feitos por terceiros e migram para mim, que variam entre: bem-feitos, <em>ok</em>, mal feitos e <strong>terríveis</strong>. Quando classifico eles assim não estou julgando <em>layout</em>, porque isso é algo que apesar de dar meus pitacos, não meto a mão, apenas sigo como está desenhado. Classifico eles assim pelas entranhas do projeto: o `código-fonte`.</p><p>Para quem não sabe o que o código-fonte é, ele é o que o computador lê e o que o programador escreve para fazer sua aplicação funcionar. (Quando digo “aplicação”, você pode entender como site, ou <em>app</em> para celular, ou para <em>desktops</em>. Estamos sendo genéricos com esse termo).</p><h4>“OK, mas está funcionando muito bem aqui. Porque uma aplicação que funciona é julgada como ruim, seu sabichão?”</h4><p>Na engenharia de <em>software</em>, temos uma característica muito importante chamada <strong>manutenibilidade</strong>. Ela diz respeito à facilidade que um <em>software </em>tem de ser modificado (adaptado: BLANCHARD, Benjamin. Logistics engineering and management. 4th ed. Englewood Cliffs: Prentice Hall, 1992. p. 15).</p><h4>“E no que a manutenibilidade influencia no projeto?”</h4><p>Primeiro é necessário saber que os projetos são cobrados em horas, o que significa que quanto mais demorado mais caro. E os projetos baratos fazem brilhar os olhos por dois motivos: <strong>eles são [normalmente] rápidos e (obviamente) baratos</strong>.</p><p>Isso não soa ruim porque você como cliente quer que fique pronto o quanto antes e também quer economizar. Afinal, quem não quer? Mas <strong>depois de um tempo é que o bicho pega</strong>.</p><p>Muito dificilmente um projeto que você faz não vai precisar de manutenção. Eu diria até que, <strong>se ele não precisa de manutenção, tem algo errado</strong>. Tem sempre um <em>bug</em> para corrigir, um recurso para adicionar, um banner pro natal / ano novo.</p><p>A questão é: <strong>quando não dá tempo de pensar na arquitetura do projeto, ele tende a ficar com o código-fonte mal-feito o que, as vezes, confunde até quem fez.</strong></p><h3>Uma má estruturação pode ser pior do que você imagina</h3><p>A visão do programador que está projetando é essencial para o sistema. Pela falta de tempo uma funcionalidade pode ficar extremamente amarrada a ponto de ter que ser refeita mesmo quando o que você precisa adicionar / remover é bem simples. Imagine da seguinte forma: você faz um móvel planejado, <strong>mas mora de casa alugada</strong>. Suponha que você queira mudar de casa ou até de quarto onde o ambiente é <strong>maior</strong>. O móvel planejado já não vai servir como antes porque ele foi feito para uma situação e para um ambiente. E agora? Você volta para onde fez o móvel e pede para adicionar o famoso <strong>remendo</strong> para fazê-lo caber no cômodo novo o que pode ser bastante trabalhoso porque alterar um móvel pronto é bem mais chato do que montá-lo do zero. E não vai ficar aquela coisa bonita, provavelmente, além do custo que também vai ser alto. Mais alto até do que deveria. Contudo você vai ter que fazer o serviço mesmo descontente com o preço porque é mais caro jogar o móvel fora e fazer um novo.</p><p>No mundo da programação existem técnicas que podem ser usadas para flexibilizar o desenvolvimento de uma forma que modificar o sistema não seja uma tarefa dificultosa e lenta, mas <strong>para isso é preciso</strong> <strong>tempo</strong>. E como já sabemos: tempo é dinheiro.</p><p>Uma regra base para a estruturação do projeto é: <strong>quando mais mal feita, mais trabalho você vai ter na manutenção e mais caro será para fazer essa manutenção</strong>.</p><h3>Pense muito bem na hora de escolher quem vai fazer seu projeto</h3><p>Cuidado com ofertas irrecusáveis porque muitas vezes elas carregam nas entrelinhas esse peso da manutenção cara e difícil. Escolha bem a empresa que fará seu projeto para não ver o dinheiro e o tempo que você economizou na hora de fazer indo pelo ralo por causa da manutenção.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0c68d7ad10" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>