atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">

  <title><![CDATA[1up4developers]]></title>
  <link href="http://1up4dev.org/atom.xml" rel="self"/>
  <link href="http://1up4dev.org/"/>
  <updated>2016-07-29T19:00:43-03:00</updated>
  <id>http://1up4dev.org/</id>
  <author>
    <name><![CDATA[1up4developers]]></name>
    <email><![CDATA[1up4dev@googlegroups.com]]></email>
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[Encerramento do blog]]></title>
    <link href="http://1up4dev.org/2016/07/encerramento-do-blog/"/>
    <updated>2016-07-08T12:00:00-03:00</updated>
    <id>http://1up4dev.org/2016/07/encerramento-do-blog</id>
    <content type="html"><![CDATA[<p>Amigos, este blog será encerrado no final deste mês :(</p>

<p>Desde 2008 vínhamos compartilhando nossas aventuras e experiências no maravilhoso mundo da programação. Aprendemos muito com esta trajetória, com os comentários que vocês leitores fizeram e com as oportunidades que surgiram através do blog.</p>

<p>Foi uma etapa muito importante e proveitosa em nossas carreiras, mas este ciclo chegou ao fim. E este é o momento de iniciar um novo ciclo em nossas carreiras.</p>

<p>O blog será encerrado, mas continuaremos compartilhando nossas experiências no Twitter, Medium e nos blogs pessoais de cada autor.</p>

<p>Aqui estão nossos feeds de conteúdo agile a partir do próximo mês:</p>

<h3>Rodrigo Panachi</h3>

<ul>
<li><a href="http://rpanachi.com">http://rpanachi.com</a></li>
<li><a href="https://medium.com/@rpanachi">https://medium.com/@rpanachi</a></li>
<li><a href="https://twitter.com/rpanachi">https://twitter.com/rpanachi</a></li>
</ul>


<h3>Roger Leite</h3>

<ul>
<li><a href="https://medium.com/@rogerleite">https://medium.com/@rogerleite</a></li>
<li><a href="https://twitter.com/rogerleite">https://twitter.com/rogerleite</a></li>
</ul>


<h3>Plinio Balduino</h3>

<ul>
<li><a href="https://medium.com/@pbalduino">https://medium.com/@pbalduino</a></li>
<li><a href="http://twitter.com/p_balduino">http://twitter.com/p_balduino</a></li>
</ul>


<h3>Tony Fabeen</h3>

<ul>
<li><a href="https://medium.com/@tonyfabeen">https://medium.com/@tonyfabeen</a></li>
<li><a href="https://twitter.com/tonyfabeen">https://twitter.com/tonyfabeen</a></li>
</ul>


<h3>Miguel Horlle</h3>

<ul>
<li><a href="https://twitter.com/miguelbaldi">https://twitter.com/miguelbaldi</a></li>
</ul>


<h3>Humberto Bulhões</h3>

<ul>
<li><a href="https://twitter.com/01berto">https://twitter.com/01berto</a></li>
</ul>


<h3>Rogério Ramos</h3>

<ul>
<li><a href="https://medium.com/@habutre">https://medium.com/@habutre</a></li>
<li><a href="https://twitter.com/habutre">https://twitter.com/habutre</a></li>
</ul>


<p>Continue nadando contra o waterfall e até a proxima. Sucesso!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Type hints no Clojure - Parte 2]]></title>
    <link href="http://1up4dev.org/2015/02/type-hints-no-clojure-parte-2/"/>
    <updated>2015-02-02T17:14:00-02:00</updated>
    <id>http://1up4dev.org/2015/02/type-hints-no-clojure-parte-2</id>
    <content type="html"><![CDATA[<p>Parte 1: <a href="http://1up4dev.org/2015/01/type-hints-no-clojure-parte-1">http://1up4dev.org/2015/01/type-hints-no-clojure-parte-1</a></p>

<h2>Quando otimizar</h2>

<p>Não adianta sair adicionando <em>type hints</em> no código sem critério. A primeira coisa a ser feita é detectar onde estão os gargalos, os pontos que consomem mais recursos sem trazer resultados imediatos utilizando uma boa ferramenta de ::profiling::.</p>

<p>Uma vez que você localize os pontos lentos da aplicação, adicione a seguinte linha no início do seu código:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nf">set!</span> <span class="nv">*warn-on-reflection*</span> <span class="nv">true</span><span class="p">)</span>
</span></code></pre></td></tr></table></div></figure>


<p>Agora o compilador vai nos avisar toda vez que for obrigado a usar <em>reflection</em> para invocar um método ou acessar um membro.</p>

<p>Vamos usar a nossa função <code>upper-case</code> para detectar os pontos que podem ser otimizados com <em>type hinting</em>.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nf">set!</span> <span class="nv">*warn-on-reflection*</span> <span class="nv">true</span><span class="p">)</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="kd">defn </span><span class="nv">upper-case</span> <span class="p">[</span><span class="nv">text</span><span class="p">]</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">.toUpperCase</span> <span class="nv">text</span><span class="p">))</span>
</span><span class='line'><span class="c1">; Reflection warning, NO_SOURCE_PATH:2:3 - reference to field </span>
</span><span class='line'><span class="c1">; toUpperCase can&#39;t be resolved.</span>
</span><span class='line'><span class="c1">; #&#39;user/upper-case</span>
</span></code></pre></td></tr></table></div></figure>


<p>Essa é a mensagem do compilador nos avisando que não sabe que tipo contém o método <code>toUpperCase</code>. Como estamos usando <code>toUpperCase</code> em <code>text</code>, vamos adicionar o <em>type hint</em> nele.</p>

<p>Perceba que o erro ocorreu durante a compilação da função, e não durante sua execução. Lembre-se que todo código executado já foi compilado em algum momento, incluindo o código que escrevemos no <em>REPL</em>.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="kd">defn </span><span class="nv">upper-case-2</span> <span class="p">[</span><span class="o">^</span><span class="nv">String</span> <span class="nv">text</span><span class="p">]</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">.toUpperCase</span> <span class="nv">text</span><span class="p">))</span>
</span><span class='line'><span class="c1">; #&#39;user/upper-case-2</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nf">upper-case-2</span> <span class="s">&quot;umba umba umba ê&quot;</span><span class="p">)</span>
</span><span class='line'><span class="c1">; &quot;UMBA UMBA UMBA Ê&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Sem erros nem avisos, resolvemos a questão do <em>reflection</em> na expressão.</p>

<p>Falamos sobre otimização e gargalos mas não mostramos na prática o que isso significa.</p>

<p>Vamos posicionar as duas funções, com e sem <em>type hint</em> e executar uma iteração apresentando o tempo gasto com cada versão.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="kd">defn </span><span class="nv">upper-case</span> <span class="p">[</span><span class="nv">texto</span><span class="p">]</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">.toUpperCase</span> <span class="nv">texto</span><span class="p">))</span>
</span><span class='line'><span class="c1">; Reflection warning, NO_SOURCE_PATH:2:3 - reference to field </span>
</span><span class='line'><span class="c1">; toUpperCase can&#39;t be resolved.</span>
</span><span class='line'><span class="c1">; #&#39;user/upper-case</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="kd">defn </span><span class="nv">upper-case-2</span> <span class="p">[</span><span class="o">^</span><span class="nv">String</span> <span class="nv">texto</span><span class="p">]</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">.toUpperCase</span> <span class="nv">texto</span><span class="p">))</span>
</span><span class='line'><span class="c1">; #&#39;user/upper-case-2</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nb">time </span><span class="p">(</span><span class="nb">dotimes </span><span class="p">[</span><span class="nv">_</span> <span class="mi">100000</span><span class="p">]</span> <span class="p">(</span><span class="nf">upper-case</span> <span class="s">&quot;mandarina&quot;</span><span class="p">)))</span>
</span><span class='line'><span class="c1">; &quot;Elapsed time: 327.720765 msecs&quot;</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nb">time </span><span class="p">(</span><span class="nb">dotimes </span><span class="p">[</span><span class="nv">_</span> <span class="mi">100000</span><span class="p">]</span> <span class="p">(</span><span class="nf">upper-case-2</span> <span class="s">&quot;mandarina&quot;</span><span class="p">)))</span>
</span><span class='line'><span class="c1">; &quot;Elapsed time: 55.403849 msecs&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Nesse nosso exemplo simples o processamento ficou de seis a sete vezes mais rápido.</p>

<p><em>(Trecho do meu livro &ldquo;Clojure: Programação Funcional Descomplicada para a JVM&rdquo;, a ser publicado em breve)</em></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Type hints no Clojure - Parte 1]]></title>
    <link href="http://1up4dev.org/2015/01/type-hints-no-clojure-parte-1/"/>
    <updated>2015-01-31T21:14:00-02:00</updated>
    <id>http://1up4dev.org/2015/01/type-hints-no-clojure-parte-1</id>
    <content type="html"><![CDATA[<p>Parte 2: <a href="http://1up4dev.org/2015/02/type-hints-no-clojure-parte-2">http://1up4dev.org/2015/02/type-hints-no-clojure-parte-2</a></p>

<h2>Otimizando com type hints</h2>

<p>Por padrão você não informa os tipos dos dados ao Clojure. Internamente o dado vai ser tratado como <code>Object</code>, que é a classe base de qualquer objeto Java.</p>

<p>Qualquer método ou propriedade que você invocar desse objeto será localizado e chamado através de <em>reflection</em>. No Java, <em>reflection</em> é a capacidade de acessar métodos e membros de um objeto ou classe através de metaprogramação.</p>

<p>Exemplificando, esse código Clojure:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="kd">defn </span><span class="nv">upper-case</span> <span class="p">[</span><span class="nv">text</span><span class="p">]</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">.toUpperCase</span> <span class="nv">text</span><span class="p">))</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nf">upper-case</span> <span class="s">&quot;umba umba umba ê&quot;</span><span class="p">)</span>
</span><span class='line'><span class="c1">; &quot;UMBA UMBA UMBA Ê&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Vai ser transformado em algo equivalente a isso:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="n">Object</span> <span class="nf">invoke</span><span class="o">(</span><span class="n">Object</span> <span class="n">par01</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>  <span class="k">return</span> <span class="o">(</span><span class="n">Object</span><span class="o">)(</span><span class="n">par01</span>
</span><span class='line'>                    <span class="o">.</span><span class="na">getClass</span><span class="o">()</span>
</span><span class='line'>                    <span class="o">.</span><span class="na">getDeclaredMethod</span><span class="o">(</span><span class="s">&quot;toUpperCase&quot;</span><span class="o">,</span> <span class="kc">null</span><span class="o">)</span>
</span><span class='line'>                    <span class="o">.</span><span class="na">invoke</span><span class="o">(</span><span class="n">par01</span><span class="o">));</span>
</span><span class='line'><span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="o">(</span><span class="k">new</span> <span class="n">user$upper_case</span><span class="o">()).</span><span class="na">invoke</span><span class="o">(</span><span class="s">&quot;umba umba umba ê&quot;</span><span class="o">);</span>
</span><span class='line'><span class="c1">// &quot;UMBA UMBA UMBA Ê&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Eu disse <em>equivalente</em> porque o seu código Clojure vai ser compilado diretamente para <em>bytecode</em> ao invés de ser convertido primeiro para código Java.</p>

<p>Como podemos notar, além de termos que invocar três métodos para fazer a chamada de um e termos que fazer <em>typecasting</em> &ndash; ou <em>coerção de tipos</em>, se preferir &ndash; para que tudo seja tratado como <code>Object</code>, o próprio processo de <em>reflection</em> é lento por si só.</p>

<p>Note como informamos o nome do método <code>toUpperCase</code> como um texto. Com isso o método <code>getDeclaredMethod</code> vai pesquisar uma tabela interna daquela objeto comparando cada nome de método até encontrar o que procuramos.</p>

<p>Para ajudar, como o Clojure não tem a mais remota ideia do que queremos transformar em letras maiúsculas, a função aceita qualquer coisa.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nf">upper-case</span> <span class="mf">3.14159</span><span class="p">)</span>
</span><span class='line'><span class="c1">; IllegalArgumentException No matching field found: toUpperCase for </span>
</span><span class='line'><span class="c1">; class java.lang.Double</span>
</span></code></pre></td></tr></table></div></figure>


<p><em>Ah, então o compilador do Clojure é mal feito?</em></p>

<p>Não. Acontece algo muito parecido quando escrevemos código JavaScript, Ruby, Python ou qualquer outra linguagem dinâmica para a JVM. Como você não informou o tipo, o compilador tem que adivinhar ou confiar cegamente no que você está dizendo.</p>

<p>Porém, existe uma forma de diminuir essa trabalheira toda dando dicas ao compilador sobre o tipo de dado que ele deve utilizar. Essas dicas chamam-se <em>type hints</em>, ou dicas de tipos.</p>

<p>Mas atenção: que fique claro que estamos dando dicas ao compilador ao invés de declararmos estaticamente o tipo de dados que estamos utilizando.</p>

<p>Podemos reescrever nosso código dessa forma para que o compilador receba nossas dicas:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="kd">defn </span><span class="nv">upper-case</span> <span class="p">[</span><span class="o">^</span><span class="nv">String</span> <span class="nv">text</span><span class="p">]</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">.toUpperCase</span> <span class="nv">text</span><span class="p">))</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nf">upper-case</span> <span class="s">&quot;umba umba umba ê&quot;</span><span class="p">)</span>
</span><span class='line'><span class="c1">; &quot;UMBA UMBA UMBA Ê&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Se tentarmos passar qualquer coisa diferente de <code>String</code>, a JVM vai reclamar na mesma hora.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nf">upper-case</span> <span class="mf">3.14159</span><span class="p">)</span>
</span><span class='line'><span class="c1">; ClassCastException java.lang.Double cannot be cast to </span>
</span><span class='line'><span class="c1">; java.lang.String  user/upper-case (NO_SOURCE_FILE:2)</span>
</span></code></pre></td></tr></table></div></figure>


<p>Aí você pensa <em>ah, tá. era para ter passado <code>String</code> e passei <code>Double</code></em>. Bonito, não?</p>

<p>Mas não é só isso. Ao usar <em>type hints</em> você ainda leva uma otimização de código totalmente de graça.</p>

<p>O <em>bytecode</em> gerado fica equivalente a esse código Java:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="n">Object</span> <span class="nf">invoke</span><span class="o">(</span><span class="n">Object</span> <span class="n">par01</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>  <span class="k">return</span> <span class="o">((</span><span class="n">String</span><span class="o">)</span><span class="n">par01</span><span class="o">).</span><span class="na">toUpperCase</span><span class="o">();</span>
</span><span class='line'><span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="o">(</span><span class="k">new</span> <span class="n">user$upper_case</span><span class="o">()).</span><span class="na">invoke</span><span class="o">(</span><span class="s">&quot;umba umba umba ê&quot;</span><span class="o">);</span>
</span><span class='line'><span class="c1">// &quot;UMBA UMBA UMBA Ê&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Se você imaginou que o código, além de menor, também ficou mais rápido, acertou.</p>

<p><em>Então vou usar isso no meu código inteiro!</em></p>

<p>Calma lá. Clojure não deixa de ser uma linguagem dinâmica apenas por ter <em>type hints</em>. A contrapartida dessas dicas é que elas poluem o código e, muitas vezes, e dificilmente você vai precisar que todo seu código seja otimizado.</p>

<p>Na próxima parte vamos aprender quando e como otimizar para praticamente todas as situações.</p>

<p>Até lá.</p>

<p><em>(Trecho do meu livro &ldquo;Clojure: Programação Funcional Descomplicada para a JVM&rdquo;, a ser publicado em breve)</em></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Lendo arquivo CSV com parcimônia no Ruby]]></title>
    <link href="http://1up4dev.org/2014/11/lendo-arquivo-csv-com-parcimonia-no-ruby/"/>
    <updated>2014-11-17T09:34:00-02:00</updated>
    <id>http://1up4dev.org/2014/11/lendo-arquivo-csv-com-parcimonia-no-ruby</id>
    <content type="html"><![CDATA[<p>Ler e escrever <a href="http://en.wikipedia.org/wiki/Comma-separated_values">arquivo csv</a> é um mal necessário de muitos sistemas, ainda mais levando em conta que esta integração será feita via Excel, em algum Windows, com quilos de texto com acentos e dados a formatar. Dado este cenário, e que ele provavelmente se repetirá no futuro, deixo aqui um post auto-ajuda para mim mesmo e provavelmente para você que está lendo. :D</p>

<p>Na versão 1.9.3 e superior, o Ruby incluiu a classe <a href="http://ruby-doc.org/stdlib-1.9.3/libdoc/csv/rdoc/CSV.html">CSV</a> na sua <em>standard lib</em>, que facilita o trabalho de ler e/ou escrever arquivos csv. Exemplos em código abaixo.</p>

<h2>Conhecendo o CSV</h2>

<p>O modo mais simples e direto para ler um arquivo csv, é usar o <code>CSV.read</code> que retorna um Array de Arrays:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;csv&#39;</span>
</span><span class='line'><span class="n">array_students</span> <span class="o">=</span> <span class="no">CSV</span><span class="o">.</span><span class="n">read</span><span class="p">(</span><span class="s1">&#39;/tmp/mock_data.csv&#39;</span><span class="p">)</span> <span class="c1"># return an Array of Arrays</span>
</span><span class='line'><span class="n">array_students</span><span class="o">.</span><span class="n">each</span> <span class="p">{</span> <span class="o">|</span><span class="n">row</span><span class="o">|</span> <span class="nb">puts</span> <span class="n">row</span><span class="o">.</span><span class="n">inspect</span> <span class="p">}</span>  <span class="c1"># =&gt; output:</span>
</span><span class='line'><span class="c1"># &quot;[\&quot;id\&quot;, \&quot;name\&quot;, \&quot;country\&quot;, \&quot;birthday\&quot;]&quot;</span>
</span><span class='line'><span class="c1"># &quot;[\&quot;1\&quot;, \&quot;Virginia Harvey\&quot;, \&quot;GB\&quot;, \&quot;01/06/1993\&quot;]&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Dentro da classe CSV, existem mais duas classes que facilitam ainda mais o manuseio dos dados.</p>

<p>Caso necessite de mais requinte e sofisticação, o método <code>CSV.table</code> retorna uma instância de <a href="http://ruby-doc.org/stdlib-1.9.3/libdoc/csv/rdoc/CSV/Table.html">CSV::Table</a>. Com o table, você tem acesso ao cabeçalho através do <code>headers</code> e acesso a cada linha do arquivo com o <code>each</code>, que retorna uma instância de <a href="http://ruby-doc.org/stdlib-1.9.3/libdoc/csv/rdoc/CSV/Row.html">CSV::Row</a>.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;csv&#39;</span>
</span><span class='line'><span class="n">table_students</span> <span class="o">=</span> <span class="no">CSV</span><span class="o">.</span><span class="n">table</span><span class="p">(</span><span class="s1">&#39;/tmp/mock_data.csv&#39;</span><span class="p">)</span> <span class="c1"># =&gt; instance of CSV::Table</span>
</span><span class='line'><span class="nb">puts</span> <span class="n">table_students</span><span class="o">.</span><span class="n">headers</span><span class="o">.</span><span class="n">inspect</span> <span class="c1"># =&gt; [:id, :name, :country, :birthday]</span>
</span><span class='line'><span class="n">table_students</span><span class="o">.</span><span class="n">each</span> <span class="p">{</span> <span class="o">|</span><span class="n">row</span><span class="o">|</span> <span class="nb">puts</span> <span class="n">row</span><span class="o">.</span><span class="n">inspect</span> <span class="p">}</span> <span class="c1"># =&gt; output:</span>
</span><span class='line'><span class="c1"># &lt;CSV::Row id:1 name:&quot;Virginia Harvey&quot; country:&quot;GB&quot; birthday:&quot;01/06/1993&quot;&gt;</span>
</span><span class='line'><span class="n">table_students</span><span class="o">.</span><span class="n">each</span> <span class="p">{</span> <span class="o">|</span><span class="n">row</span><span class="o">|</span> <span class="nb">puts</span> <span class="n">row</span><span class="o">.</span><span class="n">fetch</span><span class="p">(</span><span class="ss">:name</span><span class="p">)</span> <span class="p">}</span> <span class="c1"># =&gt; output:</span>
</span><span class='line'><span class="c1"># Virginia Harvey</span>
</span></code></pre></td></tr></table></div></figure>


<p>Tanto o <code>read</code> quanto o <code>table</code>, aceitam um hash de options como segundo argumento. Tem uma descrição detalhada na documentação do <a href="http://ruby-doc.org/stdlib-1.9.3/libdoc/csv/rdoc/CSV.html#method-c-new">método new</a>. Exemplo usando options:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;csv&#39;</span>
</span><span class='line'><span class="n">table_students</span> <span class="o">=</span> <span class="no">CSV</span><span class="o">.</span><span class="n">table</span><span class="p">(</span><span class="s1">&#39;/tmp/mock_data2.csv&#39;</span><span class="p">,</span> <span class="n">col_sep</span><span class="p">:</span> <span class="s2">&quot;;&quot;</span><span class="p">,</span> <span class="n">skip_blanks</span><span class="p">:</span> <span class="kp">true</span><span class="p">,</span> <span class="ss">converters</span><span class="p">:</span> <span class="o">[]</span><span class="p">)</span>
</span><span class='line'><span class="n">table_students</span><span class="o">.</span><span class="n">each</span> <span class="p">{</span> <span class="o">|</span><span class="n">row</span><span class="o">|</span> <span class="nb">puts</span> <span class="n">row</span><span class="o">.</span><span class="n">inspect</span> <span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2>CSV converters</h2>

<p><a href="http://www.ruby-doc.org/stdlib-1.9.3/libdoc/csv/rdoc/CSV.html#HeaderConverters">CSV::HeaderConverters</a> contém um hash de symbol e block que são usados para converter os valores do cabeçalho. Para usá-los, você deve informar qual <em>converter</em> deseja aplicar na opção <code>header_converters</code>. Acredito que o código abaixo explica melhor.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;csv&#39;</span>
</span><span class='line'><span class="nb">puts</span> <span class="ss">CSV</span><span class="p">:</span><span class="ss">:HeaderConverters</span><span class="o">.</span><span class="n">keys</span><span class="o">.</span><span class="n">inspect</span> <span class="c1"># =&gt; [:downcase, :symbol]</span>
</span><span class='line'>
</span><span class='line'><span class="c1"># Add new header converter</span>
</span><span class='line'><span class="ss">CSV</span><span class="p">:</span><span class="ss">:HeaderConverters</span><span class="o">[</span><span class="ss">:remap</span><span class="o">]</span> <span class="o">=</span> <span class="nb">lambda</span> <span class="k">do</span> <span class="o">|</span><span class="n">raw_value</span><span class="o">|</span>
</span><span class='line'>  <span class="n">raw_value</span> <span class="o">=</span> <span class="n">raw_value</span><span class="o">.</span><span class="n">to_sym</span>
</span><span class='line'>  <span class="k">case</span> <span class="n">raw_value</span>
</span><span class='line'>  <span class="k">when</span> <span class="ss">:country</span>
</span><span class='line'>    <span class="ss">:pais</span>
</span><span class='line'>  <span class="k">when</span> <span class="ss">:birthday</span>
</span><span class='line'>    <span class="ss">:dt_nascimento</span>
</span><span class='line'>  <span class="k">else</span>
</span><span class='line'>    <span class="n">raw_value</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="n">table_students</span> <span class="o">=</span> <span class="no">CSV</span><span class="o">.</span><span class="n">table</span><span class="p">(</span><span class="s1">&#39;mock_data.csv&#39;</span><span class="p">,</span> <span class="n">col_sep</span><span class="p">:</span> <span class="s2">&quot;,&quot;</span><span class="p">,</span> <span class="n">header_converters</span><span class="p">:</span> <span class="ss">:remap</span><span class="p">)</span>
</span><span class='line'><span class="n">table_students</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">row</span><span class="o">|</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="o">[</span><span class="n">row</span><span class="o">.</span><span class="n">fetch</span><span class="p">(</span><span class="ss">:pais</span><span class="p">),</span> <span class="n">row</span><span class="o">.</span><span class="n">fetch</span><span class="p">(</span><span class="ss">:dt_nascimento</span><span class="p">)</span><span class="o">].</span><span class="n">inspect</span> <span class="c1"># =&gt; [&quot;GB&quot;, &quot;01/06/1993&quot;]</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>No exemplo acima, criei o HeaderConverter &ldquo;remap&rdquo; que traduz o cabeçalho country para pais e birthday para dt_nascimento. Por padrão, o <code>CSV</code> disponibiliza os converters downcase e symbol, que por sinal são usados quando usamos o método <code>table</code> para ler csv.</p>

<p><a href="http://www.ruby-doc.org/stdlib-1.9.3/libdoc/csv/rdoc/CSV.html#Converters">CSV::Converters</a> segue o mesmo padrão de symbol e block, a única diferença que este é usado para converter os valores da linha. Vamos ao código.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;csv&#39;</span>
</span><span class='line'><span class="nb">require</span> <span class="s1">&#39;date&#39;</span>
</span><span class='line'>
</span><span class='line'><span class="nb">puts</span> <span class="ss">CSV</span><span class="p">:</span><span class="ss">:Converters</span><span class="o">.</span><span class="n">keys</span><span class="o">.</span><span class="n">inspect</span>       <span class="c1"># =&gt; [:integer, :float, :numeric, :date, :date_time, :all]</span>
</span><span class='line'>
</span><span class='line'><span class="c1"># Add new converter</span>
</span><span class='line'><span class="ss">CSV</span><span class="p">:</span><span class="ss">:Converters</span><span class="o">[</span><span class="ss">:nil_to_empty</span><span class="o">]</span> <span class="o">=</span> <span class="nb">lambda</span> <span class="k">do</span> <span class="o">|</span><span class="n">raw_value</span><span class="o">|</span>
</span><span class='line'>  <span class="n">raw_value</span><span class="o">.</span><span class="n">nil?</span> <span class="p">?</span> <span class="s2">&quot;&quot;</span> <span class="p">:</span> <span class="n">raw_value</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="c1"># Add new converter</span>
</span><span class='line'><span class="ss">CSV</span><span class="p">:</span><span class="ss">:Converters</span><span class="o">[</span><span class="ss">:brazilian_date</span><span class="o">]</span> <span class="o">=</span> <span class="nb">lambda</span> <span class="k">do</span> <span class="o">|</span><span class="n">raw_value</span><span class="o">|</span>
</span><span class='line'>  <span class="k">if</span> <span class="n">raw_value</span> <span class="o">=~</span> <span class="sr">/\d{2}\/\d{2}\/\d{4}/</span>
</span><span class='line'>    <span class="no">Date</span><span class="o">.</span><span class="n">strptime</span><span class="p">(</span><span class="n">raw_value</span><span class="p">,</span> <span class="s2">&quot;%d/%m/%Y&quot;</span><span class="p">)</span>
</span><span class='line'>  <span class="k">else</span>
</span><span class='line'>    <span class="n">raw_value</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="c1"># Group converters</span>
</span><span class='line'><span class="ss">CSV</span><span class="p">:</span><span class="ss">:Converters</span><span class="o">[</span><span class="ss">:my_custom_converters</span><span class="o">]</span> <span class="o">=</span> <span class="o">[</span><span class="ss">:nil_to_empty</span><span class="p">,</span> <span class="ss">:brazilian_date</span><span class="o">]</span>
</span><span class='line'>
</span><span class='line'><span class="n">table_students</span> <span class="o">=</span> <span class="no">CSV</span><span class="o">.</span><span class="n">table</span><span class="p">(</span><span class="s1">&#39;mock_data.csv&#39;</span><span class="p">,</span> <span class="n">col_sep</span><span class="p">:</span> <span class="s2">&quot;,&quot;</span><span class="p">,</span> <span class="ss">converters</span><span class="p">:</span> <span class="ss">:my_custom_converters</span><span class="p">)</span>
</span><span class='line'><span class="n">table_students</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">row</span><span class="o">|</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="o">[</span><span class="n">row</span><span class="o">.</span><span class="n">fetch</span><span class="p">(</span><span class="ss">:country</span><span class="p">),</span> <span class="n">row</span><span class="o">.</span><span class="n">fetch</span><span class="p">(</span><span class="ss">:birthday</span><span class="p">)</span><span class="o">].</span><span class="n">inspect</span> <span class="c1"># =&gt; [&quot;GB&quot;, #&lt;Date: 1993-06-01 ((2449140j,0s,0n),+0s,2299161j)&gt;]</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>No exemplo acima criei dois converters. Um para trocar nil por &ldquo;&rdquo; e o outro que converte para Date caso o valor esteja no formato 99/99/9999.</p>

<h2>Encoding hell com Excel</h2>

<p>Normalmente o csv é usado como meio de integração Excel &lt;=> Sistema. Acontece que o Excel não se dá muito bem com acentos especiais como ãõáé etc. Isto porque estamos em 2014. Acontece que quando há caracteres especiais, a única abordagem que funcionou foi exportar para Unicode text. Neste formato, o encoding do arquivo é UTF-16LE e separado por tab (\t). Este <a href="http://blog.plataformatec.com.br/2009/09/exportando-dados-para-excel-usando-csv-em-um-aplicativo-rails/">post de 2009 da Plataformatec</a> explica com mais detalhes este jeitinho do Excel de ser com os dados. A única diferença de 2009 pra hoje, é que podemos passar o encoding como parâmetro ao ler o arquivo, e por sorte evitar o uso do iconv. Vamos ao código:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;csv&#39;</span>
</span><span class='line'>
</span><span class='line'><span class="n">table</span> <span class="o">=</span> <span class="no">CSV</span><span class="o">.</span><span class="n">table</span><span class="p">(</span><span class="s1">&#39;mock_unicode.txt&#39;</span><span class="p">,</span>
</span><span class='line'>                  <span class="n">col_sep</span><span class="p">:</span> <span class="s2">&quot;</span><span class="se">\t</span><span class="s2">&quot;</span><span class="p">,</span> <span class="c1"># tab as delimiter</span>
</span><span class='line'>                  <span class="ss">encoding</span><span class="p">:</span> <span class="s2">&quot;UTF-16LE:UTF-8&quot;</span><span class="p">)</span> <span class="c1"># read UTF-16LE and convert to UTF-8</span>
</span><span class='line'><span class="n">table</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">row</span><span class="o">|</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="n">row</span><span class="o">.</span><span class="n">inspect</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<h2>Evitando o abuso de memória</h2>

<p>Ao ler arquivos com <code>read</code> ou <code>table</code>, o arquivo é colocado em memória, ou seja, ao processar uma planilha de 100mb, o seu processo ruby vai pra um 100mb e pouco. Agora imagina 20 workers e cada um processando uma planilha de 100mb ou mais, facilmente o seu servidor terá um pico de consumo de memória, o no pior cenário vai dar crash no processo. Para evitar este consumo devemos usar o <code>foreach</code> do <code>CSV</code>.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;csv&#39;</span>
</span><span class='line'>
</span><span class='line'><span class="no">CSV</span><span class="o">.</span><span class="n">foreach</span><span class="p">(</span><span class="s2">&quot;mock_data.csv&quot;</span><span class="p">,</span> <span class="n">col_sep</span><span class="p">:</span> <span class="s2">&quot;,&quot;</span><span class="p">)</span> <span class="k">do</span> <span class="o">|</span><span class="n">row</span><span class="o">|</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="n">row</span><span class="o">.</span><span class="n">inspect</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="c1"># =&gt;</span>
</span><span class='line'><span class="c1"># [&quot;id&quot;, &quot;name&quot;, &quot;country&quot;, &quot;birthday&quot;]</span>
</span><span class='line'><span class="c1"># [&quot;1&quot;, &quot;Virginia Harvey&quot;, &quot;GB&quot;, &quot;01/06/1993&quot;]</span>
</span></code></pre></td></tr></table></div></figure>


<p>Desta maneira a leitura é mais otimizada, pois apenas uma linha por vez é lida. O único problema é que perdemos algumas facilidades do <code>table</code>, como os <code>headers</code> e a instância do <code>CSV::Row</code> por linha. Tentando chegar no modelo ideal, montei uma classe que usa o foreach e mesmo assim tem os <code>headers</code> e os <code>rows</code>.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
<span class='line-number'>48</span>
<span class='line-number'>49</span>
<span class='line-number'>50</span>
<span class='line-number'>51</span>
<span class='line-number'>52</span>
<span class='line-number'>53</span>
<span class='line-number'>54</span>
<span class='line-number'>55</span>
<span class='line-number'>56</span>
<span class='line-number'>57</span>
<span class='line-number'>58</span>
<span class='line-number'>59</span>
<span class='line-number'>60</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;csv&#39;</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">SheetReader</span>
</span><span class='line'>
</span><span class='line'>  <span class="kp">attr_reader</span> <span class="ss">:headers</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">filepath</span><span class="p">)</span>
</span><span class='line'>    <span class="c1"># options to read unicode text file</span>
</span><span class='line'>    <span class="c1"># options = {</span>
</span><span class='line'>    <span class="c1">#   col_sep: &quot;\t&quot;,</span>
</span><span class='line'>    <span class="c1">#   skip_blanks: true,</span>
</span><span class='line'>    <span class="c1">#   encoding: &quot;UTF-16LE:UTF-8&quot;,</span>
</span><span class='line'>    <span class="c1">#   converters: []</span>
</span><span class='line'>    <span class="c1"># }</span>
</span><span class='line'>    <span class="n">options</span> <span class="o">=</span> <span class="p">{</span><span class="n">col_sep</span><span class="p">:</span> <span class="s2">&quot;,&quot;</span><span class="p">,</span> <span class="ss">converters</span><span class="p">:</span> <span class="o">[]</span><span class="p">}</span>
</span><span class='line'>    <span class="vi">@csv_reader</span> <span class="o">=</span> <span class="no">CSV</span><span class="o">.</span><span class="n">foreach</span><span class="p">(</span><span class="n">filepath</span><span class="p">,</span> <span class="n">options</span><span class="p">)</span> <span class="c1"># gets a iterator</span>
</span><span class='line'>    <span class="vi">@headers</span>    <span class="o">=</span> <span class="n">convert_headers</span><span class="p">(</span><span class="vi">@csv_reader</span><span class="o">.</span><span class="n">next</span><span class="p">)</span> <span class="c1"># read first line</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1"># yield an instance of http://ruby-doc.org/stdlib-2.1.0/libdoc/csv/rdoc/CSV/Row.html</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">each_row</span><span class="p">(</span><span class="o">&amp;</span><span class="n">block</span><span class="p">)</span>
</span><span class='line'>    <span class="k">begin</span>
</span><span class='line'>      <span class="k">while</span> <span class="kp">true</span>
</span><span class='line'>        <span class="n">raw_row</span> <span class="o">=</span> <span class="vi">@csv_reader</span><span class="o">.</span><span class="n">next</span>  <span class="c1"># raise StopIteration in EOF</span>
</span><span class='line'>        <span class="k">yield</span> <span class="ss">CSV</span><span class="p">:</span><span class="ss">:Row</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="n">headers</span><span class="p">,</span> <span class="n">raw_row</span><span class="p">)</span>
</span><span class='line'>      <span class="k">end</span>
</span><span class='line'>    <span class="k">rescue</span> <span class="no">StopIteration</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="kp">protected</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1"># Internal: Convert headers to Array of symbols.</span>
</span><span class='line'>  <span class="c1">#</span>
</span><span class='line'>  <span class="c1"># raw_headers - Array of Strings.</span>
</span><span class='line'>  <span class="c1">#</span>
</span><span class='line'>  <span class="c1"># Examples</span>
</span><span class='line'>  <span class="c1">#</span>
</span><span class='line'>  <span class="c1">#   convert_headers([&quot;ATIVO&quot;, &quot;NOME COMERCIAL&quot;])</span>
</span><span class='line'>  <span class="c1">#   # =&gt; [:ativo, :nome_comercial]</span>
</span><span class='line'>  <span class="c1">#</span>
</span><span class='line'>  <span class="c1"># Returns Array of symbols.</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">convert_headers</span><span class="p">(</span><span class="n">raw_headers</span><span class="p">)</span>
</span><span class='line'>    <span class="n">raw_headers</span><span class="o">.</span><span class="n">compact!</span> <span class="c1"># removes nil values</span>
</span><span class='line'>    <span class="n">converter</span> <span class="o">=</span> <span class="nb">lambda</span> <span class="k">do</span> <span class="o">|</span><span class="n">header</span><span class="o">|</span>
</span><span class='line'>      <span class="n">header_converters</span> <span class="o">=</span> <span class="ss">CSV</span><span class="p">:</span><span class="ss">:HeaderConverters</span><span class="o">.</span><span class="n">values</span>
</span><span class='line'>      <span class="n">header_converters</span><span class="o">.</span><span class="n">inject</span><span class="p">(</span><span class="n">header</span><span class="p">)</span> <span class="k">do</span> <span class="o">|</span><span class="n">header</span><span class="p">,</span> <span class="n">converter_proc</span><span class="o">|</span>
</span><span class='line'>        <span class="n">converter_proc</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="n">header</span><span class="p">)</span>
</span><span class='line'>      <span class="k">end</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">raw_headers</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">header</span><span class="o">|</span> <span class="n">converter</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="n">header</span><span class="p">)</span> <span class="p">}</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="n">reader</span> <span class="o">=</span> <span class="no">SheetReader</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">&#39;mock_data.csv&#39;</span><span class="p">)</span>
</span><span class='line'><span class="n">reader</span><span class="o">.</span><span class="n">headers</span> <span class="c1"># =&gt; [:id, :name, :country, :birthday]</span>
</span><span class='line'><span class="n">reader</span><span class="o">.</span><span class="n">each_row</span> <span class="k">do</span> <span class="o">|</span><span class="n">row</span><span class="o">|</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="n">row</span><span class="o">.</span><span class="n">inspect</span> <span class="c1"># =&gt; #&lt;CSV::Row id:&quot;1&quot; name:&quot;Virginia Harvey&quot; country:&quot;GB&quot; birthday:&quot;01/06/1993&quot;&gt;</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Por último, uma observação importante: todo este código acima foi rodado no ruby 2.1.0. Espero que este mini guia de como ler arquivo csv com Ruby te ajude.
Segue alguns links com mais informações:</p>

<ul>
<li><a href="http://www.sitepoint.com/guide-ruby-csv-library-part/">http://www.sitepoint.com/guide-ruby-csv-library-part/</a></li>
<li><a href="http://www.sitepoint.com/guide-ruby-csv-library-part-2/">http://www.sitepoint.com/guide-ruby-csv-library-part-2/</a></li>
<li><a href="http://technicalpickles.com/posts/parsing-csv-with-ruby/">http://technicalpickles.com/posts/parsing-csv-with-ruby/</a></li>
<li><a href="http://blog.plataformatec.com.br/2009/09/exportando-dados-para-excel-usando-csv-em-um-aplicativo-rails/">http://blog.plataformatec.com.br/2009/09/exportando-dados-para-excel-usando-csv-em-um-aplicativo-rails/</a></li>
</ul>


<p>Dúvidas, sugestões ou qualquer outra coisa. Deixe um comentário ou se preferir, mande um <a href="https://twitter.com/rogerleite">tweety!</a> :D</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Extraindo dados da Internet com Clojure]]></title>
    <link href="http://1up4dev.org/2014/10/extraindo_dados_da_internet_com_clojure/"/>
    <updated>2014-10-28T12:10:00-02:00</updated>
    <id>http://1up4dev.org/2014/10/extraindo_dados_da_internet_com_clojure</id>
    <content type="html"><![CDATA[<h2>O problema</h2>

<p>A Internet é um repositórios de dados gigantesco e frequentemente precisamos extrair algo que nos interessa de maneira automatizada. O grande problema é que esses dados normalmente são apresentados de forma não estruturada, e precisamos utilizar uma técnica chamada <em>scrapping</em>, que consiste em abrir uma página, carregar o HTML e navegar dentro desse código para extrair o que precisamos.</p>

<p>Com o uso das ferramentas certas isso não é complicado, mas pode ser trabalhoso e, uma vez que a página que você estiver lendo altere alguma coisa em sua estrutura, você terá que adaptar seu código às mudanças.</p>

<p>Vamos apresentar um exemplo simples, mas que vai te dar uma boa base de como extrair dados de uma página utilizando Clojure.</p>

<h2>Quem escreveu mais livros na Casa do Código?</h2>

<p>A Casa do Código é uma editora brasileira especializada em livros para desenvolvedores de software, empreendedores e webdesigners. Seus autores são profissionais conhecidos em suas respectivas áreas e precisamos saber quais deles escreveram mais livros.</p>

<p>Para isso, vamos abrir a página inicial da editora em <a href="http://www.casadocodigo.com.br/,">http://www.casadocodigo.com.br/,</a> que contém links para todos os livros publicados até o momento. Com esses links em mãos, vamos entrar em cada um deles e extrair os nomes dos autores para em seguida agrupá-los e apresentarmos o resultado.</p>

<h3>Como fazer</h3>

<blockquote><p>É necessário ter algum conhecimento de Clojure e Leiningen para poder acompanhar este post. Dê uma lida no texto <a href="http://1up4dev.org/2014/09/magica-com-o-repl-do-clojure/">Fazendo mágica com o REPL do Clojure</a> para aprender como criar um projeto.</p></blockquote>

<p>Vamos criar um projeto chamado <code>autores</code>, definir o namespace inicial e adicionar a biblioteca <em>Enlive</em>, que vai nos permitir extrair os dados que queremos de dentro do código HTML. O nosso arquivo project.clj vai ficar parecido com o exemplo abaixo:</p>

<pre><code>(defproject autores "0.1.0-SNAPSHOT"
  ; informações de licença e descrição do projeto

  :dependencies [[org.clojure/clojure "1.6.0"]
                 [enlive "1.1.5"]]
  :main autores.core)
</code></pre>

<p>Enlive é uma biblioteca criada por Christophe Grand, coautor de Clojure Programming, que permite que você gere código HTML escrevendo em Clojure, e permite também que você extraia textos de um arquivo HTML já existente.</p>

<p>Para utilizarmos o Enlive em nosso código, vamos referenciar as funções na nossa declaração de namespace. Vamos também adicionar o <em>Pretty Print</em> para exibir o resultado formatado e as bibliotecas do <em>clojure.string</em> para manipularmos o texto. Também vamos precisar importar a classe <code>java.net.URL</code> para tratarmos o endereço do site. Nosso código então começa assim:</p>

<pre><code>(ns autores.core
  (:require [clojure.pprint :as pp]
            [net.cgrand.enlive-html :as en]
            [clojure.string :as str])
  (:import  [java.net URL]))
</code></pre>

<p>O primeiro passo é varrer a página inicial da editora e extrair os links dos livros. Abrindo o código fonte da página, percebemos que ela tem a seguinte estrutura, que aqui está devidamente resumida para fins de apresentação:</p>

<pre><code>&lt;html&gt;
&lt;head&gt;
  &lt;!-- titulo, meta, etc --&gt;
&lt;/head&gt;
&lt;body&gt;
  &lt;nav&gt;
    &lt;!-- menu do topo --&gt;
  &lt;/nav&gt;
  &lt;section&gt;
    &lt;!-- links e imagens com os livros --&gt;
  &lt;/section&gt;
  &lt;footer&gt;
    &lt;!-- menu do rodapé --&gt;
  &lt;/footer&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>

<p>Visualmente, a página tem a aparência da imagem abaixo:</p>

<p><img src="http://1up4dev.org/images/uploads/2014/10/cdc-parts.png" alt="/images/uploads/2014/10/cdc-parts.png" /></p>

<p>Felizmente a página está bem estruturada e todos os links que nos interessam estão dentro da área <code>section</code>, o que vai nos poupar trabalho.</p>

<p>Vamos criar uma função chamada <code>get-links</code>, que vai receber a URL do site em formato texto e vamos extrair todo o código HTML usando a função <code>html-resource</code> do Enlive.</p>

<pre><code>(defn- get-links [url]
  (en/html-resource (URL. url)))
</code></pre>

<p>Perceba que a função <code>html-resource</code> exige que você converta a URL de texto para um objeto <code>java.net.URL</code>, para só então o passarmos como parâmetro para o Enlive.</p>

<p>Para evitar que o encadeamento de muitas funções torne o código difícil de ler, vamos alterá-lo para utilizar o operador <code>-&gt;</code> e vamos guardar o resultado em um <em>binding</em> chamado <code>links</code>. Perceba que essa abordagem permite que possamos adicionar funções no final da lista de argumentos de <code>-&gt;</code> sem diminuir a legibilidade do código.</p>

<pre><code>(defn- get-links [url]
  (let [links (-&gt; url
                  URL.
                  en/html-resource)]
    (pp/pprint links)))
</code></pre>

<p>Vamos então usar a função <code>select</code>, também do Enlive, que recebe como argumento um <em>vector</em> com as tags que você deseja extrair. Nós queremos somente os links, formados pela tag <code>&lt;a&gt;&lt;/a&gt;</code>, que estão contidas entre <code>&lt;section&gt;</code> e <code>&lt;/section&gt;</code>.</p>

<pre><code>(defn- get-links [url]
  (let [links (-&gt; url
                  URL. 
                  en/html-resource
                  (en/select [:body :section :a]))]))
</code></pre>

<p>A função <code>select</code> vai nos retornar uma lista contendo um <em>map</em> para cada elemento HTML que obedecer aos nossos requisitos. Cada <em>map</em> tem um item <code>:attrs</code> que contém os atributos da tag HTML, incluindo a página para a qual o link está apontando. Ainda dentro da função <code>get-links</code>, vamos converter essa lista de mapas em uma lista que contenha apenas os endereços e para isso vamos usar a função <code>map</code>, que recebe como parâmetros a função que vai transformar cada item da lista e a lista a ser transformada. Para fins de didática, vamos suprimir o código que está dentro de <code>let</code>, para só no final da explicação mostrarmos a função completa.</p>

<pre><code>  (map #((% :attrs) :href) 
       links)
</code></pre>

<p>Agora nossa função está retornando uma lista de links como na listagem abaixo, devidamente resumida:</p>

<pre><code>("/products/livro-programador-apaixonado"
 "/products/livro-aspnet-mvc"
 "/products/livro-jpa-eficaz"
 "/products/livro-photoshop"
 "/products/colecao-frameworks-java"
 ...
 "/products/livro-ciencia-da-computacao-com-jogos"
 "/products/vale-presente")
</code></pre>

<p>Os links são relativos à URL da página inicial, então vamos adicionar o endereço que que foi passado para a função <code>get-links</code> para torná-los absolutos. Note que nessa lista existem links que não são de livros, mas de coleções e do vale presente. Podemos eliminá-los usando a função <code>filter</code>, que recebe como parâmetros uma função que retorna <code>true</code> ou <code>false</code> de acordo com cada item da lista, e a lista a ser filtrada que é passada como terceiro parâmetro. Os itens que fizerem a função retornar <code>true</code> ficam, e os demais não são incluidos.</p>

<pre><code>(filter
  #(. % contains "livro")
  (map #(str url ((% :attrs) :href)) 
       links))
</code></pre>

<p>E agora nossa função retorna os endereços absolutos de todos os livros da editora, conforme a listagem abaixo:</p>

<pre><code>("http://www.casadocodigo.com.br/products/livro-programador-apaixonado"
 "http://www.casadocodigo.com.br/products/livro-aspnet-mvc"
 "http://www.casadocodigo.com.br/products/livro-jpa-eficaz"
 "http://www.casadocodigo.com.br/products/livro-photoshop"
 ...
 "http://www.casadocodigo.com.br/products/livro-ciencia-da-computacao-com-jogos")
</code></pre>

<p>Agora que concluímos o primeiro passo da nossa pesquisa, vamos editar o código da nossa função <code>main</code> para que a função <code>get-links</code> seja chamada:</p>

<pre><code>(defn -main [&amp; args]
  (pp/pprint
    (get-links "http://www.casadocodigo.com.br")))
</code></pre>

<p>Vamos criar agora uma função chamada <code>get-author</code>, que vai receber cada um dos links e, usando as funções do Enlive que já conhecemos, vai extrair o nome do autor, ou dos autores, de cada um dos livros.</p>

<p>Os nomes dos autores ficam dentro de uma tag <code>span</code> marcada com a classe <code>product-author-link</code>. Mais uma vez o site bem construído nos ajuda na tarefa. Para pesquisarmos uma tag que esteja utilizando determinada classe, vamos separar tag e classe com um ponto final, como se fosse um arquivo CSS. Assim, o nosso <code>span</code> com a classe <code>product-author-link</code> vai virar <code>:span.product-author-link</code>. O código inicial não vai ficar muito diferente do que fizemos em <code>get-links</code>:</p>

<pre><code>(defn- get-author [url]
  (let [authors (-&gt; url
                    URL.
                    en/html-resource
                    (en/select [:span.product-author-link]))]
      (pp/pprint authors)))
</code></pre>

<p>Vamos usar o link do primeiro livro para testar. O resultado traz toda a informação da tag <code>span</code> dentro de um map que está dentro de uma lista, e não só o nome do autor.</p>

<pre><code>(get-author "http://www.casadocodigo.com.br/products/livro-programador-apaixonado")

({:tag :span,
  :attrs {:class "product-author-link"},
  :content
  ("\n          \n            Chad Fowler\n          \n        ")})
</code></pre>

<p>Novamente vamos suprimir o código que está dentro do <code>let</code> para não poluir o texto. Vamos selecionar o <em>map</em> que está dentro da lista usando a função <code>first</code> e, em seguida, utilizar somente o valor que está na chave <code>:content</code>:</p>

<pre><code>((first authors) :content)
</code></pre>

<p>O valor que estava em <code>:content</code> também é uma lista contendo o nome do autor. Além do nome do autor, o texto está poluído com quebras de linhas, simbolizado por <code>\n</code> e espaços em branco. Vamos utilizar a função <code>replace</code> do namespace <code>clojure.string</code> para remover esses caracteres indesejados. Essa função recebe como parâmetros o texto original, uma expressão regular indicando o que deve ser alterado e, por último, o texto a ser utilizado na alteração.</p>

<p>Vamos utilizar o operador <code>-&gt;</code> para facilitar a leitura:</p>

<pre><code>(-&gt; ((first authors) :content)
    first
    (str/replace #"(\n|  )" ""))
</code></pre>

<p>Ao executar a função, temos o nome do autor limpo e sem caracteres indesejados:</p>

<pre><code>(get-author "http://www.casadocodigo.com.br/products/livro-programador-apaixonado")
=&gt; "Chad Fowler"
</code></pre>

<p>Tudo certo quando estamos lidando com um livro escrito por apenas um autor, mas quando temos coautorias a nossa função já não faz o que é esperado. Por exemplo, no livro de ASP.NET MVC, nossa função retorna o autor como <code>Fabrício Sanchez e Márcio Fábio Althmann</code>, e no livro de Lógica de Programação temos <code>Paulo Silveira, Adriano Almeida</code>. Tanto <code>,</code> como <code>e</code> são usados para separar os nomes dos autores.
Vamos fazer a nossa função retornar um <em>vector</em> com os nomes dos autores separados utilizando a função <code>split</code>, do namespace <code>clojure.string</code>. Essa função recebe como argumentos o texto a ser dividido e uma expressão regular indicando onde o texto deve ser dividido:</p>

<pre><code>(-&gt; ((first authors) :content)
    first
    (str/replace #"(\n|  )" "")
    (str/split #"(, | e )"))
</code></pre>

<p>Agora temos os nomes dos autores separados corretamente dentro um <em>vector</em>, como no exemplo abaixo:</p>

<pre><code>(get-author "http://www.casadocodigo.com.br/products/livro-programacao")
=&gt; ["Paulo Silveira" "Adriano Almeida"]
</code></pre>

<p>Voltando à nossa função <code>-main</code>, vamos fazer com que a função <code>get-author</code> pega os autores de cada um dos links retornados pela função <code>get-links</code>. Vamos usar o operador <code>-&gt;&gt;</code> para deixar mais fácil de entender as transformações que estamos fazendo nos dados. A diferença para o <code>-&gt;</code> é que o operador <code>-&gt;&gt;</code> passa o resultado da expressão como último parâmetro da expressão seguinte, enquanto o operador <code>-&gt;</code> passa como primeiro. Isso é necessário para podermos passar a lista retornada por <code>get-links</code> para a função <code>map</code> da expressão seguinte:</p>

<pre><code>(defn -main [&amp; args]
  (pp/pprint
    (-&gt;&gt; "http://www.casadocodigo.com.br"
         get-links
         (map get-author))))
</code></pre>

<p>A nossa função <code>-main</code> retornou uma lista contendo vários <em>vector</em> com os nomes dos autores. Um livro com mais de um autor vai retornar um <em>vector</em> com mais de um nome.</p>

<pre><code>(["Chad Fowler"]
 ["Fabrício Sanchez" "Márcio Fábio Althmann"]
 ...
 ["Mauricio Tollin" "Rodrigo Gomes" "Anderson Leite"]
 ...
 ["André Backes"]
 ["Bruno Feijó" "Esteban Clua" "Flávio S. Correa da Silva"])
</code></pre>

<p>Vamos utilizar a função <code>flatten</code> para converter essa lista de <em>vectors</em> de diversos tamanhos em uma lista de uma dimensão. Isso vai nos permitir calcular quantas vezes cada nome aparece na lista por meio da função <code>frequencies</code>. Como cada vez que o nome aparece é um livro escrito por aquele autor, podemos entender que <code>frequencies</code> vai atribuir o número de livros que aquele autor tem publicado pela Casa do Código:</p>

<pre><code>(defn -main [&amp; args]
  (pp/pprint
    (-&gt;&gt; "http://www.casadocodigo.com.br"
         get-links
         (map get-author)
         flatten
         frequencies)))
</code></pre>

<p>Agora temos uma lista não ordenada com o nome do autor e a quantidade de livros publicados:</p>

<pre><code>{"Caio Ribeiro Pereira" 1,
 "Fabrício Sanchez" 1,
 "Alexandre Saudate" 2,
 "Chad Fowler" 1,
 ...
 "Gabriel Schade Cardoso" 1,
 "Guilherme Moreira" 1}
</code></pre>

<p>Nosso próximo passo é ordenar essa lista, deixando os autores com maior número de livros no topo. Para isso vamos usar a função <code>sort</code>, que permite que você informe uma função para selecionar o critério de ordenação, que no nosso caso vai ser a função <code>last</code>, que retorna o último item de uma lista, e também a função que vai ser usada para comparar um item com outro e definir quem vem primeiro, que nosso caso vai ser <code>&gt;</code>. No caso do <code>last</code>, convém deixar claro que vamos pegar o último item do que vai ser comparado. No caso de <code>"Caio Ribeiro Pereira" 1</code>, o último item é o número 1. Se quisessemos ordenar por nome, usariámos a função <code>first</code>.</p>

<p>Em seguida vamos dividir essa lista em <em>n</em> grupos, de acordo com a quantidade de livros publicados usando a função <code>partition-by</code>. No nosso exemplo teremos um grupo com autores que tenham dois livros publicados e outro com autores com apenas um livro. Como nos interessa apenas os autores que mais publicaram livros, vamos usar a função <code>first</code> para selecionarmos apenas o primeiro grupo. Com isso nosso código ficará assim:</p>

<pre><code>(defn -main [&amp; args]
  (pp/pprint
    (-&gt;&gt; "http://www.casadocodigo.com.br"
         get-links
         (map get-author)
         flatten
         frequencies
         (sort-by last &gt;)
         (partition-by last)
         first)))
</code></pre>

<p>Agora temos o resultado abaixo:</p>

<pre><code>(["Alexandre Saudate" 2]
 ["Sérgio Lopes" 2]
 ["Paulo Silveira" 2]
 ["Tárcio Zemel" 2]
 ["Anderson Leite" 2]
 ["Mauricio Aniche" 2]
 ["Gilliard Cordeiro" 2]
 ["Hébert Coelho" 2]
 ["Eduardo Guerra" 2]
 ["Rafael Steil" 2])
</code></pre>

<p>Agora que temos a lista dos maiores autores, vamos otimizar um o nosso código adicionando uma dose de processamento paralelo. Note que a função <code>get-links</code> retorna uma lista de endereços que é passada como parâmetro para a função <code>map</code>, que passa endereço por endereço para a função <code>get-author</code>, sequencialmente. Se trocarmos <code>map</code> por <code>pmap</code>, serão criadas threads que executarão <code>get-author</code> em paralelo, melhorando o tempo total do nosso código. A quantidade de thread criadas por <code>pmap</code> está diretamente ligada ao número de núcleos ou processadores que sua máquina tiver.</p>

<p>Porém, o uso de <code>pmap</code> pode trazer um problema: é comum que a aplicação fique congelada por até um minuto após a execução do <code>pmap</code> por conta de questões internas de timeout de threads e configurações do pool utilizado pelo Clojure. Para resolver isso, devemos solicitar ao Clojure que finalize todas as thread que não estiverem sendo usadas, liberando-as para que o programa possa ser encerrado. Para isso usamos a função <code>shutdown-agents</code> na última linha da função <code>-main</code>.</p>

<p>Agora temos o nosso código funcionando alguns segundos mais rápido e trazendo os autores que mais publicaram livros pela Casa do Código.</p>

<h3>Código completo</h3>

<pre><code>(ns autores.core
  (:require [clojure.pprint :as pp]
            [net.cgrand.enlive-html :as en]
            [clojure.string :as str])
  (:import  [java.net URL]))

(defn- get-links [url]
  (let [links (-&gt; url
                  URL. 
                  en/html-resource
                  (en/select [:body :section :a]))]
      (filter
        #(. % contains "livro")
        (map #(str url ((% :attrs) :href)) 
             links))))

(defn- get-author [url]
  (let [authors (-&gt; url
                    URL.
                    en/html-resource
                    (en/select [:span.product-author-link]))]
    (str/split
      (str/replace
        (first
          ((first authors) :content))
        #"(\n|  )" "")
      #"(, | e )")))

(defn -main [&amp; args]
  (println "Os autores com mais publicações na Casa do Código:")
  (pp/pprint
    (-&gt;&gt; "http://www.casadocodigo.com.br"
         get-links
         (pmap get-author)
         flatten
         frequencies
         (sort-by last &gt;)
         (partition-by last)
         first))
  (shutdown-agents))
</code></pre>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Fazendo mágica com o REPL do Clojure]]></title>
    <link href="http://1up4dev.org/2014/09/magica-com-o-repl-do-clojure/"/>
    <updated>2014-09-23T18:24:00-03:00</updated>
    <id>http://1up4dev.org/2014/09/magica-com-o-repl-do-clojure</id>
    <content type="html"><![CDATA[<p>Caso você não esteja íntimo com o REPL do Clojure, recomendo a leitura do <a href="http://1up4dev.org/2014/04/alguns-truques-com-o-repl-do-clojure/">texto anterior</a> para aprender o básico.</p>

<p>É recomendado também que você leia as mensagens emitidas pela aplicação com a voz do <a href="http://pt.wikipedia.org/wiki/Cid_Moreira">Cid Moreira</a>. Para uma versão em inglês do artigo estou considerando sugerir as vozes do Morgan Freeman ou do Stephen Fry.</p>

<p>As pessoas me perguntam se um REPL é equivalente ao IRB do Ruby ou o modo interativo do Python. No artigo anterior eu comentei que o REPL é bem mais do que isso, mas ainda não fui convincente o bastante.</p>

<p>Nesse artigo eu pretendo demonstrar como podemos modificar a aplicação enquanto ela é executada, sem necessidade de reiniciá-la ou de esperar para que a compilação termine.</p>

<p>Primeiro, vamos instalar uma ferramenta chamada <strong>Leiningen</strong>, que pode ser facilmente instalada a partir de <a href="http://leiningen.org/#install.">http://leiningen.org/#install.</a></p>

<p>O <strong>Leiningen</strong> é uma ferramenta que automatiza uma série de processos cotidianos do desenvolvimento de uma aplicação, além de também cuidar das dependências da aplicação. Pense nele como um primo bonito do <strong>Maven</strong> ou do <strong>Gradle</strong>.</p>

<p>Primeiro, vamos criar uma aplicação usando o <strong>Leiningen</strong>.</p>

<p>No terminal, digite:</p>

<pre><code>lein new misterm
</code></pre>

<p>Se for a primeira vez que você utiliza o <strong>Leiningen</strong>, algumas dependências serão baixadas para a sua máquina.</p>

<pre><code>$ lein new misterm
Generating a project called misterm based on the 'default' template.
The default template is intended for library projects, not applications.
To see other templates (app, plugin, etc), try `lein help new`.
</code></pre>

<p>Será criado um diretório chamado <code>misterm</code>, onde teremos nossa aplicação, e dentro desse diretório, edite um arquivo <code>project.clj</code>.</p>

<pre><code>; O seu arquivo project.clj vai ter essa cara
(defproject misterm "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.6.0"]])
</code></pre>

<p>O conteúdo do arquivo <code>project.clj</code> nada mais é do que um código Clojure válido, sendo <code>defproject</code> uma <strong>macro</strong> que armazena as configurações do projeto em algum estado global. Vou deixar para explicar macros em outro artigo.</p>

<p>Para que a mágica funcione, vamos adicionar o <code>nREPL</code> na nossa aplicação. <code>nREPL</code> é uma biblioteca que permite que o REPL do Clojure seja acessado remotamente, normalmente através de uma porta TCP. O próprio REPL do Clojure disponibilizado pelo Leiningen já vem com o nREPL, como vamos ver mais para frente.</p>

<p>Para criarmos um projeto executável, precisamos informar no projeto em qual <strong>namespace</strong> estará o <strong>entrypoint</strong> da aplicação. Pense num <strong>namespace</strong> como um <strong>package</strong> do Java, apesar de existirem grandes diferenças entre ambos. Para a nossa explicação, considerar um como o outro basta.</p>

<p>Vamos editar o arquivo, adicionando a nova dependência dentro do vetor <code>:dependencies</code> e também a opção <code>:main misterm.core</code> antes do parêntese final.</p>

<p>O final do arquivo vai ficar assim:</p>

<pre><code>; final do arquivo project.clj
  :dependencies [[org.clojure/clojure "1.6.0"]
                 [org.clojure/tools.nrepl "0.2.5"]]
  :main misterm.core)
</code></pre>

<p>Agora vamos editar o arquivo <code>core.clj</code>, que está dentro de <code>src/misterm</code>. Perceba que o nome da aplicação é usado por padrão como parte do nome do <strong>namespace</strong>.</p>

<p>Encontraremos um arquivo assim:</p>

<pre><code>(ns misterm.core)

(defn foo
  "I don't do a whole lot."
  [x]
  (println x "Hello, World!"))
</code></pre>

<p>Aqui está sendo declarado o <strong>namespace</strong> <code>misterm.core</code>, e em seguida uma função <code>foo</code> que simplesmente imprime o texto <strong>Hello, World!</strong>.</p>

<p>Vamos modificar a declaração do <strong>namespace</strong> para que possamos usar o <code>nREPL</code> em nossa aplicação.</p>

<pre><code>(ns misterm.core
    (:require [clojure.tools.nrepl.server :as nrepl]))
</code></pre>

<p>Em seguida vamos iniciar o servidor do <code>nREPL</code> na porta 12345.</p>

<pre><code>(defonce server (nrepl/start-server :port 12345))
</code></pre>

<p>Estamos usando <code>defonce</code> aqui para garantir que, ao acessarmos a aplicação via <code>nREPL</code>, o servidor não seja iniciado mais de uma vez. Caso isso aconteça teremos um erro porque a porta 12345 já estará em uso.</p>

<p>Vamos apagar a função <code>foo</code> e vamos criar uma chamada <code>magic</code>:</p>

<pre><code>(defn magica []
  (Thread/sleep 2000)
  (println "Mostre-nos o seu segredo, Mister M"))
</code></pre>

<p>Nossa função simplesmente espera dois segundos e, sem seguida, imprime na tela um texto.</p>

<p>Agora vamos criar a função <code>-main</code>, que serve como <strong>entrypoint</strong> da aplicação, assim como o método <code>main</code> de uma aplicação Java.</p>

<pre><code>(defn -main [&amp; args]
  (loop []
    (magica)
    (recur)))
</code></pre>

<p>O argumento <code>&amp; args</code> indica que a função <code>-main</code> aceita uma quantidade indefinida de parâmetros, ou mesmo nenhum, exatamente como acontece com o método <code>main(String ... args)</code> do Java.</p>

<p>Os operadores <code>loop</code> e <code>recur</code> são usados para simularmos <strong>tail call recursion</strong> no Clojure, o que é assunto para outro texto. Para o que precisamos, basta saber que criamos um loop infinito com eles. Dentro desse loop infinito estamos invocando a função <code>magica</code>.</p>

<p>Tudo pronto, vamos salvar o arquivo e voltar para o terminal. Execute o comando <code>lein run</code> para executar a aplicação e a cada dois segundos será exibida a mensagem. Lembre-se de usar a voz do Cid Moreira ao ler.</p>

<pre><code>$ lein run
Mostre-nos o seu segredo, Mister M
Mostre-nos o seu segredo, Mister M
Mostre-nos o seu segredo, Mister M
Mostre-nos o seu segredo, Mister M
Mostre-nos o seu segredo, Mister M
</code></pre>

<p>Vamos abrir um novo terminal e executar o comando <code>lein repl :connect 127.0.0.1:12345</code>.</p>

<pre><code>$ lein repl :connect 127.0.0.1:12345
Connecting to nREPL at 127.0.0.1:12345
REPL-y 0.3.5, nREPL 0.2.6
Clojure 1.6.0
Java HotSpot(TM) 64-Bit Server VM 1.8.0-b132
    Docs: (doc function-name-here)
          (find-doc "part-of-name-here")
  Source: (source function-name-here)
 Javadoc: (javadoc java-object-or-class-here)
    Exit: Control+D or (exit) or (quit)
 Results: Stored in vars *1, *2, *3, an exception in *e

user=&gt;
</code></pre>

<p>O prompt indica que estamos no namespace padrão do Clojure, chamado <code>user</code>. Vamos para o namespace onde estão as nossas funções para verificar se estamos mesmo conectados na aplicação.</p>

<pre><code>(ns misterm.core)
</code></pre>

<p>Agora vamos executar a função <code>magica</code>. Se tudo foi feito corretamente até agora, vamos esperar dois minutos e então ler a mensagem <strong>Mostre-nos o seu segredo, Mister M</strong>.</p>

<pre><code>(magica)
; Mostre-nos o seu segredo, Mister M
</code></pre>

<p>Tudo certo. Agora vamos modificar a aplicação enquanto ela está sendo executada.</p>

<p>Dê uma olhada no primeiro terminal. A essa altura a nossa mensagem já encheu a tela.</p>

<p>De volta ao segundo terminal, o que está com o REPL aberto, reescreva o conteúdo da função <code>magica</code>:</p>

<pre><code>(defn magica []
  (Thread/sleep 1000)
  (println "Aaaaaahhhhh, Mister M!"))
</code></pre>

<p>A função <code>magica</code> já existia, mas estamos redefinindo em tempo de execução. Se você tentar fazer isso no IRB, por exemplo, receberá uma mensagem de erro.</p>

<p>Agora olhe novamente no primeiro terminal, aquele que estava com a tela cheia de mensagens.</p>

<pre><code>Mostre-nos o seu segredo, Mister M
Mostre-nos o seu segredo, Mister M
Mostre-nos o seu segredo, Mister M
Mostre-nos o seu segredo, Mister M
Mostre-nos o seu segredo, Mister M
Aaaaaahhhhh, Mister M!
Aaaaaahhhhh, Mister M!
Aaaaaahhhhh, Mister M!
</code></pre>

<p>A mensagem mudou! Não só isso. Agora ela leva um segundo para ser exibida na tela, ao invés dos dois originais. Nós mudamos a aplicação enquanto ela estava sendo executada.</p>

<p>Claro que toda mágica tem lá seus pontos a serem considerados. Se você reiniciar a aplicação a mensagem original será novamente exibida, já que alteramos a aplicação enquanto ela estava sendo executada, e não seu código fonte.</p>

<p>Esse recurso é muito útil para corrigir erros sem derrubar a aplicação, para desenvolver aplicações de maneira verdadeiramente incremental e iterativa, e também para aumentarmos a velocidade do ciclo de desenvolvimento ao máximo. Pense que dessa forma não precisamos mais derrubar a aplicação, recompilar, executar novamente, aguardar o tempo de carga da JVM, que não é pouco. Numa visão otimista, caso você ganhe dez segundos em cada iteração do seu ciclo de desenvolvimento, ao final do dia você terá economizado muito tempo, além de ter mantido o foco naquilo que realmente importa. É sabido que essas mudanças de contexto, por mais rápidas que sejam, atrapalham a concentração e a produtividade.</p>

<p>Editores como <strong>Emacs</strong> e <strong>ViM</strong> têm plugins que se conectam ao <code>nREPL</code>, fazendo com que você nem ao menos precise fechar a janela de edição de código para alterar a aplicação. Já o <strong>Lighttable</strong> oferece um modo chamado <strong>InstantREPL</strong>, onde seu código é avaliado na própria edição, exibindo os valores enquanto você programa.</p>

<p>O REPL é uma ferramenta poderosa não só no Clojure, mas em praticamente todos os dialetos LISP. Experimente fazer isso com a sua linguagem preferida e veja se consegue ter tanto ganho de produtividade.</p>

<p>P.S.: Jon Garret conseguiu inclusive corrigir um bug em um satélite em órbita graças ao uso do REPL. Leia mais <a href="http://www.flownet.com/gat/jpl-lisp.html">aqui</a>.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Integração Contínua e Entrega Contínua de modo fácil com Wercker]]></title>
    <link href="http://1up4dev.org/2014/09/integracao-continua-e-entrega-continua-de-modo-facil-com-wercker/"/>
    <updated>2014-09-06T12:33:00-03:00</updated>
    <id>http://1up4dev.org/2014/09/integracao-continua-e-entrega-continua-de-modo-facil-com-wercker</id>
    <content type="html"><![CDATA[<p><strong>TL;DR</strong> <a href="http://wercker.com/">Wercker</a> é uma plataforma de integração contínua, baseado em
containers e focado em facilitar o build e deploy de aplicações na nuvem. Totalmente
integrado com <a href="http://github.com">Github</a>, <a href="https://bitbucket.org/">BitBucket</a>, <a href="https://www.heroku.com/">Heroku</a>,
<a href="http://aws.amazon.com/">AWS</a> e <a href="https://www.openshift.com/">OpenShift</a>, em questão de minutos e com apenas alguns cliques
é possível configurar o build e deploy da sua aplicação. O serviço está em beta, permitindo
<strong>repositórios privados grátis</strong>!</p>

<p><img src="http://1up4dev.org/images/posts/wercker-1.png" alt="" /></p>

<h2>Como funciona</h2>

<p>Cada vez que você faz um <code>git push</code>, o Wercker recebe um sinal que houve atualização,
baixa o código do repositório, monta o ambiente do build definindo variáveis de ambiente,
rodando as migrations, etc, e executa os testes ou qualquer outro passo que você definir, como compilar os assets, etc.</p>

<p>Uma vez que o build execute com sucesso, fica disponível para deploy na plataforma que escolher,
como Heroku ou AWS. Da mesma forma do build, o deploy consiste em passos definidos, como rodar o
Capistrano ou fazer push no repositório do Heroku.</p>

<p>Durante as duas etapas deste processo de build e deploy, o Wercker ainda pode notificar seu
<a href="https://www.hipchat.com/">HipChat</a> ou <a href="https://slack.com/">Slack</a> :)</p>

<p><img src="http://1up4dev.org/images/posts/wercker-2.png" alt="" /></p>

<h2>Por que é diferente?</h2>

<p>Existem vários serviços de CI com a mesma proposta, como o <a href="https://travis-ci.org/">Travis</a> ou o
<a href="https://www.codeship.io/">Codeship</a>. Mas o Wercker permite total customização do ambiente do build
e do deploy, uma vez que é baseado em containers.</p>

<p>Você pode escolher um container oficial para seu build, como Ubuntu com Ruby instalado, por
exemplo, ou pode procurar um container disponibilizado por outro usuário no <a href="https://app.wercker.com/#explore/boxes/search/">diretório do Wercker</a>.</p>

<p>Mas se precisar de algo muito específico, você pode criar seu próprio container (ou box) com pacotes e serviços
que desejar, versões, etc, e utilizá-lo no seu build. E você também pode disponibilizar este box
no diretório do Wercker para outros usuários utilizarem!</p>

<h2>Boxes</h2>

<p>Um box é um ambiente virtual empacotado e versionado com pacotes e serviços necessários para executar o build.
Em outras palavras, é o container &ldquo;base&rdquo; que rodará seu build.</p>

<p>Para utilizar um box, basta declarar no início do <code>wercker.yml</code>:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>box: wercker/ubuntu12.04-ruby2.0.0</span></code></pre></td></tr></table></div></figure>


<p>Tem box para <a href="http://devcenter.wercker.com/articles/languages/ruby.html">Ruby</a>,
<a href="http://devcenter.wercker.com/articles/languages/nodejs.html">Node.js</a>,
<a href="http://devcenter.wercker.com/articles/languages/go.html">Go</a>,
<a href="http://devcenter.wercker.com/articles/languages/android.html">Java/Android</a>
e até para <a href="http://blog.wercker.com/2013/11/28/Announcing-docker-support.html">Docker</a>. Na prática,
os boxes oficiais vão atender a maioria dos casos, mas você pode criar seu próprio box como desejar.</p>

<p>Para definir um box, basta criar um repositório com o arquivo <code>wercker-box.yml</code> descrevendo a base
(Ubuntu, por exemplo), o provisionamento (<a href="http://www.getchef.com/chef/">Chef</a>,
<a href="http://puppetlabs.com/">Puppet</a>, etc, e adicioná-lo ao build pipeline do Wercker.</p>

<p>Uma vez que o build passar, é possível fazer o deploy para disponibilizá-lo no diretório do
Wercker. Assim, é possível utilizar este box no processo de build da sua aplicação.</p>

<p>Mais informações: <a href="http://devcenter.wercker.com/articles/boxes/">http://devcenter.wercker.com/articles/boxes/</a></p>

<h2>Services</h2>

<p>Serviços são boxes prontos disponibilizados pelo Wercker, como MySql, PostgreSql, MongoDB, Redis,
etc. Em outras palavras, é um container configurado com um serviço ready to use.</p>

<p>Para utilizar um service, basta adicionar ao seu <code>wercker.yml</code>:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>box: wercker/ruby
</span><span class='line'>services:
</span><span class='line'>    - wercker/mongodb
</span><span class='line'>    - wercker/redis</span></code></pre></td></tr></table></div></figure>


<p>Mais informações: <a href="http://devcenter.wercker.com/articles/services/">http://devcenter.wercker.com/articles/services/</a></p>

<h2>Steps</h2>

<p>As steps são os &ldquo;comandos&rdquo; executados pelo Wercker no build ou deploy da aplicação, como
<code>bundle-install</code>, <code>database-migrate</code>, <code>script</code>, etc.</p>

<p>Você pode utilizar as steps disponibilizadas pelo Wercker ou criar suas próprias steps,
executando os comandos que julgar necessário no seu build ou deploy.</p>

<p>Para definir as steps do seu build, basta adicionar o <code>wercker.yml</code>:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>build:
</span><span class='line'>    steps:
</span><span class='line'>        - rvm-use:
</span><span class='line'>            version: 2.1.2
</span><span class='line'>        - bundle-install
</span><span class='line'>        - rails-database-yml
</span><span class='line'>        - script:
</span><span class='line'>            name: db migrate
</span><span class='line'>            code: bundle exec rake db:migrate
</span><span class='line'>        - script:
</span><span class='line'>            name: rspec
</span><span class='line'>            code: bundle exec rspec</span></code></pre></td></tr></table></div></figure>


<p>Mais informações: <a href="http://devcenter.wercker.com/articles/steps/">http://devcenter.wercker.com/articles/steps/</a></p>

<h2>Deploy pipeline</h2>

<p>O Wercker permite fazer o deploy da sua aplicação em vários <a href="http://en.wikipedia.org/wiki/Platform_as_a_service">PaaS</a>
como <a href="https://www.heroku.com/">Heroku</a> automaticamente ou definir o processo de deploy manualmente,
utilizando o <a href="http://capistranorb.com/">Capistrano</a> ou executando um script de sua preferência.</p>

<p>Durante a processo de deploy, é possível definir <a href="http://devcenter.wercker.com/articles/gettingstarted/repositoryaccess.html">chaves SSH</a> específicas, <a href="http://devcenter.wercker.com/articles/steps/variables.html">variáveis de ambiente</a>, etc.</p>

<p>Para configurar seu deploy, adicione ao <code>wercker.yml</code> (por exemplo):</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>deploy:
</span><span class='line'>    steps:
</span><span class='line'>        - heroku-deploy
</span><span class='line'>        - s3sync:
</span><span class='line'>            key_id: $AWS_ACCESS_KEY_ID
</span><span class='line'>            key_secret: $AWS_SECRET_ACCESS_KEY
</span><span class='line'>            bucket_url: $AWS_BUCKET_URL
</span><span class='line'>            source_dir: build/</span></code></pre></td></tr></table></div></figure>


<p>Mais informações: <a href="http://devcenter.wercker.com/articles/deployment/">http://devcenter.wercker.com/articles/deployment/</a></p>

<h2>#comofas?</h2>

<p>O Wercker é legal, fácil, bla bla bla. Vamos à um exemplo prático, passo-a-passo, de como configurar
seu projeto no Wercker, fazer o build e o deploy automaticamente no Heroku.</p>

<p>0 &ndash; <a href="https://app.wercker.com/users/new">Crie sua conta</a> :)</p>

<p>1 &ndash; Escolha o repositório, adicione as chaves SSH, finalize;</p>

<p><img src="http://1up4dev.org/images/posts/wercker-gs.png" alt="" /></p>

<p>2 &ndash; Adicione o arquivo <code>wercker.yml</code> ao seu projeto, parecido com este:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>box: wercker/rvm
</span><span class='line'>services:
</span><span class='line'>    - wercker/postgresql
</span><span class='line'>build:
</span><span class='line'>    steps:
</span><span class='line'>        - rvm-use:
</span><span class='line'>            version: 2.1.2
</span><span class='line'>        - bundle-install
</span><span class='line'>        - rails-database-yml
</span><span class='line'>        - script:
</span><span class='line'>            name: db migrate
</span><span class='line'>            code: bundle exec rake db:migrate RAILS_ENV=test
</span><span class='line'>        - script:
</span><span class='line'>            name: rspec
</span><span class='line'>            code: bundle exec rspec -f d
</span><span class='line'>    after-steps:
</span><span class='line'>        - hipchat-notify:
</span><span class='line'>            token: $HIPCHAT_TOKEN
</span><span class='line'>            room-id: 123456
</span><span class='line'>            from-name: wercker</span></code></pre></td></tr></table></div></figure>


<p>Mais informações: <a href="http://devcenter.wercker.com/articles/werckeryml">http://devcenter.wercker.com/articles/werckeryml</a></p>

<p>3 &ndash; Dispare o build com <code>git push</code>;</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>git commit -m "Configurando Wercker"
</span><span class='line'>git push origin master</span></code></pre></td></tr></table></div></figure>


<p>4 &ndash; Configure o deploy no Heroku:</p>

<p><img src="http://1up4dev.org/images/posts/wercker-deploy.png" alt="" /></p>

<p>5 &ndash; Dispare o build/deploy com <code>git push</code> ou manualmente:</p>

<p><img src="http://1up4dev.org/images/posts/wercker-deploy-build.png" alt="" /></p>

<p>6 &ndash; \o/</p>

<h2>Espalhe a palavra!</h2>

<p>Fácil né? Não há mais <del>choro</del> desculpas para não utilizar um CI em seu projeto.</p>

<p>Configure seu projeto, tire um print screen do primeiro build com sucesso e Tuite para o
<a href="https://twitter.com/Wercker">@wercker</a> para receber stickers <em>de grátis</em>!</p>

<p>Compartilhe este post! Dúvidas e sugestões nos comentários abaixo. Sucesso!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Alguns truques com o REPL do Clojure]]></title>
    <link href="http://1up4dev.org/2014/04/alguns-truques-com-o-repl-do-clojure/"/>
    <updated>2014-04-25T11:21:00-03:00</updated>
    <id>http://1up4dev.org/2014/04/alguns-truques-com-o-repl-do-clojure</id>
    <content type="html"><![CDATA[<p>O <tt>REPL</tt> é uma das ferramentas mais úteis para se programar em Clojure. Se você está chegando do Ruby ou do Python está mais do que acostumado a usar o <tt>IRB</tt> ou o modo interativo do Python. Veremos no decorrer do capítulo que o REPL é bem mais do que um prompt da linguagem, que serve apenas para que instruções sejam testadas.</p>

<p>Existem alguns atalhos e funções auxiliares que tornam o uso do REPL bem mais produtivo. Por mais que escrever diretamente no REPL não seja tão confortável quando no seu editor preferido, algumas vezes isso acaba sendo necessário.</p>

<h3>Qual é mesmo o nome daquela função?</h3>

<p>As funções da biblioteca padrão do Clojure vem com um texto explicativo, onde você pode se situar sobre como utilizá-las.</p>

<p>Podemos pesquisar alguma palavra que estiver dentro desses textos para encontrar a função que queremos, mas não lembramos o nome. Para isso, usamos <tt>find-doc</tt>, seguido da palavra ou trecho de texto relacionado ao que queremos.</p>

<p>Vamos supor que eu esteja procurando algo sobre <em>sockets</em>. Basta digitar <tt>(find-doc &ldquo;socket&rdquo;)</tt> no REPL.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nb">find-doc </span><span class="s">&quot;socket&quot;</span><span class="p">)</span>
</span><span class='line'><span class="c1">; -------------------------</span>
</span><span class='line'><span class="c1">; clojure.tools.nrepl/connect</span>
</span><span class='line'><span class="c1">; ([&amp; {:keys [port host transport-fn], :or {transport-fn</span>
</span><span class='line'><span class="c1">;  transport/bencode, host &quot;localhost&quot;}}])</span>
</span><span class='line'><span class="c1">;  Connects to a socket-based REPL at the given host (defaults to</span>
</span><span class='line'><span class="c1">;  localhost) and port, returning the Transport (by default clojure.</span>
</span><span class='line'>
</span><span class='line'><span class="c1">; e mais um monte de coisas</span>
</span></code></pre></td></tr></table></div></figure>


<p>No nosso exemplo, encontramos a função <code>connect</code>, que está no namespace <code>clojure.tools.nrepl</code>.</p>

<p>Se você lembra de alguma parte do nome da função, então pode usar a função <tt>apropos</tt>, passando como parâmetros o trecho do nome ou uma expressão regular. Não se preocupe com expressões regulares agora, pois veremos esse assunto em detalhes mais para frente.</p>

<p>Vamos supor que eu esteja manipulando vetores e não lembre o nome da função, mas saiba que a estrutura chama-se <tt>vector</tt>:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nf">apropos</span> <span class="s">&quot;vector&quot;</span><span class="p">)</span>
</span><span class='line'><span class="c1">; (vector-of vector vector? vector-zip)</span>
</span></code></pre></td></tr></table></div></figure>


<p>E agora você pode usar a função <tt>doc</tt> para ver a documentação daquela que mais se parecer com o que você estiver procurando:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nb">doc </span><span class="nv">vector?</span><span class="p">)</span>
</span><span class='line'><span class="c1">; -------------------------</span>
</span><span class='line'><span class="c1">; clojure.core/vector?</span>
</span><span class='line'><span class="c1">; ([x])</span>
</span><span class='line'><span class="c1">;   Return true if x implements IPersistentVector</span>
</span></code></pre></td></tr></table></div></figure>


<p>Existe uma variação de <tt>apropos</tt> chamada <tt>apropos-better</tt>, que informa também o namespace da função quando ela não estiver dentro do namespace <tt>clojure.core</tt> ou dentro do namespace em que você estiver no momento:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nf">apropos-better</span> <span class="s">&quot;vector&quot;</span><span class="p">)</span>
</span><span class='line'><span class="c1">; (vector vector-of vector? clojure.zip/vector-zip)</span>
</span></code></pre></td></tr></table></div></figure>


<h3>Um pouco de Bash na sua vida</h3>

<p>Quando você usa o REPL por dentro do Leiningen, alguns atalhos já conhecidos pelos usuários de Bash estão disponíveis, mesmo para quem está usando o Leiningen no Windows.</p>

<p>O primeiro deles é a tecla <em>TAB</em>, que exibe os nomes de funções que começam com o que você já digitou.</p>

<p>Por exemplo, vou digitar <tt>map</tt> e pressionar <em>TAB</em></p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nf">map</span>
</span><span class='line'><span class="c1">; map           map-indexed   map?          mapcat        mapv</span>
</span></code></pre></td></tr></table></div></figure>


<p>Outra combinação que agiliza bastante o trabalho é a combinação <em>Control L</em>, ou <em>Command L</em> se você estiver usando MacOS, que limpa os resultados das expressões anteriores e mantém apenas a expressão que você estiver digitando no momento.</p>

<p>Existe também a combinação <em>Control R</em>, ou <em>Command R</em>, que completa o que você estiver digitando usando o histórico de comandos do REPL. Pressionando essa combinação mais de uma vez vai alternar entre todas as combinações já utilizadas que contenham o texto que você já digitou.</p>

<p>Usar as setas <em>para cima</em> ou <em>para baixo</em> permite que você navegue nos comandos utilizados recentemente.</p>

<h3>Recuperando os últimos resultados</h3>

<p>Existem também símbolos especiais que guardam os resultados das últimas expressões e exceções. Eles são <tt><em>1</tt>, <tt></em>2</tt> e <tt><em>3</tt> para os valores e <tt></em>e</tt> para a última exceção, ou erro, que ocorreu:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nb">+ </span><span class="mi">1</span> <span class="mi">2</span><span class="p">)</span>
</span><span class='line'><span class="c1">; 3</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nb">* </span><span class="mi">2</span> <span class="mi">4</span><span class="p">)</span>
</span><span class='line'><span class="c1">; 8</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nb">/ </span><span class="mi">8</span> <span class="mi">2</span><span class="p">)</span>
</span><span class='line'><span class="c1">; 4</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nb">println </span><span class="s">&quot;Resultados anteriores:&quot;</span> <span class="nv">*1</span> <span class="nv">*2</span> <span class="nv">*3</span><span class="p">)</span>
</span><span class='line'><span class="c1">; Resultados anteriores: 4 8 3</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nb">/ </span><span class="mi">1</span> <span class="mi">0</span><span class="p">)</span>
</span><span class='line'><span class="c1">; ArithmeticException Divide by zero</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nb">println </span><span class="s">&quot;Último erro:&quot;</span> <span class="nv">*e</span><span class="p">)</span>
</span><span class='line'><span class="c1">; Último erro: #&lt;ArithmeticException java.lang.ArithmeticException:</span>
</span><span class='line'><span class="c1">;   Divide by zero&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<h3>Consultando o código fonte</h3>

<p>Algumas vezes é bom ter acesso ao código fonte de determinada função ou macro para que possamos entender melhor como ela funciona. Enquanto eu escrevia este artigo, fiz isso constantemente para descobrir como as coisas funcionam por baixo dos panos.</p>

<p>Infelizmente, nem sempre é simples ir até o site onde o código fonte do Clojure está disponível e procurar o arquivo em que aquela função está definida.</p>

<p>Pior ainda quando a versão que está lá é diferente da versão que você está usando no momento. E fica ainda pior quando você não tem acesso ao código fonte da biblioteca que estiver utilizando.</p>

<p>Para nos ajudar, existe a macro <tt>source</tt>, que recebe como parâmetro o nome da função, sem aspas, e exibe o respectivo código fonte, quando possível.</p>

<p>Existem casos em que isso não é possível, como quando você tentar ler o fonte de uma forma especial ou de um código que foi compilado utilizando AOT (veremos isso em detalhes mais para frente).</p>

<p>Vamos exibir o código fonte da função <tt>+</tt>, responsável por somar dois ou mais números:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nf">source</span> <span class="nv">+</span><span class="p">)</span>
</span><span class='line'><span class="c1">; (defn +</span>
</span><span class='line'><span class="c1">;   &quot;Returns the sum of nums. (+) returns 0. Does not auto-promote</span>
</span><span class='line'><span class="c1">;   longs, will throw on overflow. See also: +&#39;&quot;</span>
</span><span class='line'><span class="c1">;   {:inline (nary-inline &#39;add &#39;unchecked_add)</span>
</span><span class='line'><span class="c1">;    :inline-arities &gt;1?</span>
</span><span class='line'><span class="c1">;    :added &quot;1.2&quot;}</span>
</span><span class='line'><span class="c1">;   ([] 0)</span>
</span><span class='line'><span class="c1">;   ([x] (cast Number x))</span>
</span><span class='line'><span class="c1">;   ([x y] (. clojure.lang.Numbers (add x y)))</span>
</span><span class='line'><span class="c1">;   ([x y &amp; more]</span>
</span><span class='line'><span class="c1">;      (reduce1 + (+ x y) more)))</span>
</span></code></pre></td></tr></table></div></figure>


<p>Note que temos acesso a todos os detalhes internos da função <tt>+</tt>, incluindo sua documentação e mais algumas informações que são úteis para o compilador ou para alguma função que gere documentação automaticamente.</p>

<p>Ao tentarmos ver o código fonte de uma forma especial ou de algum código escrito nativamente em Java, receberemos uma mensagem de que o código fonte não foi encontrado:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="nf">source</span> <span class="nv">Thread/sleep</span><span class="p">)</span>
</span><span class='line'><span class="c1">; Source not found</span>
</span></code></pre></td></tr></table></div></figure>


<p>Há muito mais recursos no REPL do Clojure, inclusive no que diz respeito a integração com o seu editor preferido, mas vou deixar isso para outro artigo.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Sowing the seeds of code]]></title>
    <link href="http://1up4dev.org/2013/09/sowing-the-seeds-of-code/"/>
    <updated>2013-09-25T23:08:00-03:00</updated>
    <id>http://1up4dev.org/2013/09/sowing-the-seeds-of-code</id>
    <content type="html"><![CDATA[<p>Seguindo a filosofia de <a href="http://1up4dev.org/2013/03/o-ano-em-que-eu-tirei-a-bunda-da-cadeira/">tirar a bunda da cadeira</a>, tive a oportunidade de falar em excelentes eventos esse ano, conhecer muita gente interessante e dar os primeiros passos no sentido de disseminar a linguagem Clojure no Brasil e organizar comunidades em São Paulo e no Rio de Janeiro.</p>

<h2>Coding Dojo</h2>

<p>Em Maio tive a honra de ter sido convidado a apresentar um coding dojo de Clojure na <a href="http://dasdad.com.br/">Das Dad</a>, que acabou tendo uma aceitação bem maior do que eu esperava.</p>

<p>Tirando o fato do trânsito de São Paulo ter me derrubado e me feito chegar atrasado, conseguimos dar uma boa olhada na linguagem e atiçar a curiosidade. Quem quiser dar uma olhada no que foi feito, o código está <a href="https://github.com/dasdad/dojo-5">no GitHub</a>.</p>

<h2>Anhanguera</h2>

<p>Ainda em Maio, Alexandre Borba e eu fomos convidados a palestrar na unidade de Osasco da Anhanguera Educacional. Borba apresentou os conceitos de Coding Dojo, Katas e o formato Randori para os alunos, enquanto eu apresentei conceitos de orientação a objetos com JavaScript.</p>

<p>Os organizadores do evento prepararam um espaço para os palestrantes atrás do palco que era muito melhor do que qualquer <em>camarim</em> que eu já tenha visto nas vezes em que toquei por aí.</p>

<p>Alguns alunos perguntaram sobre o uso de JavaScript no mercado de trabalho, o que me deu a certeza de que uma palestra menos técnica e mais focada na realidade deles teria sido melhor aproveitada.</p>

<h2>2º ENCATEC</h2>

<p>O pessoal da Adapti, empresa júnior encubada no CEUNES-UFES, em São Mateus-ES, me convidou para o Segundo Encontro Norte-Capixaba de Tecnologia.</p>

<p>Lá tive o prazer de assistir a palestra da Professora Mariella Berger, do projeto IARA, que apresentou o &ldquo;famoso carro que atropelou a Ana Maria Braga&rdquo; e o projeto da Universidade Federal do Espírito Santo que junta automatização, robótica, inteligência artificial, sistema de visão e mais um monte de coisas bacanas usando soluções de código aberto.</p>

<p>Tive a oportunidade também de dividir espaço com meus ídolos Álvaro Justen, o Turicas, que falou sobre software livre; Ricardo Valeriano, que fez uma apresentação hardcore sobre Paralelismo e Concorrência com Ruby; e Luiz Rocha apresentando conceitos de sistemas distribuídos.</p>

<p>Eu falei sobre as aplicações de programação funcional em ambientes corporativos, visto que os alunos da UFES &ldquo;aprendem&rdquo; programação funcional e Haskell logo no primeiro semestre de uma maneira bem deficiente.</p>

<p>Assim como aconteceu na Anhanguera, saí com a impressão de que um tema menos técnico teria sido melhor aproveitado pelos alunos. O fato dos alunos serem pagos com horas de atividades extra-curriculares também fez com que muitos estivessem ali obrigados, estando pouco interessados nos temas apresentados.</p>

<h2>TDC SP</h2>

<p>Em Julho tivemos a etapa de São Paulo do The Developers Conference, evento itinerante organizado pela GlobalCode.</p>

<p>Eu tive a oportunidade de apresentar a primeira palestra da trilha de JavaScript e HTML5, na Quarta-feira, e apresentei vários recursos menos conhecidos do JavaScript, além de ter sorteado uma cópia do meu livro.</p>

<p>Como eu utilizei o manjadíssimo recurso de usar animais para explicar herança, um dos presentes comentou depois, no Twitter, que acha idiota a analogia com animais, visto que ele nunca utilizou animais nos sistemas que já ajudou a desenvolver. Eu achei que seria desnecessário dizer, mas o problema aí mora no fato do colega não perceber que eu estava explicando um conceito de uma forma que qualquer pessoa possa entender. Uma vez que você entenda o conceito, você pode extrapolá-lo para a sua realidade, seja utilizando herança para definir Pessoas Físicas e Jurídicas, seja para definir classes fiscais e naturezas de operação da forma que for mais conveniente.</p>

<p>O ponto negativo ficou por conta da organização, que atrasou o início das palestras em pouco mais de uma hora, não apresentou justificativas nem um pedido de desculpas aos presentes.</p>

<p>No Domingo, último dia do evento, fui mentor de Clojure no Coding Dojo que aconteceu na trilha de Ruby. Ao mesmo tempo e na mesma sala havia máquinas com Clojure, Scala e Ruby para resolver o mesmo problema. Os participantes saiam de uma máquina e iam para outra, onde podiam ver as diferenças e características de cada uma das linguagens.</p>

<p>Fiquei feliz ao perceber que o Clojure causou uma boa impressão e, novamente, despertou o interesse.</p>

<h2>QCon SP</h2>

<p>O grande evento do ano para desenvolvedores, infelizmente, caiu nos mesmos dias do RubyConf, evento da Locaweb voltado para a comunidade Ruby e Rails. Ouvi coisas muito boas sobre o RubyConf desse ano, e foi uma pena que eu não estive por lá.</p>

<p>Como acontece todos os anos, o nível das palestras foi muito bom e, pela primeira vez, tive a honra de ter sido convidado para falar sobre Clojure na trilha &ldquo;Fronteiras do Desenvolvimento&rdquo;.</p>

<p>Para minha surpresa, a sala ficou lotada. Muita gente em pé, muita gente interessada e várias pessoas vieram falar comigo após a palestra para tirar dúvidas ou mesmo para contar suas experiências ao adotar Clojure em suas empresas.</p>

<p>Não tenho dúvidas de que, profissionalmente falando, esse foi o ponto alto do ano para mim. Só tenho a agradecer aos presentes e à organização pelo interesse e pela oportunidade.</p>

<p>O ponto negativo, e até certo ponto divertido, ficou por conta da novelinha criada por um dos palestrantes ao falar mal de SOA. Os representantes de um dos patrocinadores, que vendem consultoria no assunto, ao se sentirem ofendidos, iniciaram um festival de resmungos passivo-agressivos como se um bom diálogo fosse construído dessa forma. O evento em si e a organização nada tiveram a ver com isso, mas foi interessante acompanhar algumas reações e ver quem as pessoas realmente são quando o calo dói.</p>

<h2>(clj-sp)</h2>

<p>Entre um evento e outro, percebendo o interesse crescente na linguagem Clojure, resolvi chamar os desenvolvedores das listas Clojure Brasil e Clojure BR para participar do (clj-sp), o Grupo de Usuários Clojure no Brasil. Somos o primeiro grupo do tipo no Brasil e, por mais estranho que pareça, nosso primeiro encontro foi no Rio de Janeiro.</p>

<p>Organizado pelo nosso amigo Giuliani, sete desenvolvedores se reuniram num bar da Lapa, o equivalente carioca da Vila Madalena e trocamos experiências sobre o uso de programação funcional em geral e Clojure em particular em nossos respectivos trabalhos.</p>

<p>Dois dias depois tivemos o primeiro encontro em São Paulo, nas dependências da iMasters, contando com uma apresentação minha sobre a sintaxe do Clojure, Konrad Scorciapino falando sobre Datalog e Jonas Fagundes compartilhando sua experiência com Clojure em startups.</p>

<p>O auditório da iMasters ficou pequeno para tanta gente interessada e eu fiquei impressionado como apareceu muito mais gente do que eu estava esperando.</p>

<p>Dia 26 de Setembro, última Quinta-feira do mês, teremos o segundo encontro. Caso você tenha interesse, as informações estão em [<a href="http://www.meetup.com/clj-sp/">http://www.meetup.com/clj-sp/</a>].</p>

<h2>O que vem por aí</h2>

<ul>
<li><p>7masters JavaScript
Já 25 de Setembro será dia de 7masters de JavaScript na iMasters. Eu e mais seis especialistas vamos apresentar lightining talks de sete minutos sobre algum assunto bacana relacionado à linguagem. Acesse [setemasters.imasters.com.br/edicoes/javascript/] e compareça.</p></li>
<li><p>DevDay
Em outubro vou falar novamente sobre JavaScript no <a href="http://devday.devisland.com/">DevDay</a>, um evento muito bacana voltado para desenvolvedores de software que vai acontecer em Belo Horizonte.</p></li>
</ul>


<p>Vai ser uma chance bacana de conhecer vários desenvolvedores que eu admiro e aprender com quem realmente conhece do assunto.</p>

<ul>
<li>Programação funcional
E, finalizando, estou escrevendo meu segundo livro, mais focado em programação funcional e como isso pode salvar a sua pele no seu trabalho ou nos seus projetos pessoais. É um livro bem mais denso e especializado que o <a href="http://www.casadocodigo.com.br/products/livro-javascript-jquery">primeiro</a>, mas estou tentando manter o mesmo tom didático e fácil de assimilar.</li>
</ul>


<p>Esse ano está sendo <em>o ano da colheita</em> de tudo o que eu plantei em 2012 e, enquanto isso, estou me preparando para colher mais frutos no ano que vem. Vamos ver no que dá.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[[Off-Topic] Transforme seu roteador wireless em um NAS, MediaServer UPnP/DLNA e BitTorrent client com OpenWRT]]></title>
    <link href="http://1up4dev.org/2013/09/off-topic-transforme-seu-roteador-wireless-em-um-nas-mediaserver-upnp-dlna-bittorrent-client-com-openwrt/"/>
    <updated>2013-09-24T10:00:00-03:00</updated>
    <id>http://1up4dev.org/2013/09/off-topic-transforme-seu-roteador-wireless-em-um-nas-mediaserver-upnp-dlna-bittorrent-client-com-openwrt</id>
    <content type="html"><![CDATA[<p><strong>TL;DR</strong> <a href="http://openwrt.org">OpenWRT</a> é uma distro Linux embarcável em roteadores que permite customizar e instalar serviços sem a necessidade de compilar um novo firmware. Em outras palavras, é um &ldquo;firmware on steroids&rdquo; para roteadores.</p>

<h2>Mas por quê?</h2>

<ul>
<li>Economia. Apenas substituindo o firmware do roteador é possível adicionar funcionalidade e recursos, economizando uma grana preciosa com dispositivos semelhantes, como AppleTV, NAS dedicado, etc.</li>
<li>Funcionalidade. Provavelmente o roteador fica ligado 100% do tempo na sua casa, sendo utilizado apenas para compartilhar a internet. Praticamente um servidor disponível 24 horas por dia sem utilizaçao! Não mais&hellip;</li>
<li>Diversão. Substituir o firmware do seu roteador por uma distro baseada em Linux e configurar todos os serviços manualmente&hellip; é diversão pura!</li>
<li>Por que eu quero (e posso)!</li>
</ul>


<h2>Instalação</h2>

<p><strong>Atenção: existe a possibilidade (embora pequena) de algo sair muito errado e você ganhar um peso de papel. Prossiga por sua conta e risco&hellip; ou se tiver coragem!</strong></p>

<p>O primeiro passo é descobrir o modelo do seu roteador e verificar a compatibilidade nesta página: <a href="http://wiki.openwrt.org/toh/start.">http://wiki.openwrt.org/toh/start.</a> Se não encontrar o modelo ou houver um aviso de não-compatibilidade, sinto muito mas não vai rolar para você.</p>

<p>Se seu roteador for compatível, haverá o <strong>target</strong> da imagem e um link para uma wiki com um how-to específico do modelo, instruções de instalação, resolução de problemas, etc. Procure pelo nome da release que você deverá baixar daqui <a href="http://downloads.openwrt.org.">http://downloads.openwrt.org.</a> A imagem tem o formato <em>openwrt-TARGET-generic-MODELO-VERSAO-squashfs-factory.bin</em></p>

<p>Por exemplo, meu roteador é um <strong>TP-Link WR1043ND</strong>. Procurando na página <a href="http://wiki.openwrt.org/toh/start,">http://wiki.openwrt.org/toh/start,</a> o target compatível com meu roteador é <em>ar71xx</em>:</p>

<p><img src="http://1up4dev.org/images/posts/openwrt-1.png" alt="" /></p>

<p>Acessei a página de downloads, naveguei pelos diretórios da release, depois target e encontrei o arquivo <em>openwrt-ar71xx-generic-tl-wr1043nd-v1-squashfs-factory.bin</em> para download.</p>

<p><img src="http://1up4dev.org/images/posts/openwrt-2.png" alt="" /></p>

<p>Quando baixar a imagem, é só fazer a atualização de firmware normalmente no seu roteador pelo admin:</p>

<p><img src="http://1up4dev.org/images/posts/openwrt-3.png" alt="" /></p>

<p>Confirme e reze muito! Aguarde o roteador atualizar e reiniciar.</p>

<p>Deste ponto em diante, será necessário conectar no roteador com cabo, para setar uma senha de root e configurar o wifi. Este processo é relativamente trivial, basta utilizar a interface web do admin, sem segredo&hellip;</p>

<p><img src="http://1up4dev.org/images/posts/openwrt-4.png" alt="" /></p>

<p>Uma vez definida a senha e o wifi configurado, é possível acessar seu roteador via ssh:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>$ ssh root@192.168.1.1
</span><span class='line'>root@192.168.1.1's password:
</span><span class='line'>
</span><span class='line'>BusyBox v1.19.4 (2013-03-14 11:28:31 UTC) built-in shell (ash)
</span><span class='line'>Enter 'help' for a list of built-in commands.
</span><span class='line'>
</span><span class='line'>  _______                     ________        __
</span><span class='line'> |       |.-----.-----.-----.|  |  |  |.----.|  |_
</span><span class='line'> |   -   ||  _  |  -__|     ||  |  |  ||   _||   _|
</span><span class='line'> |_______||   __|_____|__|__||________||__|  |____|
</span><span class='line'>          |__| W I R E L E S S   F R E E D O M
</span><span class='line'> -----------------------------------------------------
</span><span class='line'> ATTITUDE ADJUSTMENT (12.09, r36088)
</span><span class='line'> -----------------------------------------------------
</span><span class='line'>  * 1/4 oz Vodka      Pour all ingredients into mixing
</span><span class='line'>  * 1/4 oz Gin        tin with ice, strain into glass.
</span><span class='line'>  * 1/4 oz Amaretto
</span><span class='line'>  * 1/4 oz Triple sec
</span><span class='line'>  * 1/4 oz Peach schnapps
</span><span class='line'>  * 1/4 oz Sour mix
</span><span class='line'>  * 1 splash Cranberry juice
</span><span class='line'> -----------------------------------------------------
</span><span class='line'>root@OpenWrt:~#</span></code></pre></td></tr></table></div></figure>


<p>Se você chegou até aqui, parabéns! Você teve coragem. E felizmente a parte difícil já passou&hellip;</p>

<p>Nota: dependendo do seu roteador, a versão do OpenWRT pode variar. Leia a <a href="http://wiki.openwrt.org/">wiki</a> do modelo do seu roteador para instruções específicas e resolução de problemas.</p>

<p><strong>Importante</strong>: caso o pior aconteça (como acabar a energia no meio do processo de flash da firmware) e você não queira utilizar seu roteador como peso de papel, tente seguir os procedimento de &ldquo;debriking&rdquo; em <a href="http://wiki.openwrt.org/doc/howto/generic.debrick">http://wiki.openwrt.org/doc/howto/generic.debrick</a></p>

<h2>Configurando o NAS</h2>

<p>Para o NAS, vamos montar as partições do HD externo e configurar uma partição de swap pois o roteador provavelmente não tem memória interna suficiente para dar conta do recado.</p>

<p>Neste exemplo, vou usar meu HD de 1TB com uma partição formatada em ext4 e outra partição de 1GB formatada como linux+swap. Não vou usar FAT32 nem NTFS e nem recomendo! A idéia aqui é deixar o HD plugado eternamente no roteador e acessá-lo pela rede.</p>

<h3>Instalando os pacotes necessários</h3>

<p>Para nossa sorte, o OpenWRT conta com um gerenciador de pacotes que facilita (e muito) a instalação das libs e módulos necessários para montar o HD externo e compartilhá-lo na rede via Samba ou NFS.</p>

<p>Logue no roteador via ssh e instale os seguintes pacotes:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>root@OpenWrt:~# opkg update
</span><span class='line'>root@OpenWrt:~# opkg install kmod-usb-storage block-mount kmod-fs-ext4</span></code></pre></td></tr></table></div></figure>


<p>O ultimo pacote vai depender do sistema de arquivos do seu HD. Por exemplo, kmod-fs-ext2, etc. Veja os módulos disponíveis em <a href="http://wiki.openwrt.org/doc/howto/storage">http://wiki.openwrt.org/doc/howto/storage</a></p>

<p>Verifique se as partições já foram detectadas rodando <em>blkid</em>:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>root@OpenWrt:~# blkid
</span><span class='line'>/dev/mtdblock2: TYPE="squashfs"
</span><span class='line'>/dev/sda1: LABEL="MEDIA" UUID="1ecad5f1-0000-0000-000f-e8b7f6ac651d" TYPE="ext4"</span></code></pre></td></tr></table></div></figure>


<h3>Montando as partições do HD</h3>

<p>Agora vamos configurar o fstab para montar as partições automaticamente quando o roteador for ligado. Edite o arquivo <em>/etc/config/fstab</em> com o seguinte (use o vi):</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>config global automount
</span><span class='line'>        option from_fstab 1
</span><span class='line'>        option anon_mount 0
</span><span class='line'>
</span><span class='line'>config global autoswap
</span><span class='line'>        option from_fstab 1
</span><span class='line'>        option anon_swap 0
</span><span class='line'>
</span><span class='line'>config mount
</span><span class='line'>        option target   /mnt/media
</span><span class='line'>        option device   /dev/sda1
</span><span class='line'>        option fstype   ext4
</span><span class='line'>        option options  rw,sync
</span><span class='line'>        option enabled  1
</span><span class='line'>        option enabled_fsck 0
</span><span class='line'>
</span><span class='line'>config swap
</span><span class='line'>        option device   /dev/sda2
</span><span class='line'>        option enabled  1</span></code></pre></td></tr></table></div></figure>


<p>No meu caso, vou montar a partição <em>/dev/sda1</em> em <em>/mnt/media</em>, então é necessário criar o diretório de destino, ativar e iniciar o serviço <em>fstab</em>:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>root@OpenWrt:~# mkdir /mnt/media
</span><span class='line'>root@OpenWrt:~# /etc/init.d/fstab enable
</span><span class='line'>root@OpenWrt:~# /etc/init.d/fstab start</span></code></pre></td></tr></table></div></figure>


<p>Pronto, seu HD externo pode ser acessado em <em>/mnt/media</em> e o swap foi montado na segunda partição.</p>

<h3>Compartilhando na rede</h3>

<p>Vou utilizar <a href="http://wiki.openwrt.org/doc/howto/nfs.server">NFS</a> para compartilhar a partição na rede, mas você também pode utilizar Samba seguindo <a href="http://wiki.openwrt.org/doc/howto/cifs.server">http://wiki.openwrt.org/doc/howto/cifs.server</a></p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>root@OpenWrt:~# opkg update
</span><span class='line'>root@OpenWrt:~# opkg install nfs-kernel-server</span></code></pre></td></tr></table></div></figure>


<p>Edite (ou crie) o arquivo <em>/etc/exports</em> com o conteúdo:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>/mnt/media 192.168.1.0/255.255.255.0(rw,sync,no_subtree_check)</span></code></pre></td></tr></table></div></figure>


<p>Ative e inicie os serviços necessários:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>root@OpenWrt:~# /etc/init.d/portmap start
</span><span class='line'>root@OpenWrt:~# /etc/init.d/portmap enable
</span><span class='line'>root@OpenWrt:~# /etc/init.d/nfsd start
</span><span class='line'>root@OpenWrt:~# /etc/init.d/nfsd enable</span></code></pre></td></tr></table></div></figure>


<p>Pronto! O server (roteador) está configurado. Para montar esta partição no client, por exemplo Ubuntu, siga:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>$ sudo apt-get install nfs-common
</span><span class='line'>$ sudo mkdir /media/nas
</span><span class='line'>$ sudo mount -t nfs 192.168.1.1:/mnt/media /media/nas</span></code></pre></td></tr></table></div></figure>


<p>Groovy! Seu NAS foi montado no seu desktop em <em>/media/nas</em>. Pode compartilhar seus arquivos a vontade!</p>

<h2>Configurando o MediaServer (minidlna)</h2>

<p>Logue no roteador e instale os pacotes necessários:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>root@OpenWrt:~# opkg update
</span><span class='line'>root@OpenWrt:~# opkg install minidlna</span></code></pre></td></tr></table></div></figure>


<p>Para configurar, basta editar o arquivo <em>/etc/config/minidlna</em> como segue:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>config minidlna config
</span><span class='line'>  option 'enabled' '1'
</span><span class='line'>  option port '8200'
</span><span class='line'>  option interface 'br-lan'
</span><span class='line'>  option friendly_name 'OpenWrt DLNA Server'
</span><span class='line'>  option db_dir '/mnt/media/minidlna/db'
</span><span class='line'>  option log_dir '/mnt/media/minidlna/log'
</span><span class='line'>  option inotify '1'
</span><span class='line'>  option enable_tivo '0'
</span><span class='line'>  option strict_dlna '0'
</span><span class='line'>  option presentation_url ''
</span><span class='line'>  option notify_interval '900'
</span><span class='line'>  option serial '12345678'
</span><span class='line'>  option model_number '1'
</span><span class='line'>  option root_container '.'
</span><span class='line'>  list media_dir '/mnt/media'
</span><span class='line'>  option album_art_names 'Cover.jpg/cover.jpg/AlbumArtSmall.jpg/albumartsmall.jpg/AlbumArt.jpg/albumart.jpg/Album.jpg/album.jpg/Folder.jpg/folder.jpg/Thumb.jpg/thumb.jpg'</span></code></pre></td></tr></table></div></figure>


<p>Ative e inicie o serviço:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>root@OpenWrt:~# /etc/init.d/minidlna enable
</span><span class='line'>root@OpenWrt:~# /etc/init.d/minidlna start</span></code></pre></td></tr></table></div></figure>


<p>Pronto! O MediaServer está configurado e compartilhando seus arquivos via DLNA na rede. Aqui na minha SmartTV aparece assim:</p>

<p><img src="http://1up4dev.org/images/posts/minidlna.jpg" alt="MiniDLNA na Samsung SmartTV" /></p>

<h2>Configurando o BitTorrent client (transmission)</h2>

<p>Vamos instalar os pacotes:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>root@OpenWrt:~# opkg update
</span><span class='line'>root@OpenWrt:~# opkg install transmission-daemon</span></code></pre></td></tr></table></div></figure>


<p>E configurar o serviço editando <em>/etc/config/transmission</em> e alterando as opções a seguir (mantenha todas as outras configs):</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>config transmission
</span><span class='line'>  option enabled 1
</span><span class='line'>  option config_dir '/mnt/media/transmission/config'
</span><span class='line'>  option download_dir '/mnt/media/transmission/complete'
</span><span class='line'>  option incomplete_dir '/mnt/media/transmission/incomplete'
</span><span class='line'>  option incomplete_dir_enabled true
</span><span class='line'>  option ratio_limit 2.0000
</span><span class='line'>  option ratio_limit_enabled true
</span><span class='line'>  option rpc_authentication_required false
</span><span class='line'>  option rpc_password ''
</span><span class='line'>  option rpc_username ''
</span><span class='line'>  option speed_limit_up 5
</span><span class='line'>  option speed_limit_up_enabled true</span></code></pre></td></tr></table></div></figure>


<p>Ative e inicie o serviço:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>root@OpenWrt:~# /etc/init.d/transmission enable
</span><span class='line'>root@OpenWrt:~# /etc/init.d/transmission start</span></code></pre></td></tr></table></div></figure>


<p>O Transmission roda como um daemon, sendo controlado remotamente. Para isso, será necessário adicionar a seguintes regra de farewall, adicionando no final do arquivo <em>/etc/config/firewall</em>:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>config rule
</span><span class='line'>        option src *
</span><span class='line'>        option proto tcp
</span><span class='line'>        option dest_port 9091
</span><span class='line'>        option target ACCEPT</span></code></pre></td></tr></table></div></figure>


<p>Reinicie o firewall executando <em>/etc/init.d/firewall restart</em></p>

<p>Para gerenciar seus torrents, instale a extensão <a href="https://chrome.google.com/webstore/detail/torrent-to-transmission/kfnbjgeekkbjcddceemhjajjiclnoekb">.torrent to Transmission</a> no Chrome, baixe o <a href="https://code.google.com/p/transmisson-remote-gui/">Transmission Remote GUI</a> para Windows, Mac e Linux ou ainda o <a href="https://play.google.com/store/apps/details?id=com.neogb.rtac">Remote Transmission</a> para Android.</p>

<p><img src="http://1up4dev.org/images/posts/transmission-gui.jpg" alt="Transmission GUI" /></p>

<p>Caso seu roteador tenha espaço disponível, você pode instalar o pacote <em>transmission-web</em> para gerenciar seus torrents diretamente do navegador.</p>

<p>Ao adicionar um .torrent pelo GUI, o mesmo será baixado diretamente no seu roteador!</p>

<h2>Conclusão</h2>

<p>Embora relativamente complicado, todo procedimento para instalação e configuração não é nada diferente do que estamos acostumados a fazer diariamente no Linux, como devops, seja configurando uma VPS ou montando um NAS na rede.</p>

<p>A liberdade que o OpenWRT oferece é imensa. O repositório é recheado com pacotes bem úteis e muito fáceis de configurar. Sem falar na economia comparando com um aparelho como AppleTV (que não ofecererá tantos recursos) ou outros media servers do mercado.</p>

<p>E aí, tem coragem??? Poste sua experiência nos comentários! :)</p>

<h2>Referências</h2>

<ul>
<li><a href="http://wiki.openwrt.org/doc/howto/usb.storage">http://wiki.openwrt.org/doc/howto/usb.storage</a></li>
<li><a href="http://wiki.openwrt.org/doc/howto/nfs.server">http://wiki.openwrt.org/doc/howto/nfs.server</a></li>
<li><a href="http://wiki.openwrt.org/doc/uci/minidlna">http://wiki.openwrt.org/doc/uci/minidlna</a></li>
<li><a href="http://wiki.openwrt.org/doc/uci/transmission">http://wiki.openwrt.org/doc/uci/transmission</a></li>
<li><a href="http://wiki.openwrt.org/toh/tp-link/tl-wr1043nd">http://wiki.openwrt.org/toh/tp-link/tl-wr1043nd</a></li>
<li><a href="http://www.rodrigorodrigues.info/index.php/2012/01/openwrt-fazendo-magica-com-linux-no-roteador-parte-1/">http://www.rodrigorodrigues.info/index.php/2012/01/openwrt-fazendo-magica-com-linux-no-roteador-parte-1/</a></li>
<li><a href="http://knowhow.bart.prokop.name/install/openwrt/wr1043nd">http://knowhow.bart.prokop.name/install/openwrt/wr1043nd</a></li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[[QuickTips] Do Wordpress para Octopress/Jekyll no GitHub Pages]]></title>
    <link href="http://1up4dev.org/2013/09/quicktips-do-wordpress-para-octopress-slash-jekyll-no-github-pages/"/>
    <updated>2013-09-20T22:38:00-03:00</updated>
    <id>http://1up4dev.org/2013/09/quicktips-do-wordpress-para-octopress-slash-jekyll-no-github-pages</id>
    <content type="html"><![CDATA[<p>Quando migramos nosso blog do Wordpress para o GitHub Pages, escrevi um email para nossos autores com instruções resumidas para configurar e postar com Octopress/Jekyll. Percebi que dando um tapa nesse email, poderia publicá-lo aqui no blog como um guia rápido e talvez incentivar outros blogueiros a fazer o mesmo.</p>

<h2>Por que GitHub Pages?</h2>

<p>Corte de custos! Manter o blog no Wordpress requer um hosting, um banco de dados e um domínio. Reduzimos as despesas apenas para o registro de domínio (por enquanto).</p>

<p>Performance! GitHub Pages é estático, e conteúdo estático é servido naturalmente mais rápido.</p>

<p>Desafio! Estavamos &ldquo;acostumados&rdquo; ao Wordpress. Aprender Jekyll e a postar &ldquo;commitando em um projeto&rdquo; permite que tenhamos novas idéias, ou no pior dos casos, aprendamos novas tecnologias.</p>

<h2>Requisitos</h2>

<p>Para utilizar o GitHub Pages, crie um repositório com o nome <strong>usuariogithub.github.io</strong>, incluindo o &ldquo;github.io&rdquo;. O GitHub gerencia este repositório e publica o conteúdo estático no endereço <a href="http://usuariogithub.github.io">http://usuariogithub.github.io</a></p>

<p>Agora, para gerar o conteúdo estático vamos usar o <a href="http://octopress.org">Octopress</a>.</p>

<h2>Instalação</h2>

<p>Basta clonar o repositório do Octopress localmente:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>git clone git@github.com:imathis/octopress.git
</span></code></pre></td></tr></table></div></figure>


<p>instalar as gems necessárias e em seguida rodar a rake para configuração:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>rake setup_github_pages
</span></code></pre></td></tr></table></div></figure>


<p>e informar o seu repositório do GitHub Pages:</p>

<pre><code>git@github.com:username/username.github.io.git
</code></pre>

<p>Pronto! Os remoting points do projeto serão configurados para seu repositório do GitHub, como segue:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>git remote -v
</span><span class='line'>
</span><span class='line'>octopress git@github.com:imathis/octopress.git <span class="o">(</span>fetch<span class="o">)</span>
</span><span class='line'>octopress git@github.com:imathis/octopress.git <span class="o">(</span>push<span class="o">)</span>
</span><span class='line'>origin     git@github.com:username/username.github.io.git <span class="o">(</span>fetch<span class="o">)</span>
</span><span class='line'>origin     git@github.com:username/username.github.io.git <span class="o">(</span>push<span class="o">)</span>
</span></code></pre></td></tr></table></div></figure>


<h2>Postando</h2>

<p>Para criar um novo post, basta rodar a rake:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>rake new_post<span class="o">[</span><span class="s2">&quot;o titulo do seu post&quot;</span><span class="o">]</span>
</span></code></pre></td></tr></table></div></figure>


<p>o que vai criar o arquivo <em>source/_posts/2013-09-17-o-titulo-do-seu-post.markdown</em>. Escreva o conteúdo do seu post normalmente em Markdown (recomendo utilizar o <a href="http://markup.herokuapp.com/">Markup Editor</a>) e execute:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>rake generate
</span></code></pre></td></tr></table></div></figure>


<p>para gerar o site estático no diretório <em>_deploy</em>. Caso queira dar um preview no que será publicado, basta rodar:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>rake preview
</span></code></pre></td></tr></table></div></figure>


<p>e acessar no browser <a href="http://localhost:4000.">http://localhost:4000.</a></p>

<h2>Publicando</h2>

<p>Quando terminar seu post, basta rodar:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>rake deploy
</span></code></pre></td></tr></table></div></figure>


<p>para publicar o site no seu repositório do GitHub Pages.</p>

<p>Pronto! Não se esqueça de subir os fontes do site (branch source), commitando suas alterações e executando o classico <em>git push</em>.</p>

<h2>Migrando</h2>

<p>Caso já tenha um site publicado no Wordpress, você pode seguir este guia para importar todo o conteúdo na estrutura do Jekyll:</p>

<p><a href="http://johnnycode.com/2012/07/10/how-to-migrate-from-wordpress-to-jekyll-running-on-github/">How to Migrate from WordPress to Jekyll Running on Github</a></p>

<h2>Referências</h2>

<ul>
<li><a href="http://pages.github.com/">GitHub Pages</a></li>
<li><a href="http://octopress.org/">Octopress.org</a></li>
<li><a href="http://jekyllrb.com/">Jekyll</a></li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Introdução a Linux Control Groups (CGroups)]]></title>
    <link href="http://1up4dev.org/2013/08/introducao-a-linux-control-groups-cgroups/"/>
    <updated>2013-08-22T14:32:23-03:00</updated>
    <id>http://1up4dev.org/2013/08/introducao-a-linux-control-groups-cgroups</id>
    <content type="html"><![CDATA[<p>Em tempos de <strong>Metodologias Àgeis</strong>, iniciativas como <strong><a href="http://en.wikipedia.org/wiki/DevOps">DevOps</a></strong>, adoção de <strong>Cloud Computing</strong> e derivados <strong>(SaaS, IaaS e PaaS)</strong>, aplicações que demorariam meses, senão anos para estar na <strong>www</strong>, hoje em questão de dias, e por que não horas, é possível estar disponíveis ao usuário final.</p>

<p>Com a necessidade de ter os aplicativos de forma mais rápida em produção, a adoção e criação de <strong><a href="http://en.wikipedia.org/wiki/Platform_as_a_service">PaaS (Platform as A Service)</a></strong> tem sido a nova &ldquo;<em>onda do verão</em>&rdquo; e tecnologias como <strong><a href="http://lxc.sourceforge.net/">LXC</a></strong>, <strong><a href="http://www.docker.io/">Docker</a> </strong>e <strong><a href="http://en.wikipedia.org/wiki/Cgroups">CGroups</a></strong> atuam como o cerne dessa &ldquo;wave&rdquo;.</p>

<h3>O que são CGroups?</h3>

<p><strong>CGroups</strong> é uma feature do Kernel que provê mecanismos para organização de Processos em forma de grupos e limita recursos de máquina como Consumo de CPU, memória e I/O para estes.</p>

<p>Curioso pra ver como funciona?</p>

<h3>Situação de Exemplo</h3>

<p>Para este exemplo teremos duas aplicações <em><a href="https://gist.github.com/tonyfabeen/6310137">Sinatra</a></em> e nosso objetivo será dedicar um grupo para cada aplicação limitando o consumo de memória para cada uma elas.</p>

<p>Para rodar o exemplo estarei utilizando um <em>Ubuntu 12.04 64 bits.</em></p>

<h4>Pré-Requisitos</h4>

<p>Antes de mais nada precisamos instalar algumas dependências:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>sudo apt-get install cgroup-bin libcgroup1
</span></code></pre></td></tr></table></div></figure>


<p>Com a instalação dos pacotes acima veremos que um novo filesystem foi montado em <strong>/sys/fs/cgroup </strong></p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>ls -al /sys/fs/cgroup
</span><span class='line'>
</span><span class='line'>drwxr-xr-x 7 root root 140 Aug  6 09:38 .
</span><span class='line'>drwxr-xr-x 6 root root   0 Aug  6 09:37 ..
</span><span class='line'>drwxr-xr-x 6 root root   0 Aug  6 09:38 cpu
</span><span class='line'>drwxr-xr-x 6 root root   0 Aug  6 09:38 cpuacct
</span><span class='line'>drwxr-xr-x 6 root root   0 Aug  6 09:38 devices
</span><span class='line'>drwxr-xr-x 6 root root   0 Aug  6 09:38 freezer
</span><span class='line'>drwxr-xr-x 6 root root   0 Aug  6 09:38 memory
</span></code></pre></td></tr></table></div></figure>


<p>CGroups estão organizados por subsistemas conhecidos também como &ldquo;resource controllers&rdquo; responsáveis por gerenciar memória, cpu, dispositivos, entre outras coisas. Na organização acima cada diretório representa um <strong>Resource Controller</strong>.</p>

<h4>CGConfig Service</h4>

<p>Para gerenciar CGroups iremos utilizar a utilitário <em>cgconfig</em> instalado como o pacote <em>libcgroup1</em>. É interessante checar se o serviço está rodando antes de continuar :</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>sudo service cgconfig status
</span></code></pre></td></tr></table></div></figure>


<p>Caso não esteja inicie o serviço</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>sudo service cgconfig start
</span></code></pre></td></tr></table></div></figure>


<p>Existem duas formas de configurar CGroups com cgconfig, diretamente no arquivo de configuração <strong>/etc/cgconfig.conf&#8217;</strong> ou via linha de comando, que será o meio que iremos utilizar.</p>

<h4>Criando Grupos</h4>

<p>Para criar um grupo, utilizamos o comando <strong>cgcreate</strong> passando como argumento quais controllers estarão associados a ele.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>sudo cgcreate -g cpu,cpuacct,devices,memory,freezer:/sinatra1
</span><span class='line'>sudo cgcreate -g cpu,cpuacct,devices,memory,freezer:/sinatra2
</span></code></pre></td></tr></table></div></figure>


<p>O argumento <strong>/sinatra</strong>* indica o caminho relativo do grupo dentro de cada Resource Controller. Ex : <strong>/sys/fs/cgroup/&lt;resource_controller>/<path></strong></p>

<h3>Executando programas em um Grupo</h3>

<p>Para executar determinado processo em um grupo utilizamos o comando <strong>cgexec</strong> passando como argumentos quais controllers estarão associados ao processo e o caminho do grupo que ele estará associado.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>sudo cgexec -g *:/sinatra1 sh -c <span class="s1">&#39;cd &lt;path_to_sinatra1&gt; &amp;&amp; exec rackup -p 4567 -D&#39;</span>
</span><span class='line'>sudo cgexec -g *:/sinatra2 sh -c <span class="s1">&#39;cd &lt;path_to_sinatra2&gt; &amp;&amp; exec rackup -p 4568 -D&#39;</span>
</span></code></pre></td></tr></table></div></figure>


<p>O asterisco <strong>(*)</strong> acima significa que o processo estará associado a todos os controllers.</p>

<p>Para checar a hierarquia criada:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>ps xawf -eo pid,cgroup,args | grep ruby
</span><span class='line'> 1476              <span class="se">\_</span>  5:freezer:              <span class="se">\_</span> grep --color<span class="o">=</span>auto ruby
</span><span class='line'> 1418  5:freezer:/sinatra1?4:memo /usr/bin/ruby1.9.1 /usr/local/bin/rackup -p 4567 -D
</span><span class='line'> 1454  5:freezer:/sinatra2?4:memo /usr/bin/ruby1.9.1 /usr/local/bin/rackup -p 4568 -D
</span></code></pre></td></tr></table></div></figure>


<p>Para setar os valores em determinado controller utilizamos o comando <strong>cgset</strong>. No caso abaixo estamos limitando o consumo de memória para o grupo <strong>sinatra1</strong> em <strong>256MB</strong> e para o grupo <strong>sinatra2</strong> em <strong>128MB</strong>.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>sudo cgset -r memory.limit_in_bytes<span class="o">=</span><span class="s1">&#39;256M&#39;</span> sinatra1
</span><span class='line'>sudo cgset -r memory.limit_in_bytes<span class="o">=</span><span class="s1">&#39;128M&#39;</span> sinatra2
</span></code></pre></td></tr></table></div></figure>


<p>Para checar a alteração:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>cat /sys/fs/cgroup/memory/sinatra1/memory.limit_in_bytes
</span><span class='line'>cat /sys/fs/cgroup/memory/sinatra2/memory.limit_in_bytes
</span></code></pre></td></tr></table></div></figure>


<h3>Conclusão</h3>

<p>O intuito deste artigo foi demonstrar um dos possíveis usos de CGroups. Caso a aplicação <strong>sinatra1</strong> cair por estouro de memória ou alguma outra falha que não seja a destruição da máquina, a aplicação <strong>sinatra2 </strong>continuará funcionando.</p>

<p>Há mais a se explorar, poderíamos inserir limitação de I/O, consumo de banda, entre outras coisas. Poderíamos até criar nossa própria implementação de LXC, mas isso é assunto para um próximo encontro.</p>

<p>Os links abaixo exploram mais detalhes sobre o assunto :</p>

<ul>
<li><p><a href="https://www.kernel.org/doc/Documentation/cgroups/cgroups.txt">https://www.kernel.org/doc/Documentation/cgroups/cgroups.txt</a></p></li>
<li><p><a href="http://linux.oracle.com/documentation/EL6/Red_Hat_Enterprise_Linux-6-Resource_Management_Guide-en-US.pdf">http://linux.oracle.com/documentation/EL6/Red_Hat_Enterprise_Linux-6-Resource_Management_Guide-en-US.pdf</a></p></li>
</ul>


<p>Divirtam-se!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Extendendo Ruby com C - Só um aperitivo]]></title>
    <link href="http://1up4dev.org/2013/08/extendendo-ruby-com-c-so-um-aperitivo/"/>
    <updated>2013-08-19T14:29:56-03:00</updated>
    <id>http://1up4dev.org/2013/08/extendendo-ruby-com-c-so-um-aperitivo</id>
    <content type="html"><![CDATA[<p>Extender Ruby em C não é complicado. É claro, você deve ao menos ter o conhecimento básico da linguagem C.</p>

<p>Vamos criar uma extensão que retorna uma simples String.</p>

<p>Primeiramente criamos o diretório onde estará nossa extensão :</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>mkdir &lt;your_path&gt;/1up4dev
</span></code></pre></td></tr></table></div></figure>


<p>Crie um arquivo chamado <strong>1up4dev.c </strong>e dentro dele inclua o header &ldquo;<strong>ruby.h&rdquo;</strong></p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='c'><span class='line'><span class="cp">#include &lt;ruby.h&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Tudo em Ruby relaciona-se com o tipo <strong>VALUE</strong>. Para nosso exemplo, vamos criar um <strong>VALUE m1up4dev</strong> representando um módulo.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='c'><span class='line'><span class="n">VALUE</span> <span class="n">m1up4dev</span><span class="p">;</span>
</span></code></pre></td></tr></table></div></figure>


<p>E para representar uma classe, abaixo deste módulo, a qual chamaremos de Talker, criaremos uma <strong>VALUE cTalker</strong>:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='c'><span class='line'><span class="n">VALUE</span> <span class="n">cTalker</span><span class="p">;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Nossa classe <strong>Talker</strong> precisa fazer algo, vamos adicionar uma simples função que retorna uma String.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='c'><span class='line'><span class="k">static</span> <span class="n">VALUE</span> <span class="nf">say_yeah</span><span class="p">(</span><span class="n">VALUE</span> <span class="n">self</span><span class="p">){</span>
</span><span class='line'>  <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">sentence</span><span class="o">=</span> <span class="s">&quot;YEAH YEAH!&quot;</span><span class="p">;</span>
</span><span class='line'>  <span class="k">return</span> <span class="n">rb_str_new2</span><span class="p">(</span><span class="n">sentence</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Na função <strong>say_yeah</strong>, <strong>VALUE self</strong> representa o objeto associado a função, <strong>sentence</strong> a String de retorno e a função <strong>rb_str_new2</strong> converte o <strong>*char </strong>em uma <strong>Ruby String</strong>.</p>

<p>Para deixar esse código acessível no mundo Ruby, criaremos uma função chamada &lsquo;<strong>Init_1up4dev</strong>&rsquo;. Por convenção estas funções sempre começam com o prefixo &lsquo;<strong>Init_</strong>&rsquo;.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='c'><span class='line'><span class="kt">void</span> <span class="nf">Init_1up4dev</span><span class="p">(){</span>
</span><span class='line'>  <span class="n">m1up4dev</span> <span class="o">=</span> <span class="n">rb_define_module</span><span class="p">(</span><span class="s">&quot;1up4dev&quot;</span><span class="p">);</span>
</span><span class='line'>  <span class="n">cTalker</span> <span class="o">=</span> <span class="n">rb_define_class_under</span><span class="p">(</span><span class="n">m1up4dev</span><span class="p">,</span> <span class="s">&quot;Talker&quot;</span><span class="p">,</span> <span class="n">rb_cObject</span><span class="p">);</span>
</span><span class='line'>  <span class="n">rb_define_singleton_method</span><span class="p">(</span><span class="n">cTalker</span><span class="p">,</span> <span class="s">&quot;say_yeah&quot;</span><span class="p">,</span> <span class="n">say_yeah</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>A função &lsquo;<strong>rb_define_module</strong>&rsquo; define um módulo no topo da hierarquia. Algo como:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="n">module</span> <span class="mi">1</span><span class="n">up4dev</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>A função &lsquo;<strong>rb_define_class_under</strong>&rsquo; define uma classe abaixo de um módulo ou outra classe. Isso irá gerar:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="n">module</span> <span class="mi">1</span><span class="n">up4dev</span>
</span><span class='line'>  <span class="k">class</span> <span class="nc">Talker</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>A função &lsquo;<strong>rb_define_singleton_method</strong>&rsquo; é responsável por criar um método singleton em uma classe ou módulo, neste caso ele estará atrelado a class Talker.</p>

<p>Para rodar nosso exemplo, crie um arquivo chamado &lsquo;<strong>extconf.rb</strong>&rsquo; contendo:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;mkmf&#39;</span>
</span><span class='line'><span class="n">create_makefile</span><span class="p">(</span><span class="s1">&#39;1up4dev&#39;</span><span class="p">)</span>
</span></code></pre></td></tr></table></div></figure>


<p>Executando o script, irá ser gerado um arquivo <strong>Makefile</strong> para executar o build da extensão.</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>ruby extconf.rb
</span></code></pre></td></tr></table></div></figure>


<p>Compile e instale a extensão:</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$ </span>make <span class="o">&amp;&amp;</span> make install
</span></code></pre></td></tr></table></div></figure>


<p>Para ver o código funcionando basta digitar o código abaixo em um &lsquo;<strong>irb</strong>&rsquo; ou algo do gênero :</p>

<figure class='code'> <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="nv">$irb</span><span class="o">(</span>main<span class="o">)</span>:001:0&gt; require <span class="s1">&#39;1up4dev&#39;</span>
</span><span class='line'><span class="nb">true</span>
</span><span class='line'><span class="nv">$irb</span><span class="o">(</span>main<span class="o">)</span>:002:0&gt; 1up4dev::Talker.say_yeah
</span><span class='line'><span class="s2">&quot;YEAH YEAH!&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>YEAH YEAH!!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Entendendo LISP, finalmente.]]></title>
    <link href="http://1up4dev.org/2013/07/entendendo-lisp-finalmente/"/>
    <updated>2013-07-14T11:35:31-03:00</updated>
    <id>http://1up4dev.org/2013/07/entendendo-lisp-finalmente</id>
    <content type="html"><![CDATA[<h2>A sintaxe invertida</h2>

<p>Ao olhar um código LISP pela primeira vez, você se assusta.</p>

<p>Eu me assustei e não havia ninguém para me ajudar a entender.</p>

<p>Que bom que você está lendo isto para entender bem depressa e perder o medo.</p>

<p>Acredite ou não, o LISP não é invertido: as outras linguagens é que são inconsistentes.</p>

<p>Matematicamente falando, funções são expressas dessa forma:</p>

<pre><code>y = f(x)
</code></pre>

<p>Para calcularmos o dobro de um número, teríamos:</p>

<pre><code>y = dobro(21)
</code></pre>

<p>Note que estamos usando uma notação diferente: primeiro vem o operador dobro e, em seguida, vem o operando, ou parâmetro, 21. Chamamos isso de notação prefixa.</p>

<p>Já para executar um cálculo matemático, usamos a forma abaixo:</p>

<pre><code>y = 21 * 2
</code></pre>

<p>Primeiro temos um operador 21, depois temos um operando responsável pela multiplicação e, finalmente, o segundo operando 2. Chamamos essa forma de notação infixa.</p>

<p>Nota: se você é um desenvolvedor Ruby, ignore essa última expressão. Em Ruby o cálculo acima utiliza internamente a notação prefixa onde 21 é um objeto, * é um método (ou uma mensagem, se preferir) e 2 é um parâmetro.</p>

<p>A coisa fica bagunçada quando misturamos as duas formas:</p>

<pre><code>y = dobro(7 * 3)
</code></pre>

<p>Na expressão acima misturamos notação prefixa com infixa. Não há problema algum com isso, mas não é um bom exemplo de consistência.</p>

<p>Quando falamos em LISP, o primeiro item de uma lista é um operador e todos os demais são operandos.</p>

<p>Todo operador é uma função, macro ou forma especial, inclusive os operadores matemáticos. Não se preocupe em entender agora o que são macros ou formas especiais. Todo o resto da lista é considerado um valor, parâmetro ou operando.</p>

<p>Imagine agora que o símbolo <code>+</code> é uma função. Para calcularmos uma soma usaríamos o seguinte código:</p>

<pre><code>+(1, 2)
</code></pre>

<p>Movendo os parênteses e removendo as vírgulas, a nossa soma inicial ficaria:</p>

<pre><code>(+ 1 2)
</code></pre>

<p>Sabemos que dobro também é uma função. Para calcular dobro, usaríamos:</p>

<pre><code>(dobro 12)
</code></pre>

<p>Percebam que agora temos uma regra que se aplica a todos os casos. Repetindo a expressão acima que mistura as notações infixa e prefixa usando as regras do LISP, teríamos:</p>

<pre><code>(dobro (+ 7 3))
</code></pre>

<p>Talvez pela sua origem acadêmica e fortemente influenciada pela matemática, as implementações de LISP levam muito a sério a questão da consistência.</p>

<h2>Os parênteses</h2>

<p>Quando eu estava na quarta série, aprendi uma coisa chamada <em>expressão numérica</em>, que consistia em resolver um cálculo extenso atacando um pedaço por vez, organizadamente.</p>

<p>Cada pedaço desse cálculo ficava dentro de parênteses, colchetes ou chaves, dependendo do quão aninhado estivesse a expressão. Eu nunca mais vi esse tipo de hierarquia,  mas era um jeito bacana de manter a organização.</p>

<p>Uma expressão numérica tem essa cara:</p>

<pre><code>x = {1 + [3 * (5 + 7)]}
</code></pre>

<p>Resolvemos a expressão de dentro para fora:</p>

<pre><code>x = {1 + [3 * (12)]}

x = {1 + [36]}

x = {37}

x = 37
</code></pre>

<p>Simples, não?</p>

<p>Agora vamos extrapolar o que aprendemos na quarta série para uma linguagem de programação, trocando chaves e colchetes por parênteses:</p>

<pre><code>x = (1 + (3 * (5 + 7)))
</code></pre>

<p>Vamos substituir a nossa conhecida notação infixa pela prefixa.</p>

<pre><code>x = (+ 1 (* 3 (+ 5 7)))
</code></pre>

<p>Pronto. Você tem uma expressão numérica com a cara do LISP, resolvendo da forma como a professora ensinou lá na quarta série: primeiro você resolve os parênteses de dentro, depois os próximos, até terminar.</p>

<p>Qualquer LISP que você encontrar pela frente, incluindo o Clojure, funciona exatamente dessa maneira.</p>

<p>Uma vantagem que isso traz é que você não precisa ficar se preocupando com precedência de operadores.</p>

<p>Imagine que você tem o código abaixo:</p>

<pre><code>x = 3 * 2 + 1

y = 1 + 2 * 3
</code></pre>

<p>Os valores de x e y serão iguais? Sim, ambas as variáveis contém o número 7, mas para saber disso você precisou ler em algum outro lugar que o operador de multiplicação tem precedência sobre o operador de adição. É algo que você espera que seja assim e age como se realmente fosse.</p>

<p>E o que aconteceria se você estiver usando uma linguagem em que a adição tem precedência sobre a multiplicação? Ou pior ainda: os operadores são executados da esquerda para a direita conforme forem aparecendo.</p>

<p>No primeiro caso, x e y continuariam sendo igual, mas ambos teriam o valor 9. No segundo caso, x seria igual a 7 e y seria igual a 9.</p>

<p>Seria mais fácil se as expressões fossem escritas assim:</p>

<pre><code>x = (3 * 2) + 1

y = 1 + (2 * 3)
</code></pre>

<p>Agora está claro para qualquer pessoa o que vai ser executado primeiro, independente do modo como a expressão seja interpretada pela linguagem. Pois saiba que é exatamente assim que um LISP trabalha. Usando a notação prefixa, as expressões acima ficariam:</p>

<pre><code>x = (+ (* 3 2) 1)

y = (+ 1 (* 3 2))
</code></pre>

<p>Primeiro será executada a multiplicação, que está nos parênteses mais internos e, em seguida, será executada a adição. Tudo isso sem se preocupar com regras ocultas ou peculiaridades do compilador.</p>

<p>Qualquer código em qualquer dialeto LISP, mesmo com suas características particulares, fica fácil de entender se você lembrar dessas regrinha.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[[QuickTips] Usando Shell Script como suite de teste]]></title>
    <link href="http://1up4dev.org/2013/06/quicktips-usando-shell-script-como-suite-de-teste/"/>
    <updated>2013-06-27T09:42:18-03:00</updated>
    <id>http://1up4dev.org/2013/06/quicktips-usando-shell-script-como-suite-de-teste</id>
    <content type="html"><![CDATA[<p>Indo na linha do programador pragmático, às vezes, dependendo do time ou linguagem do projeto, é muito mais prático usar shell script para testar. Recentemente resolvi usar esta abordagem, e cheguei no seguinte &ldquo;template&rdquo; em shell script para testar uma API Server.</p>

<p>Dependências:</p>

<ul>
<li><p>bash</p></li>
<li><p>curl</p></li>
</ul>


<p>Foi testado no Ubuntu 13.04.</p>

<p>Obs: Vou embedar <a href="https://gist.github.com/rogerleite/5869576">este gist</a>, e pode ser que não apareça no seu reader ;D.</p>

<p>Obs2: Este post é uma versão pt-br deste post no coderwall <a href="https://coderwall.com/p/nsso8w">Using Shell Script to test your server</a>.</p>

<figure class='code'><figcaption><span>test.sh </span></figcaption>
 <div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>  <span class="c">#!/bin/bash</span>
</span><span class='line'>
</span><span class='line'><span class="nv">URL</span><span class="o">=</span>http://localhost:8080
</span><span class='line'>
</span><span class='line'><span class="c">## Unit-Testable Shell Scripts (http://eradman.com/posts/ut-shell-scripts.html)</span>
</span><span class='line'><span class="nb">typeset</span> -i <span class="nv">tests_run</span><span class="o">=</span>0
</span><span class='line'><span class="k">function </span>try <span class="o">{</span> <span class="nv">this</span><span class="o">=</span><span class="s2">&quot;$1&quot;</span>; <span class="o">}</span>
</span><span class='line'><span class="nb">trap</span> <span class="s1">&#39;printf &quot;$0: exit code $? on line $LINENO\nFAIL: $this\n&quot;; exit 1&#39;</span> ERR
</span><span class='line'><span class="k">function </span>assert <span class="o">{</span>
</span><span class='line'>    <span class="nb">let </span>tests_run+<span class="o">=</span>1
</span><span class='line'>    <span class="o">[</span> <span class="s2">&quot;$1&quot;</span> <span class="o">=</span> <span class="s2">&quot;$2&quot;</span> <span class="o">]</span> <span class="o">&amp;&amp;</span> <span class="o">{</span> <span class="nb">echo</span> -n <span class="s2">&quot;.&quot;</span>; <span class="k">return</span>; <span class="o">}</span>
</span><span class='line'>    <span class="nb">printf</span> <span class="s2">&quot;\nFAIL: $this\n&#39;$1&#39; != &#39;$2&#39;\n&quot;</span>; <span class="nb">exit </span>1
</span><span class='line'><span class="o">}</span>
</span><span class='line'><span class="c">## end</span>
</span><span class='line'>
</span><span class='line'><span class="c">###############################################################</span>
</span><span class='line'>
</span><span class='line'>try <span class="s2">&quot;Example of GET and test for 404 status&quot;</span>
</span><span class='line'>
</span><span class='line'><span class="nv">out</span><span class="o">=</span><span class="k">$(</span>curl -s -w <span class="s2">&quot;%{http_code}&quot;</span> <span class="nv">$URL</span><span class="k">)</span>
</span><span class='line'>assert <span class="s2">&quot;404&quot;</span> <span class="s2">&quot;$out&quot;</span>
</span><span class='line'>
</span><span class='line'>try <span class="s2">&quot;Example of POST XML&quot;</span>
</span><span class='line'>
</span><span class='line'><span class="c"># Post xml (from hello.xml file) on /hello</span>
</span><span class='line'><span class="nv">out</span><span class="o">=</span><span class="k">$(</span>cat <span class="nb">test</span>/hello.xml | curl -s -H <span class="s2">&quot;Content-Type: text/xml&quot;</span> -d @- <span class="se">\</span>
</span><span class='line'>  -X POST <span class="nv">$URL</span>/hello<span class="k">)</span>
</span><span class='line'>assert <span class="s2">&quot;Hello World&quot;</span> <span class="s2">&quot;$out&quot;</span>
</span><span class='line'>
</span><span class='line'><span class="c">###############################################################</span>
</span><span class='line'><span class="nb">echo</span>
</span><span class='line'><span class="nb">echo</span> <span class="s2">&quot;PASS: $tests_run tests run&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Referências:</p>

<p><a href="http://eradman.com/posts/ut-shell-scripts.html">Unit-Testable Shell Scripts</a></p>

<p>Aguardo dicas, sugestões, experiências etc.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[A melhor linguagem de programação]]></title>
    <link href="http://1up4dev.org/2013/05/a-melhor-linguagem-de-programacao/"/>
    <updated>2013-05-06T07:00:44-03:00</updated>
    <id>http://1up4dev.org/2013/05/a-melhor-linguagem-de-programacao</id>
    <content type="html"><![CDATA[<p>Eu tenho a felicidade de ter um sogro que trabalha com desenvolvimento de softwares. Ele tem a experiência de já ter sido empresário e de já ter visto de quase tudo nessa área.</p>

<p>Atualmente ele está trabalhando em um projeto para Web e comentou que está dando preferência a uma ferramenta proprietária que eu particularmente não gosto.</p>

<p>Numa conversa que achei muito produtiva, nós concordamos que, independente de gostar ou não, &ldquo;software é bola na rede&rdquo;, onde o importante é entregar o produto, atendendo as necessidades do cliente no menor tempo possível.</p>

<p>Eu trabalhei com PHP por dez anos, com Delphi por seis e estou indo para oito com Java, usando diariamente cada uma dessas linguagens. Já tive experiências com C e trabalho há anos com Ruby e JavaScript, atualmente tenho me concentrado em Clojure e, gostando mais de umas e menos de outras, conheço as forças e fraquezas de cada uma delas.</p>

<p>No final das contas, eu gosto da analogia de que o nosso trabalho se assemelha ao de um carpinteiro/marceneiro (desculpe, mas eu não sei muito bem a diferença entre ambos). Esses profissionais usam várias ferramentas para chegar ao produto final e, ao invés de perderem tempo em fóruns e discussões, eles buscam as ferramentas adequadas a cada tipo de tarefa, buscando entregar o melhor produto no menor tempo e menor custo (entenda &lsquo;melhor produto&rsquo; como algo totalmente subjetivo).</p>

<p>Linguagens de programação são meras ferramentas, assim como serrotes, limas, martelos e sei lá que outras ferramentas os profissionais da madeira usam.</p>

<p>Assim sendo, o que é melhor? SASS, SCSS, LESS ou CSS puro? HAML ou ERB? A melhor é aquela que trouxer menos dor de cabeça, custo e tempo de desenvolvimento. Avalie com cautela aquilo que &ldquo;está na moda&rdquo; ou &ldquo;que é o padrão de mercado&rdquo; e escolha o que for melhor para o que você precisa, usando argumentos técnicos e financeiros, e deixando a paixão de lado.</p>

<p>Aprenda a sua linguagem de trabalho a fundo, e procure conhecer alternativas. Ao me tornar um bom desenvolvedor  Ruby, eu aprendi a escrever um código Java melhor. Ao entender LISP, eu me tornei mais produtivo em JavaScript.</p>

<p>Quando for escrever ou comentar algo do tipo &ldquo;Porque PHP fede&rdquo;, ou perguntar num fórum &ldquo;O que é melhor: PL/I ou FORTRAN 66?&rdquo;, procure estudar mais, entender que nem todo mundo vive a mesma realidade que você e mesmo, algumas vezes, nem todo mundo tem o interesse em aprender tanto quanto você.</p>

<p>Às vezes, o que o outro desenvolvedor quer é apenas entregar o trabalho, receber o pagamento e ir para casa.</p>

<p>P.S.: de qualquer maneira, se você quiser e puder, aprenda o máximo de linguagens que conseguir. Eu acho divertido, e profissionalmente é algo que tem me dado bons resultados.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[O que eu aprendi escrevendo]]></title>
    <link href="http://1up4dev.org/2013/04/o-que-eu-aprendi-escrevendo/"/>
    <updated>2013-04-11T07:30:47-03:00</updated>
    <id>http://1up4dev.org/2013/04/o-que-eu-aprendi-escrevendo</id>
    <content type="html"><![CDATA[<p>Apesar de ter <a href="http://www.casadocodigo.com.br/products/livro-javascript-jquery">um livro</a> e <a href="http://pro.imasters.com.br/online/cursos/ruby-on-rails-do-comeco-ao-fim">um curso</a> publicados, eu ainda estou longe de ser considerado um escritor. Honestamente, nem ao menos sei o que é necessário para que eu, ou outra pessoa, me considere como tal.</p>

<p>Pretendo escrever outro livro ainda esse ano, mas ainda não tenho nada definido. Escrever um curso ou um livro é algo cansativo, mas muito gratificante. Como não dei espaço entre um e outro, acho que seria bom eu tomar um ar antes de me lançar novamente nessa empreitada.</p>

<p>Seguindo os próprios passos que descrevo abaixo, resolvi separar alguns pontos que considero importantes.</p>

<h3>Escrever é um processo iterativo e incremental</h3>

<p>O texto não nasce pronto. As vezes uma coisa ou outra está pronta na sua cabeça, mas na hora de colocar no papel a coisa muda. Você esquece algumas partes, lembra de outras, muda a ordem.</p>

<p>O importante é que você coloque suas ideias no papel (ou no site), e depois releia com calma. Mostre para outras pessoas, peça opinião. Eu pensei em um texto por mais de dois anos e <a href="http://1up4dev.org/2013/02/programacao-funcional-com-javascript/">publiquei aqui</a> antes de adicionar no livro. O feedback dos leitores foi importantíssimo para que a versão final tivesse o mínimo de erros e o máximo de clareza possível.</p>

<h3>Defina bem o seu público</h3>

<p>Ao escrever sobre programação funcional em JavaScript, eu tinha bem claro quem é o leitor do 1up. Caso você não tenha definido quem será seu público e quais os requisitos necessários para que possam absorver seu conteúdo, você vai correr o risco de escrever um texto em aramaico para crianças de quarta série ou um texto de quarta série para doutores em línguas mortas.</p>

<p>Pior ainda é quando se tenta abraçar a todos. Seus braços são curtos para abraçar o mundo e, no final, alguma coisa vai acabar caindo no chão.</p>

<h3>Trace uma linha</h3>

<p>Como o Manifesto Ágil profere, <em>responder a mudanças é mais importante do que seguir um plano</em>, o que não quer dizer que você não precisa de um plano.</p>

<p>Eu costumo traçar um plano, seja como uma lista de tópicos, seja como um mindmap, e vou me guiando por ele até pegar o ritmo. Normalmente essa lista não permanece inalterada por mais de dois capítulos, mas ainda assim é importante você ter algo para te manter no caminho, por mais que esse caminho mude constantemente.</p>

<h3>Concentre-se</h3>

<p>Eu tenho problemas sérios de concentração, mas em algumas ocasiões consigo despejar quilos de texto ou código de uma única vez. Claro que uma revisão posterior é sempre bem vinda e necessária.</p>

<p>O problema são os culpados de sempre: família exigindo atenção (eles têm prioridade, não pense o contrário); Internet oferecendo todo o tipo de entretenimento; GTalk aberto e seus amigos ali, ao alcance dos dedos.</p>

<p>Escrever é um ato solitário. Lide com isso e concentre-se no que está fazendo.</p>

<h3>Arranje tempo</h3>

<p>&ldquo;Eu não tenho tempo&rdquo; é a desculpa preferida do procrastinador e do cara que quer que os outros acreditem que ele é muito ocupado.</p>

<p>Você tem tempo para conversar no GTalk, para acessar o 9gag, para ver os gols do Fantástico, mas nunca temos tempo para brincar com o filho, para conversar com a esposa (ou marido) ou para fazer aquela meia hora de esteira.</p>

<p>Um terço do meu livro foi escrito dentro de viagens em ônibus, táxis e aviões. Acho que produzi muito mais em uma hora de vôo até o Rio do que em uma tarde inteira jogada fora na frente do computador.</p>

<p>Quando você realmente quer fazer algo, o tempo aparece. Não ter tempo é uma outra forma de dizer &ldquo;isso não é importante o suficiente para mim&rdquo;.</p>

<h3>&lsquo;Pronto&rsquo; é melhor do que &lsquo;perfeito&rsquo;</h3>

<p>Depois do livro e do curso prontos e entregues, eu percebi coisas que poderia ter adicionado, frases que poderia ter mudado, assuntos que faltaram. Se existe a possibilidade de adicionar ou mudar, faça, mas não caia na armadilha de ficar polindo algo que já deveria estar em produção há tempos.</p>

<p>Pronto é melhor do que perfeito e, não importa o quanto você tente, seu trabalho nunca vai ficar perfeito.</p>

<h3>Divirta-se</h3>

<p>Principalmente, divirta-se.</p>

<p>Conheci muitas pessoas que sabem muito mais do assunto que estou escrevendo do que eu, pessoas que deram excelentes sugestões, ideias e me ensinaram a escrever melhor. E em tudo isso eu me diverti, aprendi, aproveitei o momento.</p>

<p>Não se leve tão a sério. É apenas um texto, um post, um curso, um livro. A vida é bem mais do que isso.</p>

<p>Abraço</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Novos rumos]]></title>
    <link href="http://1up4dev.org/2013/04/novos-rumos/"/>
    <updated>2013-04-01T12:00:51-03:00</updated>
    <id>http://1up4dev.org/2013/04/novos-rumos</id>
    <content type="html"><![CDATA[<p>Depois de um 2012 movimentado, resolvi tirar minha certificação PMI e, a partir de hoje, trabalho como gerente da fábrica de software de uma conhecida consultoria, líder de mercado.</p>

<p>Pretendo aplicar, de maneira holística, processos definidos e reproduziveis que performem de maneira out of box a sinergia entre o levantamento de requisitos, desenvolvimento no chão de fábrica e posterior envio ao setor de testes, visando a garantia de qualidade do entregável.</p>

<p>=)</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Pair Programming remoto com Screen e Vim]]></title>
    <link href="http://1up4dev.org/2013/03/pair-programming-remoto-com-screen-e-vim/"/>
    <updated>2013-03-20T11:27:02-03:00</updated>
    <id>http://1up4dev.org/2013/03/pair-programming-remoto-com-screen-e-vim</id>
    <content type="html"><![CDATA[<p>Limitar a produtividade e colaboração interpessoal ao espaço físico de um escritório parece uma idéia cada vez menos viável no ramo de desenvolvimento de software.</p>

<p>Empresas de TI bem sucedidas como <a href="http://37signals.com/">37signals</a> e <a href="https://github.com/">Github</a> apostam em times e colaboradores distribuídos pelo mundo trabalhando remotamente em seus projetos.</p>

<p>Usando as ferramentas e práticas certas é possível <a href="http://37signals.com/svn/posts/3435-remote-office-not-required-the-new-book-by-37signals-coming-fall-2013">trabalhar remotamente</a> e até mesmo <a href="http://en.wikipedia.org/wiki/Pair_programming">parear com outro desenvolvedor</a> à distância.</p>

<h2>Requisitos</h2>

<ul>
<li><p>ssh</p></li>
<li><p>screen</p></li>
<li><p>vim</p></li>
<li><p>skype</p></li>
</ul>


<p>Para compartilhar o mesmo &ldquo;contexto&rdquo; remotamente, ambos desenvolvedores deverão ter acesso ao mesmo ambiente de desenvolvimento, via <strong>ssh</strong>. Estando em modo texto, será necessário utilizar um editor compatível, neste caso o <strong><a href="http://www.vim.org/">VIM</a></strong>.  E para compartilhar o terminal em tempo real, utilizaremos o Screen. Para comunicação, basta utilizar o Skype. Simples não!?</p>

<h2>Instalação</h2>

<p>Uma vez escolhido o ambiente de desenvolvimento comum (um servidor de homologação, por exemplo), instale o Screen:</p>

<pre><code>$ sudo apt-get install screen
</code></pre>

<p>Em seguida, configure as permissões de execução:</p>

<pre><code>$ chmod u+s /usr/bin/screen
$ chmod 755 /var/run/screen
</code></pre>

<p>O Screen roda como um <em>daemon</em>, mantendo um <em>buffer</em> da tela. Sendo assim, o primeiro passo é iniciar a sessão do Screen:</p>

<pre><code>$ screen -S nomedasessao
</code></pre>

<p>Isso criará uma sessão com o nome &ldquo;nomedasessao&rdquo; e será exibido um shell &ldquo;limpo&rdquo;, o que quer dizer que você já está conectado a esta sessão. Para verificar, execute:</p>

<pre><code>$ screen -ls
There is a screen on:
        8095.nomedasessao   (19-03-2013 23:32:54)   (Attached)
1 Socket in /var/run/screen/S-user.
</code></pre>

<p>A partir de agora, o buffer desta sessão pode ser compartilhado com outro usuário conectado. Basta que seu par se logue no servidor via ssh e execute:</p>

<pre><code>$ screen -x nomedasessao
</code></pre>

<p>Pronto! O que você digitar, seu par vai ver e vice-versa. Assim, basta abrir o VIM e começar a parear remotamente.</p>

<p>Para se desconectar da sessão atual, execute:</p>

<pre><code># screen -d
[remote detached from 8095.nomedasessao]
</code></pre>

<h2>Usando o Screen</h2>

<p>O Screen é simples e poderoso. É possível criar abas (window), dividir a tela (split), rolar a tela (copy mode), etc.</p>

<p>Todos comandos começam com Ctrl + a, em seguida o comando ou atalho. Seguem alguns comandos e atalhos que serão muito úteis do seu dia-a-dia pareando:</p>

<p><strong>Copy mode (scroll)</strong>
Inicie o modo de cópia com Ctrl-a + [ (colchete para esquerda)
Navegue pela tela com as setas ou pageup/pagedown;
Marque o início da seleção do texto com &lt;espaço> e termine com &lt;espaço> para copiar;
Cole com Ctrl-a + ] (colchete para direita);</p>

<p><strong>Windows</strong>
Crie uma janela (ou aba) com Ctrl-a + c
Liste as janelas com Ctrl-a + &ldquo; (aspas)
Altere para a janela com Ctrl-a <numero de 0-9>
Feche (ou mate) a janela atual com Ctrl+a k</p>

<p><strong>Split</strong>
Divida a tela horizontalmente com Ctrl-a + S
Divida a tela verticalmente com Ctrl-a + V
Mude de split com Ctrl-a + Tab
Feche um split com Ctrl-a + X</p>

<p>Para digitar um comando: Ctrl-a + :</p>

<p>Consulte o <a href="http://linux.die.net/man/1/screen">manual do Screen</a> para a lista completa de atalhos/comandos.</p>

<h2>Dicas e considerações</h2>

<p>Esta é uma abordagem simplista da utilização do Screen. Deixei vários detalhes de fora do post para tentar ser o mais didático possível. Para informações mais completas como configurações, gerenciamento de sessões e usuários, consulte o <a href="http://linux.die.net/man/1/screen">manual oficial</a>.</p>

<p>Existem outras alternativas como o <a href="http://tmux.sourceforge.net/">tmux</a>, mas o conceito envolvido é o mesmo apresentado aqui.</p>

<p>Se você estiver programando em Rails, provavelmente precisará de 3 contextos: console, server e editor (Vim). Recomendo utilizar cada contexto como &ldquo;window&rdquo; na mesma sessão do Screen.</p>

<p>Utilize o Skype (ou outro voip de sua preferência) durante todo o tempo em que estiverem pareando e estabeleça intervalos. <a href="http://www.pomodorotechnique.com/">Pomodoro</a> pode ser uma boa opção.</p>

<p>Dúvidas, críticas ou sugestões nos comentários. Sucesso!</p>

<h2>Referências</h2>

<p><a href="http://www.linux.com/learn/tutorials/442418-using-screen-for-remote-interaction">http://www.linux.com/learn/tutorials/442418-using-screen-for-remote-interaction
</a><a href="http://linux.die.net/man/1/screen">http://linux.die.net/man/1/screen
</a><a href="http://aperiodic.net/screen/quick_reference">http://aperiodic.net/screen/quick_reference</a></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[O ano em que eu tirei a bunda da cadeira]]></title>
    <link href="http://1up4dev.org/2013/03/o-ano-em-que-eu-tirei-a-bunda-da-cadeira/"/>
    <updated>2013-03-18T13:45:25-03:00</updated>
    <id>http://1up4dev.org/2013/03/o-ano-em-que-eu-tirei-a-bunda-da-cadeira</id>
    <content type="html"><![CDATA[<p><strong>TL;DR: </strong><em>2012 foi o ano em que eu publiquei um curso num grande portal de tecnologia, palestrei em eventos relevantes e ministrei um curso em um lugar que eu mal conhecia no mapa.</em></p>

<p>De alguns anos para cá, passei a escrever uma pequena lista de metas para o ano seguinte e percebi que o simples fato de haver uma lista já era o suficiente para que eu não perdesse totalmente o foco.</p>

<p>A criação de uma lista, pequena, concisa, realista, também traz motivação para cumprir novas metas a cada vez que você completa algum dos itens. É a estratégia de alimentar o cérebro com pequenas recompensas para continuar em frente, como acontece num jogo.</p>

<p>Há pouco mais de dois anos, <a href="http://1up4dev.org/2011/02/pare-de-chorar-e-mexa-se/">escrevi aqui um post</a> em que eu dizia que deveríamos parar de chorar e reclamar e começar a correr atrás de nossos objetivos. Escrevi aquele texto especialmente para mim, como se uma parte do cérebro estivesse dando uma bronca na outra parte. Demorou, mas acho que a bronca fez efeito.</p>

<p>Usando a lista de metas, mesmo sem muita disciplina, consegui ir além do que eu previa, sendo que passei a considerar 2012 como o ano em que parei de reclamar, tirei a bunda da cadeira e as coisas começaram a acontecer.</p>

<p>Em 2011, resolvi que queria tentar participar de eventos como palestrante. Sempre tive dificuldade de falar em público e apresentar idéias, e achei que essa seria uma boa forma de corrigir essas limitações.</p>

<p>Em 2012 eu continuei, tanto para apresentar algum tema que eu considero interessante, como também como ferramenta de marketing pessoal. Tanto quanto ser competente e fazer um bom trabalho, é importante ver e ser visto.</p>

<p>Em Maio, apresentei um <a href="http://pbalduino.github.com/gurusp-talk-23/">talk de 30 minutos</a>, no 23º encontro do GURU-SP, demonstrando a simplicidade do LISP usando Clojure.</p>

<p>Em Agosto, para minha total surpresa, fui convidado a apresentar um lightning talk no <a href="http://www.qconsp.com/">QCON-SP</a>, onde falei sobre todos os sabores conhecidos de Ruby e dialetos, incluindo o Elixir. Apresentar um tema em cinco minutos é como fazer um show de Punk Rock, e a adrenalina de ambos é sempre bem vinda.</p>

<p>Em Outubro, foi ao ar o meu curso <a href="http://pro.imasters.com.br/online/cursos/ruby-on-rails-do-comeco-ao-fim">Ruby on Rails do começo ao fim</a>, pelo portal de cursos do iMasters. O curso nasceu como um tutorial que fiz para ajudar algumas pessoas próximas e acabou se tornando algo que me ajudou a conhecer mais pessoas.</p>

<p>Um dos frutos que colhi com esse curso foi o convite para <a href="http://pbalduino.github.com/senes2012/">palestrar</a> e ministrar um treinamento durante a IV Semana de Engenharia do Norte do Espírito Santo, no campus do CEUNES/UFES, em São Mateus &ndash; ES, que aconteceu em Novembro. Um efeito colateral muito bem vindo dessa minha ida ao Espírito Santo foi a criação do Grupo de Usuários Ruby-ES, um irmão caçula do GURU-SP.</p>

<p>Ainda em Novembro, fui convidado a participar do evento 7masters Java, organizado pelo iMasters, no qual tive a honra de dividir o espaço com pessoas que eu admiro há anos, como Bruno &ldquo;JavaMan&rdquo;, Luca Bastos e a dupla dinâmica qmx/abstractj. Lá falei sobre os usos do <a href="http://pbalduino.github.com/7masters-java/">Clojure no mundo real</a> e <a href="http://videolog.tv/video.php?id=889921">compartilhei a experiência</a> que tive em um projeto, utilizando a ferramenta.</p>

<p>Fechando o ano, tive meu livro <a href="http://www.casadocodigo.com.br/products/livro-javascript-jquery">Dominando JavaScript com jQuery</a> publicado pela <a href="http://www.casadocodigo.com.br/">Editora Casa do Código</a>. Aliás, a versão impressa do livro foi disponibilizada hoje no site. Agora só me falta plantar uma árvore.</p>

<p>Em breve, pretendo compartilhar minhas experiências ao escrever o curso e o livro.</p>

<p>Que mais realizações venham em 2013, e que os frutos do que plantei continuem nascendo, mesmo que dessa vez eu não tenha feito nenhuma lista de metas a cumprir.</p>
]]></content>
  </entry>
  
</feed>