<?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[phpzm - Medium]]></title>
        <description><![CDATA[O Grupo de PHP da Zona da Mata tem como objetivo agrupar desenvolvedores e público em geral que estejam interessados em falar sobre tecnologias - Medium]]></description>
        <link>https://medium.com/phpzm?source=rss----77537e44543c---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>phpzm - Medium</title>
            <link>https://medium.com/phpzm?source=rss----77537e44543c---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 21:20:46 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/phpzm" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Vue.JS: consumindo REST API’s com Services]]></title>
            <link>https://medium.com/phpzm/vuejs-services-consumindo-rest-apis-3bbb1488cc9d?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/3bbb1488cc9d</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[javascript-rocks]]></category>
            <category><![CDATA[rest-api]]></category>
            <category><![CDATA[service-design]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Sun, 20 Jan 2019 19:02:09 GMT</pubDate>
            <atom:updated>2019-01-27T17:11:40.429Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<h3>Vue.js: consumindo REST API’s com Services</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PdrNUk2IOTuLeBizAcz4Rw.png" /></figure><p>O desenvolvimento front-end tem se encarregado de consumir serviços providos pelo back-end de formas cada vez menos acopladas. Uma estratégia de consumo desses serviços é o REST. Vamos ver alguma coisa sobre o funcionamento do REST, sua relação com o protocolo HTTP e discutir possibilidades acerca do tema dentro do Javascript.</p><blockquote>Recomendo ler <a href="https://phpzm.rocks/vuejs-services-injetando-servicos-em-componentes-de-forma-transparente-1c7c10e90245">este artigo aqui</a> antes de prosseguir.</blockquote><h3>REST</h3><p>Representational State Transfer, abreviado como REST, é um modelo proposto para se projetar arquiteturas de software distribuído, que utilizem comunicação em rede de alguma forma. Quando associado ao HTTP é comum usarmos os verbos HTTP combinados com URL’s bem organizadas para conseguir representar as transferências de estados proposta.</p><blockquote>REST é sobre organização e não sobre uma tecnologia ou uma ferramenta.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/0*Tta-w2GXKeJjjVmz" /><figcaption>Fonte: https://www.slideshare.net/restlet/the-neverending-rest-api-design-debate</figcaption></figure><p>Combinando a semântica dos verbos HTTP com a proposta de significado do REST chegamos à um quadro como o acima.</p><h3><strong>Service REST </strong>API</h3><p>Para poder montar nossa composição vamos ter uma estrutura de pastas como a que está abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*bM7GOucL3LqwQtQgoVpV1Q.png" /></figure><blockquote>A estrutura física de diretórios é meramente ilustrativa. Organize como julgar mais conveniente, o mais importante é compreender as abstrações e suas aplicações</blockquote><p>Primeira vamos criar o nosso “Service.js”, ele será basicamente um wrapper para options e poderá ser reusado em situações muito variadas.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b0c2bf2c40c42db72ef1581868d688f5/href">https://medium.com/media/b0c2bf2c40c42db72ef1581868d688f5/href</a></iframe><p>Em seguida vamos criar nossa classe HTTP como um wrapper para o nosso HTTP Client. Vamos usar o <a href="https://github.com/axios/axios">axios</a>, mas poderia ser qualquer biblioteca. Para termos uma flexibilidade o HTTP irá importar o “standard.js”, mas poderá receber outros clientes.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3ebd4366b912dc2566b130f1e52ff31e/href">https://medium.com/media/3ebd4366b912dc2566b130f1e52ff31e/href</a></iframe><p>Perceba que o “standard.js” acima está bem simples e que você pode expor funções para atualizar headers e modificar a instância do axios caso seja necessário. Veja também que o Http.js abaixo vai estender o Service e usar os métodos que o axios entrega para criar métodos base normalizados para realizar as requisições com base nos verbos HTTP.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3134f9d17d402926565e230f005606ce/href">https://medium.com/media/3134f9d17d402926565e230f005606ce/href</a></iframe><p>Com o Http criado podemos seguir para uma especialização do Http que é o Api, nesta parte da composição estamos abstraindo o ponto de montagem das rotas da API do back-end que será consumido.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b2ecd089ab409aa16b208959ceea572a/href">https://medium.com/media/b2ecd089ab409aa16b208959ceea572a/href</a></iframe><p>Com a abstração da API pronta podemos construir uma abstração para o Rest parecida com essa abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/803cc88b71511ca5d04005ef2e914ce4/href">https://medium.com/media/803cc88b71511ca5d04005ef2e914ce4/href</a></iframe><h3>Como eu uso isso tudo agora?</h3><p>O primeiro passo é criar uma especialização do Rest para o domínio da sua entidade / recurso. Vamos imaginar que você vá consumir a API de carros como na imagem lá de cima.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/81c760380907e707c5e8038362ef5185/href">https://medium.com/media/81c760380907e707c5e8038362ef5185/href</a></iframe><p>Com essa abstração criada você pode fazer esse serviço chegar no seu componente e usar os métodos de CRUD (create, read, update, delete) que ele possui para gerenciar sua coleção. Para usar ele no seu componente poderia fazer algo como o exemplo abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c9b462f085cf5d3111f6b64f92781d3/href">https://medium.com/media/3c9b462f085cf5d3111f6b64f92781d3/href</a></iframe><h4>Conclusão</h4><p>Como eu disse no artigo anterior essa abordagem de serviços nos permite alternar facilmente sobre o que está sendo usado para o consumo da API. Com algum pouco esforço seria possível criar uma estrutura semelhante para usar com GraphQL (próximos capítulos) e usar da mesma forma dentro dos seus componentes.</p><p>A separação da lógica da sua aplicação em si da lógica operacional da apresentação dos componentes é um marco na sua produção de software, pois você terá vantagens em vários aspectos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3bbb1488cc9d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/vuejs-services-consumindo-rest-apis-3bbb1488cc9d">Vue.JS: consumindo REST API’s com Services</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NoSQL no PHP usando ArangoDB — Parte 1]]></title>
            <link>https://medium.com/phpzm/nosql-no-php-usando-arangodb-parte-1-60c57b83eaf5?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/60c57b83eaf5</guid>
            <category><![CDATA[database-administration]]></category>
            <category><![CDATA[php-development]]></category>
            <category><![CDATA[nosql]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[arangodb]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Sat, 13 Oct 2018 15:25:35 GMT</pubDate>
            <atom:updated>2018-10-14T17:06:15.547Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<h3>NoSQL no PHP usando ArangoDB — Parte 1</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DWWihj3qN1nTVuqj1YKmWg.png" /></figure><p>Aposto que você, como a maioria das pessoas, pensa em <a href="https://www.mongodb.com/">mongoDB</a> quando ouve falar sobre <a href="https://www.mongodb.com/nosql-explained">NoSQL</a>. Embora eu soubesse que existe vida além do Mongo, sempre senti falta de ter uma opção declarativa para manipular dados quando o SQL não era uma opção. Então algum tempo atrás conheci o <a href="https://www.arangodb.com/">ArangoDB</a> e a sua especificação de linguagem de gerenciamento conhecida como <a href="https://docs.arangodb.com/3.3/AQL/index.html">AQL</a>. Vamos entender um pouco mais porque isso pode mudar um pouco as perspectivas sobre a adoção do <a href="http://nosql-database.org/">NoSQL</a> e o que muda com as possibilidades que a AQL abre.</p><h3>A importância de um banco de dados para uma aplicação</h3><p>Como desenvolvedor aprendi que a fonte de dados que você escolhe para sua aplicação é muito importante. Com o tempo vamos ganhando experiência e depois de ver projetos falharem por não terem escolhido as ferramentas certas para sua construção ficamos muito cautelosos em relação à isso.</p><blockquote>Depois de fazer chover com SQL é assustador não contar com esse recurso em um projeto.</blockquote><p>Para quem tem experiência com SQL, abrir mão de uma linguagem declarativa para manipular sua base de dados é um pouco preocupante. Como a maioria dos bancos NoSQL tem uma interface imperativa não é incomum a resistência ao uso dessas tecnologias para gerenciamentos de bancos de dados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/591/1*dWlK7KxUr_LkIvIPmO-JiA.png" /><figcaption><a href="https://docs.mongodb.com/manual/reference/sql-comparison/#select">https://docs.mongodb.com/manual/reference/sql-comparison/#select</a></figcaption></figure><p>A imagem acima mostra como uma instrução SELECT pode ser usada no MongoDB e a revela as diferenças entre a abordagem <em>imperativa</em> e a <em>declarativa.</em></p><h3>Linguagem Imperativa vs Declarativa</h3><p>Quando estamos programando temos à nossa disposição alguns tipos de programação como a <a href="https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_imperativa">imperativa</a> e a <a href="https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_declarativa">declarativa</a>.</p><p>Resumidamente uma linguagem que permite o uso de uma abordagem imperativa é usada através de comandos que são instruções diretas para o seu objetivo. Por outro lado uma linguagem declarativa é aquela que irá processar seus comandos internamente. Note abaixo dois exemplos de comandos:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b28f3fa41ae7070c48f97814b5fb8573/href">https://medium.com/media/b28f3fa41ae7070c48f97814b5fb8573/href</a></iframe><p>O <strong><em>echo</em></strong> é um comando imperativo e o desenvolvedor espera que quando o interpretador passe por aquela instrução imediatamente faça uma impressão. Seguindo o exemplo, um pouco mais abaixo há uma chamada imperativa para invocar de forma declarativa que o banco de dados execute o comando SQL esperado.</p><p>Note que quando usamos um comando SQL não sabemos exatamente qual o resultado que será retornado. Depois de declaradas, as instruções serão submetidas ao interpretador do motor do banco de dados escolhido e lá é que o comando será resolvido.</p><h3>E afinal de contas o que é NoSQL?</h3><p>A definição da Wikipedia é: “NoSQL (às vezes interpretado como Not Only SQL — Não Somente SQL) é um termo genérico para uma classe definida de banco de dados não-relacionais que rompe uma longa história de banco de dados relacionais com propriedades ACID (Atomicity, Consistency, Isolation, Durability). Outros termos equivalentes para esta categoria de bancos é NF², N1NF (non first normal form), nested relational, dimensional, multivalue, free-form, schemaless, document database e MRNN (Modelo Relacional Não Normalizado).” (<a href="https://pt.wikipedia.org/wiki/NoSQL">https://pt.wikipedia.org/wiki/NoSQL</a> visitado em 02/06/2017)</p><p>Já, segundo a Amazon: “NoSQL é um termo usado para descrever bancos de dados não relacionais de alto desempenho. Os bancos de dados NoSQL usam diversos modelos de dados, incluindo <strong>documentos</strong>, <strong>grafos</strong>, <strong>chave-valor</strong> e <strong>colunares</strong>. Bancos de dados NoSQL são amplamente reconhecidos pela facilidade de desenvolvimento, desempenho escalável, alta disponibilidade e resiliência. Veja abaixo vários recursos para ajudar você a começar a usar bancos de dados No SQL.” (<a href="https://aws.amazon.com/pt/nosql/">https://aws.amazon.com/pt/nosql</a> visitando em 03/06/2017)</p><p>Certo, mas e como isso nos ajuda? Estou imaginando que como eu você está acostumado ao mundo relacional e entende bem o que são tabelas; no mundo relacional temos as tabelas rígidas e algumas vezes acabamos querendo romper isso e já vi em algumas situações o <strong><em>JSON</em></strong> sendo usado dentro de uma coluna para poder subverter essa rigidez. Talvez quando esse momento surge você esteja precisando pensar em NoSQL.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/771/1*peKMnWuuFHgRi1b_S3oyTw.png" /></figure><p>Existe uma certa analogia entre o tradicional SQL e as soluções NoSQL conhecidas. Contudo essas tabelas são apenas uma referência singela. Uma <em>Collection</em> não tem nada a ver com uma <em>Table;</em> a semelhança é apenas hierárquica. O mesmo será com uma <em>Row</em> e um <em>Document</em>.</p><p>Sendo assim NoSQL é basicamente uma estratégia de armazenamento que foge a regra da nossa estrutura tradicional de tabelas e que pretende resolver questões para as quais o mundo relacional não foi feito. É um universo heterogêneo e praticamente abrange tudo o que não é SQL.</p><h4>Certo, e o tal do AQL que você disse lá em cima?</h4><p>A AQL é uma linguagem declarativa que pode ser usada para passar instruções de forma declarativa para o banco de dados. Isto pode amenizar os impactos gerados pela ausência do SQL na ferramenta que está sendo usada para manter o banco de dados do projeto.</p><p>O pessoal do Arango fez um resumão <a href="https://www.arangodb.com/why-arangodb/sql-aql-comparison">aqui</a> comparando SQL e AQL.</p><h3>Aplicações Práticas</h3><p>“Se eu já sei tudo sobre relacional para que eu preciso do NoSQL?” — é uma das primeiras coisas que pode vir à mente dos desenvolvedores.</p><p>É cada vez mais comum termos que manter conjuntos de dados assimétricos e usando bancos relacionais somos “obrigados” à criar tabelas com (dezenas de) colunas que na verdade não importam muito e ficam vazias ou até com valores nulos.</p><p>Usando um banco NoSQL, geralmente, você pode ter registros com estruturas heterogêneas. E, se eu bem conheço o povo da TI, você deve estar pensando agora: “Como eu vou fazer aquelas consultas do meu relatório se com NoSQL eu não tenho como usar SQL?” — É ai que o AQL entra.</p><p>Usando AQL você poderá usar uma linguagem declarativa e manter sua estrutura salva de forma heterogênea.</p><h3>Mão na massa</h3><p>Pra ajudar à explicar o que estou querendo demonstrar, vamos ver brevemente como executar alguns comandos em AQL que estamos acostumados a fazer com SQL.</p><h4>Iniciando o servidor ArangoDB</h4><p>Na <a href="https://hub.docker.com/r/arangodb/arangodb">Docker Hub</a> temos uma imagem bem apropriada para rodar o ArangoDB. Vamos usá-la para poder fazermos nossa introdução ao uso da AQL.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BWZB-0YEvlLsDgjIo7ESvA.png" /><figcaption>code: docker run — rm -e ARANGO_RANDOM_ROOT_PASSWORD=1 -p 8529:8529 arangodb</figcaption></figure><p>Usando o comando acima você vai iniciar um container Docker do Arango mapeando a porta 8529 no seu host. A saída será algo como o que vemos abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z3vh1Wzc4xWOHkZ2-e1lBw.png" /></figure><p>Note na imagem acima o trecho “GENERATED ROOT PASSWORD”. Copie a senha que foi gerada para usar na tela que se abre quando você acessar o endereço “<a href="http://localhost:8529/">http://localhost:8529</a>” no seu navegador.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I8wl5rztSPF8_J_pcUIfAA.png" /></figure><p>Preencha os campos acima com o usuário “root” e a senha que estava ao lado do texto “GENERATED ROOT PASSWORD” na saída do seu terminal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dlWYhvv9dcoSv07lbcapeA.png" /></figure><p>Confirme o banco em que vai se conectar (provavelmente só terá essa opção “_system” mesmo) e você verá em seguida uma tela de dashboard. Essa interface é chama de <a href="https://www.arangodb.com/arangodb-training-center/arangodb-web-ui">ArangoDB Web UI</a> e é uma forma de ver e gerenciar seus bancos (numa analogia desconfortável para mim, seria algo parecido com o <a href="https://www.phpmyadmin.net/">phpMyAdmin</a> no PHP + MySQL)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*siOxQIgecSQHetYeYUm9Qw.png" /></figure><p>Esta é a visão que temos assim que entramos na interface web do ArangoDB.</p><h4>Criando uma coleção</h4><p>Uma coleção é como se fosse uma tabela no mundo relacional. Nela poderemos criar nossos documentos que serão as linhas de registro persistidas. Para criar uma nova coleção, basta ir até o menu “COLLECTIONS” do menu lateral esquerdo, clicar no botão “Add Collection” e informar o nome dela. No meu exemplo estou criando com o nome “users”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*yEYdBBemJK68ZuREsHx74w.png" /></figure><p>Ao clicar em “Save” você verá algo parecido com a tela abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*fOTyJHrsmvHwRqS9hmVqpQ.png" /></figure><h4>Manipulando alguns dados</h4><p>Para podermos rodar nossos comandos AQL vamos agora para o menu “QUERIES”. Nele será possível ver um editor onde podemos informar nossas instruções.</p><blockquote>Esta é apenas uma pequena demonstração do AQL, para ver mais sobre a ferramenta recomendo dar uma visitada em sua <a href="https://docs.arangodb.com/latest/AQL/Operations">documentação</a> e no <a href="https://docs.arangodb.com/3.3/Cookbook/AQL">cookbook</a>.</blockquote><p>A sintaxe para um insert é “<strong><em>INSERT</em></strong><em> document </em><strong><em>IN</em></strong><em> collection options</em>”. Partindo desse preceito, podemos combinar o operator <a href="https://docs.arangodb.com/latest/AQL/Operations/Insert.html">INSERT</a> com o <a href="https://docs.arangodb.com/latest/AQL/Operations/For.html">FOR</a> e gerar vários registros de uma vez (<a href="https://docs.arangodb.com/3.3/Cookbook/AQL/CreatingTestData.html">adaptado à partir daqui</a>). O comando abaixo vai criar 1000 registros (documentos) na nossa coleção “<em>users</em>” criada agora à pouco.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*OWxlfjcj19EtKMyU-0mpZQ.png" /></figure><p>Depois de criados os documentos podemos usar o FOR (algo parecido com o que faz um SELECT no SQL) para listar os dados das coleções. Note na saída abaixo que as propriedade <a href="https://docs.arangodb.com/3.3/Manual/DataModeling/NamingConventions/AttributeNames.html">_key, _id e _rev</a> foram criadas automaticamente pela engine e poderíamos usar as <a href="https://docs.arangodb.com/3.3/AQL/Functions/Document.html">funções relacionadas aos documentos</a> para determinar a visibilidade delas em uma query.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*Gf_Zmd3oojnuJZS7vT5u1Q.png" /></figure><p>A linguagem AQL entrega vários comandos básicos para um banco de dados que se preze como excluir, atualizar, contar, entre outros, além de permitir o “bind” de parâmetros parar as instruções e conseguir gerenciar com facilidade o offset dos documentos. Também é possível usar agregações e combinações bem interessantes com os documentos. No exemplo a seguir agrupei os usuários por status e mostrei a quantidade de usuários em cada grupo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*tMNbuBRe6ulcLWZHskPFJw.png" /></figure><h3>E como usar isso com PHP?</h3><p>Nessa primeira parte do artigo deu para ter uma ideia do funcionamento do ArangoDB e da AQL. Legal né? No próximo artigo vamos ver de forma prática como usar um Object-Document Manager (ODM) para rodar nossos comandos AQL direto do PHP. Vamos construir pequenas classes para gerenciar dados usando o Arango e a interessante linguagem declarativa que pode ser usada com ele.</p><p>&lt;SPOILERS&gt;Se quiser já ir adiantando o assunto, a biblioteca base que vamos usar é esta que está abaixo que é mantida pelo próprio ArangoDB.</p><p><a href="https://github.com/arangodb/arangodb-php">arangodb/arangodb-php</a></p><p>&lt;/SPOILERS&gt;</p><h3>Conclusão</h3><p>Com recursos interessantes o ArangoDB, demonstra ser bem versátil e pode inclusive ser configurado para receber instruções <a href="https://www.arangodb.com/tutorials/arangodb-crud">via HTTP</a>. Ainda não tenho muita experiência com ele, mas tem me agradado até o momento.</p><p>Em tempos de GraphQL o Arango pode parecer pouco poderoso, mas seria um engano pensar assim. Mantenha-o no seu cinto de utilidades e sinta-se à vontade para experimentar logo que puder : )</p><p>Esta é a primeira de duas partes deste artigo.</p><p>Quer trocar mais ideia sobre o assunto? Deixa um comentário ou me chama nas redes sociais.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60c57b83eaf5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/nosql-no-php-usando-arangodb-parte-1-60c57b83eaf5">NoSQL no PHP usando ArangoDB — Parte 1</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vue.js: injetando serviços em componentes de forma transparente]]></title>
            <link>https://medium.com/phpzm/vuejs-services-injetando-servicos-em-componentes-de-forma-transparente-1c7c10e90245?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/1c7c10e90245</guid>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[vue-router]]></category>
            <category><![CDATA[javascript-development]]></category>
            <category><![CDATA[javascript-rocks]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Tue, 22 May 2018 13:01:04 GMT</pubDate>
            <atom:updated>2019-01-27T17:09:28.440Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_2xlbnuxAuwPuw1qdAqvdg.png" /></figure><blockquote>Você provavelmente já viu alguns exemplos de aplicações utilizando Vue e já deve ter percebido que (atualmente em meados de 2018) ele ainda passa por uma fase de fragmentação quanto ao uso da ferramenta onde vários grupos tem várias arquiteturas sendo aplicadas e testadas.</blockquote><p>Esta situação é um pouco desconfortável para alguns, mas ela espelha um momento cada vez mais comum no desenvolvimento web: POSSIBILIDADES.</p><p>É muito provável que se você perguntar a cada arquiteto de cada estrutura visitada ele tenha partido de alguma experiência anterior pela qual passou e tenha organizado sua estrutura porque a que vinha usando o deixou na mão ou não escalou nesta ou naquela situação.<br>Conosco não é muito diferente. Nosso caso era realmente a preocupação com a flexibilidade e rapidez.<br>Precisávamos de estruturas que fossem criadas rapidamente e que fossem simples de serem atualizadas, sem ter que abrir centenas de arquivos para aplicar mudanças; esse era nosso desafio.</p><blockquote>Disclaimer: o conteúdo do artigo são apenas sugestões de coisas que usamos no nosso dia-a-dia, fique à vontade para concordar e/ou discordar, aproveitando as experiências da forma que melhor lhe convir.</blockquote><h3>Serviços</h3><p>Nos contextos de arquitetura de software o termo serviço refere-se a uma funcionalidade ou um conjunto de funcionalidades de software com um propósito que pode ser reutilizado em diferentes ocasiões. Geralmente associamos os acessos à recursos HTTP ao nome Service, mas nem sempre usamos uma estrutura dedicada à isso para cada domínio da nossa aplicação, o que, particularmente se tornou um problema.</p><blockquote>Devemos ter cuidado ao usar recursos como this.$http.get(&#39;/api/v1/products&#39;) dentro da nossa aplicação, pois estamos pulverizando uma camada lógica importante por toda a aplicação.</blockquote><p>Vou deixar um link abaixo como referência para construções de serviços, caso queira se aprofundar um pouco mais sobre o tema (e ainda não conheça):</p><p><a href="https://blog.codecasts.com.br/vue-js-e-servicos-4d4439320a2">Vue.js: Trabalhando com Serviços</a></p><h3>Mantendo Contratos</h3><p>Para quem está acostumado com linguagens onde a <strong>Orientação a Objeto</strong> possui suporte à recursos como interfaces, métodos abstratos, enum, entre outros, o javascript se torna um pouco assustador por não entregar esse tipo de composição. Contudo, isso não é exatamente um problema quando você organiza a sua aplicação porque essa chamada falta de rigidez pode ser compensada de outras formas para forçar que alguns caminhos não sejam seguidos. Vou deixar o link abaixo com algumas dicas de composição de serviços:</p><p><a href="http://vuejs-brasil.com.br/vue-js-ajax-patterns/">Vue.js Brasil - Artigos em Português sobre Vue.js</a></p><h4>Criando Serviços Extensíveis</h4><p>Para poder seguir com este material apresentaremos uma solução simples para criar um <strong><em>Service</em></strong> que pode ser estendido e usado nos domínios das entidades com as quais estão lidando. A seguir será apresentada uma lista de documentos e a respectiva explicação sobre o que representa cada um deles.</p><h4>A estrutura</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7dad2a6f2d87a539cfdaef6f533cfb3f/href">https://medium.com/media/7dad2a6f2d87a539cfdaef6f533cfb3f/href</a></iframe><h4>src/main.js</h4><p>Um pequeno exemplo de uso de como o serviço será usado. Ele importa o <em>service</em> de <em>Product</em> e constrói uma instância para poder executar o método read e imprimir a saída;</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/db5da1285992071bce745811f7bf8da6/href">https://medium.com/media/db5da1285992071bce745811f7bf8da6/href</a></iframe><h4>src/domains/Product/Service/Product.js</h4><p>A especialização do serviço <em>Api</em> para ser usado no escopo da entidade <em>Product</em>;</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/093d3e3d8b3890c83363226610178fee/href">https://medium.com/media/093d3e3d8b3890c83363226610178fee/href</a></iframe><h4>src/service/Api.js</h4><p>Serviço para consumo de API’s que entrega 4 métodos básicos para realizar o que é costumeiramente chamado de CRUD;</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8fbd94b276e6130da01ab83194d022f4/href">https://medium.com/media/8fbd94b276e6130da01ab83194d022f4/href</a></iframe><h4>src/service/Service.js</h4><p>Contrato básico para a <em>factory</em> de instâncias do <em>Service</em>;</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/87facee4a5fdc99d832af52d7849a7fb/href">https://medium.com/media/87facee4a5fdc99d832af52d7849a7fb/href</a></iframe><h4>src/service/helper.js</h4><p>Apenas uma função fake para simular o delay da troca de contexto de da manipulação dos dados.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4a063f52e1784d80d6c2bf471c816b1d/href">https://medium.com/media/4a063f52e1784d80d6c2bf471c816b1d/href</a></iframe><p>A saída exibida nesse caso é algo parecida com a imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/0*uw6Dhl5_74PztGqx.png" /></figure><p>Com o que fora apresentado até aqui não é difícil perceber que podemos usar essa estrutura para representar diversas estratégias de API’s porque não está fechado o que o nosso serviço consome. Essa deve ser a visão do componente acerca do <em>service</em>: conhecer o contrato e não a implementação.</p><blockquote>Embora o Javascript não tenha estruturas “formais” para contratos, é possível criar padrões para que a codificação componha esses contratos de forma orgânica</blockquote><p>Se quiser se aprofundar em abordagens de gestão de <em>services</em> pode dar uma olhada nessa dica de artigo (que recebi do <a href="https://medium.com/u/c6d9829e150b">Vinicius Reis</a>) onde é explorado a níveis bem profundos o uso do serviço como um modelo da entidade totalmente isolado da apresentação do componente.</p><p><a href="https://itnext.io/how-not-to-suffer-with-apis-8aa75f890fe6">How not to suffer with APIs</a></p><h3>Lidando com Componentes</h3><p>Bom, se o serviço agora é uma estrutura totalmente segmentada do meu componente, como posso fazer uso desse recurso dentro do componente? A resposta dessa pergunta também é uma pergunta: quão flexível será seu componente e quão dinâmica será sua estrutura?</p><h4>Importando serviços para o meu componente</h4><p>Essa estratégia é bem simples e consiste basicamente em usar os módulos javascript para usar o <em>service</em> dentro do escopo do seu componente.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b9ace4c9c8af1c34ab092445ed6025ec/href">https://medium.com/media/b9ace4c9c8af1c34ab092445ed6025ec/href</a></iframe><p>Se precisar de uma estratégia mais eficiente de distribuir o service, pode usar um plugin para manipular o estado dele dentro do componente. Seguindo essa abordagem teríamos o <strong><em>ProductTable.vue</em></strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0e7bfd5b9fc0f62aec02a5e8038ef2cb/href">https://medium.com/media/0e7bfd5b9fc0f62aec02a5e8038ef2cb/href</a></iframe><p>E teríamos uma modificação no protótipo do <strong>Vue</strong> através do <strong>src/service/Plugin.js</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c332ae1cb7c40b822245e8ad1e061566/href">https://medium.com/media/c332ae1cb7c40b822245e8ad1e061566/href</a></iframe><p>Com esta segunda abordagem, mesmo que algum desenvolvedor sem querer faça algo como this.$service = null, a resposta do <strong>Vue</strong> será contundente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/849/0*FqkcFHQZMHuTtxad.png" /></figure><p>Com a implementação do <em>plugin</em> feita dessa forma o <em>service</em> é passado para o componente e o então ele “descobre” se este é um item das opções do construtor da instância do <strong>Vue</strong> ou se é uma <em>prop</em> do componente, entregando um elemento, que como vimos acima, é imutável; o que nos leva a próxima abordagem: passar os serviços via <em>props</em>.</p><h4>Utilizando serviços como props</h4><p>No ecossistema do <strong>Vue</strong> (na verdade é um conceito um pouco mais abrangente que isso) uma <em>prop</em> é um estado que é passado para um componente. Se não estiver recordando muito bem como funcionam essas propriedades dos componentes recomendo fazer uma visita no link abaixo antes de continuar.</p><p><a href="https://vuejs.org/v2/guide/components-props.html">Props - Vue.js</a></p><p>Com a leitura em dia será fácil compreender que usando <em>props</em> tenho a capacidade de passar parâmetros para meus componentes sem ter que deliberadamente deixar esse parâmetro “hard-coded” dentro dele.</p><p>Para receber uma <em>prop</em> dentro de um componente é preciso declarar essa necessidade. O resultado é semelhante ao exemplo a seguir:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1d5981478de822c8009d6d5858977348/href">https://medium.com/media/1d5981478de822c8009d6d5858977348/href</a></iframe><p>O que implicaria em um caso de uso semelhante à &lt;ProductTable v-bind:service=&quot;service&quot;/&gt;.</p><p>Embora essa abordagem não seja ruim, ela possui alguns pontos que devem ser observados. Entre as situações que não me deixam confortável temos a questão de usar um estado do componente (uma propriedade no data) para abrigar o serviço que será mapeado à <em>prop</em>, e a necessidade imperativa de ter que criar um arquivo .vue para cada rota implementada.</p><h4>Usando o Router para injetar dependência</h4><p>Durante a construção de app’s mais robustos geralmente usamos um <em>router</em>. O <strong>Vue Router</strong> é uma ferramenta que faz parte do ecossistema do <strong>Vue</strong> e nos permite criar rotas para nossos componentes. Ele tem suporte à informar as <em>props</em> que serão usadas para montar o componente e isto é descrito no trecho abaixo da documentação.</p><p><a href="https://router.vuejs.org/en/essentials/passing-props.html">Passing Props to Route Components · vue-router</a></p><p>No caso do nosso exemplo, vamos explorar o <a href="https://router.vuejs.org/en/essentials/passing-props.html#function-mode">function mode</a> onde as <em>props</em> serão geradas por uma função que recebe a rota carregada como parâmetro. Com o <em>service</em> sendo uma <em>prop</em> poderemos passá-lo por parâmetro através da rota onde seu componente será montado.</p><p>Como podemos ver no exemplo abaixo, será possível combinar as duas abordagens no seu projeto. Poderemos usar um mesmo componente recebendo o <strong>service</strong> por <em>props</em> ou através de <em>$options</em>, <em>template</em>, <em>render</em> ou <em>route</em> porque o acesso ao <strong><em>$service</em></strong> será transparente para o componente.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/31898d4b32715356c053823f946a8abc/href">https://medium.com/media/31898d4b32715356c053823f946a8abc/href</a></iframe><h3>Conclusão</h3><p>O <strong>Vue</strong> é muito flexível e deixa à cargo da sua capacidade de manipulação do Javascript a criação do ecossistema em que o componente está inserido. Tenha sempre cuidado para escolher abordagens que te permitam escalar a sua aplicação de forma mais objetiva possível pesquisando e estudando o máximo que puder antes de começar a escrever seus códigos.<br>Ademais, você pode começar a fazer uso dessas metodologias para fazer seus <em>requests</em> sem que seu componente perceba que algo mudou.</p><blockquote>Isolar o comportamento dos serviços é uma boa pedida em tempos onde estão surgindo opções interessantes para manipulação de dados, como o <a href="https://graphql.org/">GraphQL</a>.</blockquote><p>Fique à vontade para enviar suas dúvidas, sugestões e/ou elogios. Para falar mais sobre <a href="https://vuejs.org/"><strong>VueJS</strong></a> fique ligado na comunidade e em todo o seu ecossistema : )</p><ul><li><a href="http://vuejs-brasil.com.br/">Vue.js Brasil - Artigos em Português sobre Vue.js</a></li><li><a href="https://github.com/vuejs-br/comunidades">vuejs-br/comunidades</a></li></ul><p>Ah, já ia esquecendo, segue o link do repositório e fica a dica para seguir os commits que será possível ver a evolução da mesma forma que a estrutura foi evoluindo nos artigos.</p><p><a href="https://github.com/wilcorrea/transparent-services">wilcorrea/transparent-services</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c7c10e90245" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/vuejs-services-injetando-servicos-em-componentes-de-forma-transparente-1c7c10e90245">Vue.js: injetando serviços em componentes de forma transparente</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vue.js: Componentes Dinâmicos]]></title>
            <link>https://medium.com/phpzm/vue-js-componentes-dinamicos-faf195a0b26c?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/faf195a0b26c</guid>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[dynamic-programming]]></category>
            <category><![CDATA[javascript-rocks]]></category>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[javascript-development]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Mon, 05 Mar 2018 15:49:13 GMT</pubDate>
            <atom:updated>2019-07-12T11:36:41.465Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HIjDpP0R9XLXNAckoU2npg.jpeg" /></figure><blockquote>Disclaimer: Esse artigo é sobre a história de um desenvolvedor que está sempre em busca de automatizar o que faz e narra como o Vue pode ser uma boa opção para criação de interfaces dinâmicas. Já pensou em ter apenas um componente de formulário no seu projeto?! Apenas um grid?! Se a ideia te agrada esse artigo vai fazer sentido; do contrário pode servir para abrir a sua mente.</blockquote><h3>O Problema</h3><p>Inicialmente vamos fazer um nivelamento sobre alguns conceitos tradicionais na programação. Para esse tópico, criei <a href="https://jsfiddle.net/wilcorrea/nq0b7qwo/1/">este</a> formulário de demonstração com uma ferramenta muito comum para escrita de interface (<a href="https://getbootstrap.com/">bootstrap</a>) com apenas um campo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*tCY_Hf6t28ShPH_risSytA.png" /></figure><p>Veja que temos ali uma div #app sobre a qual é montada uma instância do Vue e dentro dela algumas tags como&lt;form&gt;, &lt;input&gt; e etc. Creio que seja um consenso que esse template esteja bem simples de ser mantido, porém vou convidar você, leitor, para pensar um pouco além do que está no nosso campo de visão.</p><p>Quando olhamos mais atentamente para esse &lt;form&gt; vemos marcações no HTML e uma certa estrutura a ser seguida (aka markup) que são familiares ao contexto que estamos adotando. Além disso, embora este primeiro exemplo esteja bem simples, não é nada incomum ver formulários bem mais extensos e com muito mais informação estática, mapeamento de eventos, mensagens de validações e tantas outras necessidades que o desenvolvimento pode propiciar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/645/1*UPxuvNcjju6-2NtJ2sXkHA.png" /></figure><p>Para crescer a aplicação é comum o desenvolvedor copiar e colar alguns trechos de código, mudar algumas coisinhas e seguir para o próximo campo. Ao final desse processo, na prática, o que vamos ter é uma quantidade bem grande de código (vamos combinar que tudo que for escrito para fazer o software rodar é código) em uma quantidade bem grande de arquivos que são totalmente dependentes da ferramenta visual adotada e que fazem com que trocar algumas coisas no projeto seja quase que refazer ele.</p><h3>Entendendo o Contexto</h3><p>Voltando ao meu primeiro exemplo que vimos no artigo, vamos procurar naquela marcação HTML o que são estados da minha aplicação e o que é parte do esqueleto que o Bootstrap entrega.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*MLjjkimQK8wyHg_zkAZa3w.png" /></figure><p>Note que na imagem temos algumas marcações delineando itens que merecem nossa atenção. Os retângulos vermelhos representam os elementos que fazem parte do universo do Bootstrap, já as elipses verdes representam recursos envolvidos com a lógica impressa pela aplicação.</p><p>Esses dois grandes grupos são importantes e veremos mais sobre cada um deles a seguir. Por enquanto fique com essa ideia e tente exercitá-la olhando seus códigos e pensando em como poderia aplicar essa divisão por lá.</p><h3>Interface Descartável e Flexível</h3><p>Não é mais segredo para ninguém em pleno 2018: aparência importa. Sendo assim se sua aplicação não for pensada para ter a capacidade de se adaptar rapidamente à mudanças visuais estará comprometendo um grande esforço para ficar refazendo telas porque seu framework não é mais mantido ou porque a nova versão dele devastou tudo o que tinha sido escrito.</p><p>Para evitar isso podemos usar componentes customizados. Ao invés de declararmos explicitamente um &lt;input&gt; e todo o markup que o rodeia vamos criar um componente que encapsule-o.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/1*J8taWzV4Y0JN1vxgMbwjjw.png" /></figure><p>Com essa mudança passa a ser irrelevante qual o markup HTML que será executado. Poderíamos ter 500 &lt;input&gt; nesse &lt;form&gt;que para atualizar TODOS eles precisaríamos mudar apenas um local. Obviamente que esse mesmo conceito aplicaria-se a toda uma aplicação.</p><blockquote>Procure não usar diretamente recursos de nenhuma biblioteca ou framework. Centralize a relação entre seu código e o código alheio em pontos chave.</blockquote><p>Note que em momento nenhum eu disse que seria algo fácil e nem que conseguiremos fazer isso sempre. A dica é tentar fazer o máximo que puder para evitar refatorações sucessivas e constantes.</p><h3>Controle de Estados</h3><p>O termo <strong><em>estado</em></strong> está se tornando cada vez mais popular (<em>assim como algoritmo</em>), o que demonstra que o desenvolvimento de software tem amadurecido à passos largos. Quando usamos este termo na nossa aplicação estamos geralmente fazendo referência aos dados que estão sendo manipulados e persistidos. Contudo há mais para se ver sobre isso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/716/1*0zkxF3l3e6L29u5hznxmcQ.png" /><figcaption><a href="https://jsfiddle.net/wilcorrea/hwuog723/">https://jsfiddle.net/wilcorrea/hwuog723</a></figcaption></figure><p>Com estas modificações nosso exemplo agora consegue gerenciar o valor do campo de descrição usando um componente que mapeia o estado que será usado como estrada e saída do sistema; todavia ele ainda possui estados para administrar o &lt;label&gt;que será exibido, formatando e modificando o componente renderizado.</p><blockquote>Não vou me aprofundar muito sobre os comandos usados (se tiver dúvidas sobre algo pode consultar a doc, expressar-se por meio dos comentários, ou entrar em contato de alguma forma) porque não é o foco do artigo; estamos falando de abstração e demonstrando possíveis abordagens apenas para validar a ideia.</blockquote><blockquote>Os estados da sua aplicação são responsáveis por prover subsídios para a resolução dos problemas que ela pretende resolver. Trate-os como prioridade.</blockquote><h3>Estados Circunstanciais</h3><p>Creio que todos os leitores que estiverem lendo esse trecho agora já interagiram com telas que reagem de alguma forma aos valores informados reconfigurando o que está visível de forma a guiar o fluxo e/ou garantir uma entrada mais adequada de dados. É possível ver estados mapeados na interface para exibir/ocultar ou alterá-la circunstancialmente e eventos que alteram esses mesmos estados.</p><p>Vamos considerar nesse ponto que há dois tipos de estados na sua aplicação: um grupo de estados que representa a <strong>entrada e saída de dado</strong>s da sua aplicação e um outro grupo que é responsável por <strong>configurar os componentes da tela</strong>. Estas duas dimensões de estados são relevantes para o sistema. A “lógica” que os estados dos componentes possui é muito primitiva; ela está basicamente relacionada a laços e testes lógicos para determinar quais propriedades devem ser exibidas em um dado contexto, mas ainda assim ela é importante.</p><blockquote>O seu template é descartável, mas a lógica por trás dos seus componentes não é!</blockquote><p>Na verdade a lógica por trás dos componentes é, provavelmente, tão importante quanto o I/O (Input/Output) que sua aplicação provê. Algumas partes de alguns programas podem ser totalmente prejudicadas caso os estados que manipulam os componentes de tela sejam comprometidos. Interfaces para cadastros de pessoas física e jurídica, por exemplo, exibem um indicador de qual tipo de pessoa será persistido e também redefinem os campos na tela. Pode ser, inclusive, que a alteração do valor contido o campo que define o tipo de pessoa, além de mudar os campos de tela, redefina o destino que será usado para a persistência da informação coletada, tornando ainda mais crítico o papel desses estados.</p><h3>Composição de Componentes</h3><p>Basicamente um componente (<a href="https://www.webcomponents.org/">WebComponents</a> também) vai ser um conjunto de recursos que pode ser usado e re-usado em diversos locais. Como estamos usando VueJS para os exemplos, segue um exemplo de um componente que pode ser reusado como um módulo Javascript.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/816/1*nlR9kFJRIgYDWQ1a-87ngw.png" /></figure><p>Este componente poderia ter qualquer nome, mas com base no que temos na imagem acima vamos considerar que ele será registrado globalmente ou para o escopo local como FieldInput, o que resultaria na disponibilidade da tag &lt;field-input&gt; para os templates (isto pode ser visto nos exemplos acima). A necessidade de escrever essa tag toda vez que eu precisar desse componente me impede que eu possa criar um form sem escrever pelo menos essa marcação e reduz as minhas chances de fazer telas ainda mais dinâmicas.</p><p>Sabendo disso o Vue disponibiliza em sua renderização de templates um recurso chamado de <a href="https://vuejs.org/v2/guide/components.html#Dynamic-Components">Dynamic Component</a> e vamos ver como fazer uso dela no exemplo abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/1*F0HQCq4ezT5tM5xGb_8sFg.png" /><figcaption><a href="https://jsfiddle.net/wilcorrea/nq0b7qwo/39/">https://jsfiddle.net/wilcorrea/nq0b7qwo/39/</a></figcaption></figure><p>Na linha 4 da seção HTML é possível ver a tag &lt;component&gt; e sua <em>prop</em> <strong><em>is</em></strong>. Essa propriedade permite-nos declarar um component sobre a tag &lt;component&gt;. Sendo assim o valor que eu passar para a <em>prop</em> <strong><em>is</em></strong> deverá ser o identificador de um componente e o mesmo será instanciado na resolução do template. Esta prática retira de nós a responsabilidade de criar cada &lt;tag&gt; de cada campo de nossas telas. Ao invés de declarar cada item podemos usar uma diretiva para percorrer os metadados de um elemento que foi declarado em Javascript, para que estes sejam os responsáveis por prover os dados necessários para criar a interface.</p><p>Obviamente que isto seria apenas o começo e te abre inúmeras portas para inúmeras construções. Podemos manter seus modelos em domínios e criar as rotas de forma a consumir esses recursos. Um componente poderia ser também qualquer coisa; além de campos de formulários, poderíamos ter menus, sliders, banners e qualquer coisa que fizesse algum sentido ser organizado dessa forma dentro do seu projeto.</p><h3>Nem tudo são flores!</h3><p>No último tópico deste artigo demonstramos como usar componentes dinâmicos, como bom desenvolvedor, você já deve ter sacado a quantidade de possibilidades que a utilização de metadados para suportar uma camada de abstração sobre os seus componentes e seu I/O pode ser vantajosa. O que eu preciso te contar agora são das dificuldades que isso vai te trazer:</p><ul><li>Mensagens de erro pouco amigáveis: se até então tínhamos mensagens bem claras sobre os erros quando construímos um workflow explícito, usando abordagens dinâmicas isso não será mais realidade. Será preciso ter cuidado com erros e construir passo-a-passo suas composições para não se perder;</li><li>Alto nível de acoplamento: componentes dinâmicos vão aumentar exponencialmente o acoplamento do seu projeto. O bater de asas de uma borboleta em um componente vai se refletir em todo o projeto. Crie testes e organize como serão feitas mudanças nesses componentes centrais;</li><li>Conhecimento avançado da linguagem: quando usamos composições dinâmicas ganha-se em tempo e em reuso, mas é preciso ter conhecimentos avançados sobre a linguagem que está manipulando. No caso do Vue usamos Javascript, e, em pouco tempo seu projeto passará a ser sobre Javascript e terá pouco a se tratar sobre Vue, que ficará isolado nas interações de tela, componentes padrões e alguns componentes customizados que não valerão o esforço de torná-los agnósticos;</li><li>Crie contratos: para manter um controle de crescimento sadio será preciso estipular contratos de funcionamento no workflow, e, nada mais útil do que usar recursos da própria linguagem. No caso do exemplo que eu mostrei a propriedade <em>schema</em> deveria ser criada por algum método, classe ou qualquer estrutura que sua linguagem ofereça para padronizar a criação de recursos;</li><li>Abstração como arma e crescimento horizontal: componentes dinâmicos transformam seu projeto em provedores de abstração. Nunca permita que um módulo se torne profundo demais quando for abstrair a sua participação junto ao projeto, cresça sempre pros lados e nunca para cima ou para baixo;</li><li>Trabalhe pensando em exceções: criar estruturas dinâmicas requer um cuidado muito grande para que não sejam criadas fundações inflexíveis. No caso do Vue eu posso registrar componentes a qualquer momento, inclusive em tempo de execução, o que facilita atender exceções.</li></ul><p>Talvez hajam outros desafios que não me recordo agora, se puderem contribuir com comentários e dicas será bem vindo : )</p><h3>Conclusão</h3><p>O objetivo deste artigo era , basicamente, mostrar como trabalhar com estruturas dinâmicas usando VueJS (ou mesmo um pouco além dele) e as vantagens e desvantagens dessa abordagem. Dentre as principais vantagens está a produtividade e o poder de manutenção centralizado, já entre as principais desvantagens estão a complexidade e acoplamento que podem fazer com que manutenções precisem ser bem pensadas e organizadas.</p><p>Se gostou do tema ou tem algo a acrescentar, por favor, entre em contato. MDD (Metadata Drive Development) é um tema bem pobre de fontes e fica complicado ter uma boa bibliografia para citar.</p><p>Caso tenham dúvidas e/ou sugestões é possível me achar por ai pelo username @wilcorrea. É comum me achar pelo Telegram ou Twitter.</p><p><a href="https://t.me/vuejsbrasil">VueJS Brasil</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=faf195a0b26c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/vue-js-componentes-dinamicos-faf195a0b26c">Vue.js: Componentes Dinâmicos</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dicas & Truques em Orientação a Objetos: Ato I]]></title>
            <link>https://medium.com/phpzm/deep-in-dicas-e-truques-em-orientacao-a-objetos-ato-i-74e011693af1?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/74e011693af1</guid>
            <category><![CDATA[php-deep-in]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[php-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[laravel]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Fri, 22 Dec 2017 03:09:02 GMT</pubDate>
            <atom:updated>2017-12-22T17:18:57.956Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<h3>PHP “deep in”: dicas &amp; truques em Orientação a Objetos ~&gt; Ato I</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MUnYEbQWqnRfmOZlvTZ8yQ.png" /></figure><h3>Antes de Framework sua ferramenta é PHP</h3><p>Não tem sido incomum a turma começar a aprender a programar usando ferramentas pré-programadas. Não sou do tipo que julga isso e acho que ninguém deveria ser. Na verdade concordo tanto com não julgar que ajudei na tradução <a href="https://medium.com/devtranslate/a-comunidade-global-de-php-continua-se-intoxicando-e-precisamos-reverter-isso-antes-que-afete-da50ee793f8b">deste artigo</a> (leia se puder).</p><blockquote>É importante salientar que todo framework PHP é essencialmente PHP. Sim, isso mesmo, isso tudo lindo que você tanto admira é apenas o bom e velho PHP. Só um monte de código PHP junto!</blockquote><p>A maioria dos frameworks em PHP trazem alguma qualidade para o código dos desenvolvedores de um modo geral, e, embora não fosse preciso a adoção de ferramentas para tanto vou dar algumas dicas de como não ficar no arroz com feijão com essas ferramentas.</p><blockquote>Nesta série de artigos vou tentar responder o porquê de eu gostar tanto de PHP e o que a faz ser uma linguagem tão legal de ser usada : )</blockquote><h3>Laravel como exemplo</h3><p>Das ferramentas da categoria é uma das que mais me agrada. Embora seja perceptível, que, em muitos momentos ela abre mão da performance para oferecer um ambiente mais agradável e simples para o desenvolvedor, o Laravel não decepciona. Mesmo para quem não é fã de ActiveRecord é possível usá-lo sem qualquer problema e se sentir satisfeito com o resultado final.</p><p>Obviamente que o “laravel/laravel” é apenas um boilerplate, então vou dar algumas dicas de como eu uso a ferramenta (correndo o risco de ter opiniões pessoais perdidas por aqui).</p><h3>Estrutura de pastas</h3><p>Nenhum projeto merece ter todos os arquivos misturados numa mesma pasta. Então tente organizar seu projeto de alguma forma que faça sentido.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/919/1*ShjgEDZ1K8jDrjno5jMTNA.png" /></figure><p>A estrutura acima está sendo usada em dois projetos e, claro, que ela não é perfeita, nem é um padrão do “certo” a se fazer, inclusive, pode já ter mudado enquanto você estiver lendo esse artigo. Pense nessa imagem como uma amostra de como outra pessoa faz e tente chegar (usando outras fontes de pesquisa) a algo que se adeque ao seu fluxo de trabalho ou do seu time.</p><h3>Rotas limpas</h3><p>Evite rotas rocambolescas e repleta de lógicas. Você pode estender o “facade” Router para poder incutir seus comportamentos preferidos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6e004f08765f59ff34a53de002d0b51f/href">https://medium.com/media/6e004f08765f59ff34a53de002d0b51f/href</a></iframe><p>Com esse tipo de recurso você pode tratar suas rotas de API dessa forma.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b8ce84bb911d9982b473cf368903ab47/href">https://medium.com/media/b8ce84bb911d9982b473cf368903ab47/href</a></iframe><p>E como sabemos que a coisa complica facilmente em aplicações web, não descarte a possibilidade de fazer algo assim.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/336d7e91c254602e1c3e84ce01227506/href">https://medium.com/media/336d7e91c254602e1c3e84ce01227506/href</a></iframe><h3>Você se repete sem saber</h3><p>Procurei pela internet exemplos básicos de cadastros e consegui abstrair algo que soa como um exemplo tradicional de CRUD com Laravel.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7d0885741e93afe5bf3b72a63d9b5515/href">https://medium.com/media/7d0885741e93afe5bf3b72a63d9b5515/href</a></iframe><p>Não vou entrar nos detalhes da implementação desse Controller.php, mas te convido a pensar de outra forma. E se, apenas… e se, ao invés de fazer desse jeito você fizesse um Controller desse jeito aqui.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3438bfa95a5bfbf82946244be2d33b75/href">https://medium.com/media/3438bfa95a5bfbf82946244be2d33b75/href</a></iframe><p>E, em seguida, apenas fizesse algo assim para usar ele.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a77d6148f19d453b4f3fc737165d35a/href">https://medium.com/media/3a77d6148f19d453b4f3fc737165d35a/href</a></iframe><p>Sim, é isso mesmo. De agora em diante quando eu quiser fazer um novo Controller só preciso criar algo dessa forma que ele já tem a capacidade de fazer tudo o que era feito com todas aquelas linhas. Ao invés de copiar e colar e substituir o nome das classes eu construo estruturas que representem os domínios e reaproveitem todo o código que já fora escrito.</p><h3>Desacople-se</h3><p>Não importa o que digam, seu código é seu código e o da ferramenta é o da ferramenta. Evite estender diretamente as classes base que o framework te entrega e monte os fluxos de forma a não ficar totalmente dependente de coisas que variam, por exemplo, recuperar dados do http ou interagir com uma base de dados.</p><p>Se você ficou esperto viu que foram chamados métodos do model no Controller “automatizado” que o Eloquent não entrega. Algo simples como o trecho abaixo te permite fazer coisas mais elaboradas que o que o framework (não importa qual) te entrega como base.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d3bd507cc4cf4e7a767aa4c9018f89db/href">https://medium.com/media/d3bd507cc4cf4e7a767aa4c9018f89db/href</a></iframe><p>O lema é centralizar e distribuir, mas sem sobrecarregar. Evite sempre engordar demais uma classe com coisas desnecessárias. Algo como essas traits poderiam ser usadas em separado quando você precisasse delas. Apenas quando precisasse! Um exemplo do que podem ser essas traits a seguir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9e92f4c2cafe0c5d882295d81bb96309/href">https://medium.com/media/9e92f4c2cafe0c5d882295d81bb96309/href</a></iframe><p>Este é um exemplo de uma estratégia para executar comandos depois de chamar os métodos básicos do ORM. Claro que o Laravel tem sua API de eventos, e, por isso reforço que estes são exemplos sobre possibilidades. Eu, particularmente, curto ter hooks síncronos acessíveis de uma forma simples. Talvez seja apenas um velho hábito, mas fica claro como é simples de se ter esse tipo de abordagem usando o nosso bom e velho PHP.</p><p>Bom, era só isso que eu queria mostrar nesse “Ato I”. Nos próximos darei dicas como:</p><ul><li>caminhos para desacoplar seu projeto do framework, ou;</li><li>formas de mapear relacionamentos dinamicamente, ou;</li><li>formas de usar Model’s que escalam facilmente, ou;</li><li>estratégias para ter projetos refatoráveis e evolutivos, e;</li><li>sempre ideias para escrever cada vez menos código com cada vez mais resultado!</li></ul><p>Não se esqueça nunca que cada linha de código escrita precisa ser pensada e que um trecho de código copiado e colado é um convite à dificuldade de manutenção e, provavelmente, uma impossibilidade de uma refatoração rápida.</p><p>Espero que tenha sido de algum uso para você e dúvidas, sugestões, xingamentos e etc são sempre bem vindos.</p><p>Se quiser saber mais sobre Laravel pode usar a documentação oficial ou dar uma olhada no grupo do Telegram, onde tem uma galera que manja pacas da ferramenta.</p><ul><li><a href="https://laravel.com/">Laravel - The PHP Framework For Web Artisans</a></li><li><a href="https://t.me/laravelbr">Laravel Brasil</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=74e011693af1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/deep-in-dicas-e-truques-em-orientacao-a-objetos-ato-i-74e011693af1">Dicas &amp; Truques em Orientação a Objetos: Ato I</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PHP “like a boss” [5]: Trabalhando com Models]]></title>
            <link>https://medium.com/phpzm/php-like-a-boss-5-trabalhando-com-models-bc5eb164ee11?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/bc5eb164ee11</guid>
            <category><![CDATA[php7]]></category>
            <category><![CDATA[php-development]]></category>
            <category><![CDATA[php-like-a-boss]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Mon, 27 Nov 2017 10:55:19 GMT</pubDate>
            <atom:updated>2017-11-27T23:41:15.348Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AVa1S3a4Xww3XMHA5UF2rw.jpeg" /></figure><p>Este é o quinto artigo da série PHP “like a boss” e vou demonstrar alguns ensaios acerca dos Models. Antes disso falamos sobre outros assuntos e vou presumir que você já os leu porque vou usar tudo o que foi mostrado até aqui e escrever PHP “like a boss” daqui pra frente. Se você caiu de pára-quedas por aqui, dê uma olhada no artigo abaixo e visite os demais artigos, caso julgue necessário.</p><p><a href="https://phpzm.rocks/php-like-a-boss-como-trabalhar-com-php-em-2017-f5161b8fbfd1">PHP “like a boss”: Como trabalhar com PHP em 2017</a></p><blockquote>Só para esclarecimentos, a série teve um hiato porque foi preciso esclarecer algumas questões que foram surgindo à medida que o protótipo evoluía, e, graças a isso uma outra série spin-off germinou. Nessa <a href="https://phpzm.rocks/tagged/php-deep-in">série auxiliar</a> (link abaixo) chamada PHP “deep in” foram esmiuçadas dúvidas que foram levantadas dos outros artigos e pontos que ficariam no escuro sem uma base.</blockquote><p><a href="https://phpzm.rocks/tagged/php-deep-in">Php Deep In - phpzm</a></p><blockquote>Disclaimer: este artigo possui altos índices de opiniões pessoais e arquiteturas que fogem um pouco do senso comum das bibliografias usuais do PHP</blockquote><h3>O que são Models?</h3><p>Não vou cai na bobagem de falar de MVC (Model-View-Controller) porque já existem infinitas referências na bibliografia do desenvolvimento de software que tratam sobre o assunto. O que posso dizer é que os recursos chamados de Models atuam, quase sempre, deliberando de alguma forma sobre os dados que a aplicação gerencia. Se uma aplicação persiste dados, provavelmente, a camada de modelos terá algum papel nesse processo.</p><p>Neste artigo <a href="https://goo.gl/PQypI9">aqui</a> é apresentada uma estrutura para projetos PHP que dá suporte a criarmos uma arquitetura que se tornou clássica nas aplicações web. Nela podemos ver os “Models” interagindo com “Controllers” &amp; “Database”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*VvmaP5PBCo-6n8sU.png" /><figcaption>Source: <a href="https://developer.mozilla.org/en-US/docs/Learn/Server-side/Express_Nodejs/routes">https://developer.mozilla.org/en-US/docs/Learn/Server-side/Express_Nodejs/routes</a></figcaption></figure><p>Sendo assim poderíamos com base nessa imagem afirmar que os Models são responsáveis por fazer o meio de campo entre o dado armazenado e as requisições do usuário. Tem mais assunto, claro, mas não seria o pior resumo do mundo.</p><h3>Por que Models?</h3><p>Não foram poucas as vezes que escutei essa pergunta. Geralmente há um certo espanto quando eu respondo: porque é simples. Outras dúvidas comuns são:</p><blockquote>É errado não usar essa abordagem para salvar os dados? E se eu pegar os dados que chegam no Controller e tampar isso direto no banco, está errado?</blockquote><blockquote>Existem algumas indagações que são vistas atreladas ao uso de “Models” e a primeira coisa que deve ficar clara frente a esse tipo de dúvida é: não existe certo ou errado</blockquote><p>Você precisa trabalhar com o que faz mais sentido para você, e, principalmente para o seu projeto. O que acontece é que eu tenho certeza absoluta que você não gostaria de concatenar SQL em diversos lugares da sua aplicação. Você pode até achar que quer, mas na realidade não quer.</p><p>Não se deixe enganar. Em um primeiro momento algumas abordagens aparentam ser mais simples, mas na verdade só depois de algum tempo você percebe que ela não era tão boa assim.</p><blockquote>Se você escreve uma mesma linha de código em mais de um lugar do seu programa você tem um problema, isso é um fato. Quando você precisa mudar algo terá que mudar em todos esses lugares.</blockquote><p>Sua aplicação terá 3 mil arquivos e terá códigos que você gostaria de refatorar, mas não poderá porque poderia quebrar recursos que você nem sabe que tem na aplicação. De vez em quando eu ouço “Ah, mas eu posso mandar substituir em todo o projeto”, e, é claro que você pode, só que as vezes isso não é possível porque a mudança não impacta apenas em mudar um trecho pelo outro e sim em toda a composição de recursos daquele contexto.</p><blockquote>Da próxima vez que você quiser criar comandos manualmente para interagir com o banco de dados pense com carinho na possibilidade de entender um pouco mais sobre como não o fazer; será surpreendente.</blockquote><p>Obviamente que todo extremo é ruim. Se eu disser para você que você nunca vai precisar largar uma instrução direta para sua base de dados estaria mentindo, porém isso deveria ser a exceção e não a regra. Dependendo do seu projeto e da camada em que está atuando (relatórios, por exemplo) você vai precisar fazer isso, contudo centralizar e organizar ainda são palavras de ordem para você não ter problemas num futuro próximo.</p><h3>Mão na Massa</h3><p>No modelo que pretendo apresentar os <strong><em>Models</em></strong> trabalham depois da camada <strong><em>HTTP</em></strong>. Eles não sabem nada de <strong><em>Request</em></strong>, <strong><em>Response</em></strong>, <strong><em>Router</em></strong> e toda essa parafernália. O Objetivo do Model será apenas manter a ponte entre o <strong><em>Controller</em></strong> (que manja desses paranauês) e o <strong><em>Database</em></strong>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cd5ffa4796a08c97a8a080a9af896ec7/href">https://medium.com/media/cd5ffa4796a08c97a8a080a9af896ec7/href</a></iframe><p>O trecho acima é parte do <a href="https://phpzm.rocks/php-like-a-boss-4-utilizando-controllers-7288eddf3aab">artigo anterior da série</a>. No artigo sobre Controllers finalizamos com um index semelhante a esse. Vamos seguir desse ponto e vamos fazer com que a camada (termo usado apenas para embelezar o texto) <em>Model</em> seja introduzida dentro do contexto dessa aplicação. Para fazer um exemplo funcional será preciso fazer conexões com a base de dados, e, para isso vamos precisar de um boilerplate um pouco mais parrudo. O artigo a seguir descreve a estrutura base que será usada.</p><p><a href="https://phpzm.rocks/php-deep-in-bootstraping-eh-um-sucesso-cea6db477437">PHP “deep in”: bootstraping é um sucesso</a></p><h3>Inversão de Controle</h3><p>Para fazer com que o <strong><em>Controller</em></strong> opere utilizando um <strong><em>Model</em></strong> é preciso que haja uma relação entre eles, o que, por conseguinte configura uma dependência do <strong><em>Controller</em></strong> para com o <strong><em>Model</em></strong> que irá utilizar. A comunicação entre classes na Orientação Objeto exige certos “cuidados”.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/62e32c57947ca5a8e6bf71662018bacd/href">https://medium.com/media/62e32c57947ca5a8e6bf71662018bacd/href</a></iframe><p>No exemplo acima vamos usamos o recurso de <a href="http://br.phptherightway.com/#dependency_injection"><strong><em>Injeção de Dependência</em></strong></a> através do construtor do <em>Controller</em> para oferecer uma sintaxe suave para o uso da classe.</p><p>Provavelmente algumas pessoas mais experientes poderão notar que seria possível incluir essa dependência diretamente no método que lida com o request, porém ficará mais claro adiante que não haverá métodos para cada request.</p><h3>Organizando a Festa</h3><p>Além de uma estratégia para compor a relação entre <strong><em>Controller</em></strong> e <strong><em>Model</em></strong> também é de bom tom estabelecer certos contratos no escopo do projeto. Para fins didáticos a abordagem da imagem abaixo será usada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/499/1*jGBp3WNkwniVHeICmgOReg.png" /></figure><p>Ou seja nosso <strong><em>Controller</em></strong> irá utilizar os métodos criados no model para suportar modificações tradicionais de uma entidade. Para não ter que escrever cada método toda vez vamos criar uma classe principal para gerenciar isso pra gente.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8fd0ff24dcb511f5c4bb951bceb88494/href">https://medium.com/media/8fd0ff24dcb511f5c4bb951bceb88494/href</a></iframe><p>Note que esta classe <strong><em>BasicController</em></strong> é abstrata. Este modificador faz com que ela não possa ser usada diretamente. Estamos usando esse recurso porque o que esperamos é que ela seja um provedor de serviços nos dando a opção de apenas entregar o <strong><em>Model</em></strong> para ela resolver as operações propostas. Temos ainda que destacar que os métodos poderão ser sobrescritos quando for necessário e que vamos querer que tudo seja resolvido dinamicamente.</p><h3>Confeccionando Modelos</h3><p>Não é incomum vermos ferramentas de automatização pra desenvolvimento de software. Geradores e anotações são algumas das práticas que vemos para poder agilizar os processos. Geradores são rápidos, mas podem gerar muito lixo e código duplicado. Anotações, por sua vez, são um pouco lentas porque precisam resolver abstrações sobre o código em tempo de execução. Como sempre um ponto de equilíbrio é o melhor caminho. Não devemos descartar possibilidades antes de testar e concluirmos por nós mesmos.</p><p>Um classe de modelo básica precisa prover métodos básicos para gestão da entidade a qual ela representa. Essa é uma prática tão famosa que recebeu um acrônimo: CRUD (create, read, update, destroy).</p><h4>Metadados</h4><p>Vou introduzir um assunto que não é muito discutido na programação de um modo geral, mas que pode ser de grande proveito para aumentar a produtividade e deixar com que sua aplicação se reconheça e processe os dados que você passa para ele de forma autônoma: Metadados.</p><p>Quando dizemos que usaremos metadados para compor uma classe estamos querendo dizer que vamos criar dados que informem-na sobre ela mesma. Vamos trabalhar com o exemplo de cadastro de cliente (um clichê) e vamos imaginar que teremos apenas 3 campos: nome, telefone, endereço. Todos esses campos são campos que irão se adaptar bem a serem persistidos como string (mesmo o telefone) e ficará mais simples de dar exemplos.</p><p>Utilizando o conceito de metadados vou manter na minha entidade não apenas o nome desse campo, mas também dados relacionados a eles. Sendo assim, além de o meu model saber que ele tem um campo chamado nome, ele também saberá que esse campo deve ser informado e que a quantidade máxima de caracteres informadas será de 50 caracteres (também por razões didáticas). Sendo assim meu model seria algo como:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d6b22f783e2334d40a472bd84655575a/href">https://medium.com/media/d6b22f783e2334d40a472bd84655575a/href</a></iframe><p>Com uma implementação como a feita acima seria possível que ao invés de fazer isso</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/697cb1642bdb9988388764b629e0184d/href">https://medium.com/media/697cb1642bdb9988388764b629e0184d/href</a></iframe><p>Fosse feito isso</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/40dd611b99b31da3677748d29f0c6dbb/href">https://medium.com/media/40dd611b99b31da3677748d29f0c6dbb/href</a></iframe><p>A principal vantagem dessa implementação é que ela deixa sua estrutura fácil de ser mantida. Para adicionar um novo campo bastaria colocar uma nova entrada no Model. Como nem tudo são flores você perde a rastreabilidade direta e passa a ter que compreender fluxos mais complexos para poder debugar a aplicação.</p><h3>Utilização dos Models nos Controllers</h3><p>Já vimos mais pra cima como injetar os <em>Models</em> nos <em>Controllers</em>, e, a seguir vou mostrar um protótipo de como faria uma execução de criação de um registro.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/98b6f6c811609655cd2858be49f928d0/href">https://medium.com/media/98b6f6c811609655cd2858be49f928d0/href</a></iframe><p>Este <em>Controller</em> estaria servindo uma API então o método <em>post</em> representa o verbo HTTP POST. Quando em uma API Restful usamos o método POST fica implícito que um novo registro será criado. A implementação do método create poderia ser algo como o demonstrado abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dd0055ea776d605fa157a798fe0650e7/href">https://medium.com/media/dd0055ea776d605fa157a798fe0650e7/href</a></iframe><p>Esta é uma abordagem que confronta diretamente propostas como os famosos <em>getters</em> &amp; <em>setters</em> e imprime em seu projeto um certo grau de complexidade. Entretanto como é possível perceber que esses dois métodos são agnósticos em relação à entidade (e talvez até a base de dados) o que permite que você não precise escrever esses métodos em todas as classes.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/224a158bb5059a3bdb66c17477f1e9a4/href">https://medium.com/media/224a158bb5059a3bdb66c17477f1e9a4/href</a></iframe><p>A classe <em>Person</em> não precisa saber como seus atributos serão usados, ela apenas os guarda para configurar os comportamentos da classe deixando que toda a parte de abstração seja feita pela hierarquia de classes que ela usa.</p><h3>Fluxos complexos</h3><p>O grande desafio de organização para que um projeto de software seja escalável e manutenível não vai estar relacionado às tarefas simples. Criar CRUD’s de forma rápida é simplório e automatizar essas rotinas não é mais um bicho de sete cabeças na maioria das linguagens de alto nível.</p><blockquote>Uma das coisas que eu mais vejo complicar o desenvolvimento de projetos de software é a parte de fazer com que módulos interajam entre si.</blockquote><p><a href="http://slides.com/wilcorrea/demanda-2-software">Regras de negócio</a> como “Atualize o status da última venda do cliente quando uma nova venda for realizada” exigem que a entidade Venda tenha alguma influência sobre a entidade Cliente. É muito comum ver isso sendo feito no <em>Controller</em>, contudo essa é uma prática arriscada. Como você lembra os controllers são responsáveis por lidar com HTTP sendo executados por alguma chamada baseada nesse protocolo. Neste caso, se eu fizer uso do método de criar novos registros disponível no <em>Model</em> sem passar pelo <em>Controller</em> posso ter uma inconsistência; terei um mesmo recurso sendo usado de forma a gerar efeitos primários diferentes.</p><p>Minha recomendação é: se toda Venda deve atualizar um Cliente não deve ser possível criar uma venda sem que isso aconteça. Pois bem, mas se o <em>create</em> está na classe <em>Model</em> e <em>Client</em> estende ela, como faremos? Neste ponto entra a ideia de eventos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fcd0f44abe1367777d48f2a8c9b83a4b/href">https://medium.com/media/fcd0f44abe1367777d48f2a8c9b83a4b/href</a></iframe><p>Desta forma poderíamos definir um método <strong><em>afterCreate</em></strong> na entidade que estaria representando a Venda para que ela disparasse a atualização na entidade responsável por Cliente. Sendo a entidade Venda a única capaz de criar uma venda a regra de negócio estaria implementada com louvor.</p><h3>Mapeamento Objeto-Relacional</h3><p>Usando Orientação a Objetos juntamente com bancos de dados relacionais é comum precisarmos decompor um objeto em uma ou mais tabelas. Nesse momento entra em ação a técnica de mapeamento objeto-relacional, aka ORM (Object-Relational Mapping).</p><p>Numa aplicação PHP que esteja alinhada com aquela figura que mostrei no início é comum vermos o uso do ORM diretamente relacionado aos <em>Models</em>. Ferramentas como o <a href="http://www.doctrine-project.org/projects/orm.html">Doctrine</a> e o <a href="https://laravel.com/docs/5.0/eloquent">Eloquent</a> permitem que a aplicação gerencie a coleção relacionada ao <em>Model</em> de forma transparente para o desenvolvedor.</p><blockquote>Note que quanto mais uma ferramenta faz por você, menos ela vai te deixar fazer. Então antes de iniciar a usar uma ferramenta avalie-a de forma consistente.</blockquote><p>Pegue os pontos que você acha mais críticos no segmento e tente fazer uma prova de conceito. Também não se acanhe em procurar por soluções próprias sabendo que há uma linha tênue entre “não reinventar a roda” e iniciar um novo motor a propulsão. Principalmente no que concerne aos <em>models</em> as possibilidades são infinitas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*P8HuIpmkXgXQqwlb.png" /></figure><h3>O que fazer para ir além</h3><p>O PHP nesse exato momento em que escrevo este artigo tem um abismo entre quem usa a linguagem sem usar ferramentas de mercado e quem as usa. Existe um senso-comum de que só é possível fazer coisas de qualidade se o desenvolvedor se tornar seguidor de algum framework e isto é um baita engano.</p><p><a href="https://github.com/phpzm/model">phpzm/model</a></p><p>Nesse repositório mostro diversas possibilidades quanto aos uso de modelos na sua aplicação e recomendo que antes de usar uma tecnologia você procure entender os conceitos por trás.</p><p><a href="https://martinfowler.com/eaaCatalog/index.html">Catalog of Patterns of Enterprise Application Architecture</a></p><p>Uso <a href="https://martinfowler.com/eaaCatalog/index.html">este link</a> como fonte de consulta frequente e neste momento ele se diz ter sido atualizado em 2003.</p><blockquote>Os conceitos de desenvolvimento não envelhecem, os códigos sim.</blockquote><p>Usamos ideias antigas com novas roupagens e não nos damos conta.</p><p>Este artigo demorou meses para ser escrito porque ele envolve diversos conceitos que precisavam ser esclarecidos e até estudados por mim para poder não escrever qualquer bobagem. Ainda assim se tiverem algo com que não concordam, por favor, deixe um comentário ou entre em contato comigo. A única coisa que espero é que você tenha dúvidas ao ler e que pesquise sobre termos e conceitos que não estão no artigo. Não se esqueça da série Deep-in e dos artigos anteriores sobre como usar PHP “like a boss”!</p><p><a href="https://phpzm.rocks/tagged/php-deep-in">Php Deep In - phpzm</a></p><p>A demora pode ter gerado alguma expectativa além do que eu havia imaginado para este artigo, mas na verdade ele é apenas um compilado de experiências e testes que fui fazendo ao longo dos anos em que atuo usando o PHP.</p><ul><li><a href="https://t.me/phpzm">PHP da Zona da Mata</a></li><li><a href="https://twitter.com/phpzm">PHP ZM (@phpzm) | Twitter</a></li><li><a href="https://www.facebook.com/zmrocks/">Grupo PHP da Zona da Mata - PHPZM</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc5eb164ee11" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/php-like-a-boss-5-trabalhando-com-models-bc5eb164ee11">PHP “like a boss” [5]: Trabalhando com Models</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Meetup: Minha Stack]]></title>
            <link>https://medium.com/phpzm/meetup-minha-stack-9df4bffaa530?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/9df4bffaa530</guid>
            <category><![CDATA[php]]></category>
            <category><![CDATA[meetup]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[stack]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Sat, 23 Sep 2017 15:23:41 GMT</pubDate>
            <atom:updated>2017-09-23T15:23:40.498Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7BvnzPa8Ll3Dvq_rzUK3RQ.png" /></figure><p>Depois de alguns meses no forno a ideia de fazer os encontros finalmente saiu do papel e no último dia 7 de setembro fizemos o primeiro meetup do PHPZM.</p><p>Depois de pensarmos um pouco em como começar os nossos meetups tivemos a ideia de os desenvolvedores falarem sobre o que usam no seu dia-a-dia. Nesse primeiro encontro eu falei sobre PHP “like a boss”, uma talk um pouco teórica, mas para despertar as boas práticas na galera e o <a href="https://medium.com/u/e1133e3aa640">Pedro Mázala</a> falou sobre Git (links no rodapé).</p><p>Abrimos 40 vagas achando que jamais chegaria nisso de inscritos e, num é que deu?! Presentes forma pouco mais de 20 pessoas, mas foi show.</p><p>Não levei nenhum exemplo prático e acabou que não consegui alcançar o meu objetivo de interação porque é difícil discutir sobre coisas abstratas, mas acho que consegui mostrar que o PHP não tá pra brincadeira e que é uma linguagem TOP.</p><p>O <a href="https://medium.com/u/e1133e3aa640">Pedro Mázala</a> tava cheio dos exemplos e a galera interagiu demais. Foi massa e ele nem terminou todos os slides já que o encontro começou as 16h com previsão de acabar as 18h e já eram quase 18:30h quando finalizamos.</p><p>Fizemos um lanche massa (thanks para a minha linda <a href="https://medium.com/u/a666df4f779c">Tatiana Aleixo</a>) e fizemos o sorteio dos brindes no terminal com um rand.</p><p>A experiência superou as nossas expectativas em muito e ficamos super satisfeitos! Se vai ter mais?! Claro que vai! Tá na agenda, dia 28/10. Olha lá no <a href="https://www.meetup.com/pt-BR/preview/phpzm-uba/events/zxlrrnywnbkb">site do meetup</a> para poder acompanhar : )</p><p>Abaixo umas fotos e links relacionados ao evento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nC5-sd6rHRJDC9CxUbuuRw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZOhVUGvcFoCOLcCQcVuIgw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IIFsQR2zAybue1bIxm3z_g.png" /></figure><ul><li><a href="https://docs.google.com/presentation/d/1hkEL0aL_qk46gS3g7Je-ip3s_zIAV9-m8lp1c_XcNI0/edit?usp=sharing">Press</a></li><li><a href="http://slides.com/wilcorrea/php-like-a-boss">PHP LIKE A BOSS - Explorando recursos da linguagem by William Correa</a></li><li><a href="https://www.youtube.com/c/GrupodePHPdaZonadaMata">Grupo de PHP da Zona da Mata</a></li><li><a href="https://www.meetup.com/pt-BR/preview/phpzm-uba/events/zxlrrnywnbkb">Minha Stack - Grupo de PHP da Zona da Mata (Ubá, Brasil)</a></li><li><a href="https://t.me/phpzm">PHP da Zona da Mata</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9df4bffaa530" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/meetup-minha-stack-9df4bffaa530">Meetup: Minha Stack</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sim, Precisamos falar sobre interface]]></title>
            <link>https://medium.com/phpzm/sim-precisamos-falar-sobre-interface-a90a19d33ca0?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/a90a19d33ca0</guid>
            <category><![CDATA[phpzm]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[javascript-rocks]]></category>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Thu, 03 Aug 2017 20:29:48 GMT</pubDate>
            <atom:updated>2017-08-07T00:10:11.558Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8g0x34duFk3bSmAGrduvCA.jpeg" /></figure><blockquote>Com o passar dos anos a web não só criou uma identidade própria como também está ditando o ritmo de toda a interação entre o usuário e as aplicações, usando interfaces interativas e inteligentes</blockquote><h3>Interfaces</h3><p>A interação entre usuário e máquina é tema de várias cadeiras na área da Computação, e, tem se tornado cada vez mais importante no mundo das aplicações. Detalhes triviais tornaram-se diferenciais e junto com outras áreas (como Inteligência Artificial) criaram ecossistemas que são capazes de cativar as pessoas mais exigentes.</p><p>Se compararmos as interfaces de hoje com os primeiros terminais interativos veremos o quanto a experiência de uso foi aprimorada, deixando claro o que ainda há porvir. Guiar o usuário para o “caminho feliz” é uma das grandes metas (ou deveria ser) de quem constrói telas, e, fazer isso de forma eficiente vai depender de usar todos os recursos disponíveis no navegador.</p><h3>HTML ^5, CSS ^3, ECMAScript ^7</h3><p>Se o público está mais exigente, é preciso pensar em atender a demanda crescente por interfaces inteligentes. Por conseguinte, para atender a necessidade de quem quer fazer interfaces impecáveis, as tecnologias tem precisado se manter frequentemente atualizadas.</p><p>Os avanços nas tecnologias da web tem impulsionado os navegadores e outras ferramentas a implementarem especificações cada vez mais rebuscadas que nos permitem trabalhar com interfaces que mudaram em 360° os pilares do desenvolvimento web. Em um exemplo simples, uma simples submissão de um formulário usando os modos tradicionais pode ser totalmente redesenhada usando recursos que as versões mais atuais do HTML (<a href="https://www.w3.org/html/"><em>atualmente no 5</em></a>) e do Javascript (<a href="https://www.ecma-international.org/ecma-262/7.0/"><em>atualmente na versão ES2016 / ES7</em></a>, caso eu não tenha perdido nada). Além disso animações e definições de estilo podem usar CSS (<a href="https://www.w3.org/Style/CSS/"><em>em sua versão 3</em></a>) em um nível tão absurdo de qualidade que algumas propriedades são delegadas de forma transparente para as GPU’s quando disponíveis.</p><h3>Como entrar nesse universo?</h3><p>Minha dica é: desista de atalhos. Não é incomum eu lidar com códigos de companheiros onde visivelmente tem trechos copiados e colados de snippets encontrados em pesquisa pela internet. Trechos que se repetem e que poluem os seu próprios projetos. Sob a desculpa da pressa e da urgência fazemos algumas coisas das quais não nos orgulhamos, só que ainda assim eu insisto: invista no futuro.</p><p>Tente procurar por projetos de outras pessoas, ler seus códigos, entender o que eles fazem; ache exemplos e transcreva-os a sua necessidade; ou seja, descubra suas necessidades e compreenda profundamente o que está fazendo. Nunca vi nenhuma pessoa reclamar de ter feito isso, já o contrário é bem comum de se ver.</p><h3>Notas importantes sobre JavaScript</h3><p>Atualmente temos algumas metodologias comuns do uso do Javascript para criar interfaces para web (geralmente baseadas em DOM — <a href="https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Introduction">Document Object Model</a>). Elencando o que é mais comum:</p><ul><li>Minimalista ~&gt; pequenas injeções de Javascript no corpo de páginas que são renderizadas totalmente pelo servidor. Essa abordagem é interessante e pode ser impecável em qualidade se os códigos javascript estiverem bem organizados. Evite deixar linguagens se misturarem sem um controle claro (isso serve pra vida);</li><li>Modificação manual do DOM ~&gt; uso de javascript para criar telas complexas gerando html através de concatenação de string. Geralmente essa abordagem é combinada com alguma coisa de ajax e costuma criar grandes peças de complexidade. Embora já tenha usado muito, recomendaria abortar projetos com essa metodologia; ela pode ser feita usando ferramentas (de terceiros ou próprias) que lidem melhor com isso;</li><li>Model–view–viewmodel ~&gt; manipulação do HTML através do JavaScript de forma transparente (também conhecido por 2-way-databind). Com essa técnica é possível entregar interfaces interativas com pouco esforço para os resultados obtidos. Comumente combinada a requisições assíncronas são obtidos efeitos bem interessantes do ponto de vista de usabilidade (com uma carga menor de efeitos colaterais);</li><li>MVVM com Virtual DOM ~&gt; é uma evolução da anterior, com o adendo de se preocupar com a performance com uma técnica que diminui os custos de se modificar o DOM;</li><li>Web Components ~&gt; a especificação de <a href="https://www.webcomponents.org/">Web Components</a> (<a href="https://www.w3.org/TR/#tr_Web_Components">W3C</a>) trata de manter as peças que compõe uma página como componentes auto suficientes que possuem mecanismos para interagir com os demais itens associados ao documento.</li></ul><p>Um desenvolvedor que queira criar interfaces de alta qualidade hoje, vai em algum momento ter que lidar com alguma dessas metodologias. Isso acontece porque para ter um ganho na relação usuário e aplicação é preciso modificar pequenas partes da página ao invés de recarregar tudo a cada interação, o que transforma o JavaScript em seu melhor amigo. Cabe a nós compreendermos qual dessas técnicas citadas melhor se adapta melhor ao que está sendo produzido.</p><h3><a href="https://medium.com/the-vue-point">The Vue Point</a></h3><p>Para poder mostrar como fazer interfaces impecáveis aqui no blog usaremos o <a href="http://vuejs.org/">VueJS</a> como ferramenta piloto. Obviamente que há razões pessoais envolvidas (é uma ferramenta que está sendo usada pelos membros da comunidade nos seus trabalhos), mas é importante salientar que embora seja possível enumerar motivos para se escolher essa ou aquela ferramenta, nada substitui a capacidade que a equipe que está trabalhando em um projeto tem de identificar o que é bom ou não para o trabalho fluir da melhor forma possível.</p><p>Estamos conversados então?! Interfaces são importantes e para abordarmos esse tema usaremos VueJS. Já está saindo do forno a série de vídeos que introduz a ferramenta e vamos ter artigos também para ajudar os iniciantes, curiosos e até os mais experientes trocando experiências e impressões do cotidiano.</p><h3>Sigam-me os bons!</h3><p>Fiquem de olho no nosso canal, converse com a turma no Telegram, siga o nosso twitter para saber das novidades (links abaixo). Críticas, sugestões e até xingamentos são interações válidas ; )</p><ul><li><a href="https://www.youtube.com/c/GrupodePHPdaZonadaMata">Grupo de PHP da Zona da Mata</a></li><li><a href="https://t.me/phpzm">PHP da Zona da Mata</a></li><li><a href="https://twitter.com/phpzm">PHP ZM (@phpzm) | Twitter</a></li></ul><blockquote>to code is to think, just it</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a90a19d33ca0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/sim-precisamos-falar-sobre-interface-a90a19d33ca0">Sim, Precisamos falar sobre interface</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A importância do seu ambiente de desenvolvimento]]></title>
            <link>https://medium.com/phpzm/a-importancia-do-seu-ambiente-de-desenvolvimento-4c8992cafe56?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/4c8992cafe56</guid>
            <category><![CDATA[php-code-sniffer]]></category>
            <category><![CDATA[phpmd]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[phpstorm]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Sat, 01 Jul 2017 15:32:19 GMT</pubDate>
            <atom:updated>2017-07-02T00:00:32.226Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QbkXcXUq7RUKYWv1u2DBwQ.png" /></figure><blockquote>Este é apenas um esboço sobre as inúmeras possibilidades de configurações que você pode fazer para conseguir ganhar produtividade e organização nos seus projetos sem ter que investir em ferramentas caras e/ou recursos extra.</blockquote><h3>O Problema</h3><p>Um profissional que trabalha com desenvolvimento de software escreve diariamente uma bela quantidade de código. Como em qualquer outra área o desenvolvimento de software não escapa de precisar de alguma revisão antes de ter o produto entregue ao cliente; porém nessa mesma área é possível perceber logo cedo um desafio: o que o cliente vê não é o que ele compra. O cliente paga pela solução; o valor de um programa é o que ele é capaz de fazer e não o como foi feito.</p><p>O fato de que na maioria das vezes o código gerado não é prioridade para o negócio em si acaba fazendo com que ele seja relegado a segundo plano. Na real existem muitos desafios sobre manter uma base de código de qualidade, e, isso é até um tema que gera inúmeras discussões.</p><p>Temos um problema então que é: como manter um nível adequado de qualidade do código produzido?</p><h3>O ambiente</h3><p>Não é incomum para quem está no mercado de trabalho ver novas tendências surgirem e desaparecerem. Ferramentas despontam, tornam-se referência, vão sendo vistas como medianas, até serem consideradas “ultrapassadas” tendo em vista que surgem novas formas de se fazer a mesma coisa. Mal comparando com a antropologia, é como se no início fossem usadas pedras, depois lanças, depois arco e flecha, a pólvora e assim sucessivamente. Quando se usa a nova tecnologia pensa-se em como se sofria sem ela, até que ela venha a ser substituída por uma melhor e o ciclo se mantiver.</p><p>De forma interessante, enquanto as ferramentas evoluem as formas de trabalho pouco se dilatam. Escrevemos código de forma muito parecida com a de nossos ancestrais. Configuramos algumas coisas básicas para poder criar algo para determinada plataforma e vamos trabalhando em cima disso. Teoricamente então todos os desenvolvedores que fossem trabalhar com uma certa plataforma teriam um mesmo ambiente.</p><p>Neste ponto percebemos que há ainda um fator que pode ser um diferencial: o ambiente de trabalho. Ainda que duas pessoas estejam atuando na produção para um mesmo resultado final é possível utilizar ferramentas adicionais para tentar ser mais produtivos em algum aspecto. A ideia dessa categoria de ferramentas adicionais é entregar uma camada extra de configurações e automatizações que acaba por ter esse viés de produtividade.</p><p>Na prática é como se um pedreiro tivesse que “bater” uma laje com sua pá e enxada, ou lançar mão do uso de uma betoneira. Um ambiente bem configurado pode ser a diferença entre um resultado ruim a mediano, para um trabalho de alta qualidade e desempenho. Obviamente que as ferramentas por si só não são a solução, mas é cada vez mais evidente que podem potencializar os resultados obtidos.</p><h3>As soluções</h3><p>Utilizando ferramentas categorizadas como <em>lint</em> (ou <em>linters</em>) é possível inspecionar os códigos a medida que são escritos e analisá-los programaticamente. Através de <em>linters</em> é viável avaliar a sintaxe e comparar com padrões já catalogados, detectando problemas em potencial. Considerando que um desenvolvedor sempre submeta seus produtos de trabalho a esse processo podemos considerar que o risco de ele escrever códigos com problemas será reduzido, e, consequentemente irá até trazer confiança quanto ao que está sendo produzido.</p><p>Cada plataforma vai ter um <em>set</em> de ferramentas para o chamado <em>tooling</em>. A linguagem Javascript, por exemplo, é famosa por ter um ecossistema abrangente de ferramentas enquanto outras linguagens não tem a mesma sorte.</p><p>Para o PHP vamos citar algumas ferramentas que usamos no nosso dia-a-dia para poder fazer esse trabalho de apoio aos nossos projetos.</p><h4>PhpStorm</h4><p><a href="https://www.jetbrains.com/phpstorm/download/">Download PhpStorm: Lightning-Smart PHP IDE</a></p><p>O PhpStorm é uma IDE para desenvolvimento de software na linguagem que lhe dá nome. Embora tenha suporte as tecnologias da web, seu aprimoramento para o PHP é um diferencial. A ferramenta não é gratuita, mas pode ser usada sob a licença <a href="https://confluence.jetbrains.com/display/PhpStorm/PhpStorm+Early+Access+Program">EAP</a>.</p><h4>PHP_CodeSniffer</h4><p><a href="https://github.com/squizlabs/PHP_CodeSniffer">GitHub - squizlabs/PHP_CodeSniffer: PHP_CodeSniffer tokenizes PHP files and detects violations of a defined set of coding standards.</a></p><p>Ferramenta que pode ser usada para analisar violações de padrões de código. Você pode usar padrões pré-definidos ou criar os seus próprios. É uma ótima opção para ser usada como <em>linter</em> no seu editor favorito.</p><h4>PHP Mess Detector</h4><p><a href="https://phpmd.org/">PHPMD - PHP Mess Detector</a></p><p>O PHP Mess Detector tem a tarefa de analisar detalhes avançados quanto a sintaxe do seu projeto. Ele vai avaliar uma bela lista de questões que incluem desde métricas de tamanho a análise de complexidade ciclomática. É uma ferramenta bem avançada e garante um nível alto de qualidade de código.</p><h4>PHP Coding Standards Fixer</h4><p><a href="https://github.com/FriendsOfPHP/PHP-CS-Fixer">GitHub - FriendsOfPHP/PHP-CS-Fixer: A tool to automatically fix PHP Coding Standards issues</a></p><p>Podemos ver o PHP CS Fixer como uma ferramenta case que é capaz de arrumar seu código; literalmente arrumar porque ele processa seus arquivos, e, além de achar os problemas ele também corrige uma boa variedade de problemas de sintaxe.</p><h3>Como usar tudo isso?!</h3><p>Criamos uma série de vídeos explicando como usar essas ferramentas em conjunto com o PhpStorm no Ubuntu. Todas elas são multiplataforma e podem ser usadas no Windows, Mac ou Linux com as especificidades de cada plataforma.</p><blockquote>Lembrando que essas são apenas sugestões do que se adequou para o ambiente de trabalho com o qual mais nos identificamos. Sempre recomendo a todos que testem e tirem suas próprias conclusões. Permita-se o direito da dúvida, já que um copo cheio só serve para transbordar.</blockquote><p>Segua a playlist com esse combo de configuração.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fvideoseries%3Flist%3DPLMpauGt6IneTZloQTENz7vYvue-poV-ue&amp;url=https%3A%2F%2Fwww.youtube.com%2Fplaylist%3Flist%3DPLMpauGt6IneTZloQTENz7vYvue-poV-ue&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FSW52gSxVhME%2Fhqdefault.jpg%3Fsqp%3D-oaymwEWCKgBEF5IWvKriqkDCQgBFQAAiEIYAQ%3D%3D%26rs%3DAOn4CLDAA8Y7wxLpZuJJh3MIjb0d5_XKwA&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="853" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/1a7e92b672d5a59fa1cde63b52ca20f5/href">https://medium.com/media/1a7e92b672d5a59fa1cde63b52ca20f5/href</a></iframe><p>Tem alguma dica? Ficou faltando alguma sugestão? Contribua com o artigo e deixe uma dica para todos : )</p><p>Se tiver dúvidas as configurações sobre as ferramentas citadas pode deixar nos comentários dos vídeos, aqui mesmo ou entrar em contato conosco pelos canais abaixo.</p><ul><li><a href="https://twitter.com/phpzm">PHP ZM (@phpzm) | Twitter</a></li><li><a href="https://t.me/phpzm">PHP da Zona da Mata</a></li><li><a href="https://t.me/phpbrasil">PHP Brasil</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c8992cafe56" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/a-importancia-do-seu-ambiente-de-desenvolvimento-4c8992cafe56">A importância do seu ambiente de desenvolvimento</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PHP “like a boss” em vídeo]]></title>
            <link>https://medium.com/phpzm/php-like-a-boss-em-v%C3%ADdeo-219aa09e0257?source=rss----77537e44543c---4</link>
            <guid isPermaLink="false">https://medium.com/p/219aa09e0257</guid>
            <category><![CDATA[php-development-env]]></category>
            <category><![CDATA[php-like-a-boss]]></category>
            <category><![CDATA[phpstorm]]></category>
            <category><![CDATA[php-development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[William]]></dc:creator>
            <pubDate>Wed, 14 Jun 2017 04:59:17 GMT</pubDate>
            <atom:updated>2017-06-14T04:59:17.118Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Efykfm94D2vywtxDRasFdQ.jpeg" /></figure><p>Oi pessoas! É isso mesmo que está escrito no título! Estamos começando uma série de vídeos baseada na série PHP “like a boss” que está sendo escrita aqui no blog (<a href="https://phpzm.rocks/tagged/php-like-a-boss">phpzm.rocks</a>).</p><p>Nesta primeira série vamos começar apenas configurando o ambiente. A ideia é deixar o PhpStorm preparado para programar com alta qualidade e produtividade e o Docker + Docker-Compose rodando lisos para levantar ambientes de forma rápida e ágil.</p><p>Para quem não sabe o que é apresentado no PHP “like a boss” é posto em prática no projeto chamado <a href="https://github.com/phpzm/simples">Simples</a>, que consiste basicamente numa coleção de pacotes para construção de projetos em PHP. É um trabalho que tem muito a evoluir, mas que nos dá muito orgulho e prazer em manter. A ideia da série de vídeos é apresentar a construção dessa ferramenta na prática, usando os artigos como referência, mas apresentado exemplos práticos da aplicação no mundo real.</p><p>Esperamos que este material seja de alguma ajuda para a comunidade PHP e desenvolvedores de um modo geral! Não esqueçam de deixar feedback&#39;s; qualquer coisa que deixarem de informação (mesmo interações como “curtir” e “não curtir”) nos ajuda a fazer um trabalho melhor.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FSW52gSxVhME%3Fstart%3D79%26feature%3Doembed%26start%3D79&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DSW52gSxVhME&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FSW52gSxVhME%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/70f425be3c6b970b66dae05a18739a70/href">https://medium.com/media/70f425be3c6b970b66dae05a18739a70/href</a></iframe><p>Se precisar tirar alguma dúvida ou quiser saber mais sobre PHP pode entrar em contato conosco! Vou deixar abaixo alguns links.</p><ul><li><a href="https://github.com/phpzm/simples">phpzm/simples</a></li><li><a href="https://t.me/phpzm">PHP da Zona da Mata</a></li><li><a href="https://t.me/phpbrasil">PHP Brasil</a></li><li><a href="https://www.facebook.com/pg/zmrocks/posts/?ref=page_internal">Grupo PHP da Zona da Mata - PHPZM</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=219aa09e0257" width="1" height="1" alt=""><hr><p><a href="https://medium.com/phpzm/php-like-a-boss-em-v%C3%ADdeo-219aa09e0257">PHP “like a boss” em vídeo</a> was originally published in <a href="https://medium.com/phpzm">phpzm</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>