<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Leonardo Felicissimo on Medium]]></title>
        <description><![CDATA[Stories by Leonardo Felicissimo on Medium]]></description>
        <link>https://medium.com/@leonardomartinsfelicissimo?source=rss-1cc082736bf3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*WcwSRncM5bm0tNnOMdg54Q.jpeg</url>
            <title>Stories by Leonardo Felicissimo on Medium</title>
            <link>https://medium.com/@leonardomartinsfelicissimo?source=rss-1cc082736bf3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 20:28:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@leonardomartinsfelicissimo/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Fontes Customizadas em Apps ReactNative (ReactNative CLI)]]></title>
            <link>https://medium.com/@leonardomartinsfelicissimo/fontes-customizadas-em-apps-reactnative-reactnative-cli-87529a806996?source=rss-1cc082736bf3------2</link>
            <guid isPermaLink="false">https://medium.com/p/87529a806996</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[react-native]]></category>
            <dc:creator><![CDATA[Leonardo Felicissimo]]></dc:creator>
            <pubDate>Sun, 30 Jun 2019 03:59:44 GMT</pubDate>
            <atom:updated>2019-06-30T03:59:44.330Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Dac-d7Uw6YAwmp1n.jpg" /></figure><p>Olá povo! Estou tentando encontrar formas de escrever mais sobre tecnologia, e acredito que a melhor abordagem é registrar meus proprios passos resolvendo os problemas que preciso resolver ou implementando certas funcionalidades.</p><p>Uma vez que o ReactNative é um framework (de fato um framework) para construir aplicações nativas usando React, seria normal entender que quando usamos um elemento de texto &lt;Text /&gt; a fonte utilizada será exatamente uma fonte padrão que esteja disponível no sistema operacional em que o nosso app vai ser executado. Isso também é exatamente o que acontece quando desenvolvemos para Web (com algumas outras variações, pois dependendo do sistema operacional as fontes podem ser diferentes) ou Desktop.</p><p>No entanto, há casos em que podemos desejar usar uma fonte diferente das fontes que já venham no sistema operacional e para estes casos será preciso preparar o App para utilizar estas fontes. É esse o processo que pretendo fazer para o aplicativo que estou desenvolvendo.</p><p>Neste caso, estou buscando uma fonte específica disponível no Google Fonts. Para que a fonte possa ser utilizada sem problemas, ela precisa estar nomeada no padrão PostScript. A nomenclatura Postcript segue o seguinte padrão: NomeDaFonte-Estilo. Por exemplo:</p><pre>Roboto-Regular<br>Roboto-SemiBold<br>Roboto-Bold</pre><p>Quando você utiliza uma fonte do Google Fonts, elas já se encontram no padrão Postscript. No meu caso, baixei a <em>Satisfy</em>.</p><pre><strong>Satisfy</strong>-<strong>Regular</strong>.ttf</pre><blockquote>Atenção: Aplicativos em ReactNative podem ser escritos utilizando o CLI do Expo, ou diretamente com o CLI do ReactNative (react-native init). Estou trabalhando com uma abordagem sem o expo (desde o início, é possível ejetar no meio do caminho), então se você estiver com um projeto a partir do expo, saiba que será um pouco diferente.</blockquote><p>É comum separar os arquivos estáticos dos arquivos de código organizado eles sobre o diretório assets. Vou seguir esse padrão, criando também o diretório fonts e Satisfy para deixar organizado caso pretenda em algum momento adicionar outras fontes. A estrutura da aplicação será assim:</p><pre>MyMobileApp<br>├── __tests__<br>├── android<br>├── assets<br>|   ├── fonts<br>|       └── Satisfy<br>|           └── <strong>Satisfy-Regular.ttf</strong><br>├── ios<br>├── node_modules<br>├── .buckconfig<br>├── .flowconfig<br>├── .gitattributes<br>├── .gitignore<br>├── .watchmanconfig<br>├── App.js<br>├── app.json<br>├── babel.config.js<br>├── index.js<br>├── metro.config.js<br>└── package.json</pre><p>Agora, uma vez que estamos adicionando um recurso estático à nossa aplicação o mesmo precisa ser linkado ao código nativo. O ReactNative já permite este tipo de adição que pode ser indicada no próprio arquivo package.json. Basta adicionar a seção rnpm indicando o asset que deverá ser linkado com o código nativo:</p><pre># package.json - adicione ao final do arquivo</pre><pre>&quot;rnpm&quot;: {<br>   &quot;assets&quot;: [&quot;assets/fonts/Satisfy&quot;]<br>}</pre><p>Em seguida precisamos executar o comando de link:</p><pre>$ react-native link</pre><p>Este comando copiará o nosso asset como um recurso dentro da estrutura de código nativo tanto de iOS quanto de Android:</p><pre>MyMobileApp<br>├── ios<br>|   └── assets<br>|       └── fonts<br>|           └── Satisfy-Regular.ttf<br>├── android<br>|   └── app<br>|       └── src<br>|           └── main<br>|               └── assets<br>|                   └── fonts<br>|                       └── Satisfy-Regular.ttf</pre><p>Por fim, vou criar um &lt;Text /&gt; e aplicar nele o estilo da minha fonte customizada:</p><pre>&lt;Text style={{ fontFamily: &#39;Satisfy-Regular&#39;, fontSize: 36 }}&gt;MyMobileApp&lt;/Text&gt;</pre><p>Para ficar, melhor resolvi usar o StyleSheet para criar um estilo específico para esse componente e o chamei de title. Ficou assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1ae2c45fa4c6de6367343ab8cc27be17/href">https://medium.com/media/1ae2c45fa4c6de6367343ab8cc27be17/href</a></iframe><p>E por fim, o resultado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*scuGhAPIenTxx8rtZ8p2yw.png" /></figure><p>É isso aí! Os passos para usar a fonte customizada são bem simples. Em casos de apps criados com Expo, é ainda mais simples, pois o próprio Expo possuí um componente chamado Font que deve ser usado para carregar a fonte que será utilizada previamente. Isso deixa o processo um pouco mais completo, pois, é necessário associar a renderização do componente ao carregamento da Font. Bem, para mais informações vale a pena consultar a própria doc do Expo: <a href="https://docs.expo.io/versions/latest/guides/using-custom-fonts/">https://docs.expo.io/versions/latest/guides/using-custom-fonts/</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=87529a806996" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Github Pages, Gatsby e Contentful, Hello Blogging World!]]></title>
            <link>https://medium.com/@leonardomartinsfelicissimo/github-pages-gatsby-e-contentful-hello-blogging-world-95ad43b93ca2?source=rss-1cc082736bf3------2</link>
            <guid isPermaLink="false">https://medium.com/p/95ad43b93ca2</guid>
            <category><![CDATA[gatsby]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[github-pages]]></category>
            <category><![CDATA[contentful]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Leonardo Felicissimo]]></dc:creator>
            <pubDate>Fri, 31 May 2019 07:11:00 GMT</pubDate>
            <atom:updated>2019-05-31T07:11:55.866Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1gqGYNaDus6cmOBq42NhYA.png" /></figure><h3><strong>Github Pages, Gatsby e Contentful. Hello Blogging World!</strong></h3><p>Quem me conhece sabe que sempre estou postando coisas no LinkedIn. Posto sobre aprendizados que tenho com tecnologia e a maioria destes projetos está relacionado com ideias que tenho. Uma vez que tenho uma mente imparavel, estive pensando sobre a melhor forma de nunca deixar uma ideia passar e registrar o passo a passo de ver isso acontecendo. Mas fazer isso no LinkedIn renderia muitas publicações por dia. Foi aí que um amigo meu, me sugeriu: Cria um blog mano!</p><p>Tenho um problema enorme com textos, pois escrevo demais, então tenho muitos textos escritos incompletos, e esse foi um dos motivos iniciais para não ter feito um blog ainda. Acredite, tenho um medium cheio de Drafts de textos de tecnologia. Mas quem sabe isso não pode ser um exercício! Objetivamente vamos lá!</p><h3>Github Pages</h3><p>Decidi criar o blog, mas surgiu a ideia onde hospedá-lo. Navegando pela internet a gente sempre percebe um <a href="http://github.io/">github.io</a> em algumas urls de bloggers de tecnologia. Portanto, decidi usar o <a href="http://github.io/">github.io</a> como primeira alternativa. O Github Pages que é o nome oficial do esquema de hospedagem github.io é uma alternativa de publicar conteúdo estático na internet a partir de um repositório do próprio github. Os passos são simples:</p><ol><li>Crie o repositório, siga o padrão: &lt;seu_usuario&gt;.<a href="http://github.io/">github.io</a>, no meu caso, ficou: leomfelicissimo.github.com;</li><li>Em seguida:</li></ol><pre> $ git clone <a href="https://github.com/leomfelicissimo/leomfelicissimo.github.io">https://github.com/leomfelicissimo/leomfelicissimo.github.io</a><br> $ echo “Hello World” &gt; index.html<br> $ git add . &amp;&amp; git commit -m “Initial Commit” &amp;&amp; git push -u origin master</pre><p>Voilá! Acesse: &lt;seu_usuario&gt;.<a href="http://github.io/">github.io</a> e você vai conseguir acessar e ver o conteúdo que você publicou em seu html, interpretado bonitinho como se estivesse sendo servido por um nginx, apache, iis e por aí vai.</p><h3>Gastby</h3><p>Ok. Tenho o <a href="http://github.io/">github.io</a>, mas agora preciso publicar conteúdo. Obviamente, resolvi utilizar uma tecnologia com a qual já sou confortável, assim como também para servir de portfolio. Foquei no React, que é o meu forte. Mas pensei, vou criar um blog, isso significa que terei conteúdos publicados ali, dinamicamente. É nesse momento, que você cogita utilizar um CMS, e pensar tradicionalmente num CMS é arrastar uma tecnologia toda complexa, que exige bem mais do que um <a href="http://github.io/">github.io</a>. Ele se torna só uma parte do processo. Eu teria que pensar em uma API de CMS, teria que pensar no conteúdo e toda uma estrutura o que levaria tempo desenvolvendo.</p><p>Foi quando me lembrei do Gastby. Que de certa forma é meio-mussarela, meio calabresa. Não porque é bagunçado, mas porque é um gerador de sites em React, que te permite gerar esse site, estático, mas a partir de um data source de dados. Ou seja, ele gera um site estático, mas no meio do processo ele é capaz de obter os dados a partir de uma fonte de dados externa para gerar estes dados estáticos no final. Isso é bom, porque me ajudaria e muito a ter um blog simples e rápido!</p><p>Pensei em utilizar o Gastby, mas me lembrei que deveria toda a vez criar um arquivo manualmente do post, escrever uma porção de Markdown, fazer git add, git commit, git push para ver o conteúdo online. E mais uma vez o processo ficaria mais simples, rápido, mas ainda massante. Preciso um CMS simples!</p><h3>Contentful</h3><p>O contentful é um gerenciador de conteúdo API-first que pode ser facilmente integrado com Gatsby. Na verdade, quando você decide utilizar o Contentful como CMS, ele mesmo já te permite uma configuração para usar o Gastby para gerar um site estático integrado ao conteúdo gerado pelo Contentful. Isto faz toda a diferença para um blog pessoal, pois além de simplificar todo o processo, ele com certeza ficará absolutamente rápido, pois o conteúdo não será lido de uma base de dados, ou caching e então renderizado do servidor, mas será gerado a cada deploy e existirá no <a href="http://github.io/">github.io</a> estáticamete. Lógico, isto possui perdas, para um projeto grande, não acredito ser o melhor caminho. Mas para o meu caso, cuja frequência é baixa, e pretendo construir o blog estático com React, essa estrutura é suficiente.</p><p>Após criar a conta no Contentful, o próprio contentful te direcionará para a melhor opção. No meu caso, escolhi a Deploy new website. Feito isso, o Contentful já me disponibilizará um starter para ser baixado, que possui o Gatsby como gerador e a integração ao Conteful como Datasource. Os passos para configurar o Contentful e o Gatsby estão nas instruções do próprio Contentful:</p><h4>Criar o novo repositório, no meu caso lmfblog.git e cloná-lo localmente:</h4><pre>$ git clone <a href="https://github.com/leomfelicissimo/lmfblog.git">https://github.com/leomfelicissimo/lmfblog.git</a><br>$ cd lmfblog</pre><h4>Fazer um clone do starter com Gastby do próprio repo do Contentful:</h4><pre>$ git clone <a href="https://github.com/contentful/starter-gatsby-blog.git">https://github.com/contentful/starter-gatsby-blog.git</a></pre><p>No caso do comando acima, estou clonando no diretório corrente.</p><h4>Instalar as dependências com o NPM ou Yarn</h4><pre>$ npm install</pre><h4>Executar o setup do Contentful usando o Token de sua conta</h4><pre>$ npm run setup — — spaceId &lt;seu_space_id&gt; — deliveryToken &lt;seu_delivery_token&gt; — managementToken &lt;seu_management_token&gt;</pre><h4>Executar localmente</h4><pre>$ npm run dev</pre><p>Todos estes passos estão disponíveis logo após criar sua conta no Contentful e criar um novo website. O passo final é o Deploy.</p><h3>Deploy</h3><p>Aqui tem um detalhe importante, ao fim do processo no Contentful, as únicas formas de publicação segundo o tutorial são para netlify e o heroku, mas eu tenho o meu próprio “servidor”, que é o <a href="http://github.io/">github.io</a>. Como fazer para substituir? Antes de tudo foi necessário criar um repositório a parte o leomfelicissimo/lmfblog.git este repositório, será onde ficará armazenado meu código React/Gastby/Contentful, a partir do qual posso editar a aparência, fazer alterações, adicionar novos data sources e funcionalidades. No repositório leomfelicissimo/<a href="http://leomfelicissimo.github.io/">leomfelicissimo.github.io</a>, estará apenas o código publico, que será disponibilizado ao usuário via Github Pages. Os passos finais então serão o seguinte:</p><h4>Gerar um build da aplicação (repo lmfblog):</h4><pre>$ cd lmfblog<br>$ npm run build</pre><p>É exatamente neste momento em que o processo de build se conecta no Contentful, obtém o conteúdo e gera o site estático.</p><h4>Copiar o conteúdo do diretório public para o repositório do Github:</h4><pre>$ cp -r public/* ../leomfelicissimo.github.io</pre><h4>Publicar o conteúdo gerado para o GitHub Pages</h4><pre>$ git add . &amp;&amp; git commit -m “Publishing new content to GH Pages” &amp;&amp; git push</pre><h3>Continuous Deployment</h3><p>Sim, é ruim demais ter que ficar fazendo npm run build, git add, commit, push toda a vez para publicar um novo conteúdo. É possível automatizar as coisas? Sim! É plenamente possível, mas para isso será necessário ir a fundo em outros conceitos, WebHooks do Contentful e uma ferramenta/app de CI para a publicação no repositório GH Pages, e isso acho melhor ser um assunto de outra publicação.</p><p>Té mais, se não continuo escrevendo!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95ad43b93ca2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introdução ao Jenkins com Build de WebApi em .NET Core]]></title>
            <link>https://medium.com/@leonardomartinsfelicissimo/introdu%C3%A7%C3%A3o-ao-jenkins-com-build-de-webapi-em-net-core-2bf8ce71386f?source=rss-1cc082736bf3------2</link>
            <guid isPermaLink="false">https://medium.com/p/2bf8ce71386f</guid>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Leonardo Felicissimo]]></dc:creator>
            <pubDate>Sat, 10 Jun 2017 03:56:30 GMT</pubDate>
            <atom:updated>2017-06-10T03:56:30.436Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/676/1*hE_6eVlhsJ2X63lF2pXj0A.png" /></figure><p>Em outro momento no meu Linkedin, e aliás, já comecei até a escrever por aqui, já abordei um pouco sobre como a cultura que se formou em nossa história influencia nossa tecnologia e é também moldada por ela. Nesse sentido, vivemos um tempo onde tudo é precisa ser feito com &quot;agilidade&quot;, velocidade, há um senso de imediatismo enorme em muitas pessoas do nosso tempo e isto se reflete em nossas soluções de T.I.</p><p>Uma vez que temos estruturas independentes, falando cada uma uma linguagem, cada qual com suas responsabilidades, ciclo de vida específico e estratégias de tolerância e consistência, precisamos de soluções que nos ajudem a organizar todo esse processo, automatizar tarefas como a execução de uma rotina de cópia de arquivos, criação de databases, instalação de binários como serviços e por aí vai. Fazer deploy de suas aplicações hoje não requer mais o velho copiar e colar, ou clicar inúmeras vezes em Publish. Aliás, tudo isso vem associado com uma rotina automatizada de execução de testes para garantir a maior qualidade possível no que vai ser publicado.</p><p>Não sou inexperiente com esse universo. Trabalhei há certa de 3 meses atrás por 4 anos mais ou menos (a época em que adotamos o modelo) com este processo de automatização usando Builds TFS e a ferramenta Release Manager da Microsoft. O Build era extremamente poderoso, o Release Manager era lento, mas dava pro gasto, e nossos processo de deploy estava cada vez mais automatizado, embora pudessemos ir muito mais longe com isso. Tenho lido bastante coisa sobre o assunto também (dentro de um mundo Microsoft), mas agora sinto estar na hora também de experimentar novos horizontes. Aqui o Jenkins se torna um diferencial. Pois, por ser open-source é uma solução muito mais barata do que o Microsoft VSTS, e você consegue facilmente instalar no seu computador. Como toda a solução lançada nos últimos tempos o Jenkins é uma Web Application.</p><p>Lembrando que os textos que venho postando por aqui tratam-se de um compartilhamento das minhas experiências de aprendizado e não representam aqui a verdade última compartilhada. Não pretende ser um tutorial, mas um registro da minha utilização das ferramentas, frameworks ou linguagens que utilizo.</p><h3>Jenkins, definição e instalação</h3><p>O Jenkis é uma solução criada em Java, isto significa que para executá-la é necessário ter uma JVM instalada, no site eles recomendam a versão 8. Você pode acessar o site para baixar a JRM <a href="http://www.oracle.com/technetwork/pt/java/javase/downloads/jre8-downloads-2133155.html">aqui</a>. Após isso, fiz o download do Jenkins no site. Aqui está o <a href="http://mirrors.jenkins.io/war-stable/latest/jenkins.war">link</a> para o próprio arquivo war.</p><p>Para quem não é do mundo de java (como eu), ter um arquivo com uma extensão assim deve ser no mínimo estranho. WAR em tese é semelhante a um arquivo JAR, ambos trata-se de &quot;pacotes&quot; com conteúdo de binários java. Um arquivo JAR (Java ARquive), é como uma dll. Para quem é do mundo Microsoft, é comum ter nossas classes, objetos, componentes reunidos nesse único arquivo binário ao qual damos o nome de Assembly. Agora, quanto ao WAR, imagine o pacote gerado após você fazer a publicação de um WebApp. Aquele resultado, compactado e reunido em um único binário, seria um arquivo WAR (Web Application ARquive).</p><p>Após baixar o jenkins e com a JRM devidamente instalada, basta abrir um Terminal ou Command, acessar o diretório onde o jenkins.war foi baixado e executar o seguinte comando:</p><p>LeonardsMacBook:Downloads leonardo$ java -jar jenkins.war</p><p>Feito isso o java fará a extração do conteúdo do WAR para o diretório home (do seu usuário) e criará uma senha aleatória para usar como usuário admin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/1*dubwpkNlMz2cqOvXlWX1qg.png" /></figure><p>Ao fim do processo você verá uma mensagem informando:</p><p>Jenkins is fully up and running</p><p>Após isto, o java disponibilizará o Jenkins no endereço: <a href="http://localhost:8080/">http://localhost:8080</a> e usar a senha exibida no prompt no processo de extração do jenkins.war.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eVbecIFznKJIYDLcNbGD0A.png" /></figure><p>Na próxima tela, será necessário escolher instalar o Jenkins com plugins sugeridos ou escolher os plugins a serem instalados. Uma vez que o Jenkins trata-se de uma solução que visa automatizar os processos de build, teste e deploy de aplicações ou serviços de diversas tecnologias, sua flexibilidade, não se dá automagicamente, mas devido a estes plugins desenvolvidos por terceiros e que permitem que o jenkins reconheça diferentes frameworks, linguagens e possa utiliza-los no processo. Os plugins são recursos que podem ser adicionados para permitir funcionalidades para diversas áreas dentro do Jenkins: Organização e administração, funcionalidades de build, ferramentas de build, análise e relatório de builds, pipelines (processos de execução, com uma série de comandos executados sequencialmente) e continuous delivery (automação de deploy), gerenciamento de código-fonte, builds distribuidos, gerenciamento de usuários e segurança, notificações e deploy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wfn9oYOB20x2J1cDiyJIjQ.png" /></figure><p>Ao usar a opção de selecionar os plugins, percebi que o plugin de NodeJS para Jenkins estava desabilitado. Este plugin acrescenta ao processo de build do Jenkins uma nova possibilidade (step), que é a execução de um script NodeJS. Acredito que sem esse plugin, por exemplo, não seria possível automatizar o deploy de um serviço escrito em NodeJS. Outra coisa que me pareceu interessante é que logo acima do plugin NodeJS, existe a opção de incluir também a execução do MSBuild para compilar projetos .NET. Dois importantes plugins que não são instalados por default.</p><p>Em Source Code Management, instalei também o plugin para o GitHub. Percebi também ali um plugin para integração com o TFS. Após isso, é só aguardar a instalação completa. Após isto, uma tela será exibida para a criação do primeiro usuário admin. Em meu caso, descartei, usando a opção &quot;Continue as admin&quot; e assim para logar na administração do jenkins, precisarei utilizar o usuário &quot;admin&quot; e a senha fornecida na instalação. Após isso, já é possível acessar o Dashboard de Jenkins.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SQeUO9lGkz9Kj04fEQAUOg.png" /></figure><h3>Criação e Configuração do primeiro Job/Pipeline/Project</h3><p>Dentro do Jenkins encontro uma pequena contradição com nomenclaturas. Aparentemente um Job é a definição de um processo de Build baseado em um SCM (Source Control Management). Mas segundo o site do Jenkins, o coração de tudo é o Pipeline, um processo onde vamos agregando uma porção de plugins que ajudarão a compor o cenário de automatização do build. Create New Pipeline ou Create New Jobs? Acredito que o Job é algo mais isolado ou um cenário mais simples de automação, enquanto o Pipeline trata-se de um cenário mais complexo chegando a envolver uma série de plugins e até multiplos branches.</p><p>Estou indo na contra-mão do que está no tutorial do site do Jenkins em dois sentidos. 1) Ao clicar seja em Create New Jobs ou New no menu lateral iremos para a mesma página de criação de um novo Job (ou pipeline segundo o site).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KD6sw8AgwToG-3DtPZlKjw.png" /><figcaption>Página de Criação de um Novo Job</figcaption></figure><p>Aqui, não pretendo seguir o que foi descrito no tutorial. A idéia no tutorial é criar um pipeline usando a opção Multibranch Pipeline. Esta opção permite um build muito mais completo baseado na estrutura de repositórios do SCM indicado. Ele é capaz de identificar os branches e criar automaticamente um script a partir disto.</p><p>Para o meu caso acredito que o Freestyle project é suficiente pois trata-se de uma opção de automatização bem mais simples.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jhMjexH-YcgLjwKtmrOqPA.png" /></figure><p>A página inicial do Job permite diversas configurações e nada tão diferente do que já pude lidar com o contexto do TFS Build. Na primeira aba algumas configurações específicas sobre o projeto (agora não é mais Job, nem Pipeline, é project. Mas também é configuração do job, conforme o endereço da página) do job, desabilita-lo, indicar integração com o Git, paralelismo de builds. Embora no print acima eu já tenha clicado na opção &lt;Advanced&gt; ela está presente com uma série de opções. Uma delas bem interessante, é a possibilidade de repetição em caso de falha.</p><p>As outras abas, apresentam diferentes configurações quanto a definição do Source Control, agendamento de disparos do build (triggers) que indicam quando ele deve acontecer, uma opção interessante de iniciá-lo a partir de scripts externos e finalmente a Aba Build, onde pode ser definido algum processo que deve ser executado no build. Aqui aparece a primeira opção que selecionei logo na instalação ao adicionar o plugin para o Node. Caso seja necessário executar algum script NodeJS no processo do Build, agora é possível fazê-lo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/323/1*F1ULpTdQAwyqXBWJ9lQqUA.png" /></figure><p>Por ultimo, se tem o Post-build Actions, que trata-se de uma indicação do que deve ser feito imediatamente após o build. Uma notificação de email, exlcusão de workspace, publicar um report de TestUnitário ou ainda mudar o status de um commit do git. A integração com o Git acontece em cada etapa.</p><h3>Jenkins e automação de build com git local</h3><p>Então vem a primeira dificuldade. Preciso configurar o Jenkins para obter o código-fonte para o build. A única opção disponível é URL com Git. Quer dizer então que não é possível fazer build de um código local? O Jenkins precisará realizar operações no repositório, então antes de tudo precisa haver um repositório, e o modo como referenciar isto é por meio de um endereço. No entanto, se o caso for semelhante ao meu, onde o meu servidor de build é o servidor de desenvolvimento onde o código de produção está rodando (rsrs), será necessário indicar o diretório físico por meio da url utilizando file:///:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KnpRgcVKH05nfqX-mbiHMg.png" /></figure><p>Salvo, e no menu lateral seleciono a opção Build Now. É necessário fazer ao menos um build pra ver tudo acontecendo. Este possivelmente é o gatilho para executar o git clone no repositório associado ao build. O build então é executado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v4E1BLu6LSzqRu8XXNp2jw.png" /></figure><p>Nada aconteceu senão o fato do Jenkins inicialmente clonar o repositório. E então já é possível visualizar o workspace que será &quot;buildado&quot;:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WN5M6ACCPGChJ1pcpDh3iA.png" /></figure><p>Mas, até o momento não há nada para executar, pois não foi acrescentado nenhuma atividade de execução.</p><h3>Executando Build de .NET Core com Jenkins</h3><p>Aqui é o segundo diferencial do tutorial do Jenkins. Os exemplos de Jenkinsfile (a configuração do Jenkins que fazemos no dashboard e que pode ser feita por meio deste arquivo) são de linguagens como Java, Python, Ruby e NodeJS. Mas fui obrigado, por conta do projeto que estou construindo a utilizar o .NET Core. Aqui vem a novidade. Não faço a menor ideia se isso realmente vai funcionar, mas vamos lá.</p><p>Uma vez que não faço a menor ideia se o plugin do MSBuild funcionaria para .NET Core, então vou tentar fazê-lo com o shell mesmo. Considerando que em um ambiente de produção utilizando Jenkins, o Docker sem dúvida estará presente, portanto, posso contar com uma imagem oficial Microsoft linux que execute código do .NET Core. Usando shell fica assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JwgdYisy0300CqAIe-ArTw.png" /></figure><p>Vamos ver se funciona. Sim, estou fazendo o teste neste exato momento. Acompanho no Build History. A barra fica azul, de repente vermelha, e estou aguardando problemas enquanto tiro um print:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*009R0te9WnD4_anCXQrRHQ.png" /></figure><p>Clico no Build #3 e vejo que está indo tudo bem:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dj4zsJN7dEXhpMw_w8MAbg.png" /></figure><p>E então, funcionou! hahahahaha Show de bola!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C3iHsgqlZRgMNI-V6ToV9Q.png" /></figure><p>Agora é codificar mais, fazer o commit, e iniciar uma segunda fase, que é o teste unitário e há soluções muito mais complexas de CD/CI as quais podemos aplicar o cenário do Jenkins, principalmente se considerarmos a possibilidade de escalar e replicar o próprio Jenkins. Obviamente que, para que tudo funcione corretamente, o Jenkins precisa ser executado a partir de um contâiner ou VM sempre ativos. Mas o processo foi prático, a ferramenta é muito intuitiva e o melhor de tudo: GRATUITA!</p><p>Gostou do conteúdo? Clique no coração e recomende o texto para sua rede. Minha iniciativa envolve o compartilhamento do meu processo particular em conhecer novas tecnologias e espero que isso seja um diferencial para todos que acessarem. Conto com vocês! :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2bf8ce71386f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[API RESTFul com NodeJS (Dev ao Deploy) — Parte 1]]></title>
            <link>https://medium.com/@leonardomartinsfelicissimo/api-restful-com-nodejs-dev-ao-deploy-parte-1-f241b5c59a1c?source=rss-1cc082736bf3------2</link>
            <guid isPermaLink="false">https://medium.com/p/f241b5c59a1c</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Leonardo Felicissimo]]></dc:creator>
            <pubDate>Mon, 05 Jun 2017 15:06:08 GMT</pubDate>
            <atom:updated>2017-06-05T15:53:39.875Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CSElhR5gv4pOaN_zMAVu2g.png" /></figure><p>O aprendizado de uma nova tecnologia é um desafio. Pois, trata-se da imersão em uma nova sintaxe, organização, bibliotecas e etc. Ainda sou daqueles que acreditam no jeito antigo de aprender algo novo. Gosto do papel, gosto de texto. Vejo hoje em dia uma enxurrada de tutoriais em forma de vídeo, com pouco tempo de exibição. Isto não cobre as dificuldades, e problemas que cada um pode encontrar no trajeto de entrar no mundo de outra tecnologia. Se você gosta de vídeos. Ok. Mas nada como um bom texto que dê certo detalhe sobre aquilo que você quer aprender.</p><p>Este artigo é fruto da minha própria experiência de aprendizado. E compartilho aqui cada etapa baseado no que pretendo fazer. Isso significa que vou registrando pouco a pouco minha experiências e um pouco do conceito envolvido no que fiz para estudo e claro, uns questionamentos ácidos para dar aquela provocada.</p><p>Uma vez que ser professor é parte do que amo fazer, pretendo compartilhar minha própria experiência de um modo didático para que outros possam tirar certo proveito do material que construir aqui.</p><p>Antes de tudo, vamos delimitar os conhecimentos. Uma vez que estes textos baseiam-se na minha experiência de aprendizado, há coisas que não pretendo trabalhar com detalhes aqui, pois trata-se de algo que já conheço, então se você está acompanhando é bom que tenha um certo conhecimento sobre:</p><ol><li>Programação</li><li>RESTful</li><li>Banco de Dados</li><li>JavaScript</li><li>Conhecimentos Básicos (Ouvir falar): NodeJs</li></ol><p>Meu ponto de partida é a experiência que já tenho com JavaScript até sua versão segundo ES8. ES de ECMAScript, que era originalmente o JavaScript criado por um desenvolvedor da Netscape e que com o tempo teve sua variante desenvolvida pela Microsoft, o JScript, o que trouxe a necessidade de uma padronização das keywords, sintaxe, operadores e funcionalidades. Muitas versões se seguiram daí em diante, padronizada para a maioria dos navegadores, menos para o Internet Explorer, é claro (pois, quantas vezes ao desenvolver um script nos deparamos com problemas de compatibilidade). Enfim. Não vou gastar tempo aqui, compartilhando minhas experiências com o JavaScript, mas sim na utilização do NodeJs e no processo de desenvolver até fazer o Deploy.</p><h3>Hands-on: Baixando e Instalando NodeJs</h3><p>Antes de tudo, foi preciso baixar o NodeJs do site <a href="http://nodejs.org/">nodejs.org</a>. Obtenha ali a última versão e instale com o bom e velho Next, Next, Finish.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/763/1*8XZmBSqV8GxO3r7PD73zUA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*kSe8kW-EsTl3zD0eoHABWQ.png" /><figcaption>NodeJs e Npm o Node Package Manager</figcaption></figure><p>Após instalado chegou a hora de começar a brincadeira. Criei um diretório usando o mkdir, cd, ls etc, atribuindo o mesmo nome do meu repositório e como acho que deve ficar a estrutura no Git.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/651/1*_6huDREKtQF40pqqg2lHyQ.png" /></figure><p>Aqui um ponto importante. Tenho aprendido que devo colocar tudo no Git! É um registro da minha experiência comprovada disponível publicamente para que qualquer um possa avaliar. Isto é importante, acredite. Perca a vergonha e comece a publicar suas POCs projetos no Github, isto é importante para sua carreira profissional.</p><h4>npmjs: Node Package Manager</h4><p>Após isto, chega a hora de conhecer o npm. Já tinha visto alguma coisa e portanto não era algo muito desconhecido para mim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/1*HbMz2LsRvj1S_2TXmoU7Hw.png" /></figure><p>Junto com o NodeJs, encontramos um outro aplicativo que também já está instalado e disponível chamado NPM. Trata-se de um gerenciador das dependências do seu aplicativo. Por meio do npm, você pode instalar novos pacotes que tratam-se de códigos compartilhados de outros desenvolvedores. Imagine que você cria uma “biblioteca” (um módulo) e deseja compartilhar isto com outros desenvolvedores que possam a utilizar. O npm gerencia e organiza este processo, desde a publicação e a instalação em uma máquina local. Há pacotes de todo o tipo para o desenvolvimento de aplicações FrontEnd e BackEnd, os principais frameworks e bibliotecas encontram-se disponíveis no npm, de modo que hoje em dia é muito difícil ler ou assistir um tutorial sobre desenvolvimento Web e não ter uma referência ao npm. Além disso, o npm cria um arquivo local chamado packages.json, onde armazena informações sobre seu próprio aplicativo e suas dependências. Isto ajuda e muito na gestão de dependências do nosso aplicativo. Algo semelhante também encontra-se disponível no ambiente Microsoft, o NuGet. Com o adendo da gestão das dependências (neste caso se assemelha ao conceito dos arquivos yml do Docker). O npm dispões de diversos comandos utilizados para o gerenciamento de pacotes, desde a construir seu próprio pacote, até criar um novo e publicá-lo no próprio npm, avaliar, adicionar permissionamento, instalá-lo localmente e etc. Algo também muito interessante sobre o npm, é que ele possui um gerenciamento de pacotes baseado em uma estrutura de dependência, o que embora, torne o diretório de sua aplicação muito maior, traz também a garantia de que tudo funcionará corretamente.</p><p>Este foi um ponto negativo que encontrei sobre o npm. Porque um módulo pode ter inúmeras dependências e tudo isso é baixado. Isto prejudica por exemplo estruturas de microserviços em nuvem, pois, você acabará gastando mais com storage. Por isso, o npm é geralmente indicado para utilização junto a desenvolvimento BackEnd, enquanto que, para desenvolvimento FrontEnd sugere-se a utilização do bower (descontinuado este ano) ou o yarn (depois posso escrever algo sobre).</p><p>Após esta breve descrição do npm, vou usá-lo. Primeiro, de tudo executo o comando init.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*RFSwCkUizqiL6rg2SkiRyQ.png" /></figure><p>Em tese, não seria necessário, uma vez que não estou criando uma biblioteca para ser reutilizada como um node module e isto é apenas uma POC. No entanto, ainda que não seja inicialmente pública, não deixa de ser uma biblioteca e portanto, possui uma versão, um nome, um repositório e dependências que são configurações básicas do arquivo packages.json gerado pelo npm, após o comando init. Este comando, tem o objetivo de auxiliar na criação deste arquivo *.json que descreve o módulo que estou criando, e assim a qualquer momento em que disponibilizar meu código, ele será encontrado e reconhecido por estas configurações.</p><h3>NodeJs: O bom e velho Hello World</h3><p>Algumas informações importantes que aprendo com esta trajetória de conhecer o NodeJs. Compilei elas em uma lista de características principais sobre o que é o NodeJs.</p><h4>1. É basicamente um Web Server</h4><p>Isto significa que acima de tudo ele mesmo é o responsável por &quot;servir&quot; a página como resposta de uma requisição feita via http por um cliente. A novidade que ele apresenta, é o fato de que até então as linguagens que rodavam código no servidor eram: PHP, Java, ASP.NET, Ruby. Mas o JavaScript sempre era a linguagem para manipular dados entregues no lado cliente. O NodeJs entra na jogada como um servidor capaz de interpretar código JavaScript a partir do próprio servidor e servir a pagina conforme estas regras. Do ponto de vista do NodeJs, cada app é seu próprio servidor.</p><h4>2. É Single Thread</h4><p>Isto significa que não há paralelismo em uma instancia de NodeJs. A simulação de sua &quot;assícronicidade&quot; se dar por ser orientado a eventos. No caso de minha aplicação ser por exemplo multthreading, com diversos processos acontecendo ao mesmo tempo dentro de uma única instancia de serviço, será necessário uma nova instancia de NodeJs e assim por diante. Embora isto pareça estranho, quando consideramos o que de fato é um microserviço, temos que conceder razão ao criador da idéia. Pois, esta independência faz parte do que entendemos ser uma boa estratégia de segregação de serviço, delegação de responsabilidade, bounded contexts, e a formação de uma solução que seja altamente escalável e disponível por meio de Container ou uma VM na nuvem.</p><h4>3. Usa a engine de JavaScript V8 do Google</h4><p>Esta engine do Google, como o próprio site diz, é responsável por compilar e executar em C++, garantindo alta-performance, alocação de memória no servidor e semelhante ao .NET, um sistema inteligente de limpeza de endereços de memória que foram ocupados e não foram devidamente liberados, um Garbage Collector. Para saber mais sobre, é bom adicionar a lista de leitura o site do <a href="https://developers.google.com/v8/">V8</a>, é o que estou fazendo agora.</p><h4>4. Por utilizar a V8, compila o código para código nativo de máquina</h4><p>Isso significa que o JavaScript torna-se uma linguagem intermediária, interpretada, assim como o Python, por exemplo, dependendo de uma outra estrutura responsável por executar o código, digitado em JavaScript</p><h4>5. É multiplataforma</h4><p>Não depende de uma plataforma específica para rodar, mas abrange todas as plataformas, e sendo completamente isolado como WebServer, exclui algumas dificuldade, que algumas stacks ainda tinham conforme sua plataforma. Por exemplo, o PHP no Windows, o .NET no Linux (antes do .NET Core é claro. Os textos que li são textos contextuais e mais antigos).</p><p>Há muitos bons editores que poderia usar para trabalhar com o NodeJs pelo visto. Vi, Emacs, são mais para os conservadores eu acredito. Sublime, sempre brinco que é uma poderosa ferramenta para os PHPzeiros. Eu, por vir de ambiente microsoft, não poderia escolher outra coisa. Visual Studio Code. Uma ferramenta excepcional com recurso de AutoComplete, extensível, e que acrescenta de modo inteligente pré-configurações para que eu possa fazer o debug da minha aplicação.</p><p>O exemplo não é nada demais, e nada diferente do que você pode ter visto rolando por aí na internet, nos inúmeros tutoriais e até vídeos:</p><p>Abro o meu Visual Studio Code, inicio um novo arquivo o salvo como app.js e começo a codificar.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bfc55b11035f868e9dab920b203a1de2/href">https://medium.com/media/bfc55b11035f868e9dab920b203a1de2/href</a></iframe><p>Para executar, bastou ir até o diretório da aplicação e executar o commando: node app.js. Qual o resultado? Nada! Nada foi exibido no navegador e menos ainda notificado.</p><p>Este é o problema da ausência de um compilador. Algo errado aconteceu, mas o código foi executado primeiro para depois na execução da linha apresentar a falha. É estranho porque ao mesmo tempo se você errar na sintaxe, e tentar executar, um erro será exibido imediatamente. Erro de sintaxe aparentemente são identificados e alertados imediatamente após a execução, mas os nomes de variáveis e objetos são são validados na execução da rotina em que se encontram. Estranho. Mas possivelmente há uma explicação bem coerente para isto, talvez compreender melhor o modo como o &quot;node&quot; executa o código. Ao trabalhar com uma linguagem interpretada deste modo, ganhamos a agilidade, facilidade no deploy, mas inevitavelmente precisamos ser mais críticos quanto a qualidade, e ter uma estratégia de testes bem definida.</p><p>Volto para o Code e percebo um registro do problema no Console:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/786/1*vp0P0HJfXni9i-RBFmpn_g.png" /></figure><p>Repare que o NodeJs, registrou no console o Stack Trace, e apontou diretamente o problema: A falta do &quot;s&quot; na instancia de nome: response. Corrigido, vamos ver se obtenho o meu texto Hello Word.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/546/1*bI9Uu5UD7somWtUWEdOGgA.png" /></figure><p>Feito. Simples, rápido e prático. JavaScript no servidor. Com isso já é possível fazer uma API usando algo semelhante a isto:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f093f2feb2ed428e2e0fc2e16bc8a5dc/href">https://medium.com/media/f093f2feb2ed428e2e0fc2e16bc8a5dc/href</a></iframe><p>Uma WebApi é nada mais nada mesmo do que um servidor atendendo a requisições HTTP respondendo conteúdo JSON. Este é o mecanismo comum de um site por exemplo, ao fazer um request de uma URL para um servidor, estamos na verdade obtendo um arquivo do tipo &quot;text/html&quot; que encontra-se salvo no servidor. O cabeçalho indica o tipo para que o navegador faça a exibição baseada no conteúdo. No caso da Api, ela retorna os dados em JSON. Seria necessário criar uma porção de outras funcionalidades, como por exemplo a identificação das rotas. Neste caso estou usando um <em>if </em>para fazê-lo, o Django (Python) por exemplo, possui um arquivo urls.py no qual você define suas rotas usando Regex. O .NET deixa isto encapsulado através de suas próprias máscaras, no seu RouteConfig. Cada linguagem em tese, possui um servidor que atende as requisições, identifica as rotas (os caminhos, url), executa o que deve ser executado e devolve o conteúdo no formato que o Client necessita.</p><p>Contudo, não precisamos reinventar a roda nesse nível. Já existe um framework, ou melhor, web framework, que implementa uma porção de facilidades para atender requisições http e respondê-las. É aí que entra o famoso Express.</p><p>Bem, não sou expert em NodeJs, até este momento na verdade estou aprendendo tanto quanto você que está lendo. A diferença é que decidi compartilhar meu processo de aprendizado e minhas reflexões baseadas neste processo. Vamos seguir em frente, que aprender é sempre bom e vem muito mais por aí. Se gostou, click no coração e recomende :)</p><p>Abraços e até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f241b5c59a1c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C# Scripting: Desenvolvimento, testes e estruturas mais simples sem compilação]]></title>
            <link>https://medium.com/@leonardomartinsfelicissimo/c-scripting-desenvolvimento-testes-e-estruturas-mais-simples-sem-compila%C3%A7%C3%A3o-f509ea76a780?source=rss-1cc082736bf3------2</link>
            <guid isPermaLink="false">https://medium.com/p/f509ea76a780</guid>
            <category><![CDATA[microsoft]]></category>
            <category><![CDATA[visual-studio]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[script]]></category>
            <dc:creator><![CDATA[Leonardo Felicissimo]]></dc:creator>
            <pubDate>Mon, 15 May 2017 03:33:54 GMT</pubDate>
            <atom:updated>2017-05-15T03:35:51.749Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*j1_usRxKWNceaUaz.jpg" /><figcaption>Imagem de: Udemy</figcaption></figure><p>Não, não é um erro de digitação. Mas de certa forma, também quis dizer, sem complicação.</p><p>Uma das características que mais me chamaram atenção dentre o que tenho aprendido de tecnologia nos últimos tempos é o <em>Scripting</em>. Uma linguagem script é uma linguagem que permite a criação de programas simplificados, e porque não dizer, métodos isolados que possam ser executados por uma run-time ou serem embutidos em outros programas. Uma linguagem scripting, é em sua maioria interpretada. O que significa que ela é lida e executada por um programa pré-compilado. Um exemplo muito simplório seria algo do tipo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*YKdgfudWm53YhD5bcpYKCg.png" /><figcaption>Código-fonte: <a href="https://dotnetfiddle.net/156zHL">https://dotnetfiddle.net/156zHL</a></figcaption></figure><p>O programa acima foi criado em C#.NET. A ideia foi simular como um interpretador trabalha. No caso do exemplo, criei um Console que lê um código Python da linha de comando, e executa. Para fins de exemplo, codifiquei apenas como seria a interpretação da função <strong><em>print</em></strong>. Mas podemos dizer que o que acontece com um código interpretado é exatamente a mesma coisa. O programa criado em uma linguagem compilada, faz a leitura de uma determinada sintaxe, obtida seja por linha de comando ou pela leitura de um arquivo e realiza a execução no código compilado. O Python por exemplo, é uma linguagem interpretada por um programa em C. Atualmente existem muitos outros interpretadores para Python, como por exemplo, o IronPython, criado em C#.</p><p>Uma das coisas que mais me fascinaram ao começar a estudar o Python e desenvolver um projeto pessoal com ele foi a experiência de não haver a necessidade de compilá-lo. De ser completamente interpretado e poder ser executado, por exemplo do prompt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/675/1*KqgG0jxQy5ZPIgqK-llFgA.png" /></figure><p>Se tinha alguma dúvida a respeito de qual seria o resultado para um método, se precisasse validar a lógica do que estava desenvolvendo ou simplesmente testar um algoritmo para utilizar, fazia isso diretamente na linha de comando. Este é o poder do <strong><em>scripting</em></strong>.</p><p>Ainda mais interessante foi o fato de que depois que meu projeto estava em produção, qualquer alteração que precisasse realizar era muito simples de ser publicada. Com o <em>git</em>, eu realizava um <em>commit</em> do novo código, conectava em meu servidor via shell, obtinha o arquivo que havia acabado de atualizar e simplesmente executava o comando <em>touch </em>no shell do linux para indicar a atualização do arquivo e forçar o recarregamento do site no apache. Fim de papo. Estava atualizado. Exatamente como um javascript qualquer, mas executando o código em uma “runtime” poderosa, rápida e robusta.</p><p>Claro, não podemos deixar de considerar, que há perigos em uma linguagem não compilada. A linguagem compilada pelo seu conjunto de regras, se torna mais segura de erros. Em todo o caso, é preciso dosar a tecnologia para cada contexto onde melhor ela se aplica. Fazendo isto, sem dúvida obteremos o melhor resultado.</p><p>Esta experiência com o Python, me trouxe uma reflexão importante sobre o desenvolvimento de uma forma mais simplificada. Ela fez questionar sobre até que ponto, por vezes, não estamos usando algo muito poderoso para processos simples. Toda vez que desejo testar alguma API, algoritmo ou um novo componente desenvolvido. Se preciso automatizar algum processo com um pouco mais de recursos, preciso, no Windows, Abrir o Visual Studio, Criar um novo <em>Unit Testing Project </em>ou <em>Console Application </em>e codificar. Em alguns casos, alguns amigos, usam o Sublime ou Code junto com um compilador do C# para executar o código. Não tem algo simples como o Python? Sim. E pelo que vi, há tempos! C# Scripting.</p><p>Não se trata de uma nova linguagem, é uma interface. Como descrito em seu próprio help, é uma REPL Interface (para pronunciar basta acrescentar um r em apple). REPL é um acrônimo para Read-eval-print Loop, cujo nome representa fielmente o seu objetivo. Com eles os usuários podem Ler, avaliar, exibir repetidamente e diretamente da linha de comando, sem a necessidade de uma IDE e suas complexidades. A descrição menos complicada para REPL, é de ser um ambiente onde são executadas rotinas descritas por um usuário. O usuário escreve a rotina e o REPL executa o que deve ser feito, interação a interação ou obtendo as rotinas de um arquivo script. O próprio prompt, é um tipo de REPL, como no meu exemplo o Python tem seu REPL que permite a escrita de rotinas para execução. Sem ficar para trás, o .NET também tem seu REPL, o CSI.</p><p>O objetivo do REPL inicialmente não é substituir o desenvolvimento dentro da IDE, mas, permitir a criação de <em>snippets </em>em C# com o fim de criar ou testar rapidamente alguma feature. De uma forma leve e simplificada você pode executar qualquer código C# sem que necessariamente esteja dentro de um arquivo CS e hospedada por um CSPROJ.</p><p>O REPL do C#, pode ser executado a partir do Visual Studio (Views | Other Windows | C# Interative) em uma janela conhecida como <strong><em>C# Interative Window</em></strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/810/1*4r7_Xeo2uWTIi-tQ63_aJA.png" /></figure><p>ou pelo <strong><em>Developer Command Prompt</em></strong>, com o comando csi. Em meu caso, farei a utilização do prompt para representar a independência total do Visual Studio. Que é exatamente o que procuro quando preciso desenvolver algo mais simples. Podemos observar que o REPL do C# é semelhante ao do Python.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*nbXCsojZ9gYYACkqg1dy7w.png" /><figcaption>REPL do Python 3.6.1</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/675/1*Jb4BmLRAszvGwFNc_cWp3w.png" /><figcaption>REPL do C# — CSI</figcaption></figure><p>Após isso, já é possível codificar:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/674/1*KM15DIgfBgdMLbqIOmmEcA.png" /></figure><p>Note que na primeira linha, onde executo o Console.WriteLine(), após pressionar &lt;enter&gt; imediatamente o CSI interpreta e executa o código. Este é o modo interativo. A medida em que vou digitando as instruções, o CSI interpreta e executa os comandos. É possível perceber uma pequena demora na primeira execução, mas ela tende a se tornar mais rápida. É importante destacar também que dependendo da instrução, o CSI automaticamente identifica a necessidade de um escopo, trocando o sinalizador do prompt de “&gt;” para “.” e indicar que aquele é o escopo da instrução iniciada. Nestes casos, o CSI, identifica por si mesmo o fim do bloco, mas em outros casos, o ponto-e-virgula “;” é o indicador de execução. É preciso ficar atento a isto pois caso hajam erros, os mesmos só serão exibidos após a execução das instruções.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/1*FsrP5FujF11CmfOqzScikQ.png" /></figure><p>A medida que o código se torna mais complexo, pode haver a necessidade de realizar a criação de classes ou métodos que possam ser invocados a partir da rotina principal. Para isso será necessário codificar um arquivo de script C#. Este arquivo deve ter a extensão *.csx. Em seguida basta executar o CSI, passando o nome do arquivo como argumento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*Qp9XC2S9tWDUv2P1YIa4jw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/835/1*FTwHSdngmgi0klbjxM-LsA.png" /></figure><p>Há ainda outros argumentos que podem ser utilizados (vide <em>/help</em>), além de ser possível passar argumentos pela linha de comando para o próprio arquivo de script.</p><p>É possível fazer referências a bibliotecas externas e a outros arquivos scripts. Para isto as referências externas é necessário utilizar uma diretiva chamada #r e indicar o caminho do assembly. Para utilização de outro arquivo script é necessário a utilização da diretiva #load. Isto é semelhante ao <strong><em>import</em></strong> do Python, ou o <strong><em>include </em></strong>de linguagens como php e também C++ por exemplo.</p><p>É possível sair a qualquer momento do CSI utilizando o atalho padrão Ctrl+C. Se precisar limpá-lo, não há atalhos, será necessário utilizar o Console.Clear().</p><p>Outro detalhe importante é quanto ao histórico do CSI. As variáveis, métodos, ou arquivos e referências carregados continuam até que a janela seja fechada. Enquanto a janela não for fechada eles permanecem, mesmo que você não esteja executando o CSI.</p><p>Algumas instruções, só serão executadas após o “;”. Em meus testes executando código de um script C#, identifiquei que ele não estava sendo executado. Nenhuma mensagem foi exibida. Nenhum erro aparente, até que percebi que faltava um ponto-e-virgula (;). Portanto, é preciso tomar cuidado.</p><p>Há muitos outros recursos que valem a pena ser explorados. Do que vi até agora é possível utilizar quase todos os recursos da linguagem. É bom poder utilizar uma linguagem e frameworks tão eficientes como o C# em modo Scripting. Com o Advento do Roslyn, surgiram sites e ferramentas que passaram a interpretar instruções .NET. Isto permitiu a criação deste poderoso recurso que está disponível desde 2013, mas até então era pouco explorado. Com a popularização do scripting, as linguagens interpretadas, e as novas linguagens que surgem pouco a pouco no mercado, isto não se torna mais trivial, mas muito necessário para mostrar que o C# não fica para trás mas avança em simplicidade, agilidade, e novas possibilidades.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f509ea76a780" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular e suas versões: Estabilidade ou Insanidade?]]></title>
            <link>https://medium.com/@leonardomartinsfelicissimo/angular-e-suas-vers%C3%B5es-estabilidade-ou-insanidade-b012f5c6b9f3?source=rss-1cc082736bf3------2</link>
            <guid isPermaLink="false">https://medium.com/p/b012f5c6b9f3</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[angularjs]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Leonardo Felicissimo]]></dc:creator>
            <pubDate>Thu, 11 May 2017 01:48:12 GMT</pubDate>
            <atom:updated>2017-05-11T01:48:12.322Z</atom:updated>
            <content:encoded><![CDATA[<p>A primeira parte desse texto é um histórico de minha trajetória desde quando despertei do profundo sono tecnológico do trabalho em que trabalhava, e acordei tendo a necessidade de uma atualização tecnológica. Achei interessante contar, no intuito de descrever como o cenário de tecnologia mudou em tão pouco tempo no mundo do desenvolvimento Web, em tese de 2015 até 2017. Se você estiver mais interessado no meu questionamento sugiro ir direto até o segundo tópico (embora seja interessante conhecer minha louca jornada).</p><h4>Como conheci o Angular?</h4><p>Era uma tarde de algum mês do ano de 2015 para 2016. Estávamos passando por um momento de grandes mudanças na empresa em que trabalhava. E neste cenário, a rádio peão fervia com novidades diversas sobre mudanças. Por causa disso, eu, que trabalhava já na empresa conhecendo toda a sua estrutura, arquitetura, bibliotecas e tendo participado de muitas reuniões sobre o projeto me vi diante de um gigantesco abismo de atualização tecnológica. De um lado, um desenvolvedor .NET atuando já há 5 anos com WCF, WPF, ASP.NET Web Forms, ASP.NET MVC, Windows Forms, EntityFramework e você sabe mais o que vem na lista. Do outro lado, o mundo repleto de novidades de aplicações Web mais simples por meio de SPA, autenticação com OAuth, e algo que eu havia ouvido falar de um amigo há 2 anos atrás que fervia no mercado internacional, mas naquela época ainda não no brasileiro: RESTful (ao menos dentre os projetos que eram anunciados). junto com isso também, o que eu conhecia como banco de dados não-relacional (NoSQL) restringia-se a algo implantado dentro da própria empresa: Apache Lucene e até então era o único lugar aonde não havia mexido.</p><p>Ao me deparar com este abismo, não tive outra opção, vi ali desafios gigantescos de atualização tecnológica (para alguém competitivo por natureza, isso com certeza era algo que não poderia passar). Um projeto surgiu para o desenvolvimento de um novo serviço que expusesse um WebService para ser acessível externamente. Imediatamente propus a utilização do RESTful em detrimento do SOAP pela simplicidade e praticidade no desenvolvimento (pra quem trabalhou com WCF e suas configurações no app.config ou web.config é claro), uma vez que a tecnologia do serviço era C# e .NET fui direto para o WebApi. Parte do abismo foi diminuindo e fui alcançando o outro lado pouco a pouco. Uma vez estudando WebApi, inevitavelmente tive que lidar com OAuth e seus padrões de autenticação, não somente isso, mas lidar também com o conceito de migrations do EntityFramework.</p><p>Nesse caminho, finalmente entrei no mundo das SPA (Single Page Applications). HTML5, Boostrap, jQuery, que era um framework do qual não queria saber, tornou-se algo importante. No entanto, a dificuldade para exibir os dados na página foram se tornando um empecilho. O código era gigante, e feio de se ler devido as criações de elementos com o retorno das chamadas Ajax. Foi aí que conheci o Knockout. Comecei achando espetacular a experiência renovada de trabalhar com DataBindings para deixar a View ser View de fato. Aliás, sejamos sinceros que a tecnologia tem algo de interessante, assim como na realidade fora dela. Parece que a tendência neste mundo é tão circular quanto as esferas que se fazem presentes em nosso universo. O que sai de moda, volta a ser moda.</p><p>Quem é que não cansou de usar VB mais HTML nas páginas asp? E então para a molecada do ASP.NET, o Razor era uma novidade. Quem é que nunca usou DataBindings com ASP.NET WebForms? Então surgem os Frameworks aproveitando-se do HTML5 e fazendo isto parecer nativo com atributos personalizados em suas tags.</p><p>O Knockout era algo realmente impressionante — na minha opinião — em relação ao Angular, por exemplo, por sua simplicidade no código javascript. Neste período já havia ouvido sobre o Angular, já estava a procura de desenvolver uma SPA, mas ainda não havia definido com que framework trabalharia. Até então jamais imaginaria ouvir falar de Vue.js, React.js, Ember.js (lógico, a não ser que eu fosse um vidente).</p><p>Comecei a ter muitas dificuldades com Knockout e percebi a sua limitação para fazer bindings em certos componentes. Me lembro de ter tido muitas dificuldades para fazer binding com o componente Popup Bootstrap com jQuery. Foi assim, que forçosamente passei a usar o Angular. E aqui é que começa uma perspectiva da insanidade do Angular Js.</p><h4>AngularJs um framework poderoso, mas insano</h4><p>Sem dúvida é um dos frameworks mais comentados e talvez utilizados do mundo da tecnologia brasileira. São muitas as vagas de empresas que tem como requerimento hoje o AngularJs, e de fato, é um grande framework javascript. De fato sua capacidade de dinamizar uma página HTML impressiona a qualquer um. Conceitos de modularização, separação da estrutura de UI da lógica de UI e o código javascript repleto de callbacks e a implícita injeção de dependência, que até então era algo geralmente feito com RequireJs. Além disso, para certos componentes o angular aplica uma forma específica de programar a exibição e obtenção dos dados, facilitando ainda mais o trabalho. Isso é perceptível, por exemplo, no caso de “date-pickers”. Mas o sonho durou pouco. A primeira versão com que trabalhei do Angular foi a versão 1.5, que em época e já estava me acostumando com ela.</p><p>Codificava com muita facilidade a exibição dos dados em diversas formas. E já estava obtendo um ótimo domínio do framework. E não só do framework, mas ele naturalmente te leva a usar muito mais javascript, ainda mais para alguém como eu que tema cabeça Orientada a Objetos. Eu criava classes e separava em arquivos, e fazia questão de usar muitos conceitos de OO, isso me ajudou a me acostumar muito com javascript. Não somente isso, mas as chamadas para as minhas APIs mudaram. Porque o que até então fazia usando o Ajax do jQuery e seus callbacks, agora, no entanto, usava uma class $http com promises. Se você estiver acostumado com programação assíncrona com Tasks em .NET, não terá problemas de entender o conceito de <em>promises</em>. Se por um lado, me desenvolvia muito, também encontrava pedras no caminho. Algumas coisas, confesso, eram irritantes. Como por exemplo, ver exibido na tela {{customer_name}} no loading da página, antes de realmente exibir, o que em alguns casos dava para resolver usando ng-bind.</p><p>E de repente, sou questionado por um amigo: “Você viu que saiu o Angular 2?” Lembro que imediatamente respondi não e fui dar uma olhada. Para minha surpresa, o site já havia mudado. Ao invés do antigo angularjs.org, agora, tudo estava no angular.io. A partir disso me deparei com as novidades que me fizeram questionar até que ponto tratava-se de uma tentativa de encontrar uma estrutura estável para o frameworks livre de demais alterações no futuro, ou pura insanidade mesmo.</p><h4>Primeira novidade: Documentação em código TypeScript, mas não para Javascript</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*oZeyrCv8FU0rpYEf6l0-Og.png" /></figure><p>De início pensei que era somente uma seleção incorreta, então fui procurar a documentação para javascript. Resposta: Ela ainda não está disponível. Para que uma mudança tão trágica? Este era só o começo da brincadeira. Hoje, a documentação já está disponível para as duas linguagem script. Entendo o fato de que o TypeScript tem muita mais semelhança com o que lidamos em .NET, e que ser <em>strongly-typed</em> realmente acrescenta mais segurança em ao fazer conversões e minimiza erros. Mais um framework que até então eram javascript, assumir TypeScript como sua linguagem principal, de uma hora para outra, naquele momento para mim era insanidade.</p><h4>Segunda novidade: @Components e Templates. Pra onde foi a Controller?</h4><p>O que era MVVM (Model-View-ViewModel) estava se tornando MTV (Model-Template-View). Para quem estava acostumado a criar a app.controller(function(){}), e mais outros vários building blocks, houve uma simplificação para 8 building blocks. Dentre os quais a controller não fazia mais parte. Mas até que ponto realmente foi simplificado?</p><p><strong>Angular 1.5</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/391/0*SQYqGihjjLFyGeQ2.png" /></figure><p><strong>Angular 2</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/838/0*Iu0J0nFsO73RsxEU.png" /></figure><p>Claro que os components e templates não eram uma novidade exclusiva no Angular 2, pois, no Angular 1.5 eles já existiam. Mas, apesar de não ter utilizado, dos exemplos que havia visto, e se tivesse trabalhado com este conceito antes, teria achado que realmente foi uma grande evolução. Mas para mim, que não tive a necessidade de componentizar tanto, e dinamizar tanto meu template, ao ver toda essa estrutura não tive dúvidas, era insanidade.</p><h4>Terceira novidade: Adeus HTML-like attributes!</h4><p>Não sei como descreveria isso como um título em português. Mas algo que também me pareceu insano foi a mudança repentina na utilização de atributos em angular que até então eram semelhantes aos atributos HTML, para algo completamente diferente dentro dos components:</p><pre>&lt;div id=&quot;simple&quot; ng-controller=&quot;MyController&quot;&gt;<br>  &lt;p&gt;Let&#39;s try this simple notify service, injected into the controller...&lt;/p&gt;<br>  &lt;input ng-init=&quot;message=&#39;test&#39;&quot; ng-model=&quot;message&quot; &gt;<br>  &lt;button ng-click=&quot;callNotify(message);&quot;&gt;NOTIFY&lt;/button&gt;<br>  &lt;p&gt;(you have to click 3 times to see an alert)&lt;/p&gt;<br>&lt;/div&gt;</pre><p>Atributos do angular: ng-repeat=””, ng-bind=””, ng-init=””, ng-click=””, ng-controller=””, isto é semelhante aos atributos HTML: id=””, class=””, src=””.</p><p>Mas então chega o Angular 2:</p><pre>&lt;li&gt;{{hero.name}}&lt;/li&gt;<br>&lt;hero-detail [hero]=&quot;selectedHero&quot;&gt;&lt;/hero-detail&gt;<br>&lt;li (click)=&quot;selectHero(hero)&quot;&gt;&lt;/li&gt;</pre><p>Atributos do angular: [class]=””, (event)=””, [(model)]=””.</p><p>E quando achei que era só isso. O pior chegou:</p><pre>&lt;li *ngFor=&quot;let hero of heroes&quot;&gt;&lt;/li&gt;<br>&lt;hero-detail *ngIf=&quot;selectedHero&quot;&gt;&lt;/hero-detail&gt;</pre><p><strong>Destacando:</strong> <strong>*</strong>ngFor,<strong> *</strong>ngIf</p><p>Para mim, usar * desse modo, é coisa de ponteiro de C++, não de uma linguagem usada junto a tags HTML! Nem os comentários de HTML usam /* */. Por que uma mudança tão drástica? Mais uma vez, vejo aqui um caso de insanidade.</p><h4>Quarta novidade: Release 1, 2 e de repente… 4. Antes AngularJs, agora só Angular</h4><p>Se você como eu, mal começou, ou mal se acostumou a utilizar o Angular 2. Agora já está disponível o Angular 4. Segundo o blog do framework, não há incompatibilidade entre as versões, os “tutoriais, dicas, truques e conteúdo que funcionavam na versão 2 continuarão a funcionar na versão 4”. A utilização da versão ao lado do nome torna-se desnecessária. Isto é, não haverão mais mudanças drásticas como aconteceu da versão 1 para a 2. Confesso que gostaria de não me importar com isso, mas até agora me pergunto porque não houve um release 3. Embora, veja um pouco de insanidade aqui também, vamos considerar que esta mudança foi devido a um cenário possível de estabilidade.</p><h4>Conclusão?</h4><p>Não sou contra Angular. Pelo contrário, hoje, como desenvolvedor, minha opção é pelo Angular para o desenvolvimento FrontEnd. E sem dúvida com o avanço da tecnologia de desenvolvimento mobile. A tendência é que cada vez mais utilizemos Angular em estratégias como Ionic, por exemplo.</p><p>Mas fui realmente impactado por essa drástica mudança do framework, como acredito que muitos outros tenham sido. E muitos projetos talvez não tenham optado pelo Angular devido a este histórico ou ainda ao menos em atualizar com cautela. Aliás, é o que indica o radar da ThoughtWorks, onde o Angular 2 ocupa o 1° lugar das linguagens que devem ser exploradas com cautela no objetivo de entender como afetará a empresa. E o AngularJs encontra-se solitário na categoria de mantê-lo com cuidado.</p><p>Ao perceber estas mudanças fico realmente pensando na hipótese de que durante certo tempo, talvez até mesmo por uma questão interna de gestão, esta equipe sofreu uma crise de instabilidade e mudanças drásticas no seu produto desenvolvido que beirou a um pouco de insanidade, atrapalhou a vida de quem estava tentando aprender ou a realmente usar sua ferramenta para desenvolvimento de seus projetos. Mas no fim, parece que encontrou uma trilha de estabilidade a seguir.</p><p>Estabilidade ou Insanidade? Um pouco de um e um pouco do outro. E que problema há nisso, de louco todo projeto tem um pouco.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b012f5c6b9f3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>