<?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 Matheus Musa on Medium]]></title>
        <description><![CDATA[Stories by Matheus Musa on Medium]]></description>
        <link>https://medium.com/@mattheus.h.m.s?source=rss-ac94881bed29------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*PH22FL2YzgEVoPeb</url>
            <title>Stories by Matheus Musa on Medium</title>
            <link>https://medium.com/@mattheus.h.m.s?source=rss-ac94881bed29------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 10:13:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mattheus.h.m.s/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[Dataset na construção de um modelo de Machine Learning]]></title>
            <link>https://medium.com/@mattheus.h.m.s/dataset-na-constru%C3%A7%C3%A3o-de-um-modelo-de-machine-learning-066287e60c45?source=rss-ac94881bed29------2</link>
            <guid isPermaLink="false">https://medium.com/p/066287e60c45</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[dataset]]></category>
            <category><![CDATA[regression-modeling]]></category>
            <dc:creator><![CDATA[Matheus Musa]]></dc:creator>
            <pubDate>Thu, 03 Oct 2024 15:10:21 GMT</pubDate>
            <atom:updated>2024-10-04T14:13:47.737Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xClJFaFld3GM20mWBHkx_g.jpeg" /></figure><p>Talvez uma das maiores dificuldades de quem está começando a estudar Machine Learning seja trabalhar, tratando os dados fazer pequenas inferências, para então montar o seu modelo.</p><p>Nesse artigo vou exemplificar como analisar um dataset para uma melhor construção de um modelo de Machine Learning passando por:</p><ol><li><em>Breve explicação do que é Machine Learning</em></li><li><em>Tipos e diferenças de Aprendizados</em></li><li><em>Entender e retirar informações importantes do dataset</em></li><li><em>Tratar dados de um dataset</em></li><li><em>Diferenças entre algoritmos de um modelo</em></li><li><em>Construção de um modelo de Regressão Linear</em></li></ol><p>Mas vamos partir do princípio, para podermos contextualizar, o que é Machine Learning (ML)?</p><p>ML é um dos diversos ramos da Inteligência Artificial (IA), assim como Redes Neurais ou Robótica, e outros. O tipo do aprendizado da maquina depende de como os dados estão estruturados, com isso podem ser divididos em diversos tipos, a partir dai criar um modelo. O modelo de um ML é criado usando algoritmos que processam os dados de entrada e aprendem a prever ou classificar os resultados.</p><h3>A Importância de um Dataset</h3><p>Para criar um modelo de ML precisamos de um conjunto de dados (dataset), dentro do dataset tem que estar as nossas características (features) de entrada, que é basicamente todo o nosso dataset exceto pela coluna target a depender do nosso tipo de aprendizado, se ele for um aprendizado Supervisionado o dataset deve conter os targets, ou rótulos, ou respostas corretas, já que vai usar essa informação para o treino e teste do modelo. Alguns tipos de aprendizado e a estrutura do dataset para eles:</p><ul><li><strong>Aprendizado Supervisionado: </strong>Aqui o modelo aprende através de um conjunto de dados rotulados, já com saídas corretas fornecidas, sendo assim o modelo tem como objetivo aprender a associar entradas e saídas para poder fazer suas previsões corretamente para os novos dados.</li><li><strong>Aprendizado não supervisionado: </strong>O treinamento do modelo é feito com dados não rotulados, não tem uma saída correta associada a entrada, assim o objetivo do modelo é identificar padrões e agrupamentos nos dados.</li><li><strong>Aprendizado por Reforço: </strong>Nesse o modelo aprende a partir da interação com o ambiente. Ele vai tomar ações no ambiente e receber recompensa por ações corretas ou receber penalidade por ações erradas, tendo como objetivo maximizar por completo as recompensas a longo prazo maximizando o comportamento que levou a executar ações corretas.</li></ul><p>Sendo assim o dataset basicamente define todo o comportamento e processo de aprendizado do modelo gerado pela maquina.</p><p>Para seguir com os exemplos usarei um dataset com rótulos, exemplificando um modelo com um Aprendizado Supervisionado, onde o objetivo será definir o valor da mensalidade de um seguro de vida para um determinado publico.</p><p>Vamos começar carregando o nosso dataset e ver suas primeiras linhas.</p><pre>import pandas as pd<br><br>data = pd.read_csv(&#39;../dataset_seguro_vida.csv&#39;)<br>data.head()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/972/1*DbkNv4tJGA0jnLEDGEK_KA.png" /></figure><p>Vamos detalhar um pouco mais os nossos dados, podemos ver seu formato, e descobrindo o numero de linhas e colunas do dataset.</p><pre>data.shape</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/499/1*cOQczWoLMpHOM7kzvHwifA.png" /></figure><p>Temos aqui uma estrutura de dados de 500 linhas e 9 colunas.</p><p>Agora vamos ver os tipos de dados que temos e se temos algum dado faltando.</p><pre>data.info()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/509/1*quXVX1Zg043P876Boe6EtQ.png" /></figure><p>Temos aqui 3 colunas numéricas dentre eles 2 int (números inteiros) e 1 float (números com casas decimais), e as outra 6 são object. Sendo assim podemos passar para o próximo passo de tratar um pouco os dados.</p><h4>Trabalhando o Dataset</h4><p>Um bom passo para o melhorar o nosso dataset, é entender que alguns tipos de dados são processados e até entendido mais facilmente pelo modelo do que outros. Por exemplo os dados que são do tipo object são mais pesados e até limitados para se trabalhar, dessa forma é melhor transforma-los para category, já que isso nos permite ter diversos ganhos desde desempenho a eficiência no uso de memória <em>(no fim podemos ainda melhorar mais isso fazendo mais uma transformação, mas hora que chegar o momento explico melhor)</em>.</p><pre>object_columns = data.select_dtypes(include=&#39;object&#39;).columns<br><br>for col in object_columns:<br>    data[col] = data[col].astype(&#39;category&#39;)<br><br>data.dtypes</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y5ac6JFXUBgJlWQgn1JkRw.png" /></figure><p>Como o nosso objetivo é conseguir estipular o valor da mensalidade de um seguro de vida, vamos dar uma olhada melhor nas nossas variáveis numéricas usando a transposição.</p><pre>data.describe().T</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fgQzq8tna9vcZKTIbRd78g.png" /></figure><p>Podemos aqui ver alguns detalhes e valores dos nossos inputs numéricos, como a média aritmética, o valor mínimo e máximo. Através desses dados podemos fazer a separação desses valores em grupos baseados em algum input de categoria, por gênero, se fuma ou não, entre outros, como demonstração vamos fazer a separação por sexo, para visualizar a media aritmética das colunas divididas por sexo.</p><pre>value_based_on_sex = data.groupby(&quot;Sexo&quot;).mean(&quot;PrecoSeguro&quot;)<br>value_based_on_sex</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cJ-fX4hH51dclI7u5_uXjA.png" /></figure><p>Como podemos ver que no nosso dataset os homens acabam pagando um preço maior de seguro (lembrando que esse dataset é fictício).</p><p>Podemos ter uma melhor visualização dos dados através do <a href="https://seaborn.pydata.org/api.html"><strong>seaborn</strong></a>, é uma biblioteca construída com base no <a href="https://matplotlib.org/stable/users/explain/quick_start.html"><strong>matplotlib</strong></a> usada especificamente para plotar gráficos estatísticos.</p><pre>import seaborn as sns<br><br>sns.set_style(&quot;whitegrid&quot;)<br><br>sns.pairplot(<br>    data[[&quot;Idade&quot;, &quot;Salario&quot;, &quot;PrecoSeguro&quot;, &quot;Sexo&quot;]],<br>    hue = &quot;Sexo&quot;,<br>    height = 3,<br>    palette = &quot;Set1&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/722/1*gEVm5WvTVV8tkAsSRwceoQ.png" /></figure><p>Aqui podemos visualizar a distribuição desses valores através dos gráficos ficando mais claro a separação do conjunto, com base no grupo que escolhemos, como um teste você pode tentar fazer um agrupamento diferente e ver como os gráficos vão ficar.</p><p>Vamos criar uma matriz de correlação, sendo essa uma outra forma de visualizar a relação das variáveis numéricas do dataset, com o auxilio visual de um heatmap.</p><pre>numeric_data = data.select_dtypes(include=[&#39;float64&#39;, &#39;int64&#39;])<br><br>corr_matrix = numeric_data.corr()<br>sns.heatmap(corr_matrix, annot= True)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/531/1*xH2f3mJaTN4gdAWZpVWqVQ.png" /></figure><p>Essa matriz transposta nos mostra quais variáveis numéricas influenciam mais no nosso modelo, é um pouco intuitivo quando você olha para a imagem, podemos observar que a idade é a que mais vai interferir no preço do seguro. Basicamente essa matriz funciona assim:</p><p><em>Os valores variam entre -1 e 1:</em></p><ul><li><strong><em>1</em></strong><em>: Correlação perfeita positiva — Quando uma variável aumenta, a outra também aumenta proporcionalmente.</em></li><li><strong><em>0</em></strong><em>: Nenhuma correlação — Não há relação linear entre as variáveis.</em></li><li><strong><em>-1</em></strong><em>: Correlação perfeita negativa — Quando uma variável aumenta, a outra diminui proporcionalmente.</em></li></ul><p>Lembra da transformada que fizemos de object para category nos dados, agora vem a outra melhoria comentada, com os dados que viraram category faremos mais uma transformada, dessa vez a ideia é transformar essa variáveis categóricas em representações numéricas, isso nos permitirá ter um ganho incrível com o desempenho do modelo já que ele entende muito melhor essas variáveis numéricas.</p><p>Conseguimos fazer isso facilmente com a lib do <a href="https://pandas.pydata.org/docs/user_guide/index.html#user-guide"><strong>pandas</strong></a><strong> </strong>, o que ele faz é criar nova colunas binarias para valores distintos, o pandas é uma biblioteca voltada principalmente para analise de dados e estrutura de dados, então ela já possui diversas funcionalidades que nos auxiliam nos processo de tratamento do dataset.</p><pre>data = pd.get_dummies(data)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3ym38PNA_nRTVEmX77jotQ.png" /></figure><p>Pronto agora temos nossas novas colunas para as categorias.</p><h3>Decidindo o Algoritmo</h3><p>Para a construção do melhor modelo, devemos saber qual o algoritmo ideal para o propósito da ML, na tabela seguinte vou deixar um resumo simplificado de como analisar seu problema e fazer a melhor escolha</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*mpIdd0Nr9E29XHw1zJLAYA.png" /></figure><p>Olhando a tabela podemos ver que o problema que temos que resolver é o de regressão. Aqui vai mais uma dica, sempre comesse simples e vá incrementando seu e fazendo os ajustes necessários até os valores de previsibilidade do modelo ser satisfatório.</p><p>Aqui no nosso exemplo vamos montar um modelo de Regressão Linear, já que temos uma linearidade entre os nossos inputs e temos como target uma variável numérica.</p><p>Sabemos que a nossa variável target é a coluna PrecoSeguro , as outras são nossos inputs. Os inputs em estatísticas são chamadas de variável independente e o target de variável dependente, pelos nomes fica claro que a ideia é que o nosso target é uma variável que depende dos nosso inputs, se os inputs variam nosso target tem que vai variar também.</p><p>Vamos definir nosso y com o target</p><pre>y = data[&quot;PrecoSeguro&quot;]</pre><p>E para x vamos remover a coluna target e inserir todas as outras</p><pre>X = data.drop(&quot;PrecoSeguro&quot;, axis = 1)</pre><p>Antes de montarmos o modelo, nosso dataset precisa ser dividido uma parte para teste e outra para o treino, para fazer isso vamos usar do <a href="https://scikit-learn.org/stable/api/index.html"><strong>scikit-learn</strong></a> o método <a href="https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html"><strong>train_test_split</strong></a>.</p><pre>from sklearn.model_selection import train_test_split<br><br>X_train,X_test,y_train,y_test=train_test_split(<br>    X,y, <br>    train_size = 0.80, <br>    random_state = 1)</pre><p>Aqui dividimos o nosso dataset em 80% para treino e 20% para testes. Agora podemos montar o nosso modelo.</p><pre>from sklearn.linear_model import LinearRegression<br><br>lr = LinearRegression()<br><br>lr.fit(X_train,y_train)</pre><p>Modelo montado agora podemos avaliar seu desempenho</p><pre>lr.score(X_test, y_test).</pre><pre>lr.score(X_train, y_train)</pre><p>Aqui podemos analisar a o coeficiente de determinação do nosso modelo para testes e para o treinamento.</p><p>Podemos usar um outro método para poder descobrir o desvio padrão do nosso modelo, e entender a estabilidade e a confiabilidade do desempenho do modelo para a amostra</p><pre>from sklearn.metrics import mean_squared_error<br>import math<br><br>y_pred = lr.predict(X_test)<br>math.sqrt(mean_squared_error(y_test, y_pred))</pre><h3>Considerações</h3><p>O valor perfeito do coeficiente de determinação é 1, quanto mais próximo desse valor, teoricamente melhor seria o nosso modelo, mas um ponto de atenção é basicamente impossível você conseguir um modelo perfeito, até mesmo algo acima de 0.95 é de se desconfiar.</p><p>Se você tiver trabalhando com dados reais e conseguir um valor desse é bom analisar o seu modelo, testar outras abordagens e até mesmo revisar seu dataset, pois seu modelo pode estar sofrendo um overfitting e por isso apresenta esse resultado quase que perfeitos.</p><p>Aqui como montamos um dataset com valores irreais e sem nenhum embasamento é normal termos esses valores quase que perfeitos.</p><p>Deixarei aqui um link para o github do código e dataset usados nesse post</p><ul><li><a href="https://github.com/mattheuzz/machine-learning-medium-post"><strong>GitHub</strong></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=066287e60c45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Elegância Funcional: Redescobrindo JavaScript Através da Programação Funcional]]></title>
            <link>https://medium.com/@mattheus.h.m.s/eleg%C3%A2ncia-funcional-redescobrindo-javascript-atrav%C3%A9s-da-programa%C3%A7%C3%A3o-funcional-ede5577621a3?source=rss-ac94881bed29------2</link>
            <guid isPermaLink="false">https://medium.com/p/ede5577621a3</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[teaching]]></category>
            <dc:creator><![CDATA[Matheus Musa]]></dc:creator>
            <pubDate>Tue, 12 Dec 2023 23:54:34 GMT</pubDate>
            <atom:updated>2023-12-12T23:54:34.486Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w0aN_gsscqGv6qCg5O5RQA.png" /></figure><p>A programação funcional, em muitos aspectos, assemelha-se à elegância e à previsibilidade das leis da física. Assim como na física, onde leis fundamentais governam o universo de maneira consistente e previsível, a programação funcional aplica princípios matemáticos rigorosos para garantir que o código execute de maneira previsível e eficiente.</p><ul><li><strong>Imutabilidade e Leis da Termodinâmica:</strong> Assim como a energia em um sistema fechado permanece constante (Primeira Lei da Termodinâmica), a imutabilidade em programação funcional assegura que os dados originais permaneçam inalterados, promovendo a integridade e a confiabilidade do estado do programa.</li><li><strong>Funções de Primeira Classe e Partículas Fundamentais: </strong>Na física, partículas fundamentais são os blocos básicos de construção do universo. Analogamente, em programação funcional, funções de primeira classe são os blocos fundamentais do código, podendo ser combinadas e transformadas de maneira flexível.</li><li><strong>Funções Puras e Leis de Newton:</strong> Assim como as leis de Newton oferecem previsibilidade no movimento dos corpos, funções puras garantem resultados consistentes, independentemente do contexto externo, assemelhando-se à forma como um sistema físico reage de maneira previsível sob forças conhecidas.</li><li><strong>Recursão e Fractais:</strong> A recursão em programação funcional pode ser comparada aos padrões repetitivos e auto-similares dos fractais na natureza, onde uma simples regra pode gerar complexidade e beleza infinitas.</li><li><strong>Avaliação Preguiçosa e o Princípio da Incerteza de Heisenberg:</strong> Assim como o Princípio da Incerteza postula que algumas propriedades físicas não podem ser medidas simultaneamente com precisão total, a avaliação preguiçosa em programação funcional retém o cálculo de um valor até que sua necessidade seja absolutamente certa, economizando recursos.</li><li><strong>Funções de Ordem Superior e Teoria das Cordas:</strong> Na física, a Teoria das Cordas sugere que as partículas subatômicas são, na verdade, ‘cordas’ vibratórias. Similarmente, as funções de ordem superior na programação funcional representam uma camada mais profunda de abstração, onde funções não são apenas valores, mas podem ser manipuladas e combinadas de formas complexas e elegantes.</li></ul><p>Assim como a física revela os mistérios do universo, a programação funcional desvenda novas formas de pensar e resolver problemas no mundo do desenvolvimento de software, oferecendo um paradigma robusto e eficiente que é tanto artístico quanto lógico.</p><p>Linguagens de programação como Haskell, Erlang, Clojure e Scala são projetadas para programação funcional, enquanto outras linguagens como JavaScript, Python, e Ruby suportam muitos aspectos deste paradigma, embora não sejam exclusivamente funcionais. A programação funcional é particularmente útil em situações que exigem alta confiabilidade e facilidade de testes, como em sistemas distribuídos e paralelismo, devido à sua natureza imutável e ao uso de funções puras.</p><h3>Imutabilidade</h3><p>A imutabilidade, no contexto da programação funcional, é um princípio fundamental que assegura a constância dos dados ao longo do tempo. Em termos simples, uma vez que um objeto ou dado é criado, ele não pode ser alterado. Qualquer operação que necessite modificar esse dado resultará na criação de uma nova instância, mantendo o original inalterado. Este conceito contrasta com a programação imperativa, onde os dados são frequentemente mutáveis e podem ser alterados diretamente.</p><h4>Por que a Imutabilidade é Importante?</h4><ol><li><strong>Previsibilidade e Confiança:</strong> Com a imutabilidade, você pode confiar que os dados não serão alterados inesperadamente ao longo do código. Isso torna o programa mais previsível, facilitando a compreensão do fluxo de dados e a detecção de erros.</li><li><strong>Facilita o Raciocínio Concorrente:</strong> Em ambientes de programação concorrentes, como em aplicações web onde múltiplos usuários podem interagir com dados ao mesmo tempo, a imutabilidade reduz a complexidade, pois não há necessidade de se preocupar com condições de corrida ou bloqueios de dados. Cada operação que altera os dados cria uma nova versão, evitando conflitos diretos.</li><li><strong>Histórico de Mudanças: </strong>Manter o estado original dos dados permite que você tenha um histórico imutável de estados. Isso é especialmente útil em aplicações onde o rastreamento de mudanças ou a reversão para estados anteriores é necessário.</li><li><strong>Otimizações de Performance:</strong> Alguns ambientes de execução e frameworks podem aproveitar a imutabilidade para otimizar o desempenho. Por exemplo, eles podem evitar a re-renderização desnecessária de componentes em interfaces de usuário se souberem que os dados subjacentes não mudaram.</li></ol><h4>Imutabilidade em JavaScript</h4><p>Em JavaScript, a imutabilidade não é imposta pela linguagem, mas pode ser adotada como uma prática. Por exemplo, ao usar objetos, em vez de modificar diretamente um objeto existente, você pode criar um novo objeto com as alterações desejadas. Métodos como Object.freeze() podem ser usados para prevenir mudanças em um objeto, enquanto operadores como spread (...) e funções como Array.map() e Array.filter() ajudam a tratar arrays de maneira imutável.</p><p>Em resumo, a imutabilidade na programação funcional não é apenas uma restrição, mas uma ferramenta poderosa para escrever código mais seguro, limpo e fácil de manter. Ao adotá-la, especialmente em linguagens como JavaScript, os desenvolvedores podem colher benefícios significativos em termos de confiabilidade e clareza do código.</p><h3>Funções de Primeira Classe: A Flexibilidade Funcional em JavaScript</h3><p>Introdução às Funções de Primeira Classe: Em JavaScript, as funções são tratadas como valores de primeira classe, o que significa que elas podem ser manuseadas e utilizadas da mesma forma que outros valores, como strings ou números. Essa característica é um dos pilares da programação funcional e abre um leque vasto de possibilidades expressivas e poderosas no design do software.</p><h4>Características das Funções de Primeira Classe:</h4><ul><li><strong>Atribuição a Variáveis:</strong> As funções podem ser atribuídas a variáveis, permitindo que sejam armazenadas e acessadas como qualquer outro valor.</li><li><strong>Passagem como Argumentos:</strong> Funções podem ser passadas como argumentos para outras funções, permitindo operações como callbacks e funções de ordem superior.</li><li><strong>Retorno por Outras Funções:</strong> Funções podem ser retornadas por outras funções, possibilitando a criação de fábricas de funções e técnicas como currying e composição de funções.</li></ul><h4>Exemplos Práticos</h4><ul><li>Atribuição a Variáveis:</li></ul><pre>const saudacao = function(nome) {<br>    return `Olá, ${nome}!`;<br>};<br><br>console.log(saudacao(&quot;Alice&quot;)); // Olá, Alice!</pre><ul><li>Passagem como Argumentos (Callbacks):</li></ul><pre>function calculadora(operacao, x, y) {<br>    return operacao(x, y);<br>}<br><br>const soma = (a, b) =&gt; a + b;<br>const resultado = calculadora(soma, 5, 3); // 8<br>console.log(resultado);</pre><ul><li>Retorno por Outras Funções (Fábricas de Funções):</li></ul><pre>function multiplicador(factor) {<br>    return function(x) {<br>        return x * factor;<br>    };<br>}<br><br>const dobro = multiplicador(2);<br>console.log(dobro(5)); // 10</pre><p>Importância nas Aplicações JavaScript: A capacidade de tratar funções como valores de primeira classe permite uma abordagem mais flexível e modular para a construção de aplicativos em JavaScript. Essa característica é essencial para a programação funcional, pois permite a criação de abstrações poderosas, reduzindo a repetição de código e aumentando a reusabilidade.</p><h3>Funções Puras e Testes de Unidades</h3><p>Funções puras são aquelas que, para os mesmos argumentos de entrada, sempre retornam o mesmo resultado e não têm efeitos colaterais (como modificar variáveis externas, realizar operações de I/O, etc.). Essa característica torna as funções puras extremamente valiosas para o teste de unidades, pois:</p><ul><li><strong>Previsibilidade</strong>: Como o resultado de uma função pura depende apenas de suas entradas, é fácil prever o que a função deve retornar para um conjunto dado de entradas. Isso simplifica a escrita de casos de teste.</li><li><strong>Isolamento:</strong> Testar uma função pura não requer um contexto externo ou um estado pré-definido, permitindo que cada função seja testada de forma isolada. Isso elimina a necessidade de configurar e manter estados complexos para testes.</li><li><strong>Confiabilidade:</strong> A ausência de efeitos colaterais significa que a execução de uma função pura não altera o estado do sistema, garantindo que os testes não interfiram uns nos outros.</li></ul><h3>Exemplo Função Pura</h3><p>Considere uma função que calcula o total de uma fatura, incluindo impostos. Esta função é pura porque seus resultados dependem exclusivamente de seus argumentos de entrada e não alteram nenhum estado externo.</p><pre>function calcularTotalFatura(valorBase, taxaImposto) {<br>    return valorBase * (1 + taxaImposto);<br>}<br>// Exemplo de uso<br>let valorBase = 100;<br>let taxaImposto = 0.2; // 20%<br>console.log(calcularTotalFatura(valorBase, taxaImposto)); // Sempre retorna 120</pre><p>Neste exemplo, a função calcularTotalFatura é pura pois, para os mesmos valores de valorBase e taxaImposto, sempre retornará o mesmo resultado, e não modifica nenhum estado fora de seu escopo.</p><h3>Exemplo Função Impura</h3><p>Agora, vamos ver uma função que registra uma venda e atualiza um registro global de vendas. Esta função é impura porque altera um estado externo.</p><pre>let vendasTotais = 0;<br>function registrarVenda(valorVenda) {<br>    vendasTotais += valorVenda;<br>    // Possível efeito colateral: logar a venda<br>    console.log(`Venda registrada: $${valorVenda}`);<br>    return vendasTotais;<br>}<br>// Exemplo de uso<br>console.log(registrarVenda(50)); // O resultado depende do estado atual de `vendasTotais`<br>console.log(registrarVenda(100)); // E continua mudando a cada chamada</pre><p>Neste caso, registrarVenda é impura por dois motivos:</p><ul><li>Ela modifica a variável global vendasTotais.</li><li>Ela realiza uma operação de I/O (log no console), que é considerada um efeito colateral.</li></ul><h4>Por que Importa?</h4><p>A diferença entre esses dois tipos de funções é crucial no desenvolvimento de software:</p><ul><li><strong>Funções Puras:</strong> Facilitam o teste, a manutenção e o raciocínio sobre o código. Elas são especialmente úteis em operações complexas de transformação de dados, onde a previsibilidade é fundamental.</li><li><strong>Funções Impuras:</strong> Podem ser necessárias para interagir com o mundo exterior (como I/O) ou manter o estado da aplicação. No entanto, elas tornam os testes mais complexos e podem levar a bugs difíceis de rastrear, especialmente em aplicações grandes e complexas.</li></ul><h3>Recursão: A Alternativa Funcional aos Loops Tradicionais</h3><p>Na programação funcional, a recursão é uma técnica poderosa que substitui os loops tradicionais encontrados na programação imperativa. Em vez de usar estruturas como for e while para repetições, a recursão alcança o mesmo resultado chamando uma função dentro de si mesma, com diferentes argumentos, até que uma condição base seja satisfeita.</p><h4>Por que Usar Recursão em JavaScript:</h4><ul><li>Clareza e Elegância: Recursão pode tornar o código mais claro e conciso, especialmente para algoritmos que se encaixam naturalmente nesse padrão, como navegação em estruturas de dados hierárquicas.</li><li>Imutabilidade e Estado Local: A recursão evita a necessidade de modificar variáveis de estado global, mantendo o estado dentro do escopo da função.</li><li>Facilita o Raciocínio Funcional: A recursão é uma abordagem natural na programação funcional, ajudando a manter a pureza das funções e a imutabilidade dos dados.</li></ul><h4>Exemplos de Recursão em JavaScript</h4><h4>1. Cálculo de Fatorial</h4><p>O fatorial de um número é um exemplo clássico de onde a recursão é frequentemente utilizada.</p><pre>function fatorial(n) {<br>    if (n === 0 || n === 1) {<br>        return 1;<br>    }<br>    return n * fatorial(n - 1);<br>}<br>console.log(fatorial(5)); // 120</pre><p>Neste exemplo, a função fatorial chama a si mesma com n - 1 até que atinja o caso base (n = 0 ou n = 1), onde retorna 1.</p><h4>2. Percorrendo uma Estrutura de Dados Hierárquica</h4><p>A recursão é particularmente útil para percorrer estruturas de dados complexas, como árvores. Por exemplo, vamos considerar a busca em uma estrutura de árvore:</p><pre>function buscarNaArvore(no, valor) {<br>    if (no.valor === valor) {<br>        return no;<br>    }<br>    for (let filho of no.filhos) {<br>        let resultado = buscarNaArvore(filho, valor);<br>        if (resultado) {<br>            return resultado;<br>        }<br>    }<br>    return null;<br>}<br>const arvore = {<br>    valor: 1,<br>    filhos: [<br>        { valor: 2, filhos: [] },<br>        { valor: 3, filhos: [<br>            { valor: 4, filhos: [] },<br>            { valor: 5, filhos: [] }<br>        ]}<br>    ]<br>};<br>console.log(buscarNaArvore(arvore, 5)); // Retorna o nó com valor 5</pre><h4>3. Recursão de Cauda para Otimização</h4><p>Recursão de cauda é uma técnica usada para otimizar chamadas recursivas, evitando o estouro da pilha de chamadas.</p><pre>function somatorioRecursivoDeCauda(n, acumulador = 0) {<br>    if (n === 0) {<br>        return acumulador;<br>    }<br>    return somatorioRecursivoDeCauda(n - 1, acumulador + n);<br>}<br>console.log(somatorioRecursivoDeCauda(5)); // 15</pre><p>Neste exemplo, somatorioRecursivoDeCauda utiliza um parâmetro adicional acumulador para manter o estado durante as chamadas recursivas.</p><h3>Avaliação Preguiçosa (Lazy Evaluation) em Programação Funcional</h3><p>A avaliação preguiçosa, ou “lazy evaluation”, é uma técnica empregada na programação funcional onde a avaliação de uma expressão é adiada até que seu valor seja estritamente necessário. Isso contrasta com a avaliação estrita, comum em muitas linguagens de programação, onde as expressões são calculadas assim que são encontradas.</p><h4>Benefícios da Avaliação Preguiçosa:</h4><ul><li>Melhoria de Performance: Evita cálculos desnecessários, especialmente útil em operações com coleções grandes ou cálculos intensivos.</li><li>Possibilita Estruturas de Dados Infinitas: Permite a criação de estruturas de dados teoricamente infinitas, como streams ou sequências, e a extração de apenas a parte necessária.</li><li>Controle de Efeitos Colaterais: Em operações que envolvem efeitos colaterais, a avaliação preguiçosa pode oferecer um melhor controle sobre quando esses efeitos ocorrem.</li></ul><p>Avaliação Preguiçosa em JavaScript: Embora JavaScript não suporte nativamente a avaliação preguiçosa em sua totalidade, é possível implementar conceitos similares através de funções e geradores.</p><h4>Exemplos Práticos</h4><ul><li>Uso de Funções para Simular Avaliação Preguiçosa:</li></ul><pre>function calculoPesado() {<br>    console.log(&quot;Executando cálculo pesado...&quot;);<br>    return 42; // Simulando um cálculo intensivo<br>}<br><br>const resultadoLazy = () =&gt; calculoPesado(); // A função não é executada aqui<br><br>console.log(&quot;Antes da avaliação&quot;);<br>console.log(resultadoLazy()); // O cálculo é feito apenas neste momento</pre><ul><li>Geradores para Sequências Infinitas:</li></ul><pre>function* geradorInfinito() {<br>    let i = 0;<br>    while (true) {<br>        yield i++;<br>    }<br>}<br><br>const gen = geradorInfinito();<br>console.log(gen.next().value); // 0<br>console.log(gen.next().value); // 1<br>// Pode continuar indefinidamente, mas calcula apenas quando necessário</pre><h3>Funções de Ordem Superior (Higher-Order Functions)</h3><p>As Funções de Ordem Superior (Higher-Order Functions) são um pilar da programação funcional em JavaScript. Essas funções têm a capacidade única de receber outras funções como argumentos e/ou retornar uma função. Elas são instrumentais em escrever código conciso, modular e expressivo. Vamos explorar alguns dos exemplos mais comuns: .map(), .filter(), e .reduce().</p><h4>1. .map()</h4><p>O método .map() é utilizado para transformar cada elemento de um array. Ele cria um novo array sem alterar o original, aplicando uma função fornecida a cada elemento do array.</p><p>Exemplo:</p><p>Suponha que temos um array de objetos representando produtos, e queremos um novo array apenas com os preços desses produtos:</p><pre>const produtos = [    { nome: &quot;Maçã&quot;, preco: 1 },    { nome: &quot;Laranja&quot;, preco: 2 },    { nome: &quot;Banana&quot;, preco: 1.5 }];<br>const precos = produtos.map(produto =&gt; produto.preco);<br>console.log(precos); // [1, 2, 1.5]</pre><h4>2. .filter()</h4><p>O método .filter() cria um novo array com todos os elementos que passam em um teste implementado por uma função fornecida. É ideal para situações onde você precisa selecionar um subconjunto de elementos com base em critérios específicos.</p><p>Exemplo:</p><p>Vamos filtrar o mesmo array de produtos para encontrar apenas aqueles com preço inferior a 2:</p><pre>const produtosBaratos = produtos.filter(produto =&gt; produto.preco &lt; 2);<br>console.log(produtosBaratos); // [{ nome: &quot;Maçã&quot;, preco: 1 }, { nome: &quot;Banana&quot;, preco: 1.5 }]</pre><h4>3. .reduce()</h4><p>O método .reduce() executa uma função redutora em cada elemento do array, resultando em um único valor de saída. É extremamente versátil e pode ser usado para operações como somar todos os elementos de um array, concatenar strings, entre outros.</p><p>Exemplo:</p><p>Para calcular o valor total dos produtos em um carrinho de compras, podemos usar .reduce():</p><pre>const total = produtos.reduce((acumulador, produto) =&gt; acumulador + produto.preco, 0);<br>console.log(total); // 4.5</pre><p>Neste exemplo, o 0 após a função é o valor inicial do acumulador. A função redutora é chamada para cada produto, somando o seu preço ao acumulador.</p><h3>Composição de Funções</h3><p>A composição de funções é uma técnica central na programação funcional, especialmente em JavaScript. Ela envolve criar novas funções pela combinação de funções existentes, cada uma realizando uma tarefa específica e pequena. Essa abordagem permite construir soluções complexas e expressivas de maneira modular e reutilizável.</p><h4>Conceito Básico</h4><p>Na composição de funções, o resultado de uma função é passado diretamente como entrada para outra. Em termos matemáticos, se você tem duas funções f e g, a composição (f ∘ g)(x) é equivalente a f(g(x)).</p><h3>Exemplos em JavaScript</h3><h4>1. Encadeamento de Métodos de Array</h4><p>Uma maneira comum de compor funções em JavaScript é através do encadeamento de métodos de array, como .map(), .filter(), e .reduce().</p><p>Exemplo:</p><p>Suponha que temos um array de números e queremos primeiro filtrar os números pares e, em seguida, elevar cada número ao quadrado:</p><pre>const numeros = [1, 2, 3, 4, 5, 6];<br>const quadradosDosPares = numeros<br>    .filter(num =&gt; num % 2 === 0)<br>    .map(num =&gt; num * num);<br>console.log(quadradosDosPares); // [4, 16, 36]</pre><h4>2. Funções de Composição Personalizadas</h4><p>Podemos também criar nossas próprias funções de composição. Isso é útil quando queremos reutilizar uma sequência específica de operações.</p><p>Exemplo:</p><p>Vamos criar uma função de composição simples que aplica duas funções em sequência:</p><pre>function compor(f, g) {<br>    return function(x) {<br>        return f(g(x));<br>    };<br>}<br>const dobrar = x =&gt; x * 2;<br>const incrementar = x =&gt; x + 1;<br>const incrementarEDobrar = compor(dobrar, incrementar);<br>console.log(incrementarEDobrar(3)); // 8 (dobro de (3 + 1))</pre><h4>Benefícios da Composição de Funções</h4><ul><li><strong>Modularidade:</strong> Permite construir soluções complexas a partir de funções simples e bem definidas.</li><li><strong>Reusabilidade: </strong>As funções individuais podem ser reutilizadas em diferentes contextos.</li><li><strong>Facilidade de Teste e Manutenção:</strong> Funções menores e bem definidas são mais fáceis de testar e manter.</li><li><strong>Legibilidade e Clareza:</strong> Encadeamentos de funções e composições expressam claramente o fluxo de dados e as transformações que estão ocorrendo.</li></ul><h3>Programação Funcional em Node.js:</h3><p>A programação funcional em Node.js oferece uma abordagem poderosa e eficiente para manipulação de dados e operações assíncronas. Vamos explorar como esses conceitos podem ser aplicados em Node.js, incluindo o uso de bibliotecas úteis.</p><h4>Manipulação de Dados com Programação Funcional</h4><p>Em Node.js, a programação funcional pode ser extremamente útil para transformar e manipular dados. Isso é especialmente verdadeiro em aplicações que lidam com grandes volumes de dados ou fluxos de dados complexos, como APIs, processamento de arquivos ou comunicação com bancos de dados.</p><h4>Exemplo Prático:</h4><p>Suponha que você esteja trabalhando com um array de objetos representando usuários e precisa transformá-lo para um formato específico:</p><pre>const usuarios = [<br>    { nome: &quot;Alice&quot;, idade: 25 },<br>    { nome: &quot;Bob&quot;, idade: 30 },<br>    { nome: &quot;Clara&quot;, idade: 28 }<br>];<br>const nomesDosUsuarios = usuarios.map(usuario =&gt; usuario.nome);<br>const idadesDosUsuarios = usuarios.map(usuario =&gt; usuario.idade);<br>const mediaIdade = idadesDosUsuarios.reduce((acc, idade) =&gt; acc + idade, 0) / usuarios.length;<br>console.log(nomesDosUsuarios); // [&#39;Alice&#39;, &#39;Bob&#39;, &#39;Clara&#39;]<br>console.log(mediaIdade); // Média de idade</pre><h3>Asynchronous Functional Patterns</h3><p>Node.js frequentemente lida com operações assíncronas, como I/O de arquivos, acesso a bancos de dados, ou chamadas de rede. As Promises e async/await oferecem uma maneira limpa e funcional de lidar com essas operações.</p><h4>Exemplo com Promises</h4><pre>function buscarDados(url) {<br>    return fetch(url).then(response =&gt; response.json());<br>}<br>buscarDados(&#39;https://api.exemplo.com/dados&#39;)<br>    .then(dados =&gt; {<br>        // Processa os dados<br>    })<br>    .catch(erro =&gt; {<br>        // Trata erros<br>    });</pre><h4>Exemplo com async/await</h4><pre>async function buscarEProcessarDados(url) {<br>    try {<br>        const dados = await fetch(url).then(res =&gt; res.json());<br>        // Processa os dados<br>    } catch (erro) {<br>        // Trata erros<br>    }<br>}<br>buscarEProcessarDados(&#39;https://api.exemplo.com/dados&#39;);</pre><h3>Bibliotecas Úteis para Programação Funcional</h3><ul><li>Lodash: Uma biblioteca que oferece muitas funções utilitárias para trabalhar com arrays, objetos e funções de maneira funcional. Lodash é conhecido por sua performance e facilidade de uso.</li><li>Ramda: Uma biblioteca focada em programação funcional que oferece currying em todas as suas funções, facilitando a criação de pipelines e composições de funções.</li></ul><h4>Exemplo com Lodash</h4><pre>const _ = require(&#39;lodash&#39;);<br>const usuarios = [<br>    { nome: &quot;Alice&quot;, idade: 25 },<br>    { nome: &quot;Bob&quot;, idade: 30 },<br>    { nome: &quot;Clara&quot;, idade: 28 }<br>];<br>const mediaIdade = _.meanBy(usuarios, &#39;idade&#39;);<br>console.log(mediaIdade); // Calcula a média de idade</pre><h3>Conclusão</h3><p>Através da exploração dos conceitos e práticas da programação funcional em JavaScript e Node.js, podemos perceber o impacto significativo que este paradigma tem no desenvolvimento de software moderno. A imutabilidade garante a constância e previsibilidade dos dados, facilitando o rastreamento de mudanças e a manutenção do código. As funções puras, com sua natureza previsível e livre de efeitos colaterais, tornam os testes e a depuração mais simples e eficazes.</p><p>As funções de ordem superior, como .map(), .filter() e .reduce(), não apenas simplificam a manipulação de dados, mas também contribuem para um código mais limpo e expressivo, reduzindo a complexidade e aumentando a legibilidade. A composição de funções, permitindo a criação de operações complexas a partir de funções simples, destaca a elegância e a eficiência da programação funcional.</p><p>Introduzindo a avaliação preguiçosa, abordamos como a computação de expressões pode ser adiada, melhorando a performance e permitindo estruturas de dados potencialmente infinitas. Além disso, ao tratar as funções como valores de primeira classe, JavaScript possibilita um leque ainda mais amplo de técnicas funcionais, como callbacks e composição dinâmica de funções, reforçando a flexibilidade e a expressividade do código.</p><p>No contexto do Node.js, a aplicação desses princípios se revela particularmente poderosa. A capacidade de lidar com operações assíncronas de forma mais controlada e expressiva através de padrões como async/await e Promises é um grande benefício. Além disso, a disponibilidade de bibliotecas como Lodash e Ramda oferece uma vasta gama de ferramentas que facilitam e incentivam a adoção da programação funcional.</p><p>Em resumo, a programação funcional oferece uma abordagem robusta e eficiente para o desenvolvimento de software. Ela promove a escrita de código mais seguro, testável e fácil de entender, características cada vez mais valiosas em um mundo onde a tecnologia e suas aplicações estão constantemente evoluindo. Com a inclusão da avaliação preguiçosa e do tratamento de funções como valores de primeira classe, reforçamos ainda mais a capacidade da programação funcional em melhorar a qualidade das aplicações e enriquecer o conjunto de habilidades dos desenvolvedores.</p><h3>Referências</h3><ol><li>“Functional Programming in JavaScript” por Luis Atencio: Um guia prático que explora os conceitos da programação funcional especificamente no contexto do JavaScript.</li><li>“Programação Funcional com JavaScript.” DevMedia, <a href="https://www.devmedia.com.br/programacao-funcional-com-javascript/34377">https://www.devmedia.com.br/programacao-funcional-com-javascript/34377</a>.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ede5577621a3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Evitando o Caos Assíncrono: Um Guia Descomplicado sobre Callbacks, Promises e Async/Await!]]></title>
            <link>https://medium.com/@mattheus.h.m.s/evitando-o-caos-ass%C3%ADncrono-um-guia-descomplicado-sobre-callbacks-promises-e-async-await-929ac4117db7?source=rss-ac94881bed29------2</link>
            <guid isPermaLink="false">https://medium.com/p/929ac4117db7</guid>
            <category><![CDATA[callback]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[asyncawait]]></category>
            <category><![CDATA[promises]]></category>
            <category><![CDATA[callback-hell]]></category>
            <dc:creator><![CDATA[Matheus Musa]]></dc:creator>
            <pubDate>Mon, 20 Nov 2023 15:40:58 GMT</pubDate>
            <atom:updated>2023-11-20T16:39:09.701Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="No centro da imagem, três placas se erguem acima das paredes do labirinto, cada uma com os rótulos “CALLBACKS”, “PROMISES” e “ASYNC/AWAIT” em letras maiúsculas, indicando diferentes métodos para gerenciar operações assíncronas. As palavras nas placas são claras e legíveis, destacando-se contra o fundo suavizado." src="https://cdn-images-1.medium.com/max/1024/1*nLDFXzz4ZYcELHaqRmLlew.png" /></figure><h3>Introdução</h3><p>Fazendo um paralelo com um fascinante conceito da física quântica: a superposição. Na física quântica, uma partícula pode existir em vários estados ao mesmo tempo até que seja observada. Esse fenômeno é conhecido como superposição. De maneira semelhante, em JavaScript, as operações assíncronas permitem que nosso código continue executando várias tarefas simultaneamente, sem esperar que uma operação termine para iniciar a próxima. Imagine que você pediu uma pizza e, enquanto espera, você lê um livro. No mundo da programação, isso é similar ao que fazemos com operações assíncronas: solicitamos algo (como dados de uma API) e, em vez de ficarmos parados aguardando a resposta, continuamos realizando outras tarefas, como ler um livro. Assim como a partícula quântica que não se limita a um único estado até ser medida, nosso programa não fica bloqueado em uma única tarefa, mantendo-se <strong><em>’em superposição’</em></strong> de atividades.</p><p>Esta abordagem não só torna o uso de recursos mais eficiente, mas também reflete a natureza dinâmica e multifacetada dos ambientes de programação modernos. Ao explorar callbacks, promises e async/await, você estará aprendendo a gerenciar essa ‘superposição’ de tarefas de forma elegante e eficiente, semelhante a um dançarino quântico que se move ao ritmo das probabilidades.</p><h3>O Que São Callbacks?</h3><p>Callbacks são funções que são passadas como argumentos para outras funções e são chamadas de volta para sinalizar a conclusão de uma operação assíncrona. Eles são fundamentais em JavaScript para operações como leituras de arquivo, solicitações de rede ou temporizadores.</p><p>Exemplo Básico de Callback Um exemplo simples é a leitura de arquivos no Node.js:</p><pre>const fs = require(&#39;fs&#39;)<br>fs.readFile(&#39;/caminho/do/arquivo.txt&#39;, &#39;utf8&#39;, (err, data) =&gt; {<br>  if (err) {<br>    console.error(&#39;Erro ao ler o arquivo:&#39;, err);<br>    return;<br>  }<br>  console.log(data);<br>});</pre><p>Neste exemplo, fs.readFile é uma função assíncrona que lê um arquivo. O terceiro argumento é um callback que é chamado quando a leitura do arquivo é concluída ou ocorre um erro.</p><h4>Problemas Comuns com Callbacks:</h4><p>Callback Hell Um dos maiores problemas com o uso de callbacks é o “Callback Hell” ou “Pyramid of Doom”, onde múltiplos callbacks aninhados tornam o código difícil de ler e manter. Por exemplo:</p><pre>fs.readFile(&#39;arquivo1.txt&#39;, &#39;utf8&#39;, (err, data1) =&gt; {<br>  if (err) {<br>    console.error(&#39;Erro:&#39;, err);<br>    return<br>  }<br>  fs.readFile(&#39;arquivo2.txt&#39;, &#39;utf8&#39;, (err, data2) =&gt; {<br>    if (err) {<br>      console.error(&#39;Erro:&#39;, err);<br>      return<br>    }<br>    // Processamento adicional aqui<br>  })<br>})</pre><p>Este código se torna rapidamente confuso e difícil de gerenciar, especialmente com mais níveis de aninhamento.</p><h4>Evitando Callback Hell</h4><p>Uma técnica comum para evitar o Callback Hell é usar funções nomeadas ou modularizar o código em funções separadas. Por exemplo:</p><pre>function lerArquivo1(callback) {<br>  fs.readFile(&#39;arquivo1.txt&#39;, &#39;utf8&#39;, callback);<br>}<br>function lerArquivo2(callback) {<br>  fs.readFile(&#39;arquivo2.txt&#39;, &#39;utf8&#39;, callback);<br>}<br>lerArquivo1((err, data1) =&gt; {<br>  if (err) {<br>    console.error(&#39;Erro:&#39;, err)<br>    return;<br>  }<br>  lerArquivo2((err, data2) =&gt; {<br>    if (err) {<br>      console.error(&#39;Erro:&#39;, err)<br>      return;<br>    }<br>    // Processamento adicional aqui<br>  })<br>})</pre><p>Este padrão ajuda a manter o código mais organizado e legível.</p><p>Comparação com Promises as Promises são uma evolução dos callbacks e oferecem uma maneira mais limpa e menos propensa a erros de lidar com operações assíncronas. Enquanto os callbacks são fundamentais para entender operações assíncronas em JavaScript, as Promises proporcionam uma abordagem mais estruturada e poderosa.</p><h3>Callbacks</h3><h4>Pontos Fortes:</h4><p><strong>1. Simplicidade para Tarefas Simples: </strong>Para operações assíncronas simples, callbacks podem ser uma solução direta e fácil de entender.</p><p><strong>2. Controle Direto: </strong>Callbacks oferecem um controle muito direto sobre o fluxo de execução.</p><p><strong>3. Amplamente Suportados: </strong>Callbacks são suportados em todas as versões de JavaScript e em todos os ambientes, sem necessidade de transpilação ou polyfills.</p><h4>Melhores momentos para usar:</h4><p><strong>1. Operações Assíncronas Simples: </strong>Quando a tarefa assíncrona é direta e não requer encadeamento complexo ou tratamento de erros sofisticado.</p><p><strong>2. Compatibilidade Total: </strong>Em ambientes onde a compatibilidade com versões mais antigas do JavaScript é uma preocupação.</p><p><strong>3. Evitando Overhead de Promises:</strong> Em operações críticas de performance onde o overhead adicional de Promises pode ser um fator.</p><h4>Desvantagens:</h4><p><strong>1. Callback Hell: </strong>Complexidade e dificuldade de manutenção aumentam rapidamente com o aninhamento de callbacks.</p><p><strong>2. Dificuldade no Tratamento de Erros:</strong> O tratamento de erros em callbacks aninhados pode se tornar confuso e propenso a falhas.</p><p><strong>3. Inversão de Controle:</strong> O chamador perde o controle do fluxo de execução para a função que recebe o callback, o que pode levar a problemas como a “inversão de controle”.</p><h4>Considerações de Desempenho:</h4><ul><li><strong>Menos Overhead que Promises: </strong>Callbacks têm menos overhead que Promises, o que pode ser benéfico em operações de alta frequência ou em ambientes com recursos limitados.</li><li><strong>Risco de Bloqueio de Event Loop: </strong>Uso inadequado de callbacks, especialmente em operações síncronas, pode bloquear o loop de eventos e afetar a performance.</li></ul><h3>O Que São Promises?</h3><p>Uma Promise no JavaScript é um objeto que representa a eventual conclusão ou falha de uma operação assíncrona. Ela permite que você escreva código que espera por um valor futuro sem bloquear a execução do programa. Uma Promise está em um destes estados:</p><ul><li><strong>Pending: </strong>Estado inicial, não foi realizada nem rejeitada.</li><li><strong>Fulfilled: </strong>Operação completada com sucesso.</li><li><strong>Rejected: </strong>Operação falhou.</li></ul><h3>Criando uma Promise</h3><p>Para criar uma Promise, usamos o construtor new Promise() com uma função executora.</p><pre>let promessa = new Promise((resolve, reject) =&gt; {<br>    // Código assíncrono aqui<br>    if (/* condição de sucesso */) {<br>        resolve(&#39;Sucesso!&#39;)<br>    } else {<br>        reject(&#39;Erro!&#39;)<br>    }<br>});</pre><h3>Consumindo uma Promise</h3><p>Promises são consumidas usando os métodos .then() e .catch().</p><pre>promessa<br>    .then((valor) =&gt; console.log(valor)) // &#39;Sucesso!&#39;<br>    .catch((erro) =&gt; console.log(erro)) // &#39;Erro!&#39;</pre><h3>Erros Comuns e Dicas</h3><ul><li>Visualização do Fluxo de Promises: Incluir diagramas explicativos pode ser muito útil para entender o fluxo de controle das Promises.</li><li>Evitando Erros Comuns: Como esquecer de retornar uma nova Promise, não lidar com erros ou criar “Promises penduradas”.</li><li>Comparação com Callbacks: Mostre como as Promises simplificam código em comparação com callbacks, evitando o “Callback Hell”.</li><li>Usando .finally(): Este método é útil para lógica de limpeza, executado independentemente do resultado da Promise.</li><li>Promises e o Event Loop: Explicação de como as Promises interagem com o Event Loop em JavaScript.</li><li>Padrões de Projeto: Discussão sobre padrões como “Promise Chaining” e como evitar a “Pyramid of Doom”.</li><li>Tratamento de Exceções: Como lidar com exceções em funções assíncronas e evitar rejeições não tratadas.</li><li>Debugging de Promises: Técnicas e ferramentas para depurar Promises.</li><li>Desempenho: O impacto no desempenho ao usar Promises e práticas recomendadas.</li><li>Atualizações do ES6+: Novidades do ECMAScript que afetam o uso de Promises.</li><li>Bibliotecas Externas: Como bibliotecas como Bluebird podem expandir a funcionalidade das Promises.</li></ul><h3>Exemplo Prático: HTTP Requests com Fetch</h3><pre>fetch(&#39;https://api.exemplo.com/dados&#39;)<br>    .then(response =&gt; response.json())<br>    .then(data =&gt; console.log(data))<br>    .catch(error =&gt; console.error(&#39;Erro na requisição:&#39;, error))</pre><h3>Encadeamento de Promises</h3><pre>let promessa = new Promise((resolve, reject) =&gt; {<br>    setTimeout(() =&gt; resolve(1), 1000)<br>})<br>promessa<br>    .then(valor =&gt; valor * 2)<br>    .then(valor =&gt; valor * 2)<br>    .then(valor =&gt; console.log(valor)) // 4</pre><h3>Promise.all</h3><pre>Promise.all([promessa1, promessa2, promessa3])<br>    .then(valores =&gt; console.log(valores))<br>    .catch(erro =&gt; console.error(erro))</pre><h3>Promises</h3><h4>Pontos Fortes:</h4><p><strong>1. Encadeamento Simples:</strong> As Promises permitem um encadeamento claro de operações assíncronas usando .then(), evitando a complexidade dos callbacks aninhados.</p><p><strong>2. Tratamento de Erros Centralizado:</strong> Com .catch(), as Promises proporcionam um ponto único para capturar erros, tornando o manejo de exceções mais simples e eficaz.</p><p><strong>3. Composição e Agregação:</strong> Operações como Promise.all() permitem a execução paralela e a agregação de múltiplas Promises, facilitando o trabalho com várias operações assíncronas.</p><h4>Melhores momentos para usar:</h4><p><strong>1. Operações Assíncronas Encadeadas:</strong> Quando diversas tarefas assíncronas precisam ser executadas em sequência, com cada uma dependendo do resultado da anterior.</p><p><strong>2. Controle de Fluxo Complexo:</strong> Em cenários onde é necessário um maior controle sobre o fluxo de execução e tratamento de erros em operações assíncronas.</p><p><strong>3. Execução Paralela de Tarefas: </strong>Quando várias tarefas assíncronas podem ser executadas em paralelo e você precisa aguardar a conclusão de todas elas.</p><h4>Desvantagens:</h4><p><strong>1. Curva de Aprendizado:</strong> Para quem está começando, o conceito de Promises e seu fluxo de controle pode ser um pouco complexo.</p><p><strong>2.Excesso de Encadeamento: </strong>Promise chaining pode se tornar complicado em cenários com muitas operações encadeadas.</p><p><strong>3. Erros Silenciosos:</strong> Se um erro não é capturado corretamente com um .catch(), ele pode passar despercebido.</p><h4>Considerações de Desempenho:</h4><ul><li><strong>Memória e Overhead: </strong>Cada Promise cria um objeto, o que pode levar a um uso aumentado de memória e overhead, especialmente em grandes quantidades ou em loops intensivos.</li></ul><h3>Async/Await</h3><p>Ao se deparar com a programação assíncrona, especialmente no JavaScript, é fácil se sentir sobrecarregado. No entanto, <em>`async/await`</em> é uma ferramenta que torna essa experiência muito mais gerenciável e compreensível, principalmente para quem está começando. Vamos mergulhar um pouco mais fundo.</p><h4>Como funciona:</h4><p>A melhor maneira de pensar no <em>`async/await`</em> é considerá-lo como uma maneira de fazer o código assíncrono parecer e comportar-se de forma síncrona. Quando você coloca a palavra-chave <em>`await`</em> antes de uma operação assíncrona, está basicamente dizendo ao JavaScript: “Espere até que isso esteja pronto antes de prosseguir”.</p><p>O <em>`async`</em> indica que uma função retornará uma promise. Mesmo que você retorne um valor que não seja uma promise, ele será envolto em uma promise automaticamente.</p><h3>Buscando dados de uma API</h3><p>Suponha que você queira buscar dados de uma API externa. A função `fetch<em>` </em>retorna uma promise, tornando-a perfeita para demonstrar o uso de <em>`async/await`</em>.</p><pre>async function buscarDadosAPI(url) {<br>    try {<br>        let resposta = await fetch(url)<br>        let dados = await resposta.json()<br>        console.log(dados);<br>    } catch (erro) {<br>        console.error(&#39;Erro ao buscar dados:&#39;, erro)<br>    }<br>}<br>buscarDadosAPI(&#39;https://api.exemplo.com/items&#39;)</pre><p>Neste exemplo, a resposta da API é esperada e convertida em JSON. Se houver algum erro durante esse processo, ele será capturado pelo bloco `catch`.</p><h3>Esperando múltiplas promises</h3><p>Se tivermos várias operações assíncronas que podem ser executadas em paralelo, podemos usar <em>`Promise.all()`</em> junto com <em>`async/await`</em>.</p><pre>async function obterMúltiplosDados(urls) {<br>    try {<br>        let respostas = await Promise.all(urls.map(url =&gt; fetch(url)))<br>        let dados = await Promise.all(respostas.map(resposta =&gt; resposta.json()))<br>        return dados<br>    } catch (erro) {<br>        console.error(&#39;Erro ao obter dados:&#39;, erro)<br>    }<br>}<br>const urls = [&#39;https://api.exemplo.com/item1&#39;, &#39;https://api.exemplo.com/item2&#39;]<br>obterMúltiplosDados(urls).then(dados =&gt; console.log(dados))</pre><h3>Simulando um atraso</h3><p>Podemos usar <em>`setTimeout`</em> com <em>`async/await`</em> para simular operações que demoram mais tempo.</p><pre>function esperar(ms) {<br>    return new Promise(resolve =&gt; setTimeout(resolve, ms));<br>}<br><br>async function operacaoDemorada() {<br>    console.log(&#39;Iniciando operação...&#39;);<br>    await esperar(2000); // Espera 2 segundos<br>    console.log(&#39;Operação concluída!&#39;);<br>}<br>operacaoDemorada();</pre><p>Neste exemplo, vemos claramente como o <em>`async/await`</em> torna o código muito mais legível, mesmo que estejamos lidando com uma operação assíncrona.</p><h3>Trabalhando com armazenamento assíncrono</h3><p>Muitos ambientes, como navegadores e aplicativos Node.js, oferecem formas de armazenamento assíncrono. Aqui está um exemplo simplificado usando uma abordagem similar:</p><pre>async function salvarNoBancoDeDados(item) {<br>    try {<br>        let resultado = await db.salvar(item);<br>        console.log(&#39;Item salvo com sucesso!&#39;, resultado);<br>    } catch (erro) {<br>        console.error(&#39;Erro ao salvar:&#39;, erro);<br>    }<br>}<br>let meuItem = { nome: &quot;Exemplo&quot;, valor: 42 };<br>salvarNoBancoDeDados(meuItem);</pre><h3>Encadeando operações assíncronas</h3><p>Às vezes, pode ser necessário encadear operações assíncronas, onde o resultado de uma operação é usado na próxima. Isso é facilmente alcançado com <em>`async/await`</em>.</p><pre>async function encadeandoOperações(id) {<br>    try {<br>        let usuario = await buscarDadosAPI(`https://api.exemplo.com/usuarios/${id}`);<br>        let posts = await buscarDadosAPI(`https://api.exemplo.com/usuarios/${usuario.id}/posts`);<br>        console.log(`O usuário ${usuario.nome} tem ${posts.length} posts.`);<br>    } catch (erro) {<br>        console.error(&#39;Erro:&#39;, erro);<br>    }<br>}<br>encadeandoOperações(1);</pre><p>No exemplo acima, obtemos detalhes de um usuário e, em seguida, usamos o ID desse usuário para buscar seus posts.</p><h3>Erros Comuns e Dicas</h3><ul><li>Não usar `<em>await`</em> com funções assíncronas: Um erro comum é esquecer de usar `<em>await`</em> ao chamar uma função assíncrona. Isso fará com que a função prossiga sem esperar, resultando em comportamentos inesperados.</li><li>Uso excessivo de <em>`async/await`</em>: Enquanto <em>`async/await`</em> torna o código mais limpo, não é necessário para todas as funções assíncronas, especialmente aquelas que não têm operações que requerem espera.</li><li>Erro ao lidar com exceções: Sempre envolva chamadas `<em>await`</em> com blocos <em>`try/catch`</em> para lidar com possíveis erros.</li></ul><h3>O Conceito de async/await em Ciclos</h3><p>Uma das características úteis do <em>`async/await`</em> é sua capacidade de ser usado dentro de loops. Suponha que você queira processar uma série de itens assincronamente:</p><pre>async function processarItens(itens) {<br>    for (let item of itens) {<br>        let resultado = await algumaFuncaoAssincrona(item);<br>        console.log(resultado);<br>    }<br>}<br>processarItens([1, 2, 3, 4]);</pre><p>Neste exemplo, cada item é processado sequencialmente. No entanto, é crucial notar que isso pode não ser eficiente se a ordem do processamento não importar. Em tais casos, usar <em>`Promise.all()`</em> pode ser uma escolha melhor.</p><h4>Pontos Fortes:</h4><p><strong>1. Legibilidade:</strong> O uso de <em>`async/await`</em> torna o código assíncrono muito mais legível. Não há mais necessidade de encadear `.then()` ou lidar com callbacks aninhados.</p><p><strong>2. Tratamento de Erros: </strong><em>`async/await`</em> permite usar a estrutura<em> `try/catch`</em>, que é uma forma familiar de lidar com erros para muitos desenvolvedores.</p><p><strong>3. Fluxo de Controle Simplificado:</strong> Juntamente com outras construções como loops e condicionais, você pode usar <em>`async/await`</em> sem se preocupar em encadear ou aninhar funções.</p><h4>Melhores momentos para usar:</h4><p><strong>1. Múltiplas Operações Assíncronas Sequenciais:</strong> Se você precisa realizar várias tarefas assíncronas uma após a outra e cada tarefa depende do resultado da anterior, <em>`async/await`</em> torna isso muito mais claro.</p><p><strong>2. Combinação de Síncrono e Assíncrono:</strong> Se você tem um mix de operações síncronas e assíncronas e quer que elas sejam executadas em uma ordem específica, `async/await` pode ser uma solução perfeita.</p><p><strong>3. Quando o Tratamento de Erros é Crucial:</strong> Se a maneira como você lida com os erros é crítica para a sua aplicação, a clareza do <em>`try/catch`</em> com <em>`async/await`</em> é inestimável.</p><h4>Desvantagens:</h4><p><strong>1. Performance:</strong> Em algumas situações, usar <em>`async/await` </em>pode não ser a opção mais performática, especialmente se as operações assíncronas não dependem uma da outra. Em tais casos, usar <em>`Promise.all()`</em> pode ser mais eficiente.</p><p><strong>2. Complexidade Potencial: </strong>Para iniciantes, pode ser um pouco confuso no começo entender que mesmo funções <em>`async`</em> que não têm <em>`await`</em> ainda retornam promises.</p><p><strong>3. Compatibilidade:</strong> Enquanto a maioria dos ambientes modernos suporta <em>`async/await`</em>, ainda pode haver situações ou plataformas mais antigas onde essa sintaxe não é suportada. Embora existam transpiladores como Babel para contornar isso, ainda é uma consideração a ter em mente.</p><h4>Considerações de Desempenho ao Usar async/await</h4><h4>Overhead de Runtime:</h4><ul><li>Cada função async adiciona um pequeno overhead de runtime, pois transforma o código em uma máquina de estados por baixo dos panos.</li><li>Isso pode ser insignificante para aplicativos menores ou operações que não são chamadas frequentemente, mas em loops intensivos ou em operações de alta frequência, pode ser notável.</li></ul><h4>Consumo de Memória:</h4><ul><li>As funções async podem levar a um maior uso de memória, pois cada chamada de função async retorna uma promise, e cada await pode adicionar um frame ao stack de chamadas, o que pode aumentar o consumo de memória.</li></ul><h4>Bloqueio de Loop de Eventos:</h4><ul><li>O uso impróprio do await pode levar ao bloqueio do loop de eventos se uma operação síncrona pesada for realizada entre os awaits, o que pode afetar a performance geral da aplicação.</li></ul><p>O <em>`async/await`</em> não é apenas uma característica de sintaxe, mas uma abordagem fundamentalmente nova para lidar com operações assíncronas em JavaScript. Para os iniciantes, ele elimina muitas das confusões associadas às promises e callbacks, apresentando uma forma linear e compreensível de entender o fluxo assíncrono.</p><p>No entanto, como em todas as técnicas e recursos, é crucial usá-lo com discernimento. Sempre pense sobre a real necessidade de sequencialidade em suas operações assíncronas e considere se há uma abordagem mais eficiente.</p><h3>Conclusão Geral: Callbacks, Promises e Async/Await em JavaScript</h3><p>Callbacks, Promises e Async/Await são ferramentas fundamentais em JavaScript para lidar com operações assíncronas. Cada uma delas oferece diferentes níveis de abstração e facilidades, adequadas para diferentes cenários de programação assíncrona.</p><p>Callbacks são a forma mais básica de manipulação assíncrona em JavaScript. Eles são simples, diretos e suportados universalmente, mas podem rapidamente levar ao complexo e difícil de manter “Callback Hell”. São mais adequados para operações assíncronas simples e quando a compatibilidade com ambientes mais antigos é uma preocupação.</p><p>Promises representam uma evolução em relação aos callbacks, fornecendo uma abstração mais poderosa e flexível. Elas permitem um encadeamento mais claro e um tratamento de erros mais centralizado, facilitando a leitura e a manutenção do código. Promises são ideais para fluxos de controle mais complexos e quando várias operações assíncronas precisam ser coordenadas ou executadas em paralelo.</p><p>Async/Await, construído sobre Promises, eleva a legibilidade e a simplicidade do código assíncrono a um novo patamar. Ele permite escrever código assíncrono que se parece e se comporta mais como código síncrono, tornando-o mais fácil de entender e manter. Async/Await é particularmente útil quando se lida com múltiplas operações assíncronas sequenciais e em cenários onde o tratamento de erros e a clareza do fluxo de controle são críticos.</p><h4>Comparação e Escolha:</h4><ul><li><strong>Complexidade vs. Simplicidade: </strong>Callbacks são simples mas podem se tornar complexos em operações aninhadas, enquanto Promises e Async/Await oferecem uma abordagem mais gerenciável para complexidades crescentes.</li><li><strong>Legibilidade:</strong> Async/Await ganha em termos de legibilidade e simplicidade, especialmente para desenvolvedores menos familiarizados com as peculiaridades das operações assíncronas.</li><li><strong>Performance:</strong> Callbacks têm menos overhead em comparação com Promises e Async/Await, o que pode ser um fator decisivo em ambientes de alto desempenho ou com recursos limitados.</li><li><strong>Compatibilidade:</strong> Callbacks são universais, mas Async/Await e algumas funcionalidades de Promises podem exigir transpilação para suporte em navegadores mais antigos.</li></ul><p><strong>Conclusão:</strong> Ao desenvolver em JavaScript, a escolha entre callbacks, promises e async/await deve ser guiada pelo contexto específico do projeto, a necessidade de legibilidade e manutenção do código, a complexidade das operações assíncronas envolvidas, e as considerações de desempenho e compatibilidade. Entender as forças e limitações de cada abordagem é essencial para escrever código assíncrono eficiente e sustentável em JavaScript.</p><p>Para criar uma seção de referências para o seu artigo, podemos listar fontes que abordam os conceitos de callbacks, promises, e async/await em JavaScript, assim como a analogia com a física quântica. Aqui estão algumas sugestões:</p><h3>Referências</h3><ol><li>Flanagan, D. (2020). <em>JavaScript: The Definitive Guide</em>. O’Reilly Media.</li><li><a href="https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous">MDN Web Docs. (2023). <em>Asynchronous Programming </em>. Mozilla.</a></li><li>Feynman, R. P. (2011). <em>QED: The Strange Theory of Light and Matter</em>. Princeton University Press.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=929ac4117db7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[De Array para Set e Volta: Uma Jornada Sem ou Com Duplicatas!]]></title>
            <link>https://medium.com/@mattheus.h.m.s/de-array-para-set-e-volta-uma-jornada-sem-ou-com-duplicatas-3997b349c84b?source=rss-ac94881bed29------2</link>
            <guid isPermaLink="false">https://medium.com/p/3997b349c84b</guid>
            <category><![CDATA[helping-others]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[teaching]]></category>
            <category><![CDATA[arrays]]></category>
            <dc:creator><![CDATA[Matheus Musa]]></dc:creator>
            <pubDate>Wed, 25 Oct 2023 15:53:54 GMT</pubDate>
            <atom:updated>2023-10-27T14:05:36.258Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6binf2o6tR_2n_JOKo0XNg.png" /></figure><h4>Introdução</h4><p>Tanto Set quanto Array são estruturas de dados essenciais em JavaScript e TypeScript, permitindo que os desenvolvedores manipulem coleções de elementos. Embora possam parecer semelhantes à primeira vista, eles têm diferenças cruciais e usos otimizados. A escolha entre eles pode influenciar tanto a performance quanto a clareza do código.</p><h4>O Básico</h4><p>Set:</p><ul><li>Descrição: É uma coleção de valores onde cada valor deve ser único.</li><li>Características Principais:</li><li>Valores únicos.</li><li>Inserção e remoção eficientes.</li><li>Verificação de existência rápida.</li></ul><p>Array:</p><ul><li>Descrição: Estrutura de dados linear que pode conter vários elementos, incluindo duplicatas.</li><li>Características Principais:</li><li>Pode conter valores duplicados.</li><li>Acesso direto aos elementos via índice.</li><li>Uma vasta gama de métodos para manipulação.</li></ul><h3>Velocidade de Consulta: Set vs Array</h3><p>Uma das diferenças mais cruciais entre Set e Array é a eficiência ao verificar a existência de um item.</p><h4>Set:</h4><ul><li>A principal vantagem do Set é sua velocidade de consulta. Internamente, Set é implementado como uma estrutura de dados de tabela hash. Isso significa que quando você verifica se um item existe no Set usando o método has(), o JavaScript pode localizar esse item extremamente rápido, quase em tempo constante. Por exemplo:</li></ul><pre>let mySet = new Set([&quot;apple&quot;, &quot;banana&quot;, &quot;cherry&quot;]); console.log(mySet.has(&quot;banana&quot;));  // Isso é super rápido!</pre><ul><li>Essa eficiência é especialmente notável quando trabalhamos com grandes conjuntos de dados. Se você tem um Set com milhões de itens e deseja verificar se um determinado item existe, o Set pode fazer isso muito mais rápido do que um Array.</li></ul><h4>Array:</h4><ul><li>Quando você tenta verificar a existência de um item em um Array, o JavaScript precisa percorrer potencialmente cada item do Array até encontrar o que está procurando (ou não). Isso é conhecido como uma busca linear e, em casos de pior cenário (por exemplo, o item não existe no Array), pode ser bastante lento. Por exemplo:</li></ul><pre>let myArray = [&quot;apple&quot;, &quot;banana&quot;, &quot;cherry&quot;]; console.log(myArray.includes(&quot;banana&quot;));  // Isso pode ser mais lento, especialmente para grandes arrays.</pre><h3>Adicionando Elementos</h3><h3>No Set:</h3><p>Ao usar add, você garante que cada valor seja único. Se você tentar adicionar um item já existente, ele não fará nada, mantendo a integridade do Set.</p><pre>let colorsSet = new Set();<br>colorsSet.add(&quot;red&quot;);<br>colorsSet.add(&quot;blue&quot;);<br>colorsSet.add(&quot;red&quot;); // &quot;red&quot; permanece único no Set.</pre><h3>No Array:</h3><p>Com push, você simplesmente adiciona um elemento ao final.</p><pre>let colorsArray = [];<br>colorsArray.push(&quot;red&quot;);<br>colorsArray.push(&quot;blue&quot;);<br>colorsArray.push(&quot;red&quot;); // Duplicatas são permitidas.</pre><h3>Verificar o Tamanho</h3><h3>No Set:</h3><p>Verificar o tamanho do Set é feito através da propriedade size.</p><pre>console.log(colorsSet.size);  // Exibe o número de elementos no Set.</pre><h3>No Array:</h3><p>Verificar o tamanho de um Array é feito através da propriedade length.</p><pre>console.log(colorsArray.length);  // Exibe o número de elementos no Array.</pre><h3>Esclarecimento sobre a Ordem</h3><h3>No Set:</h3><p>Set mantém a ordem de inserção dos elementos. O primeiro valor que você adicionar será o primeiro a ser retornado durante a iteração.</p><h3>No Array:</h3><p>A ordem em um Array é mantida pelo índice. O índice inicial é 0, e cada novo elemento adicionado aumenta o índice.</p><h3>Limpar Todos os Elementos</h3><h3>No Set:</h3><p>Para limpar todos os elementos de um Set, use o método clear.</p><pre>colorsSet.clear();</pre><p><strong>No Array:</strong></p><p>Para limpar todos os elementos de um Array, você pode simplesmente definir seu length como 0.</p><pre>colorsArray.length = 0;</pre><h3>Cenários Adicionais de Uso</h3><h3>Ordenação:</h3><p>Set não tem um método de ordenação direta. Para ordenar um Set, os desenvolvedores geralmente convertem em um Array, usam o método sort() e, se necessário, convertem de volta para um Set.</p><pre>let sortedSet = new Set([...colorsSet].sort());</pre><p>Por outro lado, o Array tem um método de ordenação embutido.</p><pre>colorsArray.sort();</pre><h3><strong>Pesquisa Avançada:</strong></h3><p>Enquanto Set é otimizado para verificações de existência, o Array oferece mais flexibilidade em pesquisas avançadas, como encontrar um objeto com base em propriedades específicas usando find() ou filtrar uma coleção de itens com base em critérios específicos usando filter().</p><h3>Removendo Elementos</h3><h3>No Set:</h3><p>A remoção é direta, pois você remove com base no valor.</p><pre>colorsSet.delete(&quot;red&quot;);</pre><h3>No Array:</h3><p>Para remover, geralmente utilizamos filter ou outras funções.</p><pre>colorsArray = colorsArray.filter(color =&gt; color !== &quot;red&quot;);</pre><h3>Iteração</h3><h3>No Set:</h3><p>A iteração é simples e percorre cada elemento.</p><pre>colorsSet.forEach(color =&gt; console.log(color));</pre><h3>No Array:</h3><p>Similar ao Set, mas com acesso direto ao índice também.</p><pre>colorsArray.forEach((color, index) =&gt; console.log(`Index: ${index}, Color: ${color}`));</pre><h3>Transformação</h3><h3>No Set:</h3><p>Não possui um método direto de transformação. Isso é uma das razões pela qual os desenvolvedores frequentemente convertem Sets para Arrays, fazem as transformações desejadas no Array e depois, se necessário, convertem de volta para um Set.</p><pre>let capitalizedColorsSet = new Set([...colorsSet].map(color =&gt; color.toUpperCase()));</pre><h3>No Array:</h3><p>Arrays possuem o método map diretamente.</p><pre>let capitalizedColorsArray = colorsArray.map(color =&gt; color.toUpperCase());</pre><h3>Cenários de Uso Recomendados</h3><p><strong>Remoção de Duplicatas</strong>: Set é ideal devido à sua garantia de unicidade.</p><pre>const numbers = [1, 2, 2, 3, 3]; const unique = [...new Set(numbers)];</pre><p><strong>Verificações Rápidas de Existência</strong>: Com a eficiência de Set e o método has, verificações são rápidas.</p><pre>if (colorsSet.has(&quot;blue&quot;)) { console.log(&quot;Blue exists in the Set!&quot;); }</pre><p><strong>Transformações Frequentes e Complexas</strong>: Arrays, com sua vasta gama de métodos integrados, são ideais para transformações.</p><pre>const squaredNumbers = [1, 2, 3].map(num =&gt; num * num);</pre><p><strong>Quando a Duplicidade é Necessária: </strong>Arrays permitem armazenar valores repetidos, o que é útil em cenários como registros de votos, logs de ação do usuário ou históricos de transações.</p><h3>Conclusão</h3><p>Ao final desta exploração entre Set e Array, esperamos que alguns pontos-chave estejam claros:</p><p><strong>Unicidade vs Duplicidade:</strong></p><ul><li>Use Set quando você precisa garantir que cada item seja único.</li><li>Use Array quando a duplicidade é aceitável ou desejada.</li></ul><p><strong>Eficiência de Consulta:</strong></p><ul><li>Para verificações rápidas de existência, especialmente em grandes conjuntos de dados, o Set é o vencedor claro. No entanto, se você precisar de operações mais complexas, como mapeamento, filtragem ou redução, o Array oferece uma ampla variedade de métodos embutidos..</li></ul><p><strong>Manipulação de Dados:</strong></p><ul><li>Array é a escolha para transformações mais complexas devido à sua vasta gama de métodos integrados, como map, filter e reduce.</li></ul><p><strong>Flexibilidade</strong></p><ul><li>Lembre-se de que você pode facilmente converter entre Set e Array usando técnicas de espalhamento (...), o que oferece muita flexibilidade no manuseio de coleções de dados.</li></ul><p><strong><em>Dica Didática:</em></strong> A escolha entre Set e Array muitas vezes não é preto no branco. A decisão pode depender do problema específico, dos dados e das operações necessárias. Portanto, encorajamos você a experimentar ambas as opções e a medir a performance em cenários do mundo real. Lembre-se de que a melhor maneira de internalizar esses conceitos é através da prática. Crie pequenos exemplos, teste os métodos discutidos e observe o comportamento de Set e Array em diferentes cenários.</p><p>Lembre-se: A escolha da ferramenta certa para o trabalho não só melhora a eficiência do seu código, mas também sua clareza e manutenibilidade. Feliz codificação!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3997b349c84b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GraphQL Code Generator na Aplicação BFF com Apollo]]></title>
            <link>https://medium.com/@mattheus.h.m.s/graphql-code-generator-na-aplica%C3%A7%C3%A3o-bff-com-apollo-cc1d4fd3da19?source=rss-ac94881bed29------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc1d4fd3da19</guid>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[apollo]]></category>
            <category><![CDATA[bff]]></category>
            <dc:creator><![CDATA[Matheus Musa]]></dc:creator>
            <pubDate>Tue, 01 Aug 2023 21:07:04 GMT</pubDate>
            <atom:updated>2023-08-01T21:07:04.074Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3e03Mz3kWZgarBmPeWkwww.png" /></figure><h3>Introdução</h3><p>A adoção do GraphQL como camada de comunicação entre frontend e backend tem ganhado destaque na comunidade de desenvolvimento de software. A flexibilidade e a eficiência do GraphQL permitem que os desenvolvedores obtenham apenas os dados necessários, além de possibilitar o trabalho em equipes independentes e a evolução ágil do esquema por isso no BFF que estamos desenvolvendo adotamos o uso do GraphQL Apollo. Neste contexto, tinha-mos alguns problemas com algumas divergências e para isso adotamos também o uso do <strong><em>GraphQL Code Generator (Code-Gen), </em></strong>o mesmo se destaca como uma ferramenta poderosa para gerar código automaticamente a partir das definições de esquema GraphQL e consultas. Neste artigo, exploraremos as vantagens do uso do GraphQL Code Generator em uma aplicação BFF Apollo, apresentando exemplos práticos para ilustrar cada benefício.</p><h4>Tipagem forte para segurança e prevenção de erros</h4><p>Uma das principais vantagens do GraphQL Code Generator é a geração automática de tipos TypeScript a partir das definições de esquema GraphQL. Isso proporciona tipagem forte em toda a aplicação, evitando erros de digitação e reduzindo erros relacionados a tipos em tempo de execução. Por exemplo, considerando uma consulta GraphQL simples em um aplicativo de lista de tarefas:</p><pre>query {<br> tasks {<br> id<br> title<br> completed<br> }<br>}</pre><p>Com o GraphQL Code Generator, podemos gerar automaticamente os tipos TypeScript correspondentes:</p><pre>interface Task {<br> id: string;<br> title: string;<br> completed: boolean;<br>}</pre><p>Ao utilizar essa tipagem forte, o TypeScript nos ajuda a evitar erros de acesso a campos inexistentes ou mal interpretados, proporcionando maior segurança e qualidade ao código.</p><h4>Redução de erros e manutenção simplificada</h4><p>A tipagem forte fornecida pelo GraphQL Code Generator também reduz a possibilidade de erros relacionados a tipos durante o desenvolvimento e a manutenção contínua. Por exemplo, se um novo campo for adicionado ao esquema GraphQL:</p><pre>type Task {<br> id: ID!<br> title: String!<br> completed: Boolean!<br> priority: Int<br>}</pre><p>O GraphQL Code Generator atualizará automaticamente os tipos TypeScript correspondentes:</p><pre>interface Task {<br> id: string;<br> title: string;<br> completed: boolean;<br> priority?: number | null;<br>}</pre><p>Essa geração automática elimina a necessidade de escrever manualmente a mutação e garante que a sintaxe esteja correta.</p><h4>Melhoria na produtividade e autonomia das equipes</h4><p>O GraphQL Code Generator reduz o esforço necessário para escrever consultas, mutações e tipagem manualmente. Isso aumenta a produtividade dos desenvolvedores, permitindo que se concentrem em implementar recursos e melhorias.</p><p>Por exemplo, suponha que precisemos executar a seguinte mutação GraphQL:</p><pre>mutation CreateTask($title: String!, $completed: Boolean!) {<br> createTask(title: $title, completed: $completed) {<br> id<br> title<br> completed<br> }<br>}</pre><p>O GraphQL Code Generator pode gerar automaticamente uma função JavaScript ou TypeScript para a mutação:</p><pre>import { gql } from &#39;@apollo/client&#39;;<br>export const CREATE_TASK = gql`<br> mutation CreateTask($title: String!, $completed: Boolean!) {<br> createTask(title: $title, completed: $completed) {<br> id<br> title<br> completed<br> }<br> }<br>`</pre><p>Essa geração automática elimina a necessidade de escrever manualmente a mutação e garante que a sintaxe esteja correta.</p><h4>Documentação viva e coerente</h4><p>Outra vantagem do GraphQL Code Generator é que ele incorpora os comentários da definição de esquema no código gerado. Isso torna a documentação sempre atualizada e ajuda os desenvolvedores a entenderem os campos disponíveis nas consultas, mutações e tipos. A documentação viva proporcionada pelo Code-Gen promove uma compreensão mais clara do esquema GraphQL, aumentando a produtividade do desenvolvimento.</p><h4>Integração com IDE e refatoração simplificada</h4><p>A geração de tipos TypeScript pelo GraphQL Code Generator permite recursos avançados em editores de código, como auto-completar, sugestões e validações em tempo real. Isso aprimora a experiência do desenvolvedor e evita erros antes mesmo deles acontecerem.</p><p>Além disso, o Code-Gen simplifica a refatoração do esquema GraphQL. Se houver alterações no esquema, como renomear ou remover campos, o GraphQL Code Generator atualiza automaticamente os tipos e consultas gerados, garantindo que o código continue funcionando conforme o esperado.</p><h4>Redução de erros na integração front BFF com o GraphQL Code Generator</h4><p>A integração entre o frontend e o Backend For Frontend (BFF) é uma etapa crítica no desenvolvimento de aplicativos modernos. Muitas vezes, essa comunicação é feita por meio de chamadas de API REST, o que pode levar a problemas como sobrecarga de dados e falta de controle granular sobre os dados recebidos. No entanto, com o uso do GraphQL como camada de comunicação, esses problemas são minimizados, e o GraphQL Code Generator amplia ainda mais os benefícios, reduzindo significativamente os erros na integração front BFF.</p><h4>Instalação e Configuração do GraphQL Code Generator</h4><p>Para começar a utilizar o GraphQL Code Generator em sua aplicação BFF Apollo, siga os passos abaixo:</p><p><strong>Passo 1:</strong> Instale o pacote do GraphQL Code Generator via npm ou yarn em seu projeto:</p><pre>npm install graphql-code-generator - save-dev<br># ou<br>yarn add graphql-code-generator - dev</pre><p><strong>Passo 2:</strong> Crie um arquivo de configuração para o GraphQL Code Generator em seu projeto, por exemplo, <strong><em>codegen.yml</em></strong>. Neste arquivo, você pode especificar as definições de esquema GraphQL e as opções de geração de código.</p><p>Exemplo de arquivo <strong><em>codegen.yml</em></strong>:</p><pre>schema: path/to/schema.graphql<br>documents: &quot;src/**/*.graphql&quot;<br>generates:<br> path/to/output.ts:<br> plugins:<br> - typescript<br> - typescript-operations<br> - typescript-react-apollo</pre><p><strong>Passo 3: </strong>Adicione as definições de esquema GraphQL em um arquivo, por exemplo, <strong><em>schema.graphql</em></strong>. Esse arquivo deve conter todas as definições de tipos, queries e mutations usadas em sua aplicação.</p><p>Exemplo de <strong><em>schema.graphql</em></strong>:</p><pre>type Task {<br> id: ID!<br> title: String!<br> completed: Boolean!<br> priority: Int<br>}<br>type Query {<br> tasks: [Task!]!<br>}<br>type Mutation {<br> createTask(title: String!, completed: Boolean!): Task!<br>}</pre><p><strong>Passo 4:</strong> Execute o comando para gerar os tipos e código automaticamente com o GraphQL Code Generator:</p><pre>npx graphql-codegen<br># ou<br>yarn graphql-codegen</pre><p>Após seguir esses passos, o GraphQL Code Generator irá ler as definições de esquema GraphQL e as consultas/mutações contidas nos arquivos especificados, gerando os tipos TypeScript e os arquivos de código correspondentes. Esses arquivos gerados serão configurados de acordo com as opções escolhidas no arquivo <strong><em>codegen.yml</em></strong>.</p><p>A partir de então, você poderá utilizar os tipos TypeScript gerados e os arquivos de código em sua aplicação BFF Apollo, aproveitando os benefícios da tipagem forte e da documentação incorporada para melhorar a produtividade e a qualidade do desenvolvimento. Certifique-se de manter o arquivo de configuração (<strong><em>codegen.yml</em></strong>) e as definições de esquema (<strong><em>schema.graphql</em></strong>) atualizados conforme a evolução de sua aplicação.</p><p>Com isso, você estará pronto para aproveitar todas as vantagens do GraphQL Code Generator em seu projeto!</p><h4>Conclusão</h4><p>O GraphQL Code Generator é uma ferramenta valiosa para aumentar a produtividade, melhorar a qualidade do código e facilitar a manutenção em aplicações BFF Apollo. Com a geração automática de tipos TypeScript, os desenvolvedores podem obter benefícios como tipagem forte, detecção de erros em tempo de compilação e uma documentação sempre atualizada. Além disso, a refatoração se torna mais segura e a integração com o IDE proporciona uma experiência de desenvolvimento mais eficiente. Ao incorporar o GraphQL Code Generator em seu fluxo de trabalho, as equipes de desenvolvimento podem aproveitar essas vantagens para construir aplicativos mais robustos e escaláveis, ao mesmo tempo que promovem a adoção de melhores práticas em toda a organização. A redução de erros na integração front BFF com o uso do GraphQL Code Generator proporciona maior segurança, consistência e confiabilidade na comunicação entre frontend e backend, resultando em uma experiência de usuário aprimorada e um desenvolvimento mais ágil e eficiente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc1d4fd3da19" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introdução ao Prisma ORM]]></title>
            <link>https://medium.com/@mattheus.h.m.s/introdu%C3%A7%C3%A3o-ao-prisma-orm-81fd6784c10c?source=rss-ac94881bed29------2</link>
            <guid isPermaLink="false">https://medium.com/p/81fd6784c10c</guid>
            <category><![CDATA[prisma-orm]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[postgres]]></category>
            <category><![CDATA[prisma]]></category>
            <dc:creator><![CDATA[Matheus Musa]]></dc:creator>
            <pubDate>Mon, 03 Jul 2023 01:00:39 GMT</pubDate>
            <atom:updated>2023-07-03T01:00:39.289Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CU3bckEA_kAhUj7kcSvC3w.jpeg" /></figure><p>Acho que vale salientar que não estamos falando do prisma objeto superfícies planas, polidas e transparentes, utilizado por Newton para demonstrar fenômenos óticos como refração e disperção luminosa, no caso estamos falando Prisma ORM um Object-Relational Mapping moderno e de alto desempenho que simplifica a interação com bancos de dados em aplicativos TypeScript. Ao utilizar o Prisma em conjunto com o TypeScript, você obtém uma combinação poderosa que oferece benefícios adicionais e potencializa o desenvolvimento de aplicativos com banco de dados. Neste artigo, vamos explorar de forma mais completa como utilizar o Prisma com o TypeScript e o PostgreSQL, fornecendo exemplos práticos para ilustrar seu uso e descrevendo o potencial dessa união. Também faremos comparações com outras ORMs populares.</p><h3>Instalação e Configuração</h3><pre>npm install prisma --global</pre><p>Após a instalação, crie um novo diretório para o seu projeto e execute o comando a seguir para iniciar um novo projeto Prisma:</p><pre>npx prisma init</pre><p>Isso criará os arquivos e diretórios necessários para a configuração do Prisma.</p><h3>Definindo o Modelo de Dados</h3><p>No diretório criado pelo Prisma, você encontrará um arquivo chamado schema.prisma. Nele, você pode definir o modelo de dados do seu aplicativo. O Prisma permite que você defina as tabelas, colunas, relacionamentos e restrições do banco de dados de forma declarativa, utilizando uma sintaxe amigável.</p><p>Vamos adicionar informações sobre os tipos de dados que você pode usar na definição do modelo. O Prisma suporta uma variedade de tipos de dados, incluindo:</p><ul><li>String: representa uma sequência de caracteres.</li><li>Int: representa um número inteiro.</li><li>Float: representa um número de ponto flutuante.</li><li>Boolean: representa um valor booleano (true/false).</li><li>DateTime: representa uma data e hora.</li><li>Json: representa um objeto JSON.</li><li>Enum: representa um conjunto de valores pré-definidos.</li></ul><p>Aqui está um exemplo de definição de modelo com tipos de dados:</p><pre>model User {<br>  id    Int     @id @default(autoincrement())<br>  name  String<br>  email String  @unique<br>  age   Int?<br>  createdAt DateTime @default(now())<br>  role  Role    @default(USER)<br>}<br><br>enum Role {<br>  USER<br>  ADMIN<br>}</pre><p>No exemplo acima, temos uma entidade “User” com várias colunas, como “id” (inteiro), “name” (string), “email” (string único), “age” (inteiro opcional), “createdAt” (data e hora com valor padrão de agora) e “role” (enum com valores USER e ADMIN).</p><h3>Gerando o Prisma Client</h3><p>Com o modelo de dados definido, você precisa gerar o Prisma Client. O Prisma Client é uma biblioteca gerada automaticamente pelo Prisma com base no seu modelo de dados. Ele fornece métodos convenientes e tipados para interagir com o banco de dados. Ao utilizar o TypeScript, o Prisma Client é gerado com suporte completo à tipagem estática, fornecendo IntelliSense e verificação de tipos em todas as operações de banco de dados.</p><h3>Utilizando o Prisma Client</h3><p>Agora que o Prisma Client está gerado, você pode utilizá-lo em seu código TypeScript para interagir com o banco de dados. O Prisma Client fornece métodos para criar, ler, atualizar e excluir registros do banco de dados. Com o TypeScript, você tem a garantia de que todas as operações são corretamente tipadas, evitando erros de digitação e detectando problemas em tempo de compilação.</p><p>Adicionando informações sobre a tipagem no exemplo de criação de um novo usuário com o Prisma:</p><pre>import { PrismaClient, Role } from &#39;@prisma/client&#39;<br><br>const prisma = new PrismaClient()<br><br>async function createUser(name: string, email: string, age?: number) {<br>  const user = await prisma.user.create({<br>    data: {<br>      name,<br>      email,<br>      age,<br>      role: Role.USER,<br>    },<br>  })<br>  return user<br>}<br><br>createUser(&#39;John Doe&#39;, &#39;john@example.com&#39;, 25)<br>  .then((user) =&gt; console.log(&#39;Usuário criado:&#39;, user))<br>  .catch((error) =&gt; console.error(&#39;Erro ao criar usuário:&#39;, error))<br>  .finally(() =&gt; prisma.$disconnect())</pre><p>No exemplo acima, temos uma entidade “User” com várias colunas, como <em>“id” (inteiro), “name” (string), “email” (string único), “age” (inteiro opcional), “createdAt” (data e hora com valor padrão de agora) </em>e <em>“role” (enum com valores USER e ADMIN</em>).</p><h3>Consultas Avançadas:</h3><p>Além das operações básicas de CRUD, o Prisma permite a execução de consultas mais avançadas, como filtros, ordenação, paginação e junções entre tabelas. Isso torna o desenvolvimento mais produtivo, evitando erros de sintaxe e facilitando a navegação pelo modelo de dados.</p><p>Exemplo de consulta utilizando filtros e ordenação com o Prisma:</p><pre>import { PrismaClient } from &#39;@prisma/client&#39;<br><br>const prisma = new PrismaClient()<br>async function getUsersByAgeRange(minAge: number, maxAge: number) {<br>  const users = await prisma.user.findMany({<br>    where: {<br>      age: {<br>        gte: minAge,<br>        lte: maxAge,<br>      },<br>    },<br>    orderBy: {<br>      name: &#39;asc&#39;,<br>    },<br>  })<br>  return users<br>}<br><br>getUsersByAgeRange(18, 30)<br>  .then((users) =&gt; console.log(&#39;Usuários encontrados:&#39;, users))<br>  .catch((error) =&gt; console.error(&#39;Erro ao buscar usuários:&#39;, error))<br>  .finally(() =&gt; prisma.$disconnect())</pre><h3>Comparação com outras ORMs:</h3><p>Embora existam várias ORMs disponíveis, o Prisma se destaca pela sua combinação com o TypeScript e o PostgreSQL. O Prisma fornece uma experiência de desenvolvimento moderna, com suporte completo para tipagem estática e recursos avançados de IntelliSense. Além disso, ele oferece consultas otimizadas, que resultam em um melhor desempenho das operações de banco de dados.</p><p>Ao comparar com outras ORMs populares, como Sequelize e TypeORM, o Prisma se destaca pela sua abordagem mais moderna e eficiente. A geração automática do Prisma Client com base no modelo de dados e a integração nativa com o TypeScript simplificam o desenvolvimento e reduzem a possibilidade de erros.</p><h3>Conclusão:</h3><p>Neste artigo, exploramos o uso do Prisma ORM com TypeScript e PostgreSQL. Vimos como instalar e configurar o Prisma, como definir o modelo de dados e gerar o Prisma Client. Também discutimos sobre os tipos de dados disponíveis no Prisma e como a tipagem funciona com o TypeScript. Além disso, apresentamos exemplos de uso do Prisma para criar registros, executar consultas avançadas e comparamos com outras ORMs populares.</p><p>O Prisma é uma ferramenta poderosa que oferece uma experiência de desenvolvimento moderna, aumentando a produtividade e fornecendo um desempenho eficiente. Ao utilizar o Prisma com o TypeScript e o PostgreSQL, você pode aproveitar ao máximo os recursos de tipagem estática, consultas avançadas e integração perfeita com o ecossistema TypeScript.</p><p>Espero que este guia tenha sido útil e tenha fornecido uma visão abrangente do uso do Prisma com TypeScript e PostgreSQL. Agora você está pronto para começar a desenvolver aplicativos incríveis com essa combinação poderosa!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=81fd6784c10c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Lambda, o Cold Start e o Provisioned Concurrency]]></title>
            <link>https://medium.com/base39/a-lambda-o-cold-start-e-o-provisioned-concurrency-cd976b6a0be6?source=rss-ac94881bed29------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd976b6a0be6</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[lambda-function]]></category>
            <category><![CDATA[aws-lambda]]></category>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[cold-start]]></category>
            <dc:creator><![CDATA[Matheus Musa]]></dc:creator>
            <pubDate>Fri, 14 Apr 2023 18:58:27 GMT</pubDate>
            <atom:updated>2023-04-14T20:59:08.737Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OCdC21bBtEpZvdIQIEGPyw.png" /></figure><h4>O que é Lambda e o modelo Serverless?</h4><p>Nesse caso, “<strong><em>Lambda</em></strong>” não se refere ao comprimento de onda, mas sim ao serviço <strong><em>AWS Lambda</em></strong>, que é um serviço sem servidor orientado a eventos. Isso significa que é possível executar o seu código em qualquer tipo de serviço ou aplicação backend, sem se preocupar em criar ou gerenciar um servidor, seguindo o modelo “<strong><em>serverless</em></strong>”.</p><p>No modelo <strong><em>serverless</em></strong>, você paga apenas pelo que utilizar para executar a sua função. A infraestrutura computacional é totalmente gerenciada pelo provedor de nuvem <strong><em>AWS</em></strong>, permitindo focar apenas na lógica do seu negócio. Ao utilizar a <strong><em>AWS</em></strong> <strong><em>Lambda</em></strong> para sua aplicação <strong><em>serverless</em></strong>, você tem a facilidade de integrar com outros serviços oferecidos pela <strong><em>AWS</em></strong>, como o <strong><em>DynamoDB</em></strong> e o <strong><em>S3</em></strong>, entre outros. Caso a sua função receba um pico de acessos, ela será escalonada automaticamente para atender a demanda.</p><h4>O problema das Lambdas em produção: &quot;<a href="https://www.youtube.com/watch?v=5Y6TqxLmxIo">The Winter is coming</a>&quot;</h4><p>Você sabe quando acorda em uma manhã fria e não quer sair de baixo das cobertas, porque o corpo se recusa a mudar de posição? Quem trabalha com <em>L</em><strong><em>ambdas</em></strong> sabe que isso também acontece com elas, o chamado “Cold Start” (inicialização fria, em tradução livre). Como não há um servidor dedicado para a sua função, a <strong><em>AWS</em></strong> precisa provisionar uma instância do seu código. Esse processo consiste em criar um container para a execução da sua função (<strong><em>EC2</em></strong>, por baixo dos panos) e carregar o código-fonte e dependências, o que acrescenta tempo à resposta da função. O Cold Start pode ocorrer em duas situações:</p><ol><li>quando a função é requisitada pela primeira vez em um período de tempo (por padrão, em um intervalo de 15 minutos);</li><li>quando a <strong><em>AWS</em></strong> precisa criar uma nova instância durante a escala automática.</li></ol><p>Não é possível prever quando o Cold Start irá ocorrer, mas existem algumas formas de diminuir seu impacto.</p><p>O intervalo de Cold Start para a execução pode ser crucial para a sua aplicação, já que alguns segundos podem levar a um timeout no endpoint. Para minimizar o impacto do Cold Start, é possível tomar as seguintes atitudes:</p><ul><li>Definir um tamanho de memória suficiente: quando a função <strong><em>Lambda</em></strong> é iniciada, a <strong><em>AWS</em></strong> aloca recursos de computação com base na quantidade de memória solicitada. Definir um tamanho de memória maior pode ajudar a reduzir o Cold Start, pois isso aumenta a capacidade computacional alocada para a função <strong><em>Lambda</em></strong>.</li><li>Minimizar o tamanho da função: funções menores são carregadas mais rapidamente, por isso é recomendável minimizar o tamanho da função. Isso pode ser feito removendo código desnecessário, otimizando bibliotecas, usando a compressão gzip e evitando o uso de dependências desnecessárias.</li><li>Usar bibliotecas compartilhadas: o uso de bibliotecas compartilhadas pode ajudar a reduzir o tamanho da função <strong><em>Lambda</em></strong> e, assim, diminuir o Cold Start. Isso pode ser feito. Talvez esse processo já seja o suficiente para a sua aplicação não sofrer tanto com o cold start. Por exemplo o utilizando como base uma <strong><em>Lambda</em></strong> da Base39 construída na linguagem NodeJS 16.x, que consome <strong><em>DynamoDB</em></strong>, <strong><em>Mongodb</em></strong>, <strong><em>APIs</em></strong> <strong><em>HTTPs</em></strong> e que possui dependências a bibliotecas de código terceiras na nossa aplicação. Algumas dessas bibliotecas estava deixando o pacote da <strong><em>Lambda</em></strong> bem pesado que foi o caso da biblioteca <strong><em>Date-fns </em></strong>fizemos sua substituição por uma mais leve e conseguimos reduzir o pacote em quase <strong>3MB</strong></li><li>Passamos de:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WN7qACeAhqknWTdGz55nPg.png" /></figure><ul><li>Para:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BdqIFAkP2Mjxc6szMPrphg.png" /></figure><p>Aqui também criamos uma classe que usava a biblioteca <a href="https://github.com/winstonjs/winston"><strong><em>winston</em></strong></a> para criar e controlar os logs, mas temos opções de lib menores com a mesma funcionalidade isso fez com que a gente chegasse em uma redução real de 3MB:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U_s7VwDaBKIC4NJnv2d-Eg.png" /></figure><p>Isso já colaborou para um tempo de cold start menor e inclusive um custo menor para a <strong><em>Lambda</em></strong>. Mas ainda sim não é o tamanho ideal, aqui estávamos usando o <strong><em>webpack </em></strong>para empacotar o código e decidimos trocar para o <strong><em>esbuild </em></strong>que é bem mais rápido e esse foi o resultado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gdDHJmZVq0DRuHkRux6Ssw.png" /></figure><p>O <strong><em>webpack</em></strong> não estava minimizando o pacote ao subi-lo, mesmo com a sua configuração marcada para fazer isso, e fez uma diferença drastica com <strong><em>esbuild</em></strong> que realmente minimizou o pacote.</p><p>Outra forma que pode ajudar é criar um evento, uma cron, para que fique executando sua função de tempo em tempo, talvez essa seja a solução mais barata, já que só será cobrado o valor de execução da <strong><em>Lambda</em></strong>, essa solução evita que sua função fique fria por inatividade.</p><h4>Antecipando com o Provisioned Concurrency</h4><p>O BFF que foi criamos aqui é usado o <strong><em>Apollo Graphql</em></strong> e ele funciona com uma única <strong><em>Lambda</em></strong> que executa <strong><em>querys </em></strong>especificas fica mais complexo fazer com um evento/cron, para ele recorremos ao <strong><em>Provisioned Concurrency </em></strong>no começo<strong><em>,</em></strong> que é um recurso oferecido pela <strong><em>AWS</em></strong> que permite que você especifique um número de instâncias de função <strong><em>Lambda</em></strong> que devem estar sempre disponíveis e prontas para atender solicitações. Isso significa que, em vez de esperar que a <strong><em>AWS</em></strong> inicie novas instâncias da função <strong><em>Lambda</em></strong> quando uma solicitação for recebida, o <strong><em>Provisioned Concurrency</em></strong> garante que um número específico de instâncias esteja disponível em todos os momentos. Isso pode ajudar a melhorar o tempo de resposta das funções <strong><em>Lambda</em></strong>, diminuindo o seu cold start.</p><p>Ao usar o <strong><em>Provisioned Concurrency</em></strong>, você pode garantir que sua função <strong><em>Lambda</em></strong> sempre tenha capacidade suficiente para atender às solicitações de maneira consistente e previsível. Isso pode ajudar a melhorar a experiência do usuário e evitar atrasos ou tempo de espera excessivo. No entanto, é importante observar que o <strong><em>Provisioned Concurrency </em></strong>aumenta os custos de execução da função <strong><em>Lambda</em></strong>, e esse custo varia com o tamanho da <strong><em>Lambda</em></strong> de instancias definidas. Para manter um custo razoável usamos um plugin para o <em>serverless</em> que ajuda nesse controle <a href="https://www.serverless.com/plugins/serverless-provisioned-concurrency-autoscaling"><em>&quot;serverless-provisioned-concurrency-autoscaling&quot;</em></a>, ele permite que você configure todos os parâmetros do provisionamento desde máximo e mínimo de recurso alocado, ele também permite que escale os números até o máximo configurado para o melhor desempenho da sua aplicação. Como uma tática para tornar mais barato podemos definir uma agenda dentro das configurações para que em momentos de pouco uso na sua aplicação não seja alocada tantas instancias,<strong><em> porque novamente provisionar uma lambda tem um custo que é relativamente alto dependendo da sua lambda e numero de instancias desejada</em></strong>.</p><p>Aqui podemos ter uma noção do resultado que obtemos ao realizar os testes com o provisioned-concurrency, como podemos ver o seu cold starte começa antes da requisição acontecer e dessa forma ela tem um impacto muito menor, em cerca de menos de 1s</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pt7EMdyGrNHqZmqyRzxo1Q.png" /></figure><p>Já sem o provisioned-concurrency temos um cold start de 2.34 a 3.2 segundos que é bem mais que o dobro e gerava um grande impacto na aplicação</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qyO5t_4BkggC6SzTwOJNDg.png" /></figure><h4>Adicionando o plugin</h4><p>Primeiro precisamos fazer a instalação do plugin:<br><em>npm install serverless-provisioned-concurrency-autoscaling</em></p><p>Com o plugin instalado adicionamos ele no nosso arquivo <em>serverless</em> (aqui usamos o <em>serverless</em> em typescript)</p><pre> <br>plugins:<br>  [&#39;serverless-provisioned-concurrency-autoscaling&#39;,]</pre><p>Agora na nossa função vamos passar as configurações do provisionamento</p><pre>&#39;apollo&#39;: {<br>      handler: &#39;src/handler/apollo.handler&#39;,<br>      provisionedConcurrency: 1,<br>      concurrencyAutoscaling: {<br>        enabled: true,<br>        alias: &#39;provisioned&#39;,<br>        maximum: 5,<br>        minimum: 1,<br>        usage: 0.75,<br>        scaleInCooldown: 0,<br>        scaleOutCooldown: 0,<br>        customMetric: {<br>          statistic: &#39;maximum&#39;,<br>        },<br>        scheduledActions: [<br>          {<br>            name: &#39;start&#39;,<br>            schedule: &#39;cron(0 0 12 ? * MON-FRI *)&#39;,<br>            action: {<br>              maximum: 5,<br>              minimum: 2,<br>            },<br>          },<br>          {<br>            name: &#39;end&#39;,<br>            schedule: &#39;cron(0 0 23 ? * MON-FRI *)&#39;,<br>            action: {<br>              maximum: 1,<br>              minimum: 1,<br>            },<br>          },<br>        ],<br>      },<br>    }</pre><p>Vamos para o significado de cada campo para que você possa decidir a melhor configuração para a sua aplicação</p><ul><li><em>“enabled”</em>: indica se a escalabilidade automática do provisionamento concurrency está ativada (valor “true”) ou desativada (valor “false”).</li><li><em>“alias”</em>: é o nome do alias do provisionamento concurrency. É usado para se referir a ele em outras partes da configuração.</li><li><em>“maximum”</em>: define o número máximo de recursos computacionais que podem ser alocados para o provisionamento concurrency. Se o limite máximo for atingido, a escalabilidade automática não aumentará a capacidade além desse número.</li><li><em>“minimum”</em>: define o número mínimo de recursos computacionais que devem ser alocados para o provisionamento concurrency. Isso garante que haja sempre recursos suficientes disponíveis para processar solicitações.</li><li><em>“usage”</em>: define o nível atual de utilização do provisionamento concurrency. Esse valor é geralmente atualizado automaticamente com base na demanda de processamento.</li><li><em>“scaleInCooldown”</em>: define o período de tempo que deve ser esperado após uma redução na capacidade de processamento antes que outra redução possa ser realizada. Isso evita que a capacidade seja reduzida com muita frequência, o que pode afetar negativamente o desempenho da aplicação.</li><li><em>“scaleOutCooldown”</em>: define o período de tempo que deve ser esperado após um aumento na capacidade de processamento antes que outro aumento possa ser realizado. Isso evita que a capacidade seja aumentada com muita frequência, o que pode resultar em custos excessivos.</li><li><em>“customMetric”</em>: permite a configuração de uma métrica personalizada para determinar a escala do provisionamento concurrency. Neste exemplo, a métrica personalizada está definida para usar o valor máximo como estatística para escalabilidade.</li></ul><p>Usamos esse recurso por um período de tempo para testes, até conseguirmos identificar e melhorar onde estavam os nossos gargalos, proporcionando a remoção desse recurso que acabou se tornando desnecessário. Mas ela pode salvar aplicações com os problemas de cold start</p><h4>Conclusão</h4><p>Em resumo, o uso da <strong><em>AWS</em></strong> <strong><em>Lambda</em></strong> e do modelo <em>serverless</em> traz diversas vantagens, como economia, escalabilidade automática e a facilidade de integração com outros serviços da <strong><em>AWS</em></strong>, além de permitir um maior foco na lógica do negócio. No entanto, a latência do cold start pode ser um problema em algumas situações, mas existem soluções para contornar esse problema, como otimizar a função deixando-a com um número baixo de dependências e consumindo pouca memória. Mas caso isso não seja suficiente pode-se criar eventos para mantê-la aquecida sendo essa uma solução mais barata, mas não aplicável em todas as situações. Além disso, tem o uso do <strong><em>Provisioned Concurrency</em></strong>, que é um recurso da <strong><em>AWS</em></strong> que permite especificar um número de instâncias de função <strong><em>Lambda</em></strong> para estarem sempre disponíveis e prontas para atender solicitações, com isso diminuir o cold start e melhorar o tempo de resposta das funções <strong><em>Lambda</em></strong>, tornando a experiência do usuário mais consistente e previsível. O uso do plugin “<em>serverless-provisioned-concurrency-autoscaling</em>” ajuda a controlar os custos do <strong><em>Provisioned Concurrency </em></strong>e permite configurar todos os parâmetros do provisionamento para melhor desempenho da aplicação.</p><h3>Referencias</h3><ul><li><a href="https://www.serverless.com/blog/aws-lambda-provisioned-concurrency">https://www.serverless.com/blog/aws-lambda-provisioned-concurrency</a></li><li><a href="https://www.serverless.com/plugins/serverless-provisioned-concurrency-autoscaling">https://www.serverless.com/plugins/serverless-provisioned-concurrency-autoscaling</a></li><li><a href="https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html">https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html</a></li><li><a href="https://date-fns.org/docs/Getting-Started">https://date-fns.org/docs/Getting-Started</a></li><li><a href="https://github.com/winstonjs/winston">https://github.com/winstonjs/winston</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd976b6a0be6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/base39/a-lambda-o-cold-start-e-o-provisioned-concurrency-cd976b6a0be6">A Lambda, o Cold Start e o Provisioned Concurrency</a> was originally published in <a href="https://medium.com/base39">Base39</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Curando engessamento de sua Aplicação com uma Injeção(de Dependência com Tsyringe)]]></title>
            <link>https://medium.com/base39/curando-engessamento-de-sua-aplica%C3%A7%C3%A3o-com-uma-inje%C3%A7%C3%A3o-de-depend%C3%AAncia-com-tsyringe-a0077c8b0a2c?source=rss-ac94881bed29------2</link>
            <guid isPermaLink="false">https://medium.com/p/a0077c8b0a2c</guid>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[node]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[tsyringe]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Matheus Musa]]></dc:creator>
            <pubDate>Thu, 26 Jan 2023 15:07:14 GMT</pubDate>
            <atom:updated>2023-01-26T17:30:44.738Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1004/1*PHSHrZaoU1L67xx4J4NpTg.png" /></figure><h3>Injeção de Dependência</h3><p>O que é esse remédio Injeção de Dependência? Dentro dos diversos padrões de desenvolvimento encontramos o <strong><em>Dependency Injection</em></strong>, nossa injeção de dependência, bastante utilizada quando queremos tornar nossa aplicação mais desacoplada, sem tantas amarras com as instancias usadas no código. A injeção de dependência é quando ao invés de deixar nossa classe responsável por criar ou buscar objetos que ela precisa para sua aplicação, fazemos a injeção deles via constructor e interface ou com o uso de ferramentas de controle de containers, fazendo nossa classe ficar sem amarras, podendo adicionar e ajustar funcionalidades nas nossas dependências sem um grande impacto e facilitando muito a criação de mocks para os testes unitários.</p><h3>Por que usar Injeção de Dependência?</h3><p>O uso da injeção de dependência resolve alguns problemas críticos quando estamos falando de uma aplicação grande tais quais:</p><ul><li>Suporte mais fácil para a aplicação, como não corremos o risco de afetar outros módulos poder ajustar ou criar novas funcionalidades fica mais tranquilo.</li><li>Componentes reutilizáveis, como os deixamos livres, sem dependência direta, podemos usa-los em varias aplicações o que dificulta a criação de código duplicado.</li><li>Testes unitários em toda aplicação, com o código nesse padrão fica mais fácil criar mocks e implementa-los no teste.</li></ul><p>Podemos pensar em uma classe com dependências que fica em um usecase e é chamada por um handler e que chama nossas classes em uma pasta data.</p><pre>import { Genre } from &#39;./genre&#39;<br>import { Platform } from &#39;./Platform&#39;<br>class Game {<br>  constructor () {}<br><br>  public create() {<br>    const genre = new Genre();<br>    genre.getGenre()<br>    const platform = new Platform();<br>  platform.getPlatform(&#39;ps5&#39;)<br>  }<br>}</pre><p><strong><em>Exemplo da organização dos diretórios</em></strong></p><figure><img alt="ideia de da organização dos diretórios" src="https://cdn-images-1.medium.com/max/416/1*UNOKY8mXTiwmBo3C65DGfA.png" /><figcaption><strong><em>organização dos diretórios</em></strong></figcaption></figure><p>Não parece algo complexo trabalhar com um código desses, mas imagine que algo dentro de Platform precise ser trocado ou ajustado de alguma forma</p><pre>export class Platform {<br> constructor (){}<br> public getPlatform(data: string) {<br>  const platforms = {<br>   ps4: {<br>    hardware: &#39;&#39;<br>    limitSize: &#39;&#39;<br>    processingSpeed: &#39;&#39;<br>   },<br>   ps5: {<br>    hardware: &#39;&#39;,<br>    limitSize: &#39;&#39;,<br>    processingSpeed: &#39;&#39;,<br>   },<br>   xboxOne: {<br>    hardware: &#39;&#39;<br>    limitSize: &#39;&#39;<br>    processingSpeed: &#39;&#39;<br>   },<br>   xboxX: {<br>    hardware: &#39;&#39;<br>    limitSize: &#39;&#39;<br>    processingSpeed: &#39;&#39;<br>   },<br>  }<br> }<br> return platforms[data]<br>}</pre><p>Fazer isso afetaria todos as classes que tivesse Platform como dependência inclusive a nossa classe Game poderia ficar comprometida. E agora faça uma extrapolação para uma classe com diversas dependências, isso foi um problema enfrentado no BFF (back for front) que estamos desenvolvendo. Em alguns usecase temos o consumo de várias dependências. Se o usecase estiver inteiramente acoplado dessa forma não será possível escalar as aplicações, o desenvolvimento ficaria extremamente travado, gerenciar todas essas dependências seria complexo, a ideia de responsabilidade única e a reutilização das classes também vai para o espaço e o esforço para criar testes unitários e dar manutenção em uma aplicação assim é gigante. Ou seja estaríamos criando uma aplicação legado já de inicio</p><p>Para a solução desse problema fizemos a aplicação de injeção de dependência usando interfaces e a biblioteca do TSyringe, que facilita o trabalho com os containers e injeção de dependências. Com ele é muito fácil gerar uma instância das dependências com as tags @injectable do TSyringe.</p><h3>Tsyringe</h3><p>É um projeto open source criado pela Microsoft, um contêiner de injeção de dependência para TypeScript/JavaScript. Com ele é possível através de decorators marcar uma dependência e obter uma instância dela.</p><p>Basicamente com ele fazemos uso dos containers que nos é fornecido e podemos buscar todas as suas dependências, assim quando necessário utilizar a instância de uma classe fazemos isso com um resolve no container com um token.</p><h3>Usando TSyringe</h3><p>Aplicando o TSyringe na nossa classe Platform para gerar sua instância:</p><pre>import { injectable } from &#39;tsyringe&#39;;<br><br>interface IPlatform {<br>    getPlatform(data: string): {<br>        hardware: string,<br>        limitSize: string,<br>        processingSpeed: string,<br>    }<br>}<br><br>@injectable()<br>export class Platform implements IPlatform {<br>    public getPlatform(data: string) {<br>        const platforms = {<br>            ps4: {<br>                hardware: &#39;&#39;,<br>                limitSize: &#39;&#39;,<br>                processingSpeed: &#39;&#39;,<br>            },<br>            ps5: {<br>                hardware: &#39;&#39;,<br>                limitSize: &#39;&#39;,<br>                processingSpeed: &#39;&#39;,<br>            },<br>            xboxOne: {<br>                hardware: &#39;&#39;,<br>                limitSize: &#39;&#39;,<br>                processingSpeed: &#39;&#39;,<br>            },<br>            xboxX: {<br>                hardware: &#39;&#39;,<br>                limitSize: &#39;&#39;,<br>                processingSpeed: &#39;&#39;,<br>            },<br>        };<br>        return platforms[data];<br>    }<br>}</pre><p>Com isso nossa classe Game fica:</p><pre>import { inject } from &#39;tsyringe&#39;<br>import { IGenre } from &#39;./genre&#39; //interface da classe<br>import { IPlatform } from &#39;./Platform&#39; //interface da classe<br><br>class Game {<br>  constructor(<br>  @inject(&#39;Genre&#39;) private genre: IGenre<br>  @inject(&#39;Platform&#39;) private platform: IPlatform<br> ) {}<br><br>  public create(gameGenre: string, gamePlatform: string) {<br>    this.platform.getPlatform(gamePlatform)<br>  this.platform.getGenre(gameGenre)<br>  }<br>}</pre><p>Perceba que agora nossa classe Game não está ligada diretamente a classe Platform e sim com sua interface, isso nos libera para poder acrescentar ou alterar a classe sem se preocupar com seu impacto, desde que respeitemos sua interface, e com o uso do TSyringe ele se encarrega de toda a árvore de dependência sem que precisemos nos preocupar com isso.</p><p>Agora usando a nossa classe Game em um handler basta fazer isso através dos containers:</p><pre>import { container } from &#39;tsyringe&#39;;<br>import { Game } from &#39;./Game&#39;;<br>import { Genre } from &#39;./genre&#39;;<br>import { Platform } from &#39;./Platform&#39;;<br><br>const game = container<br>.register(&#39;Genre&#39;, { useClass: Genre })<br>.register(&#39;Platform&#39;, { useClass: Platform })<br>.register(Game)<br>.resolve(Game)<br><br>game.create()</pre><p>E o TSyringe possui a tag scoped() que também permite da injeção de dependência em um contexto específico Ele permite criar um novo contêiner que herda todos os registros de um contêiner pai, mas também permite adicionar novos registros ou substituir os existentes com isso manusear os containers fica bem mais fácil e dinâmico.</p><p>Podemos adicionar o scoped() no nosso container inserido no handler</p><pre>const game = container<br>  .register(&#39;Genre&#39;, { useClass: Genre }, { scope: &#39;request&#39; })<br>  .register(&#39;Platform&#39;, { useClass: Platform }, { scope: &#39;request&#39; })<br>  .register(Game, { useClass: Game }, { scope: &#39;request&#39; })<br>  .resolve(Game)<br><br>game.create()</pre><p>Isso fará com que cada resolução das instâncias de serviço seja criada por solicitação.</p><p>Alternativamente, você pode usar .registerSingleton para ter um escopo solo, isso fará com que cada resolução das instâncias de serviço seja criada apenas uma vez.</p><pre>const game = container<br>  .registerSingleton(&#39;Genre&#39;, Genre)<br>  .registerSingleton(&#39;Platform&#39;, Platform)<br>  .registerSingleton(Game, Game)<br>  .resolve(Game)<br><br>game.create()</pre><p>Existem mais alguns tipos de escopos que podem ser usados dependendo da necessidade da sua aplicação.</p><p>Testar essas classes, criar seus mocks fica muito mais simples e com isso podemos abranger o teste para que ele seja realmente eficaz.</p><p>Pode parecer que com essas mudanças nossa aplicação ficou mais complexa, mas não é verdade agora temos uma aplicação desacoplada, escalável, de fácil leitura e entendimento. Dar manutenção nela também ficará mais simples, e o fato de podermos testar de forma completa suas aplicações diminui as chances de gerar bugs no código.</p><h3>Conclusão</h3><p>O uso da injeção de dependência permite sua aplicação uma longevidade muito maior, já que ela estará menos complexa e acoplada, permitindo alterações, implementações e com a possibilidade de qualquer desenvolvedor dar manutenção já que seu código estará mais legível.</p><p>Em uma aplicação grande como a nossa aqui no BFF onde nossas classes podem ter diversas outras dependências e classes com dependências iguais, o uso da injeção de dependência tornou o código mais limpo, com componentes reutilizáveis, menos duplicidade de código, de fácil manutenção e com testes em todas as suas aplicações</p><p>Implementando a Injeção de Dependência junto ao TSyringe torna tudo ainda mais fácil já que a través das tags fornecidas pela biblioteca para gerar as instâncias, seu controle de containers e gerenciamento da árvore de dependência, tira a sua preocupação de precisar lidar com tudo isso. Isso faz que com a implementação de novas funcionalidades não seja algo demorado e complexa, o TSyringe é bem leve para a aplicação isso faz com que seja possível uma melhor performance.</p><p>O TSyringe também te permite trabalhar com dependências que são bem complicadas como as dependências circulares que ocorre quando dois ou mais módulos dependem um do outro, criando um loop. Isso pode levar a problemas como recursão infinita ou comportamento inesperado, pois a ordem em que os módulos são carregados ou executados pode não ser clara, o TSyringe tem uma maneira de lidar especificamente com elas</p><h3>Referencias</h3><ul><li><a href="https://github.com/microsoft/tsyringe">https://github.com/microsoft/tsyringe</a></li><li><a href="https://martinfowler.com/articles/injection.html">https://martinfowler.com/articles/injection.html</a></li><li><a href="https://www.devmedia.com.br/design-patterns-injecao-de-dependencia-com-csharp/23671">https://www.devmedia.com.br/design-patterns-injecao-de-dependencia-com-csharp/23671</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a0077c8b0a2c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/base39/curando-engessamento-de-sua-aplica%C3%A7%C3%A3o-com-uma-inje%C3%A7%C3%A3o-de-depend%C3%AAncia-com-tsyringe-a0077c8b0a2c">Curando engessamento de sua Aplicação com uma Injeção(de Dependência com Tsyringe)</a> was originally published in <a href="https://medium.com/base39">Base39</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>