<?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 Charlotte on Medium]]></title>
        <description><![CDATA[Stories by Charlotte on Medium]]></description>
        <link>https://medium.com/@umaMaisTempo?source=rss-f55bc35eb4aa------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*NWeWCXKn-EGW6A2f8_s4PQ.jpeg</url>
            <title>Stories by Charlotte on Medium</title>
            <link>https://medium.com/@umaMaisTempo?source=rss-f55bc35eb4aa------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 06:44:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@umaMaisTempo/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[O que é recursão e Tail-Call Optimization (TCO) ?]]></title>
            <link>https://medium.com/trainingcenter/o-que-%C3%A9-recurs%C3%A3o-e-tail-call-optimization-tco-f1938188223c?source=rss-f55bc35eb4aa------2</link>
            <guid isPermaLink="false">https://medium.com/p/f1938188223c</guid>
            <category><![CDATA[engenharia-de-software]]></category>
            <category><![CDATA[português]]></category>
            <category><![CDATA[programação-funcional]]></category>
            <category><![CDATA[recursão]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <dc:creator><![CDATA[Charlotte]]></dc:creator>
            <pubDate>Wed, 28 Aug 2019 15:52:44 GMT</pubDate>
            <atom:updated>2019-09-13T00:58:30.061Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-nc-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h3>O que é recursão e Tail-Call Optimization (TCO) ?</h3><p>Ao começar a aprender sobre programação funcional, um dos primeiros conceitos que se precisa entender é o de recursão, uma vez que essa mecânica é usada para permitir um programa a trabalhar em cima de conjuntos de coisas (por exemplo listar todos funcionários de uma empresa), manter-se rodando indefinidamente (<em>loop</em>, usado para manter um programa rodado por tempo indefinido) e até produzir conteúdo indefinidamente (como produzir números primos <em>on-demand</em>).</p><p>Segundo o <a href="https://dicionario.priberam.org/recursividade">Priberam</a>, no contexto de informática, recursão pode ser definida como “Propriedade de função, programa ou afim que se <strong>pode invocar a si próprio</strong>”[1]. Isto é, em termos práticos, podemos exemplificar recursão como uma função chamando a si mesma. Veja:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/45900c48e8b2fda6c6ac4b53cbaada2d/href">https://medium.com/media/45900c48e8b2fda6c6ac4b53cbaada2d/href</a></iframe><p>Como pode se ver no codigo acima, a função <em>funcao_recursiva</em> chama a si própria; isso por si só é recursão; simples assim.</p><h3>Dando voltas com a recursão</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*YOFlZySO0AjQkZBtkzvtgw.png" /></figure><p>O objetivo da recursão é lidar com problemas de uma forma natural. Por exemplo, digamos que queremos enviar um email para cada conhecido da nossa lista de email, certo ? Programaticamente falando isso significaria <em>pegar uma lista de endereços e para cada um deles enviar um email</em>; veja o exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/55758c990b82da8504ad329031230e87/href">https://medium.com/media/55758c990b82da8504ad329031230e87/href</a></iframe><p>No exemplo acima, a função <em>enviar_email_para_varios_contatos</em> recebe uma lista de endereços, pega o primeiro (variável <em>email</em>) e separa do<em> resto</em>; então envia o email (usando a função <em>codigo_que_vai_enviar_o_email</em>), retornando <em>true </em>se esse for o último email da lista ou passando o <em>resto </em>de volta para a função.</p><p>Perfeito, espero que até aqui esteja suficientemente claro que recursão é basicamente você fazer com que uma função fique executando a si mesma como forma de passar por uma lista ou fazer algo similar.</p><h3>Recursão é ineficiente ?</h3><p>Uma das primeiras coisas que você deve ter ouvido sobre recursão, especialmente se você cursou ciência da computação, é que ela é ineficiente. Isso é uma meia-verdade, vou explicar o porquê:</p><p>Primeiro, vamos entender por que alegam que recursão é ineficiente; considere o código abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f68bebe37821cd4800626720b2d83a39/href">https://medium.com/media/f68bebe37821cd4800626720b2d83a39/href</a></iframe><p>Basicamente o que o código faz é <em>“considerando uma lista, pegue o primeiro elemento e some com o resto da lista (para cada elemento da lista); caso este seja o fim da lista, considere como zero”</em>. Assim, para a execução de soma([1, 2, 3, 4]) , esperamos o resultado 10 (que é a soma de todos os números da lista).</p><p>Tudo bem até aí, né ? Agora vamos fazer uma analogia com matemática. Considere:</p><pre>1 + x = ?</pre><p>Qual o resultado ? Não temos como saber porque x não é um número, por isso precisamos descobrir o que é x :</p><pre>1 + x = ?<br>x = 2 + y = ?</pre><p>Ok, agora sabemos que x é 2 + y. Mas o que é y ? Não sabemos, então temos que continuar expandindo até o fim:</p><pre>1 + x = ?<br>x = 2 + y<br>y = 3 + z<br>z = 4<br>Portanto<br>1 + x =<br>1 + (2 + y) =<br>1 + (2 + (3 + z)) =<br>1 + (2 + (3 + (4))) =<br>1 + (2 + (7)) =<br>1 + (9) =<br>10</pre><p>Se não ficou muito claro, vejamos como uma representação da stack em si:</p><pre>soma([1, 2, 3, 4])<br>-&gt; 1 + soma([2, 3, 4])<br>       -&gt; 2 + soma([3, 4])<br>              -&gt; 3 + soma([4])<br>                     -&gt; 4<br>              -&gt; 3 + 4<br>       -&gt; 2 + 7<br>-&gt; 1 + 9<br>// 10</pre><p>Viu quantos passos foram necessários para chegar ao resultado ? Considere que no contexto de programação, cada passo dessa operação é uma execução de função que consome memória etc, então estamos gastando muito por algo simples; se fizessemos direto 1 + 2 + 3 + 4teríamos o resultado sem todo esse trabalho, né ? É por isso que dizem que recursão é ineficiente.</p><p>No entanto, no mundo real, hoje em dia, isso não é mais verdade pois temos diversas otimizações de operações de recursão como a <em>tail-call optimization </em>(ou em português, <em>otimização de chamada de cauda</em>).</p><h3>Ok, mas o que é Tail-Call Optimization ?</h3><p>Então, considerando que computadores têm recursos (como memória e processamento) finitos e que queremos um programa rápido sem desperdiçar <em>desnecessariamente</em> esses recursos, cientistas bolaram um meio de se fazer recursão sem que se aumente exponencialmente a quantidade de recursos gastos para poder passar por uma lista de coisas.</p><p>Vamos falar sobre <em>stack</em>. Computadores precisam de memória para rodar programas, certo ? (se você jogou Minecraft ou qualquer outro jogo 3D indie no começo, tu vai se lembrar que eram super lentos e quebravam muito e sempre falavam que para consertar era só comprar mais memória, né ?) Então, essa memória é usada para armazenar o código compilado do seu programa e para armazenar as informações usadas numa execução de código. Talvez eu faça no futuro um artigo explicando isso em mais detalhes mas se quiser saber mais, leia sobre a <a href="https://pt.wikipedia.org/wiki/Arquitetura_de_von_Neumann">Arquitetura de von Neumann</a>.</p><p>Bem, imagine o seguinte código:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/36ebd98c957cdc20fc6ca53a6628e82c/href">https://medium.com/media/36ebd98c957cdc20fc6ca53a6628e82c/href</a></iframe><p>Então, se fossemos executar esse código, além de armazenar na memória o código compilado, precisaríamos armazenar na parte de execução que o código começou executando funcao0() , que existe a variável a com o valor 1 , que a funcao0() chamou a funcao1 passando 1 como argumento e que esse valor 1 foi colocado na variável input etc…</p><p>Então, a parte que armazena que funções estão sendo chamadas (eg: funcao0 -&gt; funcao1 -&gt; console.log e qual argumento é usado para elas é a <em>stack</em>, as variáveis e seus valores ficam em outra parte chamada <em>heap</em>. Não se preocupe, não é importante memorizar isso, só entender que cada chamada de função precisa ocupar memória.</p><p>Bem, considerando que precisamos armazenar cada função que chamamos, isso não significaria que numa recursão teríamos que armazenar nessa stack inúmeras vezes que a função foi chamada ? Sim… E aqui começa a parte interessante: sabendo que recursão é ineficiente basicamente por ter que armazenar informação de inúmeras chamadas a si mesmo, não teria como fazer a mesma coisa mas sem armazenar essas informações das chamadas de função ? Sim, isso é o tal do TCO.</p><p>Vamos então entender direitinho como essa otimização é feita:</p><p>Considere que loop está chamando a si própria, por que precisamos então adicionar na <em>stack</em> informação de cada chamada a si mesma se o fluxo será o mesmo ? Talvez pudéssemos, sabendo disso, só armazenar informação da chamada uma vez e a reutilizar mudando só qual parâmetro está sendo usado para isso.</p><p>Pois é, é isso que é a <em>tail-call optimization:</em> uma simples otimização do compilador que identifica que uma função está se chamando de forma recursiva e então usa algumas trapaças de computação para que não se armazene informação inútil na <em>stack</em>.</p><p>Como ela sabe que está chamando a si mesma ? Ela vê que a última operação chamada no corpo da função é a própria função; isto é:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c346f2152bd2d304a8802e8c9813a9f/href">https://medium.com/media/7c346f2152bd2d304a8802e8c9813a9f/href</a></iframe><p>Como você pode ver, funcao_nao_otimizada e funcao_nao_otimizada2 são basicamente a mesma coisa. Elas não podem ser otimizadas porque a gente precisa executar as chamadas até o fim para então somar o resultado de uma com a outra (vide o exemplo que usamos lá em cima). No entanto, funcao_otimizada é um tanto differente, ela tem uma variável a mais que guarda o valor contado até então e ela chama a si mesma até bater no 0; por isso o compilador consegue dizer com segurança que a função é recursiva e aplicar as modificações necessárias para que a <em>stack</em> não se expanda ao executá-la.</p><blockquote><strong>Segredo de Charlotte:</strong> Nas implementações de diversas linguagens, a otimização de tail-call é feita aplicando uma iteração (um loop de for). Isso mesmo, mutável, feio e eficiente.<br>Mas esse é um segredo só entre eu, você e o compilador, viu ? <em>🤫</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*FqUSf96rhnS-38hDNvKxZQ.png" /></figure><p>Muito curioso como programação é algo que evolui tão rápido que poucas décadas atrás era inviável programar com recursão e hoje ela é uma forma cada vez mais adotada.</p><p>Bem, por hoje é só isso, mas que tal no próximo artigo falarmos sobre como o compilador moderno tem o dever de ajudar o programador ? :)</p><p>Poste nos comentários suas dúvidas, impressões e até a história de como foi para você se envolver com as comunidades de programação!</p><h4>Créditos</h4><p>Desenho “Moinho” por <a href="https://www.streamlineicons.com/ux/free-illustrations.html">Webalys - Streamline Illustrations</a>.<br>Desenho “Quadrinho XKCD” por <a href="https://www.xkcd.com/1270/">XKCD — Functional</a></p><h4>Referências bibliográficas</h4><p>[1] Dicionário Priberam da Língua Portuguesa — <a href="https://dicionario.priberam.org/recursividade">https://dicionario.priberam.org/recursividade</a> [consultado em 18–04–2019].</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1938188223c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trainingcenter/o-que-%C3%A9-recurs%C3%A3o-e-tail-call-optimization-tco-f1938188223c">O que é recursão e Tail-Call Optimization (TCO) ?</a> was originally published in <a href="https://medium.com/trainingcenter">Training Center</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Closures, Funções Anônimas e Funções Nomeadas]]></title>
            <link>https://medium.com/trainingcenter/closures-fun%C3%A7%C3%B5es-an%C3%B4nimas-e-fun%C3%A7%C3%B5es-nomeadas-f840782a486c?source=rss-f55bc35eb4aa------2</link>
            <guid isPermaLink="false">https://medium.com/p/f840782a486c</guid>
            <category><![CDATA[português]]></category>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[javascript-tips]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Charlotte]]></dc:creator>
            <pubDate>Tue, 04 Sep 2018 15:23:05 GMT</pubDate>
            <atom:updated>2018-09-04T21:30:59.148Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-nc/4.0/</cc:license>
            <content:encoded><![CDATA[<p>Quando começamos a explorar recursos de programação funcional em uma linguagem (como JavaScript, por exemplo), ouvimos falar de <em>funções anônimas</em>, <em>closures</em> e outras coisas mas parece um salto gigante entender o que são. Este pequeno texto busca explicar o que são e porquê são usadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DRcQbAsE92URCsOE" /><figcaption>“silhouette of grass” by <a href="https://unsplash.com/@marysill?utm_source=medium&amp;utm_medium=referral">Mary Sill</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Para começar, precisamos entender o que são funções anônimas.</p><p>Imagine que numa linguagem qualquer você tem o seguinte fragmento de código:</p><pre>function churrasqueira_eletrica() {<br>  return “Tá pegando fogo, bicho!”;<br>}</pre><p>Como pode ser visto, esse código define a função <em>churrasqueira_eletrica </em>que não recebe nenhum argumento e retorna uma frase famosa. Essa função é nomeada porque nós demos a ela um nome ( churrasqueira_eletrica ) e você pode acessar essa função novamente usando esse nome (executando churrasqueira_eletrica();).</p><p>Como você deve imaginar, função anônima é algo quase igual:</p><pre>function() {<br>  return “Nada a ver”;<br>}</pre><p>A função acima é uma <em>função anônima</em> pelo simples motivo de que você não deu um nome para ela.</p><p>Normalmente você faz isso para utilizar essa função como parte auxiliar de outra parte do código. Se você já mexeu com map ou reduce em JavaScript ou Ruby ou qualquer linguagem do gênero, você já viu isso.</p><p><em>map</em> e <em>reduce</em> são um conceito de programação funcional em que você pega uma coleção (um conjunto de coisas, por exemplo uma lista) e aplica uma função sobre cada um dos itens dessa coleção, retornando o resultado disso. Por exemplo:</p><pre>minha_colecao = [1, 2, 3, 4]</pre><pre># Vamos elevar todos valores ao quadrado<br>minha_colecao.map(<strong>function(valor) { valor * valor }</strong>)<br># [1, 4, 9, 16]</pre><p>No código acima nós temos uma lista de números e aplicamos map nela. map espera como argumento uma função a ser aplicada em cada elemento, então definimos uma função anônima que multiplica cada elemento por ele mesmo :)</p><p>Agora que você já pegou tudo isso (a maior parte do artigo) vem a parte interessante.</p><p>Uma <em>closure</em> não é muito mais que “<em>uma função anônima com acesso ao ambiente em que foi definida</em>”. Com ambiente entenda o acesso à memória (aos nomes de variáveis e os seus valores) no momento em que essa parte do código roda. Por exemplo:</p><pre># 12:31:00<br>var hora_que_rodou = Time.now()</pre><pre>var as_hora_no_time_doctor = function() {<br>  console.print(“Esta função foi definida às ” + hora_que_rodou)<br>  console.print(“Agora são ” + Time.now())<br>  console.print(“O valor da variável eita é: “ + eita)<br>}</pre><pre>var eita = 123</pre><pre>as_hora_no_time_doctor()<br># Esta função foi definida às <em>12:31:00</em><br># Agora são <em>12:32:18</em><br># O valor da variável eita é: <em>undefined</em></pre><p>Viu ? A variável hora_que_rodou tinha um valor (“12:31:00”) no momento em que definimos a <em>closure</em>, então ela conseguiu acessar esse valor. A variável eita, no entanto, não estava definida na hora que definimos a <em>closure</em>, por isso seu valor não é acessável.</p><p>Então podemos usar <em>closures</em> para referenciarmos um certo momento no tempo para execução de código.</p><p>Um adendo importante é que usualmente <em>closures</em> têm acesso de leitura a <em>snapshots</em> do ambiente. Isto é, o valor das variáveis somente no momento em que a <em>closure</em> foi definida, qualquer alteração posterior não é acessável por ela. No entanto, JavaScript (e potencialmente outras linguagens) têm acesso ao próprio ambiente, o que significa que mudanças no valor das variáveis se propagam à <em>closure</em>. Exemplo:</p><pre>var x = 1<br>var eita = function() {<br>  console.print(x)<br>}</pre><pre>x = 2<br>run(eita)<br># 2</pre><p>Restou alguma dúvida ? Mande nos comentários que será respondida quão cedo possível!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f840782a486c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trainingcenter/closures-fun%C3%A7%C3%B5es-an%C3%B4nimas-e-fun%C3%A7%C3%B5es-nomeadas-f840782a486c">Closures, Funções Anônimas e Funções Nomeadas</a> was originally published in <a href="https://medium.com/trainingcenter">Training Center</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>