<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Rafael Tardivo on Medium]]></title>
        <description><![CDATA[Stories by Rafael Tardivo on Medium]]></description>
        <link>https://medium.com/@rafaeltardivo?source=rss-18a85bd49c3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*xkUATRnXopC31eD2YUweWQ.jpeg</url>
            <title>Stories by Rafael Tardivo on Medium</title>
            <link>https://medium.com/@rafaeltardivo?source=rss-18a85bd49c3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 11:44:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rafaeltardivo/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Bubble sort — Passo a passo]]></title>
            <link>https://medium.com/rafaeltardivo/bubble-sort-passo-a-passo-67bb5e11677c?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/67bb5e11677c</guid>
            <category><![CDATA[pytho]]></category>
            <category><![CDATA[bubble-sort]]></category>
            <category><![CDATA[algorithms]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Sat, 20 Jun 2020 19:12:59 GMT</pubDate>
            <atom:updated>2020-06-20T19:12:59.329Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bubble sort — Passo a passo</h3><p>Entendendo o infame algoritmo de ordenação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/0*lVrEr3Pfc98VUL-p.png" /><figcaption>fonte: <a href="https://bit.ly/2CrqzLu">https://bit.ly/2CrqzLu</a></figcaption></figure><p>Se você estuda/estudou computação, provavelmente já ouviu falar do <em>Bubble Sort</em>. Tirando o fato de que ele é conhecidamente ineficiente, sua implementação é relativamente fácil e entendê-lo pode ser uma porta de entrada para o universo dos algoritmos de ordenação.</p><h4>De onde vem o nome Bubble Sort?</h4><p>De uma suposta analogia do processo de ordenamento com um “bolhas emergindo em um tanque de água”.</p><h4><strong>O que vamos ordenar?</strong></h4><p>Uma pequena lista de inteiros : [7, 3, 6, 2, 0].</p><h4>Como vamos ordenar?</h4><p>Cada elemento será comparado com os adjacentes, de maneira que a cada “passada” o maior elemento será deslocado para o fim da lista. Exemplificando fica mais fácil:</p><h4>Primeira iteração:</h4><pre><strong>Estado inicial antes da primeira iteração</strong>: [3, 7, 6, 2, 0]</pre><pre><strong>7 &gt; 3</strong>? Sim, realiza a troca:<br>[3, <strong>7</strong>, 6, 2, 0]</pre><pre><strong>7</strong> <strong>&gt; 6</strong>? Sim, realiza a troca:<br>[3, 6, <strong>7</strong>, 2, 0]</pre><pre><strong>7</strong> <strong>&gt;</strong> <strong>2</strong>? Sim, realiza a troca:<br>[3, 6, 2, <strong>7</strong>, 0]</pre><pre><strong>7</strong> &gt; <strong>0</strong>? Sim, realiza a troca:<br>[3, 6, 2, 0, <strong>7</strong>]</pre><pre><strong>Estado final após a primeira iteração: </strong>[3, 6, 2, 0, 7]</pre><p>Observe que o maior número foi para o fim, <strong>assim como um bolha emerge do fundo para a superfície de um tanque de água!</strong></p><h4>Segunda iteração:</h4><pre><strong>Estado inicial antes da segunda iteração</strong>: [3, 6, 2, 0, 7] </pre><pre><strong>3 &gt; 6</strong>? Não, vá para o próximo:<br>[3, 6, 2, 0, 7]</pre><pre><strong>6 &gt; 2</strong>? Sim, realiza a troca:<br>[3, 2, <strong>6</strong>, 0, 7]</pre><pre><strong>6 &gt; 0</strong>? Sim, realiza a troca:<br>[3, 2, 0, <strong>6</strong>, 7]</pre><pre><strong>6 &gt; 7</strong>? Não, como não existe próximo, acaba aqui.<br>[3, 2, 0, 6, 7]</pre><pre><strong>Estado final após a segunda iteração</strong>: [3, 2, 0, 6, 7]</pre><p>Observe que o segundo maior número foi para o penúltimo lugar, logo antes do maior.</p><h4>Terceira iteração:</h4><pre><strong>Estado inicial antes da terceira iteração</strong>: [3, 2, 0, 6, 7]</pre><pre><strong>3 &gt; 2</strong>? Sim, realiza a troca:[7, 3, 6, 2, 0]<br>[2, <strong>3,</strong> 0, 6, 7]</pre><pre><strong>3 &gt; </strong>0? Sim, realiza a troca:<br>[2, 0<strong>,</strong> <strong>3</strong>, 6, 7]</pre><pre><strong>3 &gt; 6</strong>? Não, mantém o estado atual e vai para o próximo:<br>[2, 0<strong>,</strong> 3, 6, 7]</pre><pre><strong>3 &gt; 6</strong>? Não, como não existe próximo, acaba aqui.<br>[2, 0<strong>,</strong> 3, 6, 7]</pre><pre><strong>Estado final após a terceira iteração</strong>: [2, 0<strong>,</strong> 3, 6, 7]</pre><p>Novamente, observe que o terceiro maior número se tornou o antepenúltimo</p><h4>Quarta iteração:</h4><pre><strong>Estado inicial antes da quarta iteração</strong>: [2, 0<strong>,</strong> 3, 6, 7]</pre><pre><strong>2 &gt; </strong>0 ? Sim, realiza a troca:<br>[0, <strong>2,</strong> 3, 6, 7]</pre><pre><strong>2 &gt; </strong>3? Não, mantém o estado atual e vai para o próximo:<br>[0, 2<strong>,</strong> 3, 6, 7]</pre><pre><strong>2 &gt; </strong>6? Não, mantém o estado atual e vai para o próximo:<br>[0, 2<strong>,</strong> 3, 6, 7]</pre><pre><strong>2 &gt; </strong>7? Não, como não existe próximo, acaba aqui:<br>[0, 2<strong>,</strong> 3, 6, 7]</pre><pre><strong>Estado final após a quarta iteração</strong>: [2, 0<strong>,</strong> 3, 6, 7]</pre><p>Nossa lista finalmente está ordenada! Observe que, justamente pelo fato dos maiores números “borbulharem” para o fim, a última iteração só realizou uma troca, as demais nem precisariam ser feitas.</p><p>Pois bem, vamos agora implementar o algoritmo em Python ❤</p><h3>Primeira implementação</h3><p>Propositalmente não otimizada:</p><pre>numbers = [7, 3, 6, 2, 0]<br>size = len(numbers)</pre><pre>for i in range(size -1): <br>    for j in range (size -1):<br>        if numbers[j] &gt; numbers[j + 1]:<br>            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]</pre><p>Descrição do raciocínio:</p><pre>Para cada item na lista: <strong>(primeiro for)</strong><br>    Compare com todos os itens: <strong>(segundo for)<br>        </strong>Se o item atual for maior que o seguinte: <strong>(if)<br>            </strong>Troque eles de posição <strong>(atual,seguinte = seguinte,atual)</strong></pre><p>Bem simples, não? Já é uma implementação funcional do algoritmo <em>Bubble Sort.</em></p><h3>Segunda implementação</h3><p>Evitando comparações desnecessárias.</p><p>se você observar bem, a cada iteração um número é “empurrado” para o fim da lista. No nosso caso foi mais ou menos assim:</p><pre>[. . . . 7]<br>[. . . 6 7]<br>[. . 3 6 7]<br>[. 2 3 6 7]<br>[0 2 3 6 7]</pre><p>Sendo assim, concorda comigo que a cada iteração nós temos um índice a menos para se preocupar? Em outras palavras, <strong>a cada iteração, um índice é definitivamente ordenado</strong>.</p><p>Vamos otimizar nossa implementação inicial:</p><pre>numbers = [7, 3, 6, 2, 0]<br>size = len(numbers)</pre><pre>for i in range(size -1): <br>    for j in range (size <strong>-i</strong> -1):<br>        if numbers[j] &gt; numbers[j + 1]:<br>            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]</pre><p>Observe que agora<strong> nós subtraímos o valor de i no segundo laço for</strong>. O motivo é:</p><p>1 — Na primeira iteração o número 7 é ordenado e posicionado no fim da lista:</p><pre>[. . . . 7]</pre><p>Nessa iteração, i vale 0, então verificamos todos os índices no segundo laço.</p><p>2 — Na segunda iteração, podemos considerar que o último índice já se encontra ordenado, certo? Sendo assim, precisamos realmente ir até o último índice?<strong> Não! é aí que entra o nosso -i no segundo laço:</strong></p><pre>...<br>    for j in range (size <strong>-i</strong> -1):<br>...</pre><p>Observe que agora i vale 1, e nós só iremos até o penúltimo índice (já que o último já se encontra ordenado). O algoritmo continua assim até que na última iteração, só os dois últimos números sejam comparados.</p><h3>Terceira implementação</h3><p>Para a terceira (e última) implementação, precisaremos de uma lista diferente para reproduzir a possível otimização:</p><pre>[1, 3, 2, 6, 7, 8]</pre><p>Observe que só existe uma troca a ser feita: 3 pelo 2. Sendo assim, faz sentido avaliar todas as possibilidades? Ou será que poderíamos fazer algo do tipo:</p><pre>Trocou nenhum número de lugar nesta iteração? <strong>Não.<br>    </strong>Encerra o processo de ordenação</pre><p>Ou seja, Nós paramos a ordenação assim que identificamos que nenhuma troca foi feita, já que,<strong> se nenhuma troca foi feita, a lista já se encontra ordenada!</strong></p><p>Em termos de implementação, ficaria assim:</p><pre>numbers = [7, 3, 6, 2, 0]<br>size = len(numbers)</pre><pre>for i in range(size -1):<br>    <strong>swapped = False </strong><br>    for j in range (size -i -1):<br>        if numbers[j] &gt; numbers[j + 1]:<br>            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]<br>            <strong>swapped = True<br>    if not swapped:<br>        break</strong></pre><h3>Conclusão</h3><p>Mesmo não sendo um algoritmo “performático”, o <em>Bubble Sort</em> ainda serve como introdução ao tema. Além disso, vimos que mesmo uma solução considerada “não tão boa” pode ser repensada e melhorada.</p><h4>EXTRA: Ainda não entendeu? veja meu Github ;)</h4><p><a href="https://github.com/rafaeltardivo/sort-algorithms">https://github.com/rafaeltardivo/sort-algorithms</a></p><p>Deixei exemplos das três implementações por lá. Espero que ajude!</p><p>Até mais!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67bb5e11677c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/bubble-sort-passo-a-passo-67bb5e11677c">Bubble sort — Passo a passo</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exceções: de onde vêm, para onde vão e como organizá-las em Python]]></title>
            <link>https://medium.com/rafaeltardivo/exce%C3%A7%C3%B5es-de-onde-v%C3%AAm-para-onde-v%C3%A3o-e-como-organiz%C3%A1-las-em-python-3d50bee2b317?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d50bee2b317</guid>
            <category><![CDATA[exception]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Fri, 10 Apr 2020 16:16:02 GMT</pubDate>
            <atom:updated>2020-04-10T16:16:02.126Z</atom:updated>
            <content:encoded><![CDATA[<p>Quando e como tratar exceções e a importância dos tratamentos especializados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/957/0*2GtXOM1b9qE_jmyX.jpg" /><figcaption>créditos da imagem: <a href="https://tinyurl.com/sr6eelw">https://tinyurl.com/sr6eelw</a></figcaption></figure><h4>Antes de mais nada, o que são exceções?</h4><p>Podemos dizer que exceções são resultado de “eventos excepcionais” ocorridos durante o fluxo regular de um software.</p><h4>Como assim?</h4><p>Em termos práticos, se algo deu errado, uma exceção que corresponde ao problema ocorrido será lançada.</p><h4>Um exemplo do mundo real:</h4><p>Imagine que você acabou de clicar no botão “imprimir” de um PDF, sua impressora está ligada, configurada e com papel. No entanto, você percebe que a impressão não foi realizada e se depara com a seguinte mensagem:</p><blockquote>IMPRESSORA SEM TINTA!</blockquote><p>Pois é, você provavelmente já passou por isso! O fluxo normal seria imprimir o documento, mas algo aconteceu e esse fluxo foi interrompido… Em outras palavras, <strong>uma exceção ocorreu</strong>.</p><h4>Um exemplo em Python</h4><p>Vamos imaginar que estamos escrevendo o trecho de código responsável pelo processo de impressão:</p><pre>try:<br>    print_document(document)<br>except <strong><em>OutOfInkError</em></strong>:<br>    display_message(&quot;IMPRESSORA SEM TINTA&quot;)</pre><p>O exemplo acima nos diz: tente (<strong><em>try</em></strong>) imprimir, caso a impressora esteja sem tinta (<strong><em>except OutOfInkError</em></strong>), exiba no display a mensagem <strong><em>IMPRESSORA SEM TINTA!</em></strong>.</p><h3>Múltiplas Exceções</h3><p>Concorda comigo que faltar tinta não é o único possível erro em um processo de impressão? A impressora poderia, por exemplo, ter tinta e não ter papel!</p><p>Como você já deve imaginar, podemos nos preparar para mais de uma exceção:</p><pre>try:<br>    print_document(document)<br>except <strong><em>OutOfInkError</em></strong>:<br>    display_message(&quot;IMPRESSORA SEM TINTA!&quot;)<br>except <strong><em>OutOfPaperError</em></strong>:<br>    display_message(&quot;IMPRESSORA SEM PAPEL!&quot;)</pre><h3>Hierarquia de Exceções</h3><p>Exceções geralmente são definidas de maneira hierárquica e conhecer essa hierarquia é extremamente importante para nós. Vejamos por exemplo, uma versão da hierarquia de exceções <strong><em>built-in</em></strong> do Python:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/0*NqgnokVVMdr3cntg.png" /><figcaption><strong><em>?</em></strong></figcaption></figure><p>Observe o seguinte exemplo de hierarquia: <strong><em>AttributeError</em></strong> herda de <strong><em>Exception</em></strong>, que por sua vez herda de <strong><em>BaseException</em></strong><em>.</em></p><h4>Na prática, o que isso muda?</h4><p>Voltando ao nosso exemplo de impressão, vamos imaginar que nossas exceções <strong><em>OutOfInkError</em></strong> e <strong><em>OutOfPaperError</em></strong> herdam de <em>PrintError</em>, que por sua vez <em>(</em>assim como todas exceções em Python<em>), </em>herda de<em> </em><strong><em>Exception</em></strong><em>:</em></p><pre>            <strong><em>Exception</em></strong><br>                ^<br>                | <br>                | <br>            <strong><em>PrintError</em></strong><br>            ^        ^<br>            |        |<br>            |        |          <br>   <strong><em>OutOfInkError</em></strong>  <strong><em>OutOfPaperError</em></strong></pre><p>Em Programação Orientada a Objetos, um objeto sempre passará no teste <strong>É- Um</strong> de uma classe pai, ou seja:</p><pre><strong><em>?OutOfInkError</em></strong><em> É Um</em><strong><em> PrintError<br>PrintError</em></strong><em> É Um </em><strong><em>Exception</em></strong></pre><p>Um exemplo mais lúdico seria a relação entre as classes <strong><em>Animal</em></strong> e <strong><em>Cachorro</em></strong>:</p><pre><strong><em>   Animal</em></strong><br>     ^<br>     | <br>     | <br>   <strong><em>Cachorro</em></strong></pre><p>Concorda que todo cachorro <strong>É-Um</strong> animal? Em contrapardida, nem todo animal<strong> É-Um</strong> cachorro, certo? (Caso não tenha entendido o exemplo, dê uma olhada <a href="https://en.wikipedia.org/wiki/Is-a">aqui</a>)</p><h3>A ordem dos fatores altera o produto</h3><p>Se tratando de exceções, a ordem faz MUITA diferença! As exceções são tratadas de acordo com a ordem de seus blocos e é aí que entra a relacão <strong>É-Um</strong>.</p><h4>É-Um</h4><p>Supondo que agora as exceções do nosso processo de impressão sejam tratadas da seguinte maneira:</p><pre>try:<br>    print_document(document)<br>except <strong><em>PrintError</em>:</strong><br>    display_message(&quot;ERRO AO IMPRIMIR DOCUMENTO!&quot;)<br>except <strong><em>OutOfInkError</em></strong>:<br>    display_message(&quot;IMPRESSORA SEM TINTA!&quot;)<br>except <strong><em>OutOfPaperError</em></strong>:<br>    display_message(&quot;IMPRESSORA SEM PAPEL!&quot;)</pre><p>As exceções <strong><em>OutOfInkError</em></strong> e <strong><em>OutOfPaperError </em></strong>nunca seriam tratadas! Ambas seriam tratadas como:</p><blockquote>ERRO AO IMPRIMIR DOCUMENTO!</blockquote><p>O motivo? Ambas passam no teste <strong>É-Um </strong>do tratamento de PrintError.</p><h3>Visibilidade</h3><p>O ponto chave para o tratamento de exceções específicas é:<strong> visibilidade</strong>.</p><p>Como você saberá se precisa comprar tinta ou papel se a única informação disponível é: <strong><em>ERRO AO IMPRIMIR DOCUMENTO</em></strong><em>?</em></p><p>O mesmo se aplica ao seu software! Saber <strong>exatamente o que aconteceu</strong> fará com que tempo e esforço empregados para conter o incidente sejam significamente menores ;)</p><h3>Conclusão</h3><ul><li>Conheça a hieraquia de exceções da linguagem de programação em uso;</li><li>A ordem importa: da mais específica para a mais generalizada, <strong>SEMPRE</strong>;</li><li>Evite tratamentos excessivamente genéricos, você pode acabar suprimindo exceções que não deveria.</li></ul><p><strong>EXTRA</strong>: O (excelente) site <a href="https://realpython.com/">realpython</a> tem um artigo bem bacana sobre um <em>anti-pattern</em> amplamente usado em Python: <a href="https://realpython.com/the-most-diabolical-python-antipattern/">https://realpython.com/the-most-diabolical-python-antipattern/</a></p><p>Vale a pena ler!</p><p>CYA :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d50bee2b317" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/exce%C3%A7%C3%B5es-de-onde-v%C3%AAm-para-onde-v%C3%A3o-e-como-organiz%C3%A1-las-em-python-3d50bee2b317">Exceções: de onde vêm, para onde vão e como organizá-las em Python</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git: criando tags]]></title>
            <link>https://medium.com/rafaeltardivo/git-criando-tags-7c34ee6786be?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c34ee6786be</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Tue, 09 Jul 2019 23:24:08 GMT</pubDate>
            <atom:updated>2019-07-09T23:24:08.711Z</atom:updated>
            <content:encoded><![CDATA[<p>Como e quando usar <em>tags</em> no Git!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/559/1*81bl0O0cEQdMmU9lemUriQ.png" /><figcaption>Figura 1 — My first tag</figcaption></figure><p>Já que agora <a href="https://medium.com/rafaeltardivo/git-github-uma-introdu%C3%A7%C3%A3o-pr%C3%A1tica-fed91ee56b8d">já sabemos como criar e versionar repositórios</a><em>, </em>chegou a hora de investirmos um tempo na organização dos nossos projetos. Sendo assim, nosso primeiro passo será aprender como (e quando) criar <em>tags</em>.</p><h3>O que são tags?</h3><p>São etiquetas que demarcam um ponto (<em>commit</em>) que representa alguma mudança significativa no seu código, ou seja, uma versão (ou <em>release) </em>do seu projeto.</p><h3>Criando a versão inicial de uma calculadora</h3><p>Para exemplificar o uso de tags, vamos fazer uma calculadora simples em Python. Crie um repositório vazio chamado<strong><em> simplecalculator </em></strong>(se você ainda não sabe como criar um repositório, <a href="https://medium.com/rafaeltardivo/git-github-uma-introdu%C3%A7%C3%A3o-pr%C3%A1tica-fed91ee56b8d">veja no meu post anterior</a>).</p><p>Uma vez criado o repositório, vamos cloná-lo:</p><pre>$ git clone <a href="https://github.com/rafaeltardivo/simplecalculator.git">https://github.com/<strong>seuuser</strong>/simplecalculator.git</a></pre><p>Você irá receber um <em>warning</em> por estar clonando um repositório vazio, tudo bem até aí. Vá até o diretório simplecalculator e crie o arquivo <strong><em>README.md</em></strong>:</p><pre>$ cd simplecalculator<br>$ touch README.md</pre><p>Agora, com seu editor preferido, abra o arquivo <strong><em>README.md</em></strong> e insira:</p><pre><strong># Simple Calculator</strong></pre><pre>A simple calculator made in Python</pre><p>Antes de mais nada, porque criamos um arquivo chamado <strong><em>README.md</em></strong>? E porque a extensão dele é<strong><em> md?</em></strong></p><p>Por padrão, todo repositório tem um arquivo <strong><em>README.md</em></strong> que explica o básico de seu funcionamento para outros desenvolvedores e/ou usuários!</p><p>Já sobre a extensão <strong><em>.md</em></strong>, Trata-se de um arquivo <strong><em>markdown</em></strong>! Se quiser saber mais sobre, acesse: <a href="https://www.markdownguide.org/">https://www.markdownguide.org/</a></p><p>Pois bem, agora que editamos nosso arquivo, vamos versioná-lo:</p><pre>$ git add README.md<br>$ git commit -m &quot;Initial commit&quot;<br>$ git push</pre><p>Vá até o <a href="https://github.com/">Github</a> e observe que o nosso <strong><em>README.md</em></strong> foi automaticamente renderizado na <em>home</em> do repositório:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*6tni8jhiGlg4Y-lb6NTRhA.png" /><figcaption>Figura 2 — Repositório com README.md inicializado</figcaption></figure><p>Observe também que temos 1 <strong><em>commit</em></strong>, 1 <strong><em>branch</em></strong> e 0 <strong><em>releases</em></strong> e 1 <strong><em>contributor</em></strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*ILy7pROu8pW7-hegYrckPQ.png" /><figcaption>Figura 3— Informações sobre o repositório</figcaption></figure><p>Sobre essas informações, <strong><em>commit</em></strong> nos já sabemos o que é, <strong><em>release</em></strong> faremos agora e <strong><em>contributor</em></strong> indica o número de participantes no repositório (nesse caso, só eu). Quanto às <strong><em>branches</em></strong>, serão assunto do próximo post ;)</p><p>Adicionamos o<strong><em> README.md</em></strong> mas nós ainda não temos uma versão funcional para lançar, certo? Criaremos então a versão 1.0 da nossa calculadora. No diretório simplecalculator, crie o arquivo <strong><em>calculator.py</em></strong>:</p><pre>$ touch calculator.py</pre><p>Agora adicione a função <strong><em>sum_numbers</em></strong> a ele:</p><pre>def sum_numbers(n1, n2):<br>&quot;&quot;&quot;Simple sum of two numbers.&quot;&quot;&quot;<br>    return n1 + n2</pre><p>Feito isso, vamos versioná-lo também:</p><pre>$ git add calculator.py<br>$ git commit -m &quot;Add sum function&quot;<br>$ git push</pre><p>Agora que temos uma versão minimamente funcional, chegou a hora de criar a nossa primeira <em>tag</em>!</p><h3>Tipos de <strong><em>tag</em></strong></h3><p>Existem dois tipos de <em>tag</em>: <em>annotaded</em> e <em>lightweight. </em>De maneira bem resumida, podemos dizer que tags <em>annotated</em> armazenam detalhes sobre o estado do repositório naquele momento, enquanto tags <em>lightweight</em> armazenam apenas o <em>checksum</em> do <em>commit</em> em que foram geradas! Se quiser saber mais sobre o assunto, acesse<em>: </em><a href="https://git-scm.com/book/en/v2/Git-Basics-Tagging">https://git-scm.com/book/en/v2/Git-Basics-Tagging</a></p><h3>Criando nossa primeira tag</h3><p>No nosso caso, criaremos uma tag <em>annotated. </em>A sintaxe é bem simples e parecida com a do<em> commit:</em></p><pre>$ git tag -a &lt;name&gt; -m &lt;message&gt;</pre><p>No nosso caso, chamaremos a versão de<em> v1.0</em> e incluiremos a mensagem “<em>v1.0 sum function</em>”:</p><pre>$ git tag -a v1.0 -m “S<em>um functionality</em>”</pre><p>Voilá! Nossa tag foi criada! Vamos ver se deu tudo certo? Execute o comando:</p><pre>$ git tag</pre><p>A saída deverá ser:</p><pre>v1.0</pre><p>Agora iremos obter informações sobre nossa tag. Execute o comando:</p><pre>$ git show v1.0</pre><p>Observe a quantidade de informações que uma<em> tag annotated</em> pode nos fornecer:</p><pre>tag v1.0<br>Tagger: <strong>Seu User &lt;seuemail@email.com&gt;</strong><br>Date:   Fri Jun 28 23:34:12 2019 -0300</pre><pre>v1.0 - sum function</pre><pre><strong>commit 25083f2a4ac59654e16a05524d1e4dce045fee31</strong> (HEAD -&gt; master, tag: v1.0, origin/master)<br>Author: <strong>Seu User &lt;seuemail@email.com&gt;</strong><br>Date:   Fri Jun 28 23:15:56 2019 -0300</pre><pre>Add sum function</pre><pre>diff --git a/calculator.py b/calculator.py<br>new file mode 100644<br>index 0000000..3d22ba3<br>--- /dev/null<br><strong>+++ b/calculator.py</strong><br>@@ -0,0 +1,3 @@<br><strong>+def sum(n1, n2):<br>+&quot;&quot;&quot;Simple sum of two numbers.&quot;&quot;&quot;<br>+    return n1 + n2</strong></pre><p>Dentre outras informações, temos:</p><ul><li>Usuário que criou a <em>tag</em></li><li><em>Checksum</em> do commit que a originou</li><li>Arquivo(s) alterado(s)</li><li>Conteúdo da(s) alteração(ões)</li></ul><h3>Versionando nossa primeira tag</h3><p>Agora que já criamos a tag, vamos versioná-la. Para isso, execute o comando:</p><pre>$ git push origin v1.0</pre><p><strong>Obs:</strong> v1.0 é o nome da nossa tag</p><p>Pronto! Vá até o seu repositório no <a href="https://github.com/">Github</a> e veja que agora temos nosso primeiro <em>release</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zHNttCH0IrCGG_NZ1FIXnQ.png" /><figcaption>Figura 4 — Primeiro release</figcaption></figure><p>Ao clicarmos nele:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/408/1*anOokXU_NRStBxB2JizwNg.png" /><figcaption>Figura 5 — Detalhe do primeiro release</figcaption></figure><h3>Excluindo uma tag</h3><p>Normalmente <em>tags</em> não são excluidas a menos que tenham sido geradas por engano! Se for esse o seu caso, primeiro realize a exclusão local:</p><pre>git tag -d v1.0</pre><p>e depois a exclusão no seu <em>remote</em>:</p><pre>git push --delete origin v1.0</pre><p>Bom, por hoje é só! Espero que tenham gostado! O próximo post será sobre <em>branches</em>! Mantenham o repositório <strong><em>simplecalculator</em></strong>, ele será usado lá também.</p><p>Até mais o/</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c34ee6786be" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/git-criando-tags-7c34ee6786be">Git: criando tags</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git + Github: uma introdução prática]]></title>
            <link>https://medium.com/rafaeltardivo/git-github-uma-introdu%C3%A7%C3%A3o-pr%C3%A1tica-fed91ee56b8d?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/fed91ee56b8d</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Mon, 24 Jun 2019 03:04:54 GMT</pubDate>
            <atom:updated>2019-06-24T13:43:16.022Z</atom:updated>
            <content:encoded><![CDATA[<p>Uma guia prático introdutório para que você entenda os bastidores dos seus primeiros comandos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yfkUIurJzWNIdfL6.png" /><figcaption>Figura 1 — Octopus. Fonte: <a href="https://imgbin.com/png/LbLYtTnE/octopus-black-and-white-monochrome-png">imgbin</a></figcaption></figure><p>O Git foi criado por Linus Torvalds, para o controle de versões do kernel do Linux (antes versionado no <a href="https://www.bitkeeper.org/">BitKeeper</a>) e hoje é disparadamente o versionador mais usado do mercado! Se quiser saber mais sobre como o Git mudou o versionamento de software o <a href="https://hackernoon.com/">Hackernoon</a> fez um <a href="https://hackernoon.com/how-git-changed-the-history-of-software-version-control-5f2c0a0850df">artigo</a> bem bacana sobre o assunto!</p><p>Mas… Como diria o próprio Linus Torvalds:</p><blockquote>Talk is cheap. Show me the code.</blockquote><h3><strong>Instalando o Git</strong></h3><p>Antes de mais nada, precisamos instalar o Git! Em uma distro Debian-like (Ubuntu, Linux Mint, Xubuntu…), execute:</p><pre>$ sudo apt-get install git</pre><p>Após a instalação, vamos verificar a versão instalada:</p><pre>$ git --version</pre><p>A saída deverá ser algo como <strong><em>git version 2.xx.y. </em></strong>Tudo certo até aí!</p><h3>Definindo suas configurações globais</h3><p>Agora iremos definir as configurações globais de <strong>nome</strong> e <strong>email</strong> do Git. Elas não serão usadas para fins de autenticação, e sim para melhor controle das alterações realizadas nos arquivos:</p><pre>$ git config --global user.name &quot;Seu Nome&quot;<br>$ git config --global user.email &quot;seu@email.com&quot;</pre><p>Para confirmar que as configurações foram registradas, execute:</p><pre>$ git config --list</pre><p>A saída deverá conter as informações recém cadastradas.</p><p><strong>Extra: </strong>As configurações globais do Git ficam armazenadas em<strong> ~/.gitconfig</strong>. Caso queira visualizá-las, execute:</p><pre>$ cat ~/.gitconfig</pre><p>A saída será algo como:</p><pre>[user]<br> name = Seu Nome<br> email = seu@email.com</pre><h3>Criando um repositório</h3><p>Podemos criar um repositório de duas maneiras: pelo <em>site</em> do <em>Github </em>e localmente, pelo Git<em>. </em>Criaremos um pelo Git<em>.</em></p><ol><li>Crie um diretório para armazenar o nosso projeto <strong>hellogit</strong>:</li></ol><pre>$ mkdir hellogit</pre><p>2. Uma vez criado o diretório, vamos inicializá-lo com o comando <strong><em>git init:</em></strong></p><pre>$ cd hellogit<br>$ git init</pre><p>A saída será algo como:</p><pre>Initialized empty Git repository in /home/user/hellogit/.git/</pre><p>Observe que um diretório oculto (por isso o . no nome) chamado git foi criado, ele será o responsável pelo gerenciamento do repositório.</p><h3>Definindo suas configurações locais</h3><p>Em determinados casos você precisará definir configurações locais diferentes das suas globais (email de outro domínio, por exemplo). Para esses casos, temos a opção de configurar parâmetros somente para o repositório em questão:</p><ol><li>Vá até o diretório desejado</li></ol><pre>$ cd hellogit</pre><p>2. Execute o comando de configuração sem a flag <strong><em>— global</em></strong>:</p><pre>$ git config user.email &quot;outro@email.com&quot;</pre><p><strong>Extra: </strong>As configurações locais de um repositório ficam armazenadas em <strong>.git/config</strong>. Caso queira visualizá-las, execute:</p><pre>$ cat .git/config</pre><p>A saída será algo como:</p><pre>[user]<br> email = outro@email.com</pre><h3>Adicionando arquivos ao repositório</h3><p>Agora que já configuramos nossas informações e criamos um repositório, vamos de fato começar a usá-lo!</p><h4>Antes de mais nada…</h4><p>O comando <strong><em>git status </em></strong>nos mostrará o atual estado do nosso repositório:</p><pre>$ git status</pre><p>Saída:</p><pre>On branch master</pre><pre>No commits yet</pre><pre>nothing to commit (create/copy files and use &quot;git add&quot; to track)</pre><p>Pela saída podemos observar que estamos na <strong><em>branch</em></strong> <strong><em>master </em></strong><em>e n</em>enhum <strong><em>commit </em></strong>foi realizado (não se preocupe com <strong><em>branches</em></strong> agora/já falaremos sobre <strong><em>commits</em></strong><em>)</em></p><h4><strong>Criando um arquivo</strong></h4><p>Vamos criar o arquivo <strong><em>README.md</em></strong><em>, que tradicionalmente armazena informações sobre o projeto do respositório (tecnologias usadas, como executar e etc):</em></p><pre>$ touch README.md</pre><p>Execute o comando <strong><em>git status</em></strong> novamente, agora seremos informados que existe um arquivo não rastreado pelo Git:</p><pre>On branch master</pre><pre>No commits yet</pre><pre>Untracked files:<br>  (use &quot;git add &lt;file&gt;...&quot; to include in what will be committed)</pre><pre>README.md</pre><pre>nothing added to commit but untracked files present (use &quot;git add&quot; to track)</pre><h4>Adicionando o arquivo ao Git</h4><p>Para que o Git passe a rastrear as alterações no arquivo <strong><em>README.md</em></strong>, execute:</p><pre>$ git add README.md</pre><p>Execute o comando <strong><em>git status</em></strong> novamente e verifique que o arquivo agora está sendo rastreado pelo Git:</p><pre>On branch master</pre><pre>No commits yet</pre><pre>Changes to be committed:<br>  (use &quot;git rm --cached &lt;file&gt;...&quot; to unstage)</pre><pre>new file:   README.md</pre><p><strong>EXTRA: </strong>Você pode verificar o arquivo onde o Git armazena os arquivos rastreados executando:</p><pre>$ cat .git/index</pre><p>Essa área onde o Git armazena os arquivos rastreados é popularmente chamada de <strong><em>staging</em></strong> ou <strong><em>staging area</em></strong><em>.</em></p><h4>Mas o que é staging area?</h4><p>Quando falamos de <strong><em>staging area</em></strong>, estamos falando da área que armazena o que será rastreado pelo Git no próximo <strong><em>commit</em></strong><em>.</em></p><h3>Seu primeiro commit</h3><p>Uma vez em staging, podemos agora realizar um <strong><em>commit </em></strong>das alterações rastreadas.</p><h4>Mas o que é um commit?</h4><p>É o comando que salva as informações em <strong><em>staging </em></strong>no seu repositório local.</p><p>Vamos recapitular os passos até aqui:</p><ol><li><strong><em>git status</em></strong> nos mostra o status do(s) arquivo(s) (pendentes de rastreamento ou rastreados)</li><li><strong><em>git add </em></strong>adiciona o(s) arquivo(s) não rastreados à area rastreada (<strong><em>staging</em></strong>)</li></ol><p>Faremos agora nosso primeiro <strong><em>commit</em></strong>! Execute o comando:</p><pre>$ git commit</pre><p>Observe que um arquivo será aberto para que você insira uma mensagem no <strong><em>commit. </em></strong>Sem ela a ação não será concluída!</p><p>Insira a mensagem<strong><em> Initial commit </em></strong>e salve do arquivo:</p><pre>GNU nano 2.9.3      /home/dev/hellogit/.git/COMMIT_EDITMSG<br><strong>Initial commit</strong></pre><pre># Please enter the commit message for your changes. Lines starting<br># with &#39;#&#39; will be ignored, and an empty message aborts the commit.<br>#<br># On branch master<br>#<br># Initial commit<br>#<br># Changes to be committed:<br>#       new file:   README.md<br>#</pre><p>Pronto! Você acaba de fazer seu primeiro <strong><em>commit</em></strong>!</p><p>Para visualizar o registro dele, execute:</p><pre>$ git log</pre><p>A saída será algo como:</p><pre>commit 49324be62acc671d15c5f362b550535b463500b9 (HEAD -&gt; master)<br>Author: User &lt;user@<a href="/service/mailto:rafaeldt.br@gmail.com">mail.com</a>&gt;<br>Date:   Fri Jun 21 19:11:33 2019 -0300</pre><p>Existe também uma maneira de abreviar o processo: inserindo a flag <strong><em>-m </em></strong>e a mensagem já no <strong><em>commit</em></strong>! Nosso exemplo anterior ficaria assim:</p><pre>$ git commit -m &quot;Initial commit&quot;</pre><h3>Seu primeiro push</h3><p>Agora que já fizemos o <strong><em>commit</em></strong>, podemos enviar o seu conteúdo ao nosso serviço de hospedagem de repositórios.</p><h3>Github, Gitlab e Bitbucket: O que são?</h3><p>São serviços de hospedagem de repositórios na nuvem e pelo nome dos dois primeiros, você já deve imaginar que eles fazem isso usando o Git (ou Mercurial, mas isso não vem ao caso agora). Simplificando: são gerenciadores de repositórios Git com interfaces gráficas <em>web </em>e serviços adicionais relacionados a gerenciamento de repositórios e equipes<em>.</em></p><p>No nosso exemplo, usaremos o <a href="https://github.com/"><strong><em>Github</em></strong></a>.</p><h4>Criando uma conta no Github</h4><p>O processo é bem simples: faça seu cadastro em <a href="https://github.com/join">https://github.com/join</a>, optando pelo plano <strong><em>free </em></strong>(que é mais que suficiente para o nosso exemplo).</p><h4>Criando seu primeiro repositório no Github</h4><p>Na página inicialda sua conta recém-criada, na aba <strong><em>repositories, </em></strong>clique em <strong><em>New</em></strong><em>:</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*wVgIk7rwaNbk_h8-SYZguQ.png" /><figcaption>Figura 2— Botão “New” da aba “repositories” do Github</figcaption></figure><p>Crie o repositório <strong><em>hellogit:</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*L7tm-ht565Y8ymUXwLZCUA.png" /><figcaption>Figura 3 — Criação o repositório “hellogit”</figcaption></figure><p>Pronto! Agora que você já tem uma conta e um repositório no <a href="https://github.com/"><strong><em>Github</em></strong></a>, chegou a hora de relacionarmos eles ao nosso repositório local!</p><h4>Configurando o remote</h4><p>Agora iremos “mapear” o nosso repositório no Github ao nosso repositório local, em outras palavras, configuraremos o <strong><em>remote</em></strong> do nosso repositório!</p><h4>Mas o que é remote?</h4><p>Chamamos de <strong><em>remote</em></strong><em> o nosso repositório “correspondente” </em>criado no serviço de hospedagem de repositórios. Em outras palavras, faremos com que o nosso <strong><em>hellogit</em></strong> local “aponte” para o <strong><em>hellogit</em></strong> que criamos no<strong><em> </em></strong><a href="https://github.com/"><strong><em>Github</em></strong></a><em>.</em></p><p>Se tudo deu certo, o repositório que você criou estará em:</p><pre><a href="https://github.com/rafaeltardivo/hellogit">https://github.com/<strong>seuusario</strong>/hellogit</a></pre><p>acesse ele e observe o seguinte componente no canto superior direito:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*banPyKmbQQU_0C4L5hmgWA.png" /><figcaption>Figura 4 — Botão “Clone or Download” do Github</figcaption></figure><p>Clique nele e você verá duas opções:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/438/1*KgtuNd6dib-2J0U04k1Uhg.png" /><figcaption>Figura 4— Diálogo do botão “Clone or Download” do Github</figcaption></figure><p>Escolha a opção <strong><em>Use HTTPS</em></strong>. Observe que a url foi alterada e agora utiliza o protocolo HTTPS:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/430/1*W22vJ7FbWMQuAHdd6sPAYA.png" /><figcaption>Figura 5 — Diálogo do link “Use HTTPS” do Github</figcaption></figure><p>Não entraremos no mérito das diferenças entre SSH e HTTPS agora, mas saiba que são protocolos seguros de comunicação entre redes.</p><p>Copie a url exibida, ela deve se parecer com:</p><pre><a href="https://github.com/rafaeltardivo/hellogit.git">https://github.com/<strong>seuusuario</strong>/hellogit.git</a></pre><p>Pois bem, de volta ao terminal! Execute o comando:</p><pre>$ git remote -v</pre><p>Como ainda não configuramos nosso remote, você não receberá nenhuma saída. Para configurar o <strong><em>remote</em></strong>, execute:</p><pre>$ git remote add origin <a href="https://github.com/rafaeltardivo/hellogit.git">https://github.com/<strong>seuusuario</strong>/hellogit.git</a></pre><p>Para termos certeza de que tudo deu certo, execute novamente:</p><pre>$ git remote -v</pre><p>A saída agora deverá ser:</p><pre>origin <a href="https://github.com/rafaeltardivo/hellogit.git">https://github.com/<strong>seuusuario</strong>/hellogit.git</a> (fetch)<br>origin <a href="https://github.com/rafaeltardivo/hellogit.git">https://github.com/<strong>seuusuario</strong>/hellogit.git</a> (push)</pre><p><strong>Observação:</strong> <strong><em>origin </em></strong>é só o nome padrão do nosso<strong><em> remote.</em></strong></p><p>Pronto! Já mapeamos o repositório, agora vamos enviar nosso código para lá!</p><h4>Push</h4><p>Agora executaremos o comando final do nosso processo! o comando <strong><em>push</em></strong> é o responsável por de fato enviar nossas alterações ao <strong><em>remote</em></strong><em>.</em></p><p>No terminal, execute:</p><pre>$ git push origin master</pre><p><strong>Observação:<em> master</em> </strong>é a <strong><em>branch</em> </strong>em que estamos, mas branches serão o assunto do próximo post ;)</p><p>Como estamos usando HTTPS, você precisará autenticar seu usuário no terminal. Se tudo deu certo, você receberá no terminal uma saída parecida com essa:</p><pre>Counting objects: 3, done.<br>Writing objects: 100% (3/3), 276 bytes | 276.00 KiB/s, done.<br>Total 3 (delta 0), reused 0 (delta 0)<br>To <a href="https://github.com/seuusuario/hellogit.git">github.<strong>com:seuusuario</strong>/hellogit.git</a><br>   49324be..9dd0152  master -&gt; master</pre><p>Agora vamos até o Github verificar se o arquivo está lá:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/1*4nq-G_2ghLLURr0df3jwlA.png" /><figcaption>Figura 6— Exibição do primeiro push</figcaption></figure><p>Voilá! versionamos nosso arquivo o/</p><h3>Um jeito mais fácil de começar um repositório</h3><p>Agora que já entendemos o fluxo do Git, podemos explorar um jeito mais fácil de começar um repositório!</p><p>Para isso, vamos criar mais um repositório. Na aba <strong><em>repositories</em></strong>, clique em<strong><em> New</em></strong><em>:</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*wVgIk7rwaNbk_h8-SYZguQ.png" /><figcaption>Figura 7— Botão “New” da aba “repositories” do Github</figcaption></figure><p>Crie o repositório <strong><em>helloagaingit</em></strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/737/1*rHkQDrGjckyudx2PllRK-Q.png" /><figcaption>Figura 8— Criação do repositório “helloagaingit”</figcaption></figure><p>Pois bem, faremos agora o caminho inverso! Mapearemos o repositório criado no <a href="https://github.com/"><strong><em>Github</em></strong></a> em nosso repositório local!</p><p>Copie a url do repositório <strong><em>helloagaingit:</em></strong></p><pre><a href="https://github.com/rafaeltardivo/hellogit.git">https://github.com/<strong>seuusuario</strong>/helloagaingit.git</a></pre><p>Agora vá até o seu diretório de preferência (~ é uma boa opção!) e execute o comando:</p><pre>git clone <a href="https://github.com/rafaeltardivo/hellogit.git">https://github.com/<strong>seuusuario</strong>/helloagaingit.git</a></pre><p><strong>Observação: </strong>O comando <strong><em>git clone</em></strong> copia (ou clona) um repositório existente para sua máquina.</p><p>Após a execução do <strong><em>git clone</em></strong>, execute:</p><pre>$ ls -la</pre><p>Observe que o o respositório oculto <strong><em>.git </em></strong>estará lá! O <a href="https://github.com/"><strong><em>Github</em></strong></a> inicializou o repositório para você. Além disso, não será preciso configurar o <strong><em>remote.</em></strong></p><p>E é só isso! Observe que <strong><em>git add</em></strong>, <strong><em>git commit</em></strong> e <strong><em>git push</em></strong> funcionarão normalmente:</p><pre>$ touch README.md<br>$ git add README.md<br>$ git commit -m &quot;Initial commit&quot;<br>$ git push origin master</pre><p>Ufa! Terminamos! Você está livre para deletar os repositórios do seu <a href="https://github.com/"><strong><em>Github</em></strong></a>.</p><h3>Recapitulando…</h3><p><strong><em>git config — global: </em></strong>configura atributos globais.<br><strong><em>git config:</em></strong> configura atributos locais.<br><strong><em>git status:</em></strong> exibe o status atual do repositório.<br><strong><em>git add: </em></strong>faz com que os arquivos sejam rastreados pelo Git.<br><strong><em>git commit</em>:</strong> salva as alterações no seu repositório local e as elenca para o próximo <strong><em>push.<br>git push: </em></strong>envia as alterações para o seu <strong><em>remote.<br>remote: </em></strong>repositório remoto que corresponde ao seu local.<br><strong><em>git remote -v: </em></strong>configura o <strong><em>remote.<br>git clone: </em></strong>clona um repositório existente para a sua máquina.</p><p>Então é isso aí! Espero que tenham gostado!<br>No próximo entenderemos como as <strong><em>branches</em></strong> funcionam :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fed91ee56b8d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/git-github-uma-introdu%C3%A7%C3%A3o-pr%C3%A1tica-fed91ee56b8d">Git + Github: uma introdução prática</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desbravando o Go: Estruturas de repetição (parte 4)]]></title>
            <link>https://medium.com/rafaeltardivo/desbravando-o-go-estruturas-de-repeti%C3%A7%C3%A3o-parte-4-b0023f468b16?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0023f468b16</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[golang-tutorial]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Thu, 14 Feb 2019 12:37:26 GMT</pubDate>
            <atom:updated>2019-02-14T12:37:26.904Z</atom:updated>
            <content:encoded><![CDATA[<p>Ou melhor, estrutura (singular) de repetição!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-XTuMCfBnUTBVZ7U80x6cw.png" /></figure><p>Em Go, nós só temos uma estrutura de repetição: o<strong><em> for</em></strong>! Mas não se preocupe, o <strong><em>for</em></strong> é flexível o suficiente para ser usado em qualquer situação que antes pedia um <strong><em>while </em></strong>ou muito raramente um <strong><em>do-while</em></strong>.</p><p>Sem mais delongas, vamos ver como ele funciona:</p><h4>For tradicional</h4><pre>for initialization; condition; post {<br>    // zero or more statements <br>}</pre><p>O for tradicional que conta com <strong>inicialização</strong>, <strong>condição</strong> e <strong>execução pós-iteração:</strong></p><pre>for i:=0; i &lt; 10; i++{<br>    fmt.Println(i)<br>}</pre><p>No entanto, as etapas de <strong>inicialização</strong> e <strong>execução pós-iteração</strong> podem ser omitidas! E isso nos leva ao próximo exemplo.</p><h4>While</h4><pre>for condition {<br>    // ... <br>}</pre><p>Observe que só existe uma condição (comportamento do laço <strong><em>while</em></strong> em outras linguagens):</p><pre>for len(name) &lt; 5 {<br>    fmt.Println(&quot;Insira seu nome (min 5 chars): &quot;)<br>    name, _ = reader.ReadString(&#39;\n&#39;)<br>}</pre><p>Ou seja, <strong>enquanto</strong> o tamanho do nome for menor que 5 caracteres, o laço continuará (sem necessidade de inicialização ou execução pós-iteração).</p><h4><strong>While (infinito)</strong></h4><pre>for {<br>    // ...<br>}</pre><p>Sem condição ou inicialização, o laço acima só seria parado por um<strong><em> break</em></strong>, por exemplo.</p><h4><strong>Foreach</strong></h4><pre>vogals := []string{&quot;A&quot;, &quot;E&quot;, &quot;I&quot;, &quot;O&quot;, &quot;U&quot;}</pre><pre>for index, value := range vogals {<br>    fmt.Printf(&quot;%d - %v\n&quot;, index, value)<br>}</pre><p>IMHO, o mais bonito de todos! Iterar de maneira intuitiva em coleções facilita (e muito) nossa vida! Observe que iteramos sobre <strong>índice</strong> e <strong>valor</strong> do range vogals:</p><pre>for index, value := range vogals</pre><p>Mas também seria possível aproveitar só o <strong>valor</strong>:</p><pre>for _ , value := range vogals</pre><p>Ou mesmo só o <strong>índice</strong>:</p><pre>for index := range vogals</pre><h4><strong>Do While</strong></h4><p>Por último, o menos frequente <strong><em>do while</em></strong>, muitas vezes nem incluso em liguagens modernas é possível de ser simulado da seguinte maneira:</p><pre><strong>for</strong> ok := true; ok; ok = condition {<br>    // ...<br>}</pre><p>Por hoje é só ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0023f468b16" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/desbravando-o-go-estruturas-de-repeti%C3%A7%C3%A3o-parte-4-b0023f468b16">Desbravando o Go: Estruturas de repetição (parte 4)</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desbravando o Go: Funções (parte 3)]]></title>
            <link>https://medium.com/rafaeltardivo/desbravando-o-go-fun%C3%A7%C3%B5es-parte-3-b3a5cbad1e72?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3a5cbad1e72</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Sat, 02 Feb 2019 20:38:42 GMT</pubDate>
            <atom:updated>2019-02-03T20:18:24.073Z</atom:updated>
            <content:encoded><![CDATA[<p>Como funcionam as funções em Go.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ThZpQq9AvX21LXq5.jpg" /></figure><p>Já falamos sobre <a href="https://medium.com/rafaeltardivo/fun%C3%A7%C3%B5es-em-python-n-maneiras-diferentes-de-declarar-e-chamar-280d60f407fa">funções em Python</a> e hoje falaremos sobre funções em Go!</p><h3><strong>Keyword func e chaves</strong></h3><p>Vamos novamente analisar o “Hello, World!” do primeiro post da série:</p><pre>func main() {<br>    fmt.Printf(&quot;Hello, World!\n&quot;)<br>}</pre><p>observe que se trata de uma função. Em Go, funções são caracterizadas pela <em>keyword</em> <strong><em>func</em>. </strong>Chaves também são obrigatórias! (saudades, Python!).</p><p>Até aí tudo bem, certo? <strong><em>main</em></strong> não tem nenhuma parâmetro e também não retorna nada.</p><h3>Funções com retorno de valores</h3><p>Mas e se precisássemos retornar valores? Como ficaria?</p><p>Vamos usar como exemplo uma função que nos retorna uma <strong><em>string</em></strong> contendo o nosso bom e velho “Hello, World!”, chamaremos ela de <strong><em>sayHello</em></strong>:</p><pre>func sayHello() string{<br>    return &quot;Hello, World!&quot;<br>}</pre><p>Observe que agora foi necessário incluir <strong><em>string </em></strong>logo após os parênteses, na assinatura da função. A declaração em questão também é obrigatória, pois <strong>é ela quem determina o tipo do retorno da função</strong>.</p><h4>Retornando múltiplos valores</h4><p>Em Go também é possível retornar múltiplos valores! Basta declarar também o segundo tipo de retorno:</p><pre>func multipleValues() string, int{<br>    return &quot;Foo&quot;, 42<br>}</pre><h3>Funções com parâmetros</h3><p>Parâmetros em Go são declarados da mesma maneira que em outras linguagens: dentro dos parênteses que sucedem o nome da função (juntamente com o seu respectivo tipo):</p><pre>func sumTwoNumbers(numOne int, numTwo int) int{<br>    return numOne + numTwo<br>}</pre><h3>Passagem de argumentos: valor ou referência?</h3><p>Em Go, assim como em C, temos ponteiros! Isso quer dizer que existe passagem por referência? <strong>NÃO</strong>.</p><p>Todas as passagens em Go são por valor! O que acontece é que quando passamos um “ponteiro”, passamos a cópia do valor do endereço de um objeto, enquanto quando passamos um “valor”, passamos uma cópia do valor daquele endereço. Vamos ver na prática</p><h4>Cópia do valor</h4><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>type pet struct {<br>    name <em>string<br></em>}</pre><pre>func changeName(p pet) {<br>    p.name = &quot;Nina&quot;<br>    fmt.Println(&quot;During the call&quot;, p.name)<br>}</pre><pre>func main() {<br>    pluto := pet{name: &quot;Pluto&quot;}<br>    fmt.Println(&quot;Before the call&quot;, pluto.name)<br>    changeName(pluto)<br>    fmt.Println(&quot;After the call&quot;, pluto.name)<br>}</pre><p>A saída do trecho acima será:</p><pre>Before the call Pluto<br>During the call Nina<br>After the call Pluto</pre><p>Isso porque passamos uma cópia da <strong><em>struct pet</em></strong>! A alteração durante a função só afeta a <strong><em>struct</em></strong> cópia.</p><h4>Cópia do endereço (ponteiro)</h4><p>Já se passarmos a <strong><em>struct</em></strong> como ponteiro, a cópia do endereço fará com que ela seja alterada fora do escopo da função, causando o efeito de <em>“passagem por referência”</em>:</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>type pet struct {<br>    name <em>string<br></em>}</pre><pre>func changeName(p *pet) {<br>    p.name = &quot;Nina&quot;<br>    fmt.Println(&quot;During the call&quot;, p.name)<br>}</pre><pre>func main() {<br>    pluto := pet{name: &quot;Pluto&quot;}<br>    fmt.Println(&quot;Before the call&quot;, pluto.name)<br>    changeName(&amp;pluto)<br>    fmt.Println(&quot;After the call&quot;, pluto.name)<br>}</pre><p>Observe que dessa vez a saída será algo como:</p><pre>Before the call Pluto<br>During the call Nina<br>After the call Nina</pre><p>Então é isso aí! Atenção aos detalhes e particularidades da linguagem!</p><p>Cya ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3a5cbad1e72" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/desbravando-o-go-fun%C3%A7%C3%B5es-parte-3-b3a5cbad1e72">Desbravando o Go: Funções (parte 3)</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desbravando o Go: Packages (Parte 2)]]></title>
            <link>https://medium.com/rafaeltardivo/desbravando-o-go-packages-parte-2-342daeb5a57b?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/342daeb5a57b</guid>
            <category><![CDATA[go]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[golang-tutorial]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Sat, 26 Jan 2019 20:12:26 GMT</pubDate>
            <atom:updated>2019-01-26T20:12:26.980Z</atom:updated>
            <content:encoded><![CDATA[<p>Entendendo o funcionamento dos pacotes em Go</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*vK3yzHbmtys9w5RBLTieeg.png" /></figure><p>Conforme dito no <a href="https://medium.com/rafaeltardivo/desbravando-o-go-setup-e-hello-world-parte-1-89b3c4e4eb8c">primeiro post</a>, um pacote (ou <strong><em>package</em></strong>) é basicamente uma unidade composta por arquivos fonte que juntos servem a um propósito comum. Até aí tudo bem, certo? Então vamos entender os tipos de <strong><em>packages</em></strong> existentes em Go.</p><h3>Packages executáveis</h3><p>Lembra do nosso Hello World? Vamos analisá-lo melhor:</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>func main() {<br>	fmt.Printf(&quot;Hello, World!\n&quot;)<br>}</pre><p>Ele foi feito no <strong><em>package main</em></strong><em>, </em>e isso significa que ele é um pacote executável! Para compravar isso, basta ir até o diretório dele e executar:</p><pre>go build hello.go</pre><p>Observe que um executável chamado <strong><em>hello</em></strong> será gerado, já que a declaração <strong><em>package main</em></strong> e a função <strong><em>func main()</em></strong> indicam que o trecho de código em questão se trata de um ponto de entrada:</p><pre><br>├── hello<br>└── hello.go</pre><p>E é assim que criamos um <strong><em>package </em></strong>executável!</p><h3>Packages reusáveis</h3><p>Ainda no nosso Hello World, observe o seguinte trecho:</p><pre>import &quot;fmt&quot;</pre><p>Trata-se da importação de um pacote reusável, ou seja,<strong> uma lib!<em> fmt</em> </strong>é por si só um <strong><em>package</em></strong> sem ponto de entrada, ou seja, um <strong><em>package</em></strong> reusável, feito para ser importado e utilizado em outros <strong><em>packages. </em></strong>Você pode encontrar a documentação dele <a href="https://golang.org/pkg/fmt/">aqui</a>.</p><h3><strong><em>Packages customizados</em></strong></h3><p>Em determinadas situações você precisará criar packages customizados para sua aplicação. No nosso caso criaremos o package <strong><em>greet</em></strong><em>, que </em>disponibizará funções de “saudação” ao usuário.</p><p>Então vamos lá:</p><p>1 — Crie o diretório <strong><em>greet</em></strong> no seu <strong><em>$GOPATH/src/</em></strong>:</p><pre>cd $GOPATH/src<br>mkdir greet</pre><p>2 — Dentro do diretório <strong><em>greet</em></strong>, crie o arquivo fonte <strong><em>informal.go</em></strong><em>:</em></p><pre>cd greet<br>touch informal.go</pre><p>O arquivo informal.go conterá as saudações “informais”.</p><p>3 — No arquivo informal.go, adicione a função <strong><em>HiThere</em></strong>:</p><pre>package greet</pre><pre>import &quot;fmt&quot;</pre><pre>// HiThere says hi<br>func HiThere(name string) {<br>    fmt.Printf(&quot;Hi There, %s!\n&quot;, name)<br>}</pre><p>4 — No diretório superior, construa o <strong><em>package greet</em></strong>:</p><pre>go build greet</pre><p>Pronto! Fizemos um <strong><em>package</em></strong>, agora vamos usá-lo!</p><h3>Utilizando packages</h3><p>Agora vamos utilizar nosso novo <strong><em>package</em></strong> arquivo <strong><em>hello.go</em></strong> feito no <a href="https://medium.com/rafaeltardivo/desbravando-o-go-setup-e-hello-world-parte-1-89b3c4e4eb8c">post anterior</a>:</p><p>1 — Altere o arquivo <strong><em>hello.go</em></strong> para usar o <strong><em>package greet</em></strong>:</p><pre>package main</pre><pre>import &quot;greet&quot;</pre><pre>func main() {<br>    greet.HiThere(&quot;Nina&quot;)<br>}</pre><p>2 — Execute o <strong><em>hello.go</em></strong>:</p><pre>go run hello.go</pre><p>A saída deverá ser algo como:</p><pre>Hi There, Nina!</pre><h3>Observações importantes</h3><p>1 — Um arquivo fonte pertencente a um <strong><em>package</em></strong> obrigatoriamente deve começar com a declaração <strong><em>package x</em></strong>, onde <strong><em>x</em></strong> representa o nome do <strong><em>package </em></strong>que o contém. Observe a primeira linha do arquivo <strong><em>informal.go</em></strong>:</p><pre>package greet</pre><p>2 — Atributos e funções devem começar com letra maiúscula para que sejam exportados (usados fora do <strong><em>package</em></strong>). Observe a função <strong><em>HiThere</em></strong> do arquivo <strong><em>informal.go</em></strong><em>:</em></p><pre>// HiThere says hi<br>func HiThere(name string) {<br>    fmt.Printf(&quot;Hi There, %s!\n&quot;, name)<br>}</pre><p>3 — Atributos e funções exportad(os)(as) obrigatoriamente devem ser comentados. Além disso, o comentário deve começar com o nome do objeto em questão. Observe o comentário da função <strong><em>HiThere</em></strong><em>:</em></p><pre>// HiThere says hi<br>func HiThere(name string) {<br>    fmt.Printf(&quot;Hi There, %s!\n&quot;, name)<br>}</pre><p>4 — Todos os atributos e funções declarados em um arquivo serão automaticamente disponibilizados aos outros arquivos do mesmo <strong><em>package</em></strong>, sem necessidade de importação;</p><p>5 — Também é possível construir packages dentro de packages (para separar melhor as responsabilidades).</p><h3>Mas por que construir packages?</h3><p>Reusabilidade e legibilidade,<em> my friend</em>. Com alta coesão e baixo acoplamento, um pacote poderá ser usado em qualquer outro software!</p><p>Enough said ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=342daeb5a57b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/desbravando-o-go-packages-parte-2-342daeb5a57b">Desbravando o Go: Packages (Parte 2)</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desbravando o Go: Setup e Hello World (parte 1)]]></title>
            <link>https://medium.com/rafaeltardivo/desbravando-o-go-setup-e-hello-world-parte-1-89b3c4e4eb8c?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/89b3c4e4eb8c</guid>
            <category><![CDATA[go]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Tue, 15 Jan 2019 02:30:32 GMT</pubDate>
            <atom:updated>2019-01-15T02:53:09.922Z</atom:updated>
            <content:encoded><![CDATA[<p>Escreva seu primeiro programa em Go!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EQNU31YO936cUO8I.jpg" /></figure><p>Ser constantemente desafiado profissionalmente é um privilégio! Meu mais novo desafio é aprender Go e por isso decidi compartilhar aqui as etapas do meu processo de aprendizado!</p><h4>First of all…</h4><p>Se quiser saber mais sobre o projeto da linguagem, recomendo <a href="https://golang.org/doc/faq#What_is_the_purpose_of_the_project">este link</a>, nosso propósito é colocar a mão na massa!</p><h3>Instalação (Linux, MacOS e FreeBSD)</h3><p>1 — Faça o download do tarball <a href="https://golang.org/doc/install?download=go1.11.4.linux-amd64.tar.gz">aqui</a></p><p>2 — Como <strong><em>superuser</em></strong>, descompacte o tarball no seu diretório /<strong><em>usr/local/</em></strong>:</p><pre>sudo tar -C /usr/local -xzf go1.11.4.linux-amd64.tar.gz</pre><p>3 — Adicione o seguinte trecho ao seu arquivo<strong> <em>~/.profile</em></strong>:</p><pre>export PATH=$PATH:/usr/local/go/bin</pre><p>Isso fará com que o diretório em que o Go foi instalado seja adicionado a sua variável de ambiente <strong><em>$PATH.</em></strong></p><p>4 — Recarregue seu arquivo <strong><em>~/.profile</em></strong>:</p><pre>source ~/.profile</pre><h3>Criando seu workspace</h3><p>Sem entrar no mérito da necessidade de múltiplos <strong><em>workspaces</em></strong>, criaremos um <strong><em>workspace</em></strong> padrão para a nossa instalação. Para isso, será necessário definir um valor para a variável de ambiente <strong>$GOPATH</strong>.</p><p>1 — No diretótio home <strong><em>(~)</em></strong>, crie o diretório<strong><em> go</em></strong><em>:</em></p><pre>cd ~<br>mkdir go</pre><p>2 — No fim do arquivo <strong><em>~/.bashrc</em></strong>, adicione:</p><pre>export GOPATH=$HOME/go</pre><p>3 — Recarregue o arquivo <strong><em>~/.bashrc</em></strong>:</p><pre>source .bashrc</pre><h4>Mas o que são workspaces?</h4><p>Um <strong><em>workspace</em></strong> nada mais é do que um diretório que abriga os outros dois diretórios: <strong><em>src</em></strong> e <strong><em>bin</em></strong>. Como você já deve ter inferido, o <strong><em>src</em></strong> irá conter os fontes e o <strong><em>bin </em></strong>os executáveis. Se quiser saber mais sobre eles, <a href="https://golang.org/doc/code.html#Workspaces">clique aqui</a>.</p><h3>Hello, World!</h3><p>Seguindo a tradição de Brian Kernighan e Dennis Ritchie, faremos“ um “Hello, World!” em Go!</p><p>1 — No seu <strong><em>workspace </em>(~/go), </strong>crie o diretório <strong><em>src/hello</em></strong>:</p><pre>cd ~/go<br>mkdir -p src/hello</pre><p>A estrutura resultante deverá ser algo como:</p><pre>go<br>├── bin<br>└── src<br>    └── hello</pre><p>2 — No diretório <strong><em>~/go/src/hello/</em></strong>, crie o arquivo <strong><em>hello.go</em></strong>:</p><pre>touch hello.go</pre><p>Agora, dentro do diretório hello, você terá o arquivo <strong><em>hello.go:</em></strong></p><pre>go<br>├── bin<br>└── src<br>    └── hello<br>        └── hello.go</pre><p>3 — Usando seu editor preferido, insira o seguinte trecho do código no arquivo <strong><em>hello.go</em></strong>:</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>func main() {<br>	fmt.Printf(&quot;Hello, World!\n&quot;)<br>}</pre><p>4 — Ainda no diretório <strong><em>~/go/src/hello/</em></strong>, execute:</p><pre>go install</pre><p>5 — Observe que o binário <strong>hello</strong> será gerado no diretório <strong>~/go/bin</strong>:</p><pre>go<br>├── bin<br>│   └── hello<br>└── src<br>    └── hello<br>        └── hello.go</pre><p>6 — Va até o diretório <strong>~/go/bin</strong> e execute:</p><pre>./hello</pre><p>Se tudo der certo, a saída será algo como:</p><pre>Hello, World!</pre><p><strong>BOOM!</strong> Você fez seu primeiro programa em Go!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/0*1NohgKtU9gIe45fC.jpg" /></figure><h3>Entendendo o que foi feito</h3><p>Vamos agora entender linha por linha do nosso código</p><p>1 — Pacote:</p><pre>package main</pre><p>Um pacote é basicamente uma unidade composta por arquivos fonte que juntos servem a um propósito comum. Um bom exemplo seria o <strong><em>package math</em></strong>, que agrupa um conjunto funções matemáticas. No nosso caso, usamos o <strong><em>package main, </em></strong>é usado quando estamos desenvolvendo o “ponto de entrada” de uma aplicação. Em todos os outros casos, os package se tornam pacotes reusáveis, em outras palavras, <strong>bibliotecas</strong>!</p><p>2 — Importação</p><pre>import &quot;fmt&quot;</pre><p>O comando import serve para importar bibliotecas. No nosso caso fmt é usada para entrada e saída de dados formatados, algo similar aos já conhecidos <strong><em>printf</em></strong> e <strong><em>scanf</em></strong> do C.</p><p>3 — Função <strong><em>main</em></strong> e <strong><em>Printf</em></strong></p><pre>func main() {<br>    fmt.Printf(&quot;Hello, World!\n&quot;)<br>}</pre><p>Funções em Go são precedidas pela keyword <strong><em>func. </em></strong>No nosso caso, main() é o ponto de entrada de um executável Go. Dentro delas, utilizamos o <strong><em>Printf </em></strong>da biblioteca<strong><em> fmt </em></strong>(anteriormente importada).</p><p>Por hora é só isso! No próximo post veremos mais sobre ambiente, escopo, funções e tipos!</p><p><strong>OBS</strong>: Logo após concluir este post, encontrei um bem similar em inglês. Ele se encontra <a href="https://www.callicoder.com/golang-introduction-hello-world/">aqui</a>.</p><p>Cya ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=89b3c4e4eb8c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/desbravando-o-go-setup-e-hello-world-parte-1-89b3c4e4eb8c">Desbravando o Go: Setup e Hello World (parte 1)</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Linux: Criando atalhos para tarefas rotineiras]]></title>
            <link>https://medium.com/rafaeltardivo/linux-criando-bash-aliases-globais-para-comandos-rotineiros-f20f94822dde?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/f20f94822dde</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[bash]]></category>
            <category><![CDATA[linux-tutorial]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Sun, 16 Sep 2018 16:10:57 GMT</pubDate>
            <atom:updated>2018-09-16T16:21:01.048Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dHtPBNxHTcygUSaFHpDohA.png" /><figcaption>Linux map 2.0</figcaption></figure><p>Faça mais digitando menos!</p><p>Tirando a poeira do blog, hoje vamos ver como criar “apelidos” para comandos no bash do Linux. Então vamos lá!</p><h4><strong>Ubuntu</strong></h4><p>Para o exemplo de hoje, usarei a distro Ubuntu 18.04.</p><h4><strong>.bashrc</strong></h4><p>De maneira bem resumida, o arquivo <strong><em>.bashrc </em></strong>(ou <strong><em>.bash_profile</em></strong> em algumas distros) é o arquivo que carrega as configurações do bash para o usuário logado. Ele fica localizado no diretório home e é um arquivo oculto (por isso o . antes do início do nome). Para visualizá-lo, execute:</p><p>1 — Vá até o diretório <strong><em>/home/</em> </strong>do atual usuário:</p><pre>cd ~</pre><p>2 — Liste todos os arquivos (inclusive ocultos), e procure <em>(</em><strong><em>grep</em></strong><em>)</em> por <strong><em>.bashrc</em></strong>:</p><pre>ls -la | grep .bashrc</pre><p>O resultado será algo como:</p><pre>-rw-r--r--  1 rdt  rdt     4252 set 15 19:56 .bashrc</pre><p>Pois bem, encontramos o arquivo, agora em seu conteúdo, observe o seguinte trecho:</p><pre># Alias definitions.<br># You may want to put all your additions into a separate file like<br># ~/.bash_aliases, instead of adding them here directly.<br># See /usr/share/doc/bash-doc/examples in the bash-doc package.</pre><pre>if [ -f ~/.bash_aliases ]; then<br>    . ~/.bash_aliases<br>fi</pre><p>Conforme dito nas instruções, Embora seja possível adicionar atalhos diretamente ao <strong><em>.bashrc</em></strong><em>, o recomendável é adicioná-los ao </em><strong><em>.bash_aliases.</em></strong></p><h3>Criando um alias</h3><p>Vamos criar um alias para o “update”, que normalmente executamos antes de instalar algum pacote novo. No arquivo<strong><em> .bash_aliases</em></strong>, insira:</p><pre>alias update=&quot;sudo apt-get update&quot;</pre><p>Salve o arquivo e recarregue o seu <strong><em>.bash_rc:</em></strong></p><pre>source .bashrc</pre><p>E voilá! À partir de agora, você pode executar o comando update para atualizar seu sistema!</p><pre>rdt@one ~$ update<br>Hit:1 <a href="http://br.archive.ubuntu.com/ubuntu">http://br.archive.ubuntu.com/ubuntu</a> bionic InRelease<br>Ign:2 <a href="http://dl.google.com/linux/chrome/deb">http://dl.google.com/linux/chrome/deb</a> stable InRelease                   <br>Get:3 <a href="https://repo.skype.com/deb">https://repo.skype.com/deb</a> stable InRelease [4.487 B]                    <br>...<br>...<br>...</pre><h3>Listando os seus aliases</h3><p>Para listar seus aliases, digite:</p><pre>alias</pre><p>Observe que, além do seu novo alias, existem outros já definidos pelo sistema:</p><pre>alias l=&#39;ls -CF&#39;<br>alias la=&#39;ls -A&#39;<br>alias ll=&#39;ls -alF&#39;<br>alias ls=&#39;ls --color=auto&#39;<br>alias update=&#39;sudo apt-get update&#39;</pre><p>That’s all folks ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f20f94822dde" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/linux-criando-bash-aliases-globais-para-comandos-rotineiros-f20f94822dde">Linux: Criando atalhos para tarefas rotineiras</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python: Tipos de Sequência]]></title>
            <link>https://medium.com/rafaeltardivo/python-tipos-de-sequ%C3%AAncia-52061f8d5d61?source=rss-18a85bd49c3------2</link>
            <guid isPermaLink="false">https://medium.com/p/52061f8d5d61</guid>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Rafael Tardivo]]></dc:creator>
            <pubDate>Sat, 16 Jun 2018 17:40:20 GMT</pubDate>
            <atom:updated>2018-06-16T17:40:20.365Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*D49d0RRw8BkD3tuGhXnAjw.jpeg" /></figure><p>Entendendo melhor a estrutura por trás das sequências mais usadas da linguagem.</p><h3>Tipos de sequência</h3><p>Existem dois tipos de sequência em Python: simples e container. É natural que pela praticidade do Python (e pela abundância de poder de processamento e memóriam RAM que nos é acessível) pouca gente se preocupe com o uso adequado de cada uma delas, certo?<strong> NOT TODAY</strong>!</p><h4>Sequências simples</h4><ul><li>Armazenam itens de um só tipo de dado</li><li>Armazenam o valor de cada item em seu próprio espaço de memória</li></ul><p>uma string (ou<strong><em> str </em></strong>em Python) é um exemplo de sequência simples:</p><pre>color_model = &#39;RGB&#39;</pre><p>Neste caso, a porção de memória alocada para a variável <strong>color_model</strong>também armazena os valores <strong>R</strong>, <strong>G</strong> e <strong>B, </strong>que como podemos observar, são do mesmo tipo (<strong><em>str</em></strong>).</p><h4>Sequências container</h4><ul><li>Podem armazenar itens de diferentes tipos</li><li>Não armazenam o valor de seus itens em sí, mas sim suas referências</li></ul><p>uma lista (ou <strong><em>list</em></strong> em Python) é um exemplo de sequência container:</p><pre>some_list = [&#39;R&#39;, 43, 5.0]</pre><p>Observe que em uma mesma lista, estamos armazenando três tipos diferentes: <strong><em>str</em></strong>, <strong><em>int</em></strong> e <strong><em>float</em></strong>. Certo? <strong>ERRADO</strong>! Estamos na verdade armazenando a referência (ou ponteiro) de cada um dos itens. Vale lembrar que <strong>todos os tipos de dados do Python são objetos</strong>!</p><p><strong>OBS: </strong>uma lista assim não faria muito sentido, considere a mistura de tipos um mal necessário para o exemplo!</p><h3>Sequências mutáveis e imutáveis</h3><p>As sequências também podem ser classificadas entre mutáveis e imutáveis. Sendo basicamente (explicando de maneira muitíssimo sucinta), alteráveis ou não após sua criação.</p><h4>Sequências mutáveis</h4><ul><li><em>list, dict, set, byte array…</em> Todas elas podem ser mudadas após a criação!</li></ul><p>Podemos perfeitamente criar uma lista com três letras:</p><pre>&gt;&gt;&gt; letters = [&#39;A&#39;, &#39;B&#39;, &#39;C&#39;]<br>&gt;&gt;&gt; print(letters)<br>[&#39;A&#39;, &#39;B&#39;, &#39;C&#39;]</pre><p>E modificá-la depois:</p><pre>&gt;&gt;&gt; letters.append(&#39;D&#39;)<br>&gt;&gt;&gt; print(letters)<br>[&#39;A&#39;, &#39;B&#39;, &#39;C&#39;, &#39;D&#39;]</pre><h4>Sequências imutáveis</h4><ul><li><em>str, tuple, frozenset</em>… Servem a propósitos diferentes e não podem ser alteradas após a criação!</li></ul><blockquote>Que burro! Dá zero pra ele! Eu altero strings direto! — Clarice Lispector</blockquote><p>Pois é meu jovem, Não é bem assim… Sempre que você altera uma string, você está na verdade criando outra(s) string(s)!</p><p>Observe o id da string <strong><em>name</em></strong>:</p><pre>&gt;&gt;&gt; name = &#39;Paul&#39;<br>&gt;&gt;&gt; id(name)<br>1400263380<strong>47680</strong></pre><p>agora, ao concatenaremos o sobrenome, o id da string <strong><em>name </em></strong>mudará:</p><pre>&gt;&gt;&gt; name += &#39; Gilbert&#39;<br>&gt;&gt;&gt; id(name)<br>1400263380<strong>57712</strong></pre><p>Ou seja, você não alterou o mesmo objeto! Você criou outra String e atribuiu a referência dela à variável <strong><em>name</em></strong>! Além disso, uma terceira string é criada:</p><pre>&#39;Paul&#39; <strong># string origina</strong>l<br>&#39;Gilbert&#39; <strong># string que será concatenada a string original</strong><br>&#39;Paul Gilbert&#39; <strong># string resultante</strong></pre><p>Agora, imagine um caso onde você precise concatenar 50 strings, diferentes! Coitada da memória RAM!</p><p>Quer entender um pouco mais sobre mutabilidade/imutabilidade? Tem um material bem bacana aqui:<br> <a href="https://medium.com/@meghamohan/mutable-and-immutable-side-of-python-c2145cf72747">https://medium.com/@meghamohan/mutable-and-immutable-side-of-python-c2145cf72747</a></p><h3>Conclusão</h3><p>Estude caso a caso qual sequência usar! Não só por questão de performance, mas também de semântica!</p><p>Cya ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=52061f8d5d61" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rafaeltardivo/python-tipos-de-sequ%C3%AAncia-52061f8d5d61">Python: Tipos de Sequência</a> was originally published in <a href="https://medium.com/rafaeltardivo">rafaeltardivo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>