<?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[HavanLabs - Medium]]></title>
        <description><![CDATA[Info Havan Labs - Medium]]></description>
        <link>https://medium.com/havanlabs?source=rss----7dc6a628382c---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>HavanLabs - Medium</title>
            <link>https://medium.com/havanlabs?source=rss----7dc6a628382c---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 04:23:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/havanlabs" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Havan inova oferecendo uma nova modalidade de pagamento para seus clientes no Aplicativo]]></title>
            <link>https://medium.com/havanlabs/havan-inova-oferecendo-uma-nova-modalidade-de-pagamento-para-seus-clientes-no-aplicativo-bbadd6b2f603?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/bbadd6b2f603</guid>
            <category><![CDATA[pagamentos-instantâneos]]></category>
            <category><![CDATA[open-finance-brasil]]></category>
            <category><![CDATA[pagamentos-digitais]]></category>
            <category><![CDATA[aplicativos]]></category>
            <category><![CDATA[open-finance]]></category>
            <dc:creator><![CDATA[Lucas Felício Alfini]]></dc:creator>
            <pubDate>Wed, 26 Jun 2024 18:43:26 GMT</pubDate>
            <atom:updated>2024-06-26T18:43:26.774Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Mais uma inovação digital, o Open Finance permite que os clientes paguem suas contas de uma forma mais fácil e segura e ainda compartilhem seus dados entre diferentes bancos a fim de conseguir diversas vantagens.</em></p><p>A experiência do cliente sempre foi uma prioridade para a Havan, tanto no ambiente físico quanto no meio digital, por isso sempre busca soluções inovadoras para atender o propósito de “surpreender e encantar a todos, oferecendo uma experiência única”.</p><p>Desta vez, a Havan sai à frente do mercado, trazendo para o cliente uma jornada moderna e simplificada para realizar o pagamento das suas faturas do Cartão Havan pelo aplicativo da loja. Trata-se de uma funcionalidade conhecida como “iniciação de pagamentos” que é a combinação entre Pix, método de pagamento mais utilizado pelos brasileiros, e Open Finance.</p><p>O serviço é inspirado no modelo europeu do <em>Payment Initiation Service Provider</em> (PISP) e abre uma gama de oportunidades ampliando a competitividade de mercado e melhorando a experiência do consumidor final.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*jEkbaxEvZjJAlj6pcui26w.png" /></figure><p>O recurso funciona similar a um pagamento com PIX, porém, com algumas facilidades a mais. Através deste recurso, ao selecionar essa opção de pagamento, o cliente é direcionado direto do nosso aplicativo (App Havan) para o aplicativo do banco que o cliente efetua suas transações financeiras à sua livre escolha, dispensando a fricção do cliente copiar e colar o código PIX como é feito hoje.</p><p>Entenda abaixo como funciona:</p><p>Após realizar o login no aplicativo e selecionar uma fatura para realizar o pagamento, é apresentado à ele uma nova opção, que é disponibilizada com o nome “Pagar com seu banco”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/142/1*Mo8WKdZ9e-PuNAGU9fxV0A.png" /></figure><p>Por ser um recurso novo no aplicativo, é apresentanda uma tela de <em>onboarding</em> para o cliente, explicando o passo a passo que ele deve fazer para realizar o pagamento de sua fatura utilizando a iniciação de pagamentos via <em>open finance</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/162/1*JrMJBHRRfepkgr0NNFzKuQ.png" /></figure><p>Na tela seguinte, é apresentada uma tela com a listagem dos bancos mais utilizados pelos nossos clientes para realizar o pagamento de suas faturas.</p><p>O cliente deve escolher entre uma das instituições e tocar no card correspondente à instituição desejada ou tocar na setinha, conforme indicação:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/237/1*N6dykXhtaFZGPGADixRY6Q.png" /></figure><p>Após a escolha do banco que o cliente deseja realizar o pagamento, será apresentado um resumo para que o cliente realize o consentimento de pagamento, realizando a conferência das informações ali dispostas e caso esteja de acordo, deve tocar em “continuar”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/237/1*rTBHayxyqkAU-gQjPNUs4w.png" /></figure><p>Neste momento, o cliente será redirecionado automaticamente ao aplicativo do banco escolhido, seguindo os passos de pagamento que o aplicativo banco do cliente indicar. Vale ressaltar que cada banco tem uma tratativa de fluxo de pagamento, mas, em ambos os casos são bem similares ao fluxo de pagamento com PIX.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/237/1*BaAT0p25ZxKITzVJhGfEjA.png" /></figure><p>Após realizar o procedimento pelo aplicativo do banco, ele será redirecionado de volta para o Aplicativo Havan onde será visualizada uma tela com a mensagem “Aguardando a confirmação do pagamento” . O cliente pode atualizar o status do seu pagamento de 15 em 15 segundos ou pode retornar à tela inicial do app, não sendo necessário que ele aguarde a conclusão da compensação do pagamento, que acontece de forma automática.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/207/1*uAts2nh2T1WaWm_qEDdLDA.png" /></figure><p>Com a nova modalidade de pagamento, os clientes são direcionados automaticamente ao aplicativo de seu banco onde podem usar o saldo em conta disponível para realizar o pagamento de suas faturas, o que melhora a sua experiência na jornada de pagamento e também reduz custos operacionais envolvidos.</p><p>Como um segundo passo a empresa aposta na evolução da solução para o ambiente web, aplicando-se nos demais canais digitais como e-commerce, portal do cliente, lista de presentes e demais serviços.</p><p>Além de uma experiência mais fluida de pagamento, o cliente que optar por utilizar esta modalidade de pagamento também tem inúmeros benecícios. Vou listar três deles aqui:</p><ul><li>Mais chance de aumento de limite: se uma pessoa sempre teve conta no banco A, mas abriu recentemente uma conta no banco B e quer pedir um aumento de limite nessa instituição, este pode ter mais chances de conseguir se enviar seus dados do banco A para o B. Assim, a nova instituição financeira pode verificar todo seu histórico e decidir de uma forma mais rápida se vai te conceder o aumento de limite.</li><li>Melhores propostas: quando a pessoa compartilha seus dados bancários com outras instituições, pode conseguir propostas mais vantajosas de empréstimo de crédito. Caso tenha um empréstimo em uma instituição financeira e quer ver se, em outro banco, pode pagar mais barato nas parcelas, compartilhe seus dados com ele.</li><li>Pagamento facilitado: Sem dúvidas, essa é a principal vantagem! Sabe quando você vai pagar sua conta do cartão de crédito de uma loja e precisa entrar no aplicativo dela para pegar o código do boleto bancário ou pix, depois sair e entrar no aplicativo do banco e só aí efetuar o pagamento? Então, com o Open Finance você não precisa fazer todo esse caminho. Aqui, a pessoa abre o aplicativo da loja e paga a conta pelo seu banco de preferência sem precisar desse &quot;vai e volta&quot;.</li></ul><p><strong>Conclusão</strong></p><p>O objetivo geral deste artigo é explorar sobre a funcionalidade em si e como ela contribui positivamente na jornada e experiência do cliente ao executá-la.</p><p>A jornada de pagamento via Open Finance representa um avanço significativo na forma como as transações financeiras são conduzidas, oferecendo uma série de benefícios tanto para os consumidores quanto para as empresas. Ao promover a interoperabilidade entre diferentes instituições financeiras e possibilitar o acesso a dados financeiros de forma segura e consentida, o Open Finance sem sombra de dúvidas transforma a experiência de pagamento, tornando-a mais rápida, conveniente e personalizada.</p><p>Os clientes são beneficiados com a maior transparência e controle sobre suas informações financeiras, podendo escolher os melhores serviços e produtos de acordo com suas necessidades e preferências e com isso, as empresas têm a oportunidade de inovar e oferecer soluções financeiras mais integradas e eficientes, aumentando a competitividade no mercado.</p><p>Na visão geral, a integração do Open Finance nas jornadas de pagamento tem o potencial de revolucionar o setor financeiro, criando um ecossistema mais inclusivo, competitivo e centrado no cliente. Com a expansão e maturação do Open Finance, espera-se que ele traga ainda mais inovações e melhorias, firmando-se como um pilar essencial da transformação digital no sistema financeiro global.</p><p>Agradeço por disponibilizar um tempo para a leitura deste artigo, forte abraço, até mais!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bbadd6b2f603" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/havan-inova-oferecendo-uma-nova-modalidade-de-pagamento-para-seus-clientes-no-aplicativo-bbadd6b2f603">Havan inova oferecendo uma nova modalidade de pagamento para seus clientes no Aplicativo</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cadastro de clientes Havan ficou 62% mais rápido]]></title>
            <link>https://medium.com/havanlabs/cadastro-de-clientes-havan-ficou-62-mais-r%C3%A1pido-cb2fa04df486?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/cb2fa04df486</guid>
            <dc:creator><![CDATA[Ana Carolina Valle de Resende]]></dc:creator>
            <pubDate>Mon, 24 Jun 2024 19:44:24 GMT</pubDate>
            <atom:updated>2024-06-24T19:44:23.971Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jsWvZeq_4tqwvWKPvHGcYg.png" /></figure><h4>Através do auxílio da tecnologia, o cadastro teve uma redução de 11 minutos em cada atendimento</h4><p>“Pensar como cliente e oferecer uma experiência única”, essa é a meta das lojas Havan. Quem conhece a megaloja sabe que vai se surpreender, seja visitando a loja física ou navegando por suas páginas nas redes sociais.</p><p>Luciano Hang sempre se dedicou a garantir que seus clientes se sintam encantados com a variedade e qualidade dos produtos, a organização das lojas e o excelente atendimento. Como destaca nossa missão: “Surpreender e encantar a todos”.</p><blockquote>“Conquistar o coração do cliente é o nosso objetivo.” diz Luciano.</blockquote><p>A Havan também oferece a possibilidade de solicitar um cartão para realizar compras em qualquer megaloja e também parcelamentos em até 10x sem juros.</p><p>Para obter esse cartão é necessário apenas informar alguns dados para realização de um cadastro e assinar o contrato. Sabemos que esse é um processo burocrático e que as vezes pode ser chato, porém é necessário.</p><p>Mas será que não conseguimos melhorar a experiência do nosso cliente nesses momentos também?</p><p>E sim, conseguimos! Através de estudos minuciosos, a equipe de crediário do Laboratório de Tecnologias da Havan, conhecido como Havan Labs, com base em mapeamento de processos e estudos sobre o comportamento e perfil dos nossos clientes, identificou uma oportunidade de aprimorar essa experiência ao reduzir o tempo necessário para o cadastro dos dados.</p><h4>Identificando o problema</h4><p>Existe um espaço dentro da loja destinado a resolver questões do nosso cliente, como negociação de pendências, reenvio de faturas, problemas com senha e principalmente, solicitação de cartão e aumento de limite.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_5tOZJ_TdFVJYh9-5Tv8gQ.jpeg" /></figure><p>Ao longo do tempo observamos longas filas se formando nesse espaço. O problema não era falta de funcionários, nem de equipamentos. A principal questão era o tempo que levava para preencher o formulário de cadastro do cliente. Levava em torno de 18 minutos desde o início do atendimento até a finalização com a impressão do cartão.</p><p>Além disso, para os colaboradores, a execução dessa tarefa era árdua pela quantidade e obrigatoriedade de campos do sistema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/671/1*5PLAnijCKgW2tqDEKXcXDA.png" /><figcaption>Sketch exemplificando formulário em lista</figcaption></figure><p>Em alguns casos específicos, como inaugurações de lojas, recebíamos um grande número de novos colaboradores que estavam aprendendo a utilizar o sistema, além de uma grande demanda de novos cadastros devido aos clientes que vinham conhecer a loja. Essa combinação de fatores causava sobrecarga no atendimento ao cliente.</p><h4>Implementando soluções</h4><p>Algumas das soluções mapeadas foram:</p><ol><li><strong>Objetividade nos documentos solicitados:</strong> identificamos os principais dados que nossa política de crédito leva em consideração para conceder limite e retiramos os campos de dados complementares sem muita importância de decisão, reduzindo a quantidade de campos a serem preenchidos.</li><li><strong>Design intuitivo:</strong> redesenhamos a interface do sistema removendo o longo formulário único de cadastro e dividindo-o em etapas.</li><li><strong>Feedback em tempo real</strong>: identificamos que o motor de crédito operava em etapas, mas o feedback do cadastro não acompanhava esse processo. Agora, à medida que cada etapa é preenchida, o sistema se atualiza em tempo real, proporcionando uma resposta mais rápida ao final do atendimento.</li><li><strong>Cartão sem nome</strong>: substituímos nossos antigos cartões personalizados com o nome do cliente por cartões sem nome, que possuem um código único vinculado ao cadastro de cada pessoa.</li><li><strong>Flexibilidade de uso:</strong> agora é possível realizar o cadastro através de dispositivos móveis, permitindo a criação do cartão Havan em qualquer lugar.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3yA4Hn0TzR92e0NxQRfRoA.png" /><figcaption>Sketch exemplificando formulário em etapas</figcaption></figure><h4>Resultados obtidos</h4><ol><li><strong>Redução das filas:</strong> dessa forma conseguimos uma redução de 38% no tempo de atendimento, de 18 minutos para aproximadamente 7 minutos no total.</li><li><strong>Maior satisfação do cliente</strong>: valorizamos o tempo do cliente, ninguém gosta de ficar esperando para resolver suas questões. Quando o atendimento é rápido gera uma experiência mais agradável que pode resultar em redução de estresse e ansiedade, diminuição da frustração, aumento da satisfação do cliente e possível fidelização e identificação com a empresa</li><li><strong>Aumento no número de cadastros</strong>: reduzindo o tempo de atendimento, aumentamos o número de cadastros realizados, já que conseguimos atender mais pessoas no mesmo período de tempo e ainda evitamos possíveis desistências ao longo do caminho devido à grande espera.</li><li><strong>Maior facilidade de manutenção: </strong>devido a modularidade do sistema, a atualização e manutenção fica facilitada, podendo adicionar ou remover etapas sem reestruturar todo o processo</li><li><strong>Maior satisfação do colaborador: </strong>reduzimos a sobrecarga cognitiva do colaborador, apresentando a informação em pequenas partes. Estabelecemos um processo único para o preenchimento dos dados, o que facilita o entendimento de cada tarefa e reduzimos a curva de aprendizado, assim novos colaboradores tem mais facilidade para aprender a utilizar o sistema</li></ol><h4>Conclusão</h4><p>Essa iniciativa não apenas melhorou a satisfação do cliente, mas também aumentou a eficiência operacional e impulsionou nossas taxas de conversão. Ao reduzir o tempo gasto no cadastro de dados, criamos uma jornada mais fluida e agradável para nossos clientes. Essas melhorias beneficiaram tanto os clientes quanto o crescimento e o sucesso de nossas lojas.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb2fa04df486" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/cadastro-de-clientes-havan-ficou-62-mais-r%C3%A1pido-cb2fa04df486">Cadastro de clientes Havan ficou 62% mais rápido</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Agents: Uma equipe "extra"]]></title>
            <link>https://medium.com/havanlabs/ai-agents-uma-equipe-extra-b3713a06995a?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/b3713a06995a</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[tecnologia]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[inovação]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <dc:creator><![CDATA[Klaus Dellano]]></dc:creator>
            <pubDate>Wed, 12 Jun 2024 13:01:29 GMT</pubDate>
            <atom:updated>2024-06-12T13:01:28.289Z</atom:updated>
            <content:encoded><![CDATA[<p>Fala manolos!! Se você curte um papo sobre IA, prepare-se, porque hoje vamos explorar os tais agentes de IA, que estão revolucionando o mundo tech. Bora entender o que são esses bichos, como funcionam e por que eles são considerados a nova &quot;arma secreta&quot; das equipes de desenvolvimento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5fnKSWcJuqEGmMk6K4vUZg.jpeg" /></figure><h3>O que são Agentes de IA?</h3><p>Se liga só: os agentes de IA são tipo uns robôzinhos virtuais que fazem tarefas sozinhos, imitando o que a gente faria, mas sem precisar ficar de olho neles o tempo todo. Eles são capazes de processar montanhas de dados, aprender com o que rola ao redor e tomar decisões inteligentes. Os principais superpoderes deles incluem:</p><p>- <strong>Autonomia</strong>: Trabalham sozinhos, sem precisar de babá.<br>- <strong>Capacidade de Aprendizado</strong>: Ficam mais espertos com o tempo, graças aos algoritmos de machine learning.<br>- <strong>Orientação a Objetivos</strong>: Foram criados para cumprir missões específicas, tipo suporte ao cliente, análise de dados ou automatização de processos.</p><blockquote>Ta… pera aí! Isso a gente já não tem? É só mais um nome <strong>gourmetizado</strong> para <em>automação de processos</em>? …. Calma ai ansioso… vai lendo…</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KjICAN1mW0ZXOBeSihDKrw.jpeg" /></figure><h3>Como Funcionam os Agentes de IA?</h3><p>Vamos simplificar a parada:</p><p>1. <strong>Percepção</strong>: Os agentes coletam informações do ambiente com sensores ou dados que recebem.<br>2. <strong>Tomada de Decisão</strong>: Processam essas informações usando modelos de IA para decidir o que fazer.<br>3. <strong>Ação</strong>: Executam as ações necessárias para alcançar seus objetivos.<br>4. <strong>Aprendizado</strong>: Aprendem continuamente com os resultados das ações para melhorar no futuro.</p><p>A IA Generativa, que é aquela que cria textos, imagens e vídeos, dá um up nas capacidades desses agentes. Com ela, os agentes conseguem produzir conteúdos e soluções &quot;<strong><em>bem bacanas&quot;</em></strong> e personalizadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QKqnb82rHSKUpbtZ1S5OQA.jpeg" /></figure><h3>Por que os Agentes de IA são consideradas uma Arma Secreta para as Equipes de Tecnologia?</h3><p>Os agentes de IA têm várias vantagens que os tornam indispensáveis para as equipes de tecnologia:</p><h4>1. Aumento da Produtividade</h4><p>Eles pegam as tarefas chatas e repetitivas pra fazer, liberando os devs humanos para se concentrarem em coisas mais complexas e criativas.</p><h4>2. Melhoria na Tomada de Decisões</h4><p>Com a habilidade de processar e analisar grandes quantidades de dados rapidinho, os agentes de IA fornecem <em>insights</em> que levam a decisões mais inteligentes. <br>Eles encontram padrões e tendências que podem passar batido pelos humanos, dando uma vantagem competitiva.</p><h4>3. Escalabilidade</h4><p>Os agentes de IA podem aumentar a operação sem precisar de mais recursos na mesma proporção. Isso é perfeito pra empresas que estão crescendo e projetos que estão bombando.</p><h4>4. Disponibilidade 24/7</h4><p>Diferente da gente, que precisa dormir, os agentes de IA trabalham 24 horas por dia, 7 dias por semana. Eles garantem que as tarefas importantes sejam concluídas sempre a tempo.</p><blockquote>Resultado: produtividade lá em cima e galera mais feliz no trabalho.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vZddq2Jz_fqnAZv8.png" /></figure><h3>Começando com Agentes de IA</h3><p>Se você quer embarcar nessa onda dos agentes de IA também, se liga nessas dicas:</p><ul><li><strong>Entenda os Conceitos Básicos</strong>: Mergulhe nos fundamentos de IA e aprendizado de máquina. O <a href="https://developer.nvidia.com/blog">NVIDIA Developer Blog</a> e o <a href="https://www.marktechpost.com/">MarkTechPost</a> são ótimos pontos de partida.</li><li><strong>Escolha as Ferramentas Certas</strong>: Use frameworks e ferramentas que se alinhem com os objetivos do seu projeto. <em>TensorFlow, PyTorch e a NVIDIA AI Kit, Groc, Crew AI </em>são bem populares.</li><li><strong>Experimente e Itere</strong>: Comece com projetos pequenos e vá aumentando gradualmente. Experimentar é a chave pra entender as capacidades e limitações dos agentes de IA.</li><li><strong>Colabore</strong>: Participe da comunidade de desenvolvedores. Fóruns, concursos e projetos colaborativos podem te dar insights valiosos e acelerar seu aprendizado.</li></ul><blockquote>Estou gostando do Crew AI, não tem interface visual ainda, mas é muito simples de usar (não precisa “saber programar”), documentação bem descritiva, enfim, vale dar uma olhada…</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aF_92BHXGbwuEOe-qYm1EQ.jpeg" /></figure><h3>Exemplos de Uso de Agentes de IA</h3><p>Para entender melhor o impacto dos agentes de IA, vamos dar uma olhada em alguns exemplos práticos de como eles podem ser usados:</p><ol><li><strong>Suporte ao Cliente Automatizado:</strong> Empresas podem usar agentes de IA para gerenciar chatbots que fornecem atendimento ao cliente 24/7. Esses agentes conseguem responder perguntas frequentes, resolver problemas comuns e encaminhar questões mais complexas para um atendente humano.</li><li><strong>Análise de Dados em Tempo Real:</strong> Agentes de IA podem monitorar grandes volumes de dados em tempo real para detectar anomalias, prever tendências de mercado e fornecer insights acionáveis para as equipes de marketing e vendas.</li><li><strong>Automatização de Processos de TI:</strong> Em operações de TI, agentes de IA podem automatizar tarefas repetitivas, como atualizações de software, gerenciamento de segurança e monitoramento de sistemas, reduzindo a carga de trabalho dos administradores de sistemas.</li><li><strong>Assistentes Pessoais Virtuais:</strong> No ambiente corporativo, assistentes pessoais virtuais podem ajudar os funcionários a gerenciar suas agendas, organizar reuniões e lembrar de prazos importantes, aumentando a eficiência e a produtividade.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*85ddeDDu-CfDRP2O09KqXw.jpeg" /></figure><h3>Casos de Uso Reais de Agentes de IA</h3><p>Para trazer uma perspectiva ainda mais atual, se liga em alguns cases com esses AI Agents:</p><ol><li><strong>Marketing Personalizado:</strong> Empresas como Cosabella usam IA para criar campanhas publicitárias personalizadas com base no histórico de compras e interações nas redes sociais dos clientes, aumentando a eficiência das campanhas de marketing​ (<a href="https://clickup.com/blog/ai-use-cases/">ClickUp</a>).​</li><li><strong>Saúde:</strong> A Johns Hopkins University utiliza <strong>machine learning</strong> para quantificar a resposta ao tratamento do câncer de pulmão a partir de tomografias, permitindo ajustes no tratamento <strong><em>cinco meses antes dos métodos tradicionais</em></strong>​ (<a href="https://medwave.io/2024/01/how-ai-is-transforming-healthcare-12-real-world-use-cases/">Medwave Billing &amp; Credentialing</a>)​.</li><li><strong>Imobiliário:</strong> A Zillow usa IA para prever valores de imóveis com alta precisão, ajudando compradores e vendedores a tomar decisões mais informadas​ (<a href="https://www.mckinsey.com/industries/real-estate/our-insights/generative-ai-can-change-real-estate-but-the-industry-must-change-to-reap-the-benefits">McKinsey &amp; Company</a>)​.</li><li><strong>Atendimento ao Cliente:</strong> A Domino’s Pizza utiliza um chatbot chamado Dom para receber pedidos, rastrear entregas e até entreter os clientes com piadas​ (<a href="https://sproutsocial.com/insights/ai-use-cases-in-marketing/">Sprout Social</a>)​.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FrXsFVD64gPiBkhZRosHxA.jpeg" /></figure><h3>Conclusão</h3><p>Os agentes de IA não são só coisinha de filme futurista; eles já estão aqui e estão mudando a forma como as equipes de tecnologia trabalham. Com sua autonomia, capacidade de aprendizado e escalabilidade, os devs podem atingir novos níveis de eficiência e inovação. À medida que exploramos e expandimos o potencial dos agentes de IA, uma coisa é certa: o futuro da tecnologia é brilhante, e os agentes de IA estão na linha de frente dessa revolução.</p><p>Ficou empolgado pra mergulhar no mundo dos agentes de IA? Conta aí nos comentários o que você acha!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3713a06995a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/ai-agents-uma-equipe-extra-b3713a06995a">AI Agents: Uma equipe &quot;extra&quot;</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA['Ás na manga' da Intel: O Processador Lunar Lake]]></title>
            <link>https://medium.com/havanlabs/%C3%A1s-na-manga-da-intel-o-processador-lunar-lake-b6582cbe01cc?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/b6582cbe01cc</guid>
            <category><![CDATA[tecnologia]]></category>
            <category><![CDATA[lunarlake]]></category>
            <category><![CDATA[inovação]]></category>
            <category><![CDATA[intel]]></category>
            <dc:creator><![CDATA[Klaus Dellano]]></dc:creator>
            <pubDate>Sat, 08 Jun 2024 21:19:55 GMT</pubDate>
            <atom:updated>2024-06-08T21:19:55.345Z</atom:updated>
            <content:encoded><![CDATA[<p>A indústria de tecnologia é um ambiente em constante evolução. Para empresas que desejam permanecer no topo, a mudança não é apenas necessária, é vital. A Intel, que basicamente domina o mercado de processadores, tem plena consciência dessa realidade.</p><p>Recentemente, a empresa anunciou uma mudança considerável em sua estratégia com o próximo processador, o Lunar Lake. Vamos entender o que está por vir e como isso pode impactar a <strong><em>guerra dos chips</em></strong>!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/457/1*An4vqL5tEP6UzU_PuCaOwQ.png" /></figure><h3>Seguindo uma estratégia alternativa e inovadora</h3><p>Até agora, a Intel seguiu um padrão bastante consistente em sua linha de arquiteturas de processadores, como um relógio suíço.</p><p>Masssss, isso está prestes a mudar.</p><p>A empresa planeja adotar um modelo alternado, oscilando entre arquiteturas de desempenho e eficiência.</p><p>Essa transformação representa um esforço estratégico da Intel para competir de maneira mais efetiva com seus principais concorrentes, a AMD e a Apple, que já implementaram abordagens similares. Se você achava que a briga no mercado de processadores estava acirrada, prepare-se para &quot;<em>mutxas-loukuras</em>&quot;!</p><p>Mas por que isso é tão importante? Veja bem, meu pequenino… no mundo dos processadores, ter um chip que equilibre velocidade e eficiência é como encontrar <em>(leia como se uma voz santificada surgisse na luz)</em> o <strong>Santo Graaaaaaaal</strong>.</p><figure><img alt="pessoa com 11 dedos santificando um chip" src="https://cdn-images-1.medium.com/max/1000/0*hYaApOVvo1Ke5y9w" /><figcaption>pessoa com 11 dedos santificando um chip</figcaption></figure><p>Com esse novo modelo alternado, a Intel espera trazer uma combinação de poder de processamento bruto e uma eficiência energética que vai fazer seu notebook durar mais que uma maratona de série da Netflix.</p><h3>Processo de Fabricação de 3nm?</h3><p>Vamos entrar agora no campo técnico (mas fique tranquilo, vou explicar do jeito mais fácil que eu puder!)</p><p>Já ouviu falar em nanômetros? Não? Bom, basicamente, quanto menor, melhor. É como cortar um bolo em fatias tão finas que dá pra alimentar mais gente (ou no caso, mais dados). <em>(Não necessariamente para matar a fome, mas você entendeu……)</em></p><p>Dizem por aí que o Lunar Lake pode ser fabricado com um processo de 3nm. Isso seria um baita avanço, tipo trocar o seu Fusca 69 por um Tesla novinho em folha. 🚗⚡ Ainda não é certeza, mas se isso acontecer &quot;<strong><em>meu brother</em></strong>&quot;………………………………..</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/676/1*6acPWvNSvKBbRRA2mUmHcw.png" /></figure><p>Por que isso importa tanto? Imagine conseguir enfiar mais transistores em um espaço menor.</p><h4>É como tentar colocar mais nerds numa sala de aula: quanto mais, melhor!</h4><blockquote>em termos de eficiência e poder de processamento, claro</blockquote><p>Se a Intel realmente conseguir chegar aos 3nm, isso não só vai aumentar a potência dos processadores, mas também a eficiência energética, permitindo dispositivos mais rápidos e que duram mais tempo longe da tomada.</p><h3>Futuro = Chiplets?</h3><p><strong><em>Chiplets.</em></strong> Esse nome parece de salgadinho, né? Mas calma, é melhor que Doritos! A Intel está considerando usar chiplets nos seus processadores futuros. Basicamente, é como montar um Lego super avançado, onde cada peça é um mini processador.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*uHhQhNvUP5ouGYMVoUbdzA.png" /></figure><h4>E…?</h4><p>E………. isso significa que os processadores podem ficar mais eficientes e poderosos, quase como um super-herói high-tech. 🦸‍♂️🦸‍♀️ E sim, a Intel está de olho nos seus rivais, que já estão brincando de &quot;Lego&quot; faz tempo.</p><h4>Mágica ou Canivete Suíço?</h4><p>Pense nos chiplets como módulos independentes que podem ser combinados para criar um processador completo. Cada chiplet pode ser otimizado para uma tarefa específica, seja desempenho bruto, gráficos ou eficiência energética. Isso dá à Intel a flexibilidade de criar processadores que são verdadeiros canivetes suíços tecnologicamente mágicos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/1*ALEPCh4aic13dHj8y-VAgA.png" /></figure><p>Além disso, usar chiplets pode reduzir custos e melhorar a produção. Em vez de fabricar um único grande chip, a Intel pode fabricar vários chiplets menores e depois juntá-los, como um quebra-cabeça. Isso é inovação na prática, meus <em>biru-birus</em>!!</p><h3>Conclusão</h3><p>A Intel está claramente saindo da zona de conforto com o Lunar Lake, apostando em novas estratégias como a fabricação de 3nm e a estrutura de chiplets. Eles estão tipo, “Ok, pessoal, vamos parar de jogar no modo fácil e partir pro hard!”</p><blockquote>(quero dizer nada não… mas até que enfim né?)</blockquote><p>Vai ser <em>curiosamente emocionante</em> ver como essas mudanças vão se desenrolar. Se tudo der certo, poderemos ver a Intel subindo de novo no pódio da inovação tecnológica. Então, preparem a pipoca, porque essa novela tecnológica promete muitos capítulos emocionantes! 🍿</p><blockquote>Não vai mudar muito o seu dia a dia porque vai ser tão caro quanto as inovações na NVIDIA… mas vai poder assistir reviews e unboxing de alguns youtubes…</blockquote><p>Essas mudanças não são apenas um sinal de que a Intel está se adaptando ao mercado competitivo, mas também uma indicação de que eles estão dispostos a arriscar e inovar. Então, se você é um entusiasta de tecnologia como eu, fique de olho, porque o futuro dos processadores promete ser &quot;<strong><em>mutxo</em></strong>&quot;, mas &quot;<strong><em>mutxo-loko</em></strong>&quot;!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/1*v6UmMgYkNamqOafOgTzvCA.png" /></figure><p>Bom… fiquei animado com essas notícias e estou torcendo para que a Intel traga outras surpresinhas para o mercado. Espero que tenha te deixado animado também… Enfim, é sobre isto… até a próxima manolos!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6582cbe01cc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/%C3%A1s-na-manga-da-intel-o-processador-lunar-lake-b6582cbe01cc">&#39;Ás na manga&#39; da Intel: O Processador Lunar Lake</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A tecnologia que empodera o Portal do Cliente Havan]]></title>
            <link>https://medium.com/havanlabs/a-tecnologia-que-empodera-o-portal-do-cliente-havan-5854dbcbbf88?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/5854dbcbbf88</guid>
            <category><![CDATA[react-query]]></category>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[stitches]]></category>
            <category><![CDATA[css-modules]]></category>
            <dc:creator><![CDATA[Daniel Boso]]></dc:creator>
            <pubDate>Wed, 22 May 2024 13:11:04 GMT</pubDate>
            <atom:updated>2024-05-22T13:11:04.591Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2kmVd5GqyCjv2pp4" /><figcaption>Photo by <a href="https://unsplash.com/@jameswiseman?utm_source=medium&amp;utm_medium=referral">James Wiseman</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Este artigo busca compartilhar a experiência do processo de reconstrução do <a href="https://portalcliente.havan.com.br/">Portal do Cliente Havan</a>, sua evolução e tecnologia nele empregadas como também os desafios encontrados neste processo.</p><p>O desafio de recriar o Portal do Cliente se iniciou logo após ter construído uma aplicação de uso interno e também após o lançamento do Portal de Negociação Havan.</p><p>Com este desafio, houve a decisão de utilizar o framework Next.js e a biblioteca CSS-in-JS chamada Stitches. Tal decisão se deve ao fato de observar na própria comunidade do React a recomendação de se utilizar algum framework ao invés do tradicional <em>create-react-app. </em>Além disso, a comunidade do Next.js só vem crescendo e hoje temos features muito interessantes como o suporte a server side rendering, cache e toda a arquitetura de roteamento de páginas, layouts, etc.</p><p>Quanto ao Stitches, a escolha foi determinada pela sua api simples e prática para criar componentes mais complexos e modificá-los de forma fácil. Seu maior ganho se dá através da estrutura de criar variantes e variantes compostas. Isso se tornou necessário para cumprir com o desafio de desenvolver o frontend de forma tão rápida, onde neste momento era preciso criar os próprios componentes core, tais como buttons, inputs, etc. Neste meio tempo, mudanças no ecossistema React demandariam que o Stitches tivesse que realizar modificações significativas para suportar server side rendering, problemas que outras bibliotecas sofreram e neste momento em que escrevo muitas delas já resolveram. Apesar disso, a ocorrência da indisponibilidade do criador do repositório, e aviso no repositório sobre não ter mais manutenção foi um fator determinando para considerar uma migração de biblioteca.</p><p>Isso teve um certo impacto próximo a data de release, quando após fazer o primeiro deploy para o ambiente de desenvolvimento, o css da aplicação simplesmente não funcionava. Neste momento, via o problema do Stitches em relação a server side rendering, e era preciso uma solução rápida pois a release estava a caminho. A solução consistiu em muita pesquisa em canais confiáveis como o próprio github da biblioteca. A solução abaixo integrou a biblioteca com o Next.js e resolveu o problema do css no site.</p><pre>&quot;use client&quot;;<br><br>import { ReactNode, useState } from &quot;react&quot;;<br>import { useServerInsertedHTML } from &quot;next/navigation&quot;;<br>import { getCssText } from &quot;@styles/config&quot;;<br><br>export default function StitchesRegistry({ children }: {<br>  children: ReactNode;<br>}) {<br>  const [isRendered, setIsRendered] = useState(false);<br><br>  useServerInsertedHTML(() =&gt; {<br>    if (!isRendered) {<br>      setIsRendered(true);<br>      return (<br>        &lt;style<br>          id=&quot;stitches&quot;<br>          dangerouslySetInnerHTML={{ __html: getCssText() }}<br>        /&gt;<br>      );<br>    }<br>  });<br><br>  return &lt;&gt;{children}&lt;/&gt;;<br>}</pre><p>Junto ao Stitches, foi utilizado uma biblioteca de componentes de baixo nível seu foco não é estilos mas sim acessibilidade, customização e experiência do desenvolvedor, onde apenas é preciso escrever os etilos para estes componentes. Tal biblioteca se chama radix-ui e é implementada utilizando <em>dot notation</em>. Sua documentação pode ser vista <a href="https://www.radix-ui.com/primitives/docs/overview/introduction">aqui</a>.</p><p>Após a publicação do site, houve mudança no DNS para que o tráfego do site antigo fosse redirecionado para o site novo. Com isso, o site estaria oficialmente em produção. Por exemplo, <a href="http://cliente.havan.com.br/">cliente.havan.com.br/{path}</a> seria traduzido para <a href="https://portalcliente.havan.com.br/">portalcliente.havan.com.br/{path}</a>. Isso gerou alguns problemas tais como se houvesse algum <em>path</em> que existisse no site antigo e não existisse no novo, o cliente cairia na página 404. Tais URLs do sistema antigo ainda estavam indexadas no google, podendo ainda estar salvo o endereço antigo no navegador do cliente e na indexação do Google.</p><p>Para resolver este problema, pode-se dizer que a solução saiu da cartola de um mágico. O mágico era o Next.js. O framework possui um backend, onde as páginas são obtidas através de requests e com isso há um mecanismo disponível para fazer redirecionamentos. Tal configuração é feita no arquivo de configuração do Next.js chamado <em>next.config.js. </em>Um exemplo do que foi feito pode ser visto abaixo.</p><pre>module.exports = {<br>  async redirects() {<br>    return [<br>      {<br>        source: &#39;/cartao/:path*&#39;,<br>        destination: &#39;/cartao-havan&#39;,<br>        permanent: true,<br>      },<br>    ]<br>  },<br>}</pre><p>É preciso declarar a função <em>redirects </em>e seu retorno é uma lista de configurações de redirecionamento. O atributo <em>source </em>indica o padrão da request <em>/cartao/:path*</em>, o atributo <em>destination </em>indica para onde será redirecionado para a página <em>/cartao-havan</em> e o atributo <em>permanent </em>como true sinaliza as engines de pesquisa para fazer o cacheamento do redirect. No Atributo <em>source </em>é possível indicar expressões regulares, e no caso de <em>:path*</em>, indica que qualquer endereço iniciando em <em>/cartao/ </em>o redirect será realizado. Essa feature de redirecionamentos pode ir muito além e fazer mais do que um simples redirecionamentos e é muito bem documentada na <a href="https://nextjs.org/docs/app/api-reference/next-config-js/redirects">documentação</a>.</p><p>No Next.js, utilizando o roteamento com a pasta <a href="https://nextjs.org/docs/app/building-your-application/routing"><em>app</em></a> temos os arquivos de rotas formados por arquivos ou pastas e estes precisam conter um arquivo chamado <em>page</em> com as extensões .js, jsx ou tsx. Desta maneira, a página já será criada e roteada pelo framework.</p><p>Nas últimas versões do Next.js, compatível com React 18 ou acima, ele possui um atributo de configuração para utilizar renderização de componentes do lado do servidor (SSR) e este vem ativo como padrão. Este artigo não descreverá em detalhes seus benefícios pois estão muito bem descritos <em>n</em>a <a href="https://nextjs.org/docs/app/building-your-application/rendering/server-components"><em>documentação</em></a>. Esta configuração pode ser desativada em cada componente fazendo uso da diretiva <em>“use client”</em> e o componente será renderizado do lado do cliente. Um exemplo pode ser visto no código abaixo.</p><pre>&quot;use client&quot;;<br><br>export function Component() {<br>...<br>}</pre><p>Um dos usos do SSR, é em relação a SEO. É utilizado para configurar título, descrição da página entre outras várias configurações possíveis. Neste caso, é preciso que o componente seja renderizado do lado do servidor, pois o framework irá incluir os metadados no processo de build e renderizado no servidor.</p><pre>import { Metadata } from &quot;next&quot;;<br>import { default as Home } from &quot;./_home&quot;;<br><br>export const metadata: Metadata = {<br>  title: &quot;Portal do Cliente Havan&quot;,<br>  description:<br>    &quot;Acesse sua conta e acompanhe sua fatura do Cartão Havan. Veja seu limite, histórico de compras e muito mais.&quot;,<br>};<br><br>export default Home;</pre><p>Outro uso é a requisição de dados do lado do servidor. Para isto, devemos utilizar a função fetch, pois o Next.js herda a api de fetch a exportando com algumas configurações tais como o atributo <em>revalidate</em>, onde determina quanto tempo, em segundos, os dados ainda estarão válidos. Ao se tornarem inválidos, o framework irá automaticamente refazer a request e atualizar estes dados. Vale lembrar que estes dados estarão cacheados no servidor. Isto implica que ao carregar a página, os dados já virão com a página, sem a necessidade que cada cliente faça a request para o backend, reduzindo a apenas uma realizada pelo backend do Next.js.</p><pre>import { Metadata } from &quot;next&quot;;<br><br>async function getData() { <br>  return fetch(url, {<br>      next: { revalidate: 3600 },<br>  })<br>}<br><br>export default async function Page() {<br>  const data = await getData();<br><br>  return (<br>    ...<br>  );<br>}</pre><p>Em questões de roteamento de páginas, contamos com o uso de <a href="https://nextjs.org/docs/app/building-your-application/routing/layouts-and-templates"><em>layouts</em></a> e também layouts juntamente com <a href="https://nextjs.org/docs/app/building-your-application/routing/parallel-routes"><em>roteamento paralelo</em></a>. O uso de layouts tem a mesma finalidade que os tradicionais layouts do react-router-dom, por exemplo. Para criar um layout basta apenas criar um arquivo chamado <em>layout</em> com as extensões .js, .jsx ou .tsx. Tal exemplo pode ser visto abaixo, onde o <em>children</em> será o componente referente ao arquivo <em>page</em> já descrito anteriormente, presente no mesmo nível de pasta.</p><pre>import { Fragment, PropsWithChildren, useEffect } from &quot;react&quot;;<br><br>import Navbar from &quot;@/components/navbar&quot;;<br>import Footer from &quot;@/components/footer&quot;;<br><br>export default function Layout({ children }: PropsWithChildren) {<br>  return (<br>    &lt;Fragment&gt;<br>      &lt;Navbar /&gt;<br>      {children}<br>      &lt;Footer /&gt;<br>    &lt;/Fragment&gt;<br>  );<br>}</pre><p>Após melhorias de performance, os primeiros problemas com o Stitches vs SSR começaram a aparecer. O primeiro é que não era possível utilizar esta biblioteca utilizando <em>server side rendering</em>, o que não invibializa algumas melhorias de performance tais como a utilização do fetch aliado com cache no backend do Next.js. Porém, não era possível importar componentes criados com ela em componentes que não faziam uso da diretiva <em>use client</em>. Outro problema encontrado, foi quando integramos o <a href="https://clarity.microsoft.com/">Microsoft Clarity</a>. Como o CSS era injetado na página, e o Clarity necessita de arquivos de CSS disponibilizados publicamente, os estilos apareciam completamente quebrados.</p><p>Uma opção para resolver o problema foi utilizar CSS Modules, pois o próprio Next.js possui suporte e está mais próximo do CSS nativo, ótimo para evitar conflitos e melhorar a manutenção. A migração exigiu apenas o trabalho repetitivo de criar os arquivos de estilos, copia-los, converter os atributos de camelCase para kekab-case e importá-lo no arquivo do componente.</p><p>Após ir migrando os componentes aos poucos, já foi possível observar melhorias nas métricas de desempenho disponibilizadas pelo Clarity, tais como LCP, FID e CLS. A migração dos estilos para CSS Modules foi uma escolha muito boa, pois agora o Clarity consegue capturar os estilos das páginas e renderizá-las perfeitamente, possibilitando com que dados de uso das páginas possam ser utilizadas para identificar pontos de melhorias.</p><p>Outra ferramenta utilizada amplamente é o react-query, onde permite cachear dados de requests no frontend. É mais utilizado em relação a dados do usuário, requests mais específicas onde cachear diretamente pelo Next.js não seria adequado. Com ele, é possível reduzir número de requests ao backend e carregar informações para o cliente de forma mais rápida.</p><p>Sendo assim, o Portal do Cliente, segue fundamentado em um dos melhores frameworks para React aliado com suas últimas features e bibliotecas que só vem acrescentar, garantiando assim uma ótima experiência ao cliente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5854dbcbbf88" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/a-tecnologia-que-empodera-o-portal-do-cliente-havan-5854dbcbbf88">A tecnologia que empodera o Portal do Cliente Havan</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Canary Leak — Um “X9 do Bem”]]></title>
            <link>https://medium.com/havanlabs/canary-leak-um-x9-do-bem-f68a2443057d?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/f68a2443057d</guid>
            <category><![CDATA[memory-leak]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[leak-detection]]></category>
            <dc:creator><![CDATA[Klaus Dellano]]></dc:creator>
            <pubDate>Mon, 06 May 2024 13:02:13 GMT</pubDate>
            <atom:updated>2024-05-06T13:02:12.715Z</atom:updated>
            <content:encoded><![CDATA[<h3>Canary Leak — Um “X9 do Bem”</h3><p>Se você já enfrentou desafios com vazamentos de memória que deixam seus aplicativos lentos ou até mesmo instáveis, você vai gostar de conhecer a <strong><em>Canary Leak.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*OokLjJS0CGvK9Ul3.png" /></figure><h4>Mas o que são vazamentos de memória?</h4><p>São situações em que a memória que deveria ser liberada não é, levando a uma diminuição progressiva da memória disponível. Isso pode causar lentidão e até mesmo fazer com que o aplicativo pare de funcionar.</p><h4>O que é a Canary Leak?</h4><p>A <em>Canary Leak</em> é uma ferramenta de detecção (X9) de vazamento de memória. Com ela, é possível identificar e corrigir esse problemas em seus aplicativos Android de forma eficiente, podendo ser uma verdadeira aliada na otimização dos seus apps…</p><h4>ta… blz… e quais a vantagens?…</h4><p>Com uma interface intuitiva, uso simples e verificação em tempo real… são os principais pontos que ajudam na identificação dos vazamentos e agilizam o processo de correção.</p><h4>e como se usa esse treco?</h4><p>Imagine que você está desenvolvendo um aplicativo e, de repente, ele começa a ficar lento (coisa chata né?). Segue os exemplos mais comuns (e que pode até ser o seu)…</p><ul><li><strong>Monitoramento de Fragmentos </strong><br>Se você estiver trabalhando com múltiplos fragmentos e observar que eles não estão sendo destruídos corretamente. Pode ser que exista algum vazamento de memória associado a eles.<br>Por exemplo, você pode ter um fragmento que não está sendo destruído porque está retendo uma referência a uma Activity.</li></ul><pre>class MyFragment: Fragment() {<br>    private lateinit var myActivity: Activity<br><br>    override fun onAttach(context: Context) {<br>        super.onAttach(context)<br>        myActivity = context as Activity<br>    }<br>}</pre><ul><li><strong>Verificação de Listeners</strong> <br>Listeners são uma fonte comum de vazamentos de memória. <br>Por exemplo, você pode <em>registrar </em>um listener, mas esquecer de ‘<em>desregistrar</em>’ quando não for mais necessário.</li></ul><pre>class MyActivity: Activity() {<br>    private val myListener = MyListener()<br><br>    override fun onStart() {<br>        super.onStart()<br>        MySingleton.registerListener(myListener)<br>    }<br><br>    override fun onStop() {<br>        super.onStop()<br>        // Esquecemos de desregistrar o listener aqui<br>        // Obrigado CanaryLeak &#39;S2&#39;<br>    }<br>}</pre><ul><li><strong>Examinar o uso de objetos grandes</strong> <br>Objetos grandes que são mantidos na memória podem causar problemas de desempenho. <br>Será que esses objetos estão sendo retidos por mais tempo do que o necessário?</li></ul><pre>class BigObjectActivity: Activity() {<br>    private lateinit var bigObject: BigObject<br><br>    override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br>        bigObject = BigObject()<br>    }<br><br>    // Esquecemos de liberar o bigObject aqui<br>    // CanaryLeak, nos te amamos!<br>}</pre><ul><li><strong>Verificação de Serviços</strong> <br>Serviços em Android podem ser uma fonte de vazamentos de memória, especialmente se eles retêm contextos.</li></ul><pre>class MyService : Service() {<br>    private lateinit var myContext: Context<br><br>    override fun onCreate() {<br>        super.onCreate()<br>        myContext = this<br>    }<br>}</pre><ul><li><strong>Análise de Threads</strong><br>Threads que não são interrompidas corretamente podem causar vazamentos de memória.<br>Suponha que você tenha uma Thread executando em segundo plano para realizar uma tarefa longa, como baixar um arquivo.</li></ul><pre>class DownloadThread(private val url: String) : Thread() {<br>    override fun run() {<br>        // Código para baixar o arquivo aqui<br>    }<br>}</pre><p>Agora, se você iniciar esta Thread em uma Activity…</p><pre>class MyActivity : Activity() {<br>    private lateinit var downloadThread: DownloadThread<br><br>    override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br>        downloadThread = DownloadThread(&quot;&lt;http://example.com/file&gt;&quot;)<br>        downloadThread.start()<br>    }<br>}</pre><p>… e então sair da Activity antes da Thread terminar, a Thread poderá reter uma referência da Activity, causando um vazamento de memória.</p><blockquote>Este é um exemplo típico de vazamento que pode ser difícil de detectar sem uma ferramenta como o Canary Leak.</blockquote><p>Ao usar o Canary Leak, você seria notificado sobre o problema e poderia então tomar medidas para corrigi-lo… poderia, por exemplo, fazer com que a Thread seja interrompida quando a Activity for destruída:</p><pre>class MyActivity : Activity() {<br>    private lateinit var downloadThread: DownloadThread<br><br>    override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br>        downloadThread = DownloadThread(&quot;&lt;http://example.com/file&gt;&quot;)<br>        downloadThread.start()<br>    }<br><br>    override fun onDestroy() {<br>        super.onDestroy()<br>        if (downloadThread.isAlive) { // Agradeça ao Canary Leak <br>            downloadThread.interrupt()<br>        }<br>    }<br>}</pre><p>Desta forma, a Thread não reterá mais a Activity depois que ela for destruída, evitando o vazamento de memória.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fH97AGIfHXfSHE3g.png" /></figure><h3>Resumindo…</h3><p>a Canary Leak é uma ferramenta que facilita a identificação e correção de vazamentos de memória, ajudando a melhorar a performance dos seus aplicativos. (Essencial para qualquer desenvolvedor Android)…</p><p>Iai? Deu vontade de usar essa ferramenta? Ou você utiliza outras opções para melhorar a performance? Quais?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f68a2443057d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/canary-leak-um-x9-do-bem-f68a2443057d">Canary Leak — Um “X9 do Bem”</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pílula K#09 — Tipos Numéricos]]></title>
            <link>https://medium.com/havanlabs/p%C3%ADlula-k-09-tipos-num%C3%A9ricos-3e4e864a0063?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/3e4e864a0063</guid>
            <category><![CDATA[data-type]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Klaus Dellano]]></dc:creator>
            <pubDate>Thu, 25 Apr 2024 08:13:43 GMT</pubDate>
            <atom:updated>2024-04-25T08:13:43.733Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pílula K#09 — Tipos Numéricos</h3><p>No universo da programação, os números são mais do que meros dígitos; eles formam a base de quase todas as operações computacionais. Entender como os números funcionam em Kotlin, pode melhorar significativamente a qualidade do código e a eficiência da execução. Na pílula de hoje, exploraremos detalhadamente os tipos numéricos em Kotlin, suas peculiaridades, e como utilizá-los eficazmente em diferentes cenários.</p><h3>1. Tipos de Números e Suas Inferências</h3><p>Kotlin é inteligente o suficiente para inferir tipos de dados, simplificando o trabalho dos programadores. Por exemplo, ao atribuir um número inteiro a uma variável sem especificar seu tipo, Kotlin automaticamente assume que é um Int:</p><pre>fun main() {<br>    val milhao = 1_000_000<br>    println(milhao) <br>}<br><br>/* Saída: <br> * 1000000<br> */</pre><p>Essa inferência automática ajuda a manter o código limpo e legível. Além disso, Kotlin suporta a adição de underscores em números grandes para melhorar a legibilidade, uma pequena, mas valiosa, característica de design da linguagem.</p><h3>2. Operações Matemáticas Básicas e Precedência de Operadores</h3><p>Operações matemáticas são fundamentais em qualquer linguagem de programação, e Kotlin oferece todos os operadores básicos como adição (+), subtração (-), multiplicação (*), divisão (/) e módulo (%). A precedência desses operadores segue regras universais, onde multiplicação e divisão são priorizadas em relação à adição e subtração:</p><pre>fun main() {<br>    println(45 + 5 * 6) <br>    println((45 + 5) * 6) <br>}<br><br>/* Saída<br> * 75<br> * 300<br> */</pre><h3>3. Divisão de Números: Inteiros vs. Flutuantes</h3><p>Ao dividir números em Kotlin, é crucial entender a diferença entre a divisão inteira e a divisão flutuante. A divisão inteira descarta o resto, enquanto a divisão flutuante leva em consideração o valor total dos operandos:</p><pre>fun main() {<br>    val numerador: Int = 19<br>    val denominador: Int = 10<br>    println(numerador / denominador) <br>}<br><br>/* Saída:<br> * 1<br> */</pre><h3>Uso Prático</h3><h3>1. Calculando o Índice de Massa Corporal (IMC)</h3><p>Usar tipos numéricos para resolver problemas do mundo real, como o cálculo do IMC. O Kotlin permite uma manipulação precisa dos dados ao utilizar o tipo Double para esse tipo de cálculo:</p><pre>fun metricaIMC(<br>    peso: Double,<br>    altura: Double<br>): String {<br>    val imc = peso / (altura * altura) // [**]<br>    return if (imc &lt; 18.5) &quot;Abaixo do peso&quot;<br>    else if (imc &lt; 25) &quot;Peso normal&quot;<br>    else &quot;Sobrepeso&quot;<br>}<br><br>fun main() {<br>    val peso = 72.57<br>    val altura = 1.727<br>    val status = metricaIMC(peso, altura)<br>    println(status)<br>}<br><br>/* Saída:<br> * Peso normal<br> */</pre><blockquote>[**] Se você remover os parênteses, você dividirá o peso pela altura e depois multiplicará esse resultado pela altura. Esse é um número muito maior, e a resposta errada.</blockquote><p>metricaIMC() usa Double para o peso e a altura.</p><p>Um Double armazena números flutuantes muito grandes e muito pequenos.</p><p>Aqui está uma versão usando unidades inglesas, representadas por parâmetros Int:</p><pre>fun metricaInglesaIMC(<br>    peso: Int,<br>    altura: Int<br>): String {<br>    val imc = peso / (altura * altura) * 703.07 // [**]<br>    return if (imc &lt; 18.5) &quot;Abaixo do peso&quot;<br>    else if (imc &lt; 25) &quot;Peso normal&quot;<br>    else &quot;Sobrepeso&quot;<br>}<br><br>fun main() {<br>    val peso = 160 // em libras<br>    val altura = 68 // em polegadas<br>    val status = metricaInglesaIMC(peso, altura)<br>    println(status)<br>}<br><br>/* Saída:<br> * Abaixo do peso<br> */</pre><p>Por que o resultado difere de metricaIMC(), que usa Doubles? Quando você divide um inteiro por outro inteiro, Kotlin produz um resultado inteiro.</p><p>A maneira padrão de lidar com o resto durante a divisão inteira é a truncagem, ou seja, &quot;corte e jogue fora&quot; (não há arredondamento).</p><p>Então, se você dividir 5 por 2, obterá 2, e 7/10 é zero.</p><p>Quando Kotlin calcula imc na expressão [**], ele divide 160 por 68 * 68 e obtém zero. Depois, multiplica zero por 703.07 para obter zero.</p><p>Para evitar esse problema, mova 703.07 para o início do cálculo. Os cálculos são então forçados a serem Double: <strong>val imc = 703.07 * peso / (altura * altura)</strong></p><p>Os parâmetros Double em metricaIMC() previnem esse problema. Converta os cálculos para o tipo desejado o mais cedo possível para preservar a precisão.</p><h3>2. Lidando com Limites…</h3><p>Todas as linguagens de programação têm limites para o que podem armazenar dentro de um inteiro. O tipo Int do Kotlin pode assumir valores entre -²³¹ e +²³¹-1, uma restrição da representação Int de 32 bits. Se você somar ou multiplicar dois Ints grandes o suficiente, você estourará o resultado:</p><pre>fun main() {<br>    val i: Int = Int.MAX_VALUE<br>    println(i + i)<br>}<br><br>/* Saída:<br> * -2<br> */</pre><p><strong>Int.MAX_VALUE</strong> é um valor predefinido que é o maior número que um Int pode armazenar. O estouro produz um resultado claramente incorreto, pois é negativo e muito menor do que esperamos.</p><blockquote>Kotlin emite um aviso sempre que detecta um estouro potencial.</blockquote><p>Se o seu programa contiver números grandes, você pode usar Longs, que acomodam valores de -²⁶³ a +²⁶³-1. Para definir um val do tipo Long, você pode especificar o tipo explicitamente ou colocar um L no final de um literal numérico, que informa ao Kotlin para tratar esse valor como um Long:</p><pre>fun main()<br>    val i = 0 // Infere Int<br>    val l1 = 0L // L cria Long<br>    val l2: Long = 0 // Tipo explícito<br>    println(&quot;$l1 $l2&quot;)<br>}<br><br>/* Saída:<br> * 0 0<br> */</pre><p>Ao mudar para Longs, evitamos o estouro em <strong>IntegerOverflow.kt</strong>:</p><pre>fun main() {<br>    val i = Int.MAX_VALUE<br>    println(0L + i + i) // [1]<br>    println(1_000_000 * 1_000_000L) // [2]<br>}<br><br>/* Saída:<br> * 4294967294<br> * 1000000000000<br> */</pre><p>Usando um literal numérico tanto em [1] quanto em [2] força os cálculos Long, e também produz um resultado do tipo Long. A localização onde o L aparece é irrelevante. Se um dos valores for Long, a expressão resultante será Long.</p><p>Embora possam armazenar valores muito maiores que os Ints, os Longs ainda têm limitações de tamanho:</p><pre>fun main() {<br>    println(Long.MAX_VALUE)<br>}<br><br>/* Saída:<br> * 9223372036854775807<br> */</pre><p><strong>Long.MAX_VALUE</strong> é o maior valor que um Long pode armazenar.</p><p>eeeeeeeeeeeeeeeeeeeeee….</p><p>E chegamos ao final de outra dose… e com ela espero que você tenha entendido (pelo menos um pouco) os tipos numéricos no Kotlin. Por &quot;parível que increça&quot;, não aplicar corretamente os tipos, pode impactar significativamente o desempenho e a confiabilidade do seu aplicativo.</p><p>vlwflw, Até a próxima….</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/0*jOjFG-Pb69CeBdRO.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e4e864a0063" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/p%C3%ADlula-k-09-tipos-num%C3%A9ricos-3e4e864a0063">Pílula K#09 — Tipos Numéricos</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Freedom Design System]]></title>
            <link>https://medium.com/havanlabs/freedom-design-system-0bf2277fbcde?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/0bf2277fbcde</guid>
            <category><![CDATA[enterprise-software]]></category>
            <category><![CDATA[havan]]></category>
            <category><![CDATA[complex-problem-solving]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ui-design]]></category>
            <dc:creator><![CDATA[Havan Labs]]></dc:creator>
            <pubDate>Tue, 02 Apr 2024 19:16:53 GMT</pubDate>
            <atom:updated>2024-04-02T19:16:53.540Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A frase “freedom DS” seguida do logo Havan e uma a fachada de uma loja havan no fundo durante o por do sol." src="https://cdn-images-1.medium.com/max/1000/1*TXyKzJidGqVxIMeIjSw38Q.png" /></figure><p>Na Havan a liberdade tecnológica é essencial para o negócio, por isso construímos e evoluímos nossa própria tecnologia. Esse recurso é que nos dá a agilidade para se adaptar as mudanças do mercado de varejo brasileiro. São diversas ferramentas para garantir o sucesso da operação e a inovação no negócio, entre a compra e a venda de cada produto existem inúmeros processos e tecnologias envolvidas.</p><p>Para garantir a excelência tecnológica necessária para encantar colaboradores e fornecedores, investimos em uma inteligência coletiva através de um design system.</p><p>Nesse contexto, como resultado do esforço de pessoas que querem melhores experiências para usuários e de uma liderança que acredita na excelência tecnológica, nasce o FreeDOM como ferramenta para garantir a qualidade de uso e velocidade de entrega dos sistemas de uso interno da Havan.</p><p><strong>Hoje o FreeDOM design system é usado por mais de 300 profissionais de tecnologia, que compões o Havan Labs e impacta positivamente na qualidade de uso dos sistemas para os mais de 18.000 colaboradores espalhados por 175 lojas no Brasil.</strong></p><figure><img alt="dez exemplos de telas genéricas utilizando os elementos do freedom design system" src="https://cdn-images-1.medium.com/max/700/0*luDnypfYkr58aP5I.png" /></figure><h3>Pilares do design system</h3><p>Existem 4 pilares norteadores para o desenho e manutenção do FreeDOM DS. Isso não quer dizer que outras preocupações não são levadas em consideração, mas que estas são as prioridades na hora da tomada de decisão.</p><ul><li><strong>Projetado para o complexo:</strong> Deve ser suporte para cenários desafiadores com atividades complexas e grandes quantidades de informação.</li><li><strong>Projetado para evolução:</strong> Deve ser focado em flexibilidade na realização de tarefas, atendendo usuários iniciantes, mas oferecendo recursos avançados para acelerar a produtividade dos usuários mais experientes.</li><li><strong>Projetado para o sucesso:</strong> Deve ser pensado com atenção dobrada para prevenir e recuperar erros e deslizes do usuário, garantindo o sucesso contínuo das operações.</li><li><strong>Projetado para o foco:</strong> Dever ser cuidadoso nos detalhes, pensado para gerenciar a atenção do usuário entre as tarefas do sistema e as operacionais.</li></ul><h3>Organização</h3><p>O FreeDOM funciona com 4 principais fontes de informação sendo 3 delas bibliotecas de componentes.</p><p><strong>Tokens:</strong> É fonte de verdade para as libs e conta com as definições base para qualquer componente (ex. Cores, espaçamentos, curva de borda);<br><strong>Base lib:</strong> É uma biblioteca com componentes base, ou seja, não consomem outro componentes como dependência (ex. Botões, tags, checkbox);<br><strong>Core lib:</strong> É a biblioteca com os componentes mais estruturados, e que dependem dos componentes base para sua composição (ex. Filtro, Data grid, Total cards);<br><strong>Sup lib:</strong> É uma biblioteca com outros elementos que podem ser utilizados para compor os componentes ou em conjunto com componentes (ex. Ícones, Imagens, Ilustrações);</p><figure><img alt="Diagrama mostrando como as bibliotecas estão conectadas" src="https://cdn-images-1.medium.com/max/700/0*RdgoxHxvtHVa7j2-.png" /></figure><p>As bibliotecas são desenvolvidas em react e ficam localizadas em nossa CDN para uso dos colaboradores do Havan Labs. De forma espelhada as mesmas bibliotecas estão presentes em ambiente no figma e podem ser utilizadas por qualquer designer da organização.</p><h3>Documentação</h3><p>A documentação foi construída utilizando storybook e dividida em duas partes, a documentação de diretrizes para utilizar o design system e a documentação de componentes para auxiliar na aplicação dos componentes na interface.</p><figure><img alt="Foto de duas páginas da documentação" src="https://cdn-images-1.medium.com/max/700/0*54WN5NdM65anTT9k.png" /></figure><p><strong>Documentação de diretrizes:</strong></p><ul><li>Princípios do FreeDOM (para manter a organização alinhada quanto as prioridades do sistema);</li><li>Regras de aplicação para os tokens (para quando for necessário criar componentes ou atender um cenário não previsto);</li><li>Organização da arquitetura dos componentes (para ajudar a encontrar e entender o funcionamento dos componentes);</li><li>Guia de aplicação para sistemas (Para garantir a consistência em outros aspectos como texto, navegação, feedback);</li></ul><p><strong>Documentação de componentes:</strong></p><ul><li>Declaração sobre o contexto que deve ser usado (quando usar);</li><li>Previsão de outros cenários que não devem ser usados, com indicação do que deve ser usado;</li><li>Utilização de hiperlinks para navegação rápida entre outros componentes relacionados;</li><li>Dicas com exemplos de aplicações recomendadas, não recomendadas e exceções.</li></ul><h3>Próximos passos</h3><p>O design system traz para o Havan Labs grandes poderes e grandes responsabilidades com o amadurecimento do produto, que faz seu primeiro aniversário no mês de Abril desse ano (2024).</p><p>Para os próximos passos estamos:<br>- Analisando o uso na mão do nosso usuário; <br>- Otimizando processos de governança; <br>- Criando novos componentes para atender outras necessidades;<br>- Replicando as bibliotecas para uso em Genexus.</p><p>Nosso foco é tornar o FreeDOM uma ferramenta cada vez mais eficaz para contribuir com nosso propósito de:</p><blockquote><strong><em>Garantir a excelência tecnológica e transformar ideias em soluções inovadoras que agregam valor ao nosso negócio e encantam clientes, colaboradores e fornecedores.</em></strong></blockquote><p>Leia também:</p><ul><li><a href="https://medium.com/havanlabs/aumentando-a-qualidade-de-exposi%C3%A7%C3%A3o-atrav%C3%A9s-da-tecnologia-rfid-902fa8f35b">Aumentando a qualidade de exposição através da tecnologia RFID</a></li><li><a href="https://medium.com/havanlabs/havan-faz-gest%C3%A3o-de-funcionalidades-em-tempo-real-no-aplicativo-usando-real-time-remote-config-7a084dfbe169">Havan faz gestão de funcionalidades em tempo real no aplicativo usando real-time remote config</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0bf2277fbcde" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/freedom-design-system-0bf2277fbcde">Freedom Design System</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pacote ClassNames Simplificando a Validação de Classes CSS]]></title>
            <link>https://medium.com/havanlabs/pacote-classnames-simplificando-a-valida%C3%A7%C3%A3o-de-classes-css-267e713636e2?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/267e713636e2</guid>
            <category><![CDATA[css]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[dev]]></category>
            <category><![CDATA[package]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Eduardo de Oliveira Duarte]]></dc:creator>
            <pubDate>Fri, 05 Jan 2024 11:20:52 GMT</pubDate>
            <atom:updated>2024-01-05T11:20:52.241Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JFy0RsHOWUgH0Xd8" /><figcaption>Photo by <a href="https://unsplash.com/@r3dmax?utm_source=medium&amp;utm_medium=referral">Jonatan Pie</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>O uso de classes CSS para a criação de elementos no front-end é uma prática muito comum no desenvolvimento. No entanto, em algumas situações, surge a necessidade de usar uma classe em um momento específico e outra em outro determinado estado. Isso pode se tornar complicado resultando no uso de ternários longos, na criação de variáveis ou na elaboração de funções para as validações.</p><p>Embora estes sejam métodos convencionais amplamente aceitos e funcionem bem, em casos destas validações extensas, especialmente quando envolvem classes fundamentais para o elemento, podem tornar esses métodos difíceis de comprender.</p><p>Para simplificar e tornar o código mais legível, a utilização de classes CSS para a criação de componentes recebeu um aliado valioso com o pacote <a href="https://www.npmjs.com/package/classnames"><em>ClassNames</em></a>, uma ferramenta de utilidade para a junção condicional de classes CSS.</p><p>Para ilustrar a eficácia desse pacote, criaremos um pequeno projeto de um componente de botão que muda para verde ao ser adicionado ao carrinho e para vermelho ao ser removido.</p><p>Faremos isso de maneira simples, utilizando <a href="https://vitejs.dev/">Vite</a> para criar o projeto com React e TypeScript.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k2KxCYT3K3iQWjWy1hIu9g.gif" /><figcaption>Resultado Final do Projeto</figcaption></figure><p>Após criar o projeto, procederemos com uma limpeza, removendo estilos padrão e arquivos CSS não essenciais, mantendo apenas os arquivos necessários, como App.tsx, main.tsx e vite-env.d.ts.</p><p>Agora, com o projeto organizado, iniciaremos o desenvolvimento do botão de forma simples, criaremos um componente dentro de uma pasta “components/Button”, contendo os arquivos index.tsxe style.css.</p><p>No index.tsx, criaremos o botão primeiramente de forma simples com o uso de estado através do useState, com uma validação ternaria para o texto conforme a mudança no valor, junto a uma classe simples de estilo no <em>style.css</em>.</p><pre>// components/Button/index.tsx<br>export const Button = () =&gt; {<br>  const [NoCarrinho, SetNoCarrinho] = useState&lt;boolean&gt;(false);<br><br>  return (<br>    &lt;button type=&#39;button&#39; className=&#39;button&#39; onClick={() =&gt; SetNoCarrinho(!NoCarrinho)}&gt;<br>      {NoCarrinho ? &#39;Remover do Carrinho&#39; : &#39;Adicionar no Carrinho&#39;}<br>    &lt;/button&gt;<br>  );<br>};</pre><pre>/* components/Button/style.css */<br>.button {<br>  width: 100%;<br>  border-radius: 1rem;<br>  padding: 1rem;<br>  border-width: 0 0 8px 0;<br>  border-style: solid;<br>  border-color: #ccc;<br>  cursor: pointer;<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pMW4tUTLwkEXMA3JCdAEjg.gif" /></figure><p>Agora vamos adicionar ao nosso estilo as classes adicionais para as variações de adição e remoção.</p><pre>/* components/Button/style.css */<br>.button-adicionar {<br>  background-color: #16a34a;<br>  border-color: #4ade80;<br>  color: #fff;<br>}<br><br>.button-remover {<br>  background-color: #dc2626;<br>  border-color: #f87171;<br>  color: #fff;<br>}</pre><p>Continuando, agora vamos fazer o uso do pacote <a href="https://www.npmjs.com/package/classnames"><em>ClassNames</em></a>. Portanto, devemos primeiro instalá-lo em nosso projeto através do seguinte código:</p><pre>npm install classnames</pre><p>Com a conclusão da instalação do pacote no projeto, podemos agora criar uma constante em nosso componente e atribuí-la ao método classNames.</p><p>Em seguida, devemos adotar uma das formas de uso. Inicialmente, foi incluída apenas a classe base buttondentro do método, cuja saída, por enquanto, é o valor ‘button’.</p><pre>const ButtonClasses = classNames (&#39;button&#39;); // -&gt; &#39;button&#39;</pre><p>Agora vamos adicionar nossas classes de variação <em>adicionar</em> e <em>remover, </em>no entanto, antes de prosseguirmos, é importante compreender que, para alternar entre as classes em momentos distintos, devemos seguir a seguinte estrutura para que funcione adequadamente:</p><pre>{<br>  &#39;minha-classe&#39;: true | false<br>}</pre><p>A chave representa a nossa classe, enquanto o valor, sendo verdadeiro ou falso, determina se ela deve ser visível ou não.</p><p>Portanto, é crucial fornecer um valor booleano para conduzir a validação e garantir a aplicação das classes adequadas, a seguir, inserimos uma vírgula, abrimos chaves no método e realizamos as devidas validações utilizando o estado NoCarrinho, que foi criado em passos anteriores.</p><p>Dessa maneira, a classe de variação <em>adicionar</em> será exibida quando o valor do estado for falso, e <em>remover</em> quando for verdadeiro. o código correspondente está descrito abaixo:</p><pre>export const Button = () =&gt; {<br>  const [NoCarrinho, SetNoCarrinho] = useState&lt;boolean&gt;(false);<br>  <br>  const ButtonClasses = classNames (&#39;button&#39;, {<br>      &#39;button-adicionar&#39; : !NoCarrinho,<br>      &#39;button-remover&#39; : NoCarrinho,<br>  });<br>  <br>  return (<br>      &lt;button type=&#39;button&#39; className={ButtonClasses} onClick={()=&gt;SetNoCarrinho(!NoCarrinho)} &gt;<br>          {NoCarrinho ? &#39;Remover do Carrinho&#39; : &#39;Adicionar no Carrinho&#39;}<br>      &lt;/button&gt;<br>  )<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k2KxCYT3K3iQWjWy1hIu9g.gif" /><figcaption>Resultado Final do Projeto</figcaption></figure><p>Pode-se concluir este projeto enfatizando a simplicidade do uso do pacote <a href="https://www.npmjs.com/package/classnames"><em>ClassNames</em></a>,<em> </em>este recurso simplifica consideravelmente a tarefa de adicionar validações em classes CSS, tornando-a mais acessível e agradável.</p><p>Sua aplicação no projeto não apenas simplifica o processo, mas também contribui para um código mais elegante e legível, aprimorando a qualidade geral do mesmo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=267e713636e2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/pacote-classnames-simplificando-a-valida%C3%A7%C3%A3o-de-classes-css-267e713636e2">Pacote ClassNames Simplificando a Validação de Classes CSS</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pílula K#08 — Tudo sobre Strings]]></title>
            <link>https://medium.com/havanlabs/p%C3%ADlula-k-08-tudo-sobre-strings-e508e1494a0c?source=rss----7dc6a628382c---4</link>
            <guid isPermaLink="false">https://medium.com/p/e508e1494a0c</guid>
            <category><![CDATA[string-templates]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[string]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Klaus Dellano]]></dc:creator>
            <pubDate>Mon, 18 Dec 2023 10:36:56 GMT</pubDate>
            <atom:updated>2023-12-18T10:36:56.453Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pílula K#08 — Tudo sobre Strings</h3><p>A pílula de hoje ajudará você a entender e desmistificar tudo sobre o controle das Strings no Kotlin! Então pega o café, o notepad++, e simbora!</p><p>As strings no Kotlin são imutáveis, assim como no Java. Isso significa que não é possível alterar uma string depois de criá-la. No entanto, podemos derivar uma nova string a partir de uma existente.</p><p>O Kotlin enriqueceu a classe String do Java com funcionalidades adicionais. Um exemplo rápido, para iniciarmos essa dose, seria o método <strong><em>padEnd()</em></strong> nos permite formatar uma string da seguinte forma:</p><pre>“Hello”.padEnd(10, ‘!’)<br><br><br>// Saída<br>&quot;Hello!!!!!&quot;</pre><h3>Como acessar caracteres de uma String?</h3><p>Para acessar os elementos (caracteres) de uma string, usamos o operador de acesso por índice. Por exemplo:</p><pre>val minhaString = “Oi, pessoal!” <br>val item = minhaString[1]</pre><p>Aqui, a variável <strong><em>item</em></strong> contém o caractere “i”, que é o <strong>segundo</strong> caractere da string <strong><em>minhaString</em></strong>. Isso ocorre porque a indexação no Kotlin começa a partir de 0, não de 1.</p><pre>val minhaString = &quot;Oi, pessoal!&quot; <br>var item: Char<br>item = minhaString[0] // item contém &#39;O&#39; <br>item = minhaString[9] // item contém &#39;a&#39;</pre><p>E claro, se não prestarmos atenção na string que estamos manipulando, podemos ocasionar o famoso erro: <strong>‘StringIndexOutOfBoundsException’</strong>, que acontece quando fornecemos um índice fora dos limites permitidos para o acesso de caracteres individuais da string. Por exemplo:</p><pre>val minhaString = &quot;Oi, pessoal!&quot; <br>var item: Char<br><br>item = minhaString[12] // Erro! StringIndexOutOfBoundsException<br>item = minhaString[-1] // Erro! StringIndexOutOfBoundsException</pre><p>Nesse caso, estamos tentando acessar o caractere que está na posição <strong>12 </strong>da string. Dai você pode se perguntar: `<strong><em>Mas como assim mano? Minha string tem 12 letras, e quero acessar a última letra, que está na 12° posição!!!</em></strong>`. Mas depois tu lembra que as posições iniciam no índece <strong>0</strong> e não do <strong>1.</strong> E esse erro é bem comum, então já vai se acostumando.</p><p>Uma das maneiras de consegueir o último caractere é utilizando o método last().</p><pre>val minhaString = &quot;Oi, pessoal!&quot; <br>var item: Char<br><br>item = minhaString.last() // item contém &#39;!&#39;<br><br>/*<br>last() nada mais é do que pegar o tamanho do conteúdo e subtrair 1:<br><br>fun String.last(): <br>  return this[this.length - 1] <br>}<br>*/</pre><h4>Iterar por uma String</h4><p>Se você precisar iterar pelos elementos de uma string, pode fazer isso facilmente usando um loop <strong><em>for</em></strong>.</p><pre>fun main() { <br>  val minhaString = &quot;Oi!&quot;<br>  for (caractere in minhaString) {<br>    println(caractere)<br>  }<br>}<br><br>// Saída<br>&quot;O&quot;<br>&quot;i&quot;<br>&quot;!&quot;</pre><h3>Strings são Imutáveis</h3><p>Assim como no Java, as strings são imutáveis no Kotlin. Isso significa que não é possível alterar caracteres individuais de uma string. Por exemplo:</p><pre>var minhaString = “Oi!” <br>minhaString[0] = ‘o’ // Erro! </pre><p>No entanto, você pode atribuir novamente uma variável de string se você a declarou usando a palavra-chave var. (<a href="https://medium.com/havanlabs/p%C3%ADlula-k-03-qual-a-diferen%C3%A7a-entre-var-e-val-no-kotlin-df69bf162de8">Pílula K #03</a>)</p><h3>String Templates</h3><p>Uma das características incríveis do Kotlin são os String Templates (STs), literais de string que contêm expressões embutidas.</p><p>Por exemplo, em Java, teríamos que fazer algo assim:</p><pre>String mensagem = &quot;n = &quot; + n;</pre><p>Mas no Kotlin, é muito mais simples:</p><pre>val mensagem = &quot;n = $n&quot;</pre><p>Podemos usar qualquer expressão válida do Kotlin em um ST:</p><pre>val mensagem = &quot;n + 1 = ${n + 1}&quot;</pre><p>E não para por aí! Podemos até mesmo adicionar lógica neles:</p><pre>val mensagem = &quot;$n é ${if(n &gt; 0) &quot;positivo&quot; else &quot;não positivo&quot;}&quot;</pre><p>Observe que dentro das chaves, temos uma expressão válida do Kotlin. Isso é possível porque, ao contrário do Java, muitas construções do Kotlin são expressões.</p><blockquote><em>Os String Templates são resolvidos avaliando a expressão e invocando o método </em><strong><em>toString()</em></strong><em> no resultado da avaliação.</em></blockquote><h3>String Templates Aninhados</h3><p>Os STs também podem ser aninhados. Podemos criar templates mais complexos, que incorporam outros templates:</p><pre>val n = -3<br>val mensagem = &quot;$n é ${if (n &gt; 0) &quot;positivo&quot; else if (n &lt; 0) &quot;negativo e ${if (n % 2 == 0) &quot;par&quot; else &quot;ímpar&quot;}&quot; else &quot;zero&quot;}&quot;<br>print(mensagem)<br><br>//Saída<br>&quot;-3 é negativo e ímpar&quot;</pre><p>O analisador de templates de string começa a resolvê-los a partir do template mais aninhado, avalia-o e invoca o método toString() nele.</p><p>&quot;Bonitinho né? Mas…&quot;</p><p>… só porque é possível aninhar, não significa que vai usar pra tudo e sempre… <em>peloAmor</em> neh?… tente manter os templates o mais simples possível, sua equipe agradece…</p><h4>Escapando o Símbolo de Dólar</h4><p>E se quisermos usar um símbolo de dólar cru e não como parte de um String Template? Podemos escapá-lo usando uma barra invertida antes dele:</p><pre>val mensagem = &quot;n = \$n&quot;<br>print(message1)<br><br>//Saída<br>&quot;n = $n&quot;</pre><p>O que vem depois do símbolo de dólar se torna uma string normal — ela não é mais avaliada e é interpretada como está.</p><h3>String Literais no Kotlin</h3><p>As strings são uma sequência de caracteres. Por exemplo, “Olá, HAVAN!” é uma string literal.</p><p>No Kotlin, todas as strings são objetos da classe String. Isso significa que as strings literais, como “Olá, HAVAN!”, são implementadas como instâncias dessa classe.</p><p>String Literals são uma parte indispensável da linguagem. Elas nos permitem trabalhar com texto e criar mensagens personalizadas. Vamos explorar as duas principais formas de declarar String Literais em Kotlin.</p><h4>String Escapada</h4><p>Uma String Escapada é uma sequência de caracteres que pode conter caracteres especiais. Esses caracteres especiais são precedidos por uma barra invertida (\) para indicar que eles têm um significado especial. Aqui está um exemplo de uma String Escapada:</p><pre>val saudacao = &quot;Olá, mundo!\nOlá, Havan!&quot;<br>print(saudacao)<br><br>//Saída<br>&quot;Olá, mundo!&quot;<br>&quot;Olá, Havan!&quot;</pre><p>Neste exemplo, a barra invertida seguida de “n” (\n) indica que queremos inserir uma nova linha na String. Outros caracteres especiais que podemos usar em uma String Escapada incluem:</p><ul><li>\t — insere uma tabulação</li><li>\b — insere um backspace</li><li>\r — insere um retorno de carro</li><li>\’ — insere um caractere de aspas simples</li><li>\” — insere um caractere de aspas duplas</li><li>\\ — insere uma barra invertida</li><li>\$ — insere um símbolo de dólar</li></ul><p><em>(fica o exercício pesquisar pra que serve cada uma :D)</em></p><h4>String Multilinha (ou Raw String)</h4><p>Uma String Multilinha, como o nome sugere, nos permite criar uma string que abrange várias linhas. Ela é delimitada por três aspas (“ “” “) e pode conter qualquer texto, incluindo quebras de linha. Aqui está um exemplo de uma String Multilinha:</p><pre>val text = &quot;&quot;&quot;<br>    for (x in &quot;abc&quot;)<br>        print(x)<br>&quot;&quot;&quot;</pre><p>Para remover o espaço em branco à esquerda das linhas, usamos da função trimMargin() .</p><pre>val texto = &quot;&quot;&quot;<br>    |O Brasil<br>    |Que queremos<br>    |Só depende de nós<br>    |(Luciano Hang)<br>&quot;&quot;&quot;.trimMargin()</pre><p>Por padrão, usamos o caractere pipe (|) como prefixo de margem, mas você pode escolher outro caractere e passá-lo como parâmetro, como trimMargin(“&gt;”).</p><pre>val texto = &quot;&quot;&quot;<br>    &gt;O Brasil<br>    &gt;Que queremos<br>    &gt;Só depende de nós.<br>    &gt;(Luciano Hang)<br>&quot;&quot;&quot;.trimMargin(&quot;&gt;&quot;)</pre><h3>Tudo sobre o Dollar Sign</h3><p>Para explicar melhor (na prática), vamos supor que estamos trabalhando com consultas ao MongoDB em nossa aplicação Kotlin. Além disso, queremos consultar a coleção de pessoas em busca daqueles que têm 18 anos ou mais:</p><pre>db.pessoas.find(<br>  {<br>    &quot;idade&quot;: { $gte: 18 }<br>  }<br>)</pre><p>Podemos perceber que nossa consulta é uma string multilinha com um símbolo de dólar no operador $gte. Vamos começar vendo se podemos armazenar essa consulta como está na raw string:</p><pre>val encontrarAdultosQuery = &quot;&quot;&quot;<br>db.pessoas.find(<br>  {<br>    &quot;idade&quot;: { $gte: 18 }<br>  }<br>)<br>&quot;&quot;&quot;</pre><p>Infelizmente, recebemos um erro de compilação porque o Kotlin tenta interpolar $gte como uma variável Kotlin, que não está definida. Agora, vamos verificar se podemos escapar o símbolo de dólar:</p><pre>val encontrarAdultosQuery = &quot;&quot;&quot;<br>db.pessoas.find(<br>  {<br>    &quot;idade&quot;: { \$gte: 18 }<br>  }<br>)<br>&quot;&quot;&quot;</pre><p>Infelizmente, não temos sorte novamente! Recebemos um erro de compilação porque o Kotlin não suporta a escape de caracteres especiais dentro da raw string. Então, como resolver esse problema ao usar o símbolo de dólar em uma string multilinha?</p><blockquote>&quot;Txan txan txan txaaamm&quot;</blockquote><h4>Usando Interpolação de String com Literais</h4><p>Se quisermos usar um símbolo de dólar em uma raw string, a melhor prática é usar ${‘$’}. Nessa abordagem, o Kotlin utiliza a interpolação de string usando ${} com o símbolo de dólar como um caractere literal (‘$’):</p><pre>val encontrarAdultosQuery = &quot;&quot;&quot;<br>db.pessoas.find(<br>  {<br>    &quot;idade&quot;: { ${&#39;$&#39;}gte: 18 }<br>  }<br>)<br>&quot;&quot;&quot;<br><br>//Saída<br>&quot;&quot;&quot;<br>db.pessoas.find(<br>  {<br>    &quot;idade&quot;: { $gte: 18 }<br>  }<br>)<br>&quot;&quot;&quot;<br></pre><p>Fantástico! Parece que acertamos dessa vez. Além disso, devemos observar que essa abordagem também funciona para strings multilinhas com aspas duplas com os caracteres de quebra de linha (\n):</p><pre><br>val encontrarAdultosQuery = &quot;db.pessoas.find(\n   {\n      \&quot;idade\&quot;: { ${&#39;$&#39;}gte: 18 }\n   }\n)&quot;<br>print(encontrarAdultosQuery)<br><br>//Saída<br>&quot;&quot;&quot;<br>db.pessoas.find(<br>   {<br>      &quot;idade&quot;: { $gte: 18 }<br>   }<br>)<br>&quot;&quot;&quot;<br></pre><h3>Propriedades e Funções mais usadas</h3><p>Como os literais no Kotlin são implementados como instâncias da classe String, você pode usar vários métodos e propriedades dessa classe.</p><ul><li>A propriedade ‘<strong><em>length</em></strong>’ retorna o comprimento da sequência de caracteres de uma string.</li><li>A função <strong><em>compareTo</em></strong> compara a String (objeto) com o objeto especificado. Retorna <strong>0</strong> se o objeto for igual ao objeto especificado.</li><li>A função ‘<strong><em>get</em></strong>’ retorna o caractere no índice especificado. Você pode usar o operador de acesso ao índice em vez da função get, pois o operador chama internamente a função get.</li><li>A função ‘<strong><em>plus</em></strong>’ retorna uma nova string obtida pela concatenação dessa string com a string passada para essa função. Você pode usar o operador <strong><em>+</em></strong> em vez da função <em>plus</em>, pois o operador <strong><em>+</em></strong> chama a função <em>plus</em> por baixo dos panos.</li><li>A função ‘<strong><em>subSequence</em></strong>’ retorna uma nova sequência de caracteres a partir do índice de início e do índice de término.</li></ul><pre>val s1 = &quot;Iai, como vai?&quot;<br>val s2 = &quot;Iai, como vai?&quot;<br>var resultado: String<br>println(&quot;O comprimento da string s1 é ${s1.length}.&quot;)<br><br>resultado = if (s1.compareTo(s2) == 0) &quot;iguais&quot; else &quot;diferentes&quot;<br>println(&quot;As strings s1 e s2 são $resultado.&quot;)<br><br>println(&quot;O terceiro caractere de s1 é &#39;${s1.get(2)}&#39;.&quot;)<br>println(&quot;E o quarto caractere de s1 é &#39;${s1[3]}&#39;.&quot;)<br><br>resultado = s1.plus(&quot; Tudo bem?&quot;)<br>println(&quot;resultado = $resultado&quot;)<br>println(&quot;Substring é \&quot;${s1.subSequence(5, 9)}\&quot;&quot;)<br><br>//Saída<br>&quot;O comprimento da string s1 é 14.&quot;<br>&quot;As strings s1 e s2 são iguais.&quot;<br>&quot;O terceiro caractere de s1 é &#39;i&#39;.&quot;<br>&quot;E o quarto caractere de s1 é &#39;,&#39;.&quot;<br>&quot;resultado = Iai, como vai? Tudo bem?&quot;<br>&quot;Substring é &quot;como&quot;&quot;<br></pre><p>eeeeeeeeeeeeeeeeeeeeeeeeeeeeee…..</p><p>Amém senhor! Finalizamos…</p><p>É, tem pílulas que descem rasgando mesmo.</p><p>Vou deixar você absorver esse conteúdo… mas aconselho salvar em algum lugar pra revisar depois. Até a próxima.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*L1Wc3JvqG1hyQTONmozAEg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e508e1494a0c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/havanlabs/p%C3%ADlula-k-08-tudo-sobre-strings-e508e1494a0c">Pílula K#08 — Tudo sobre Strings</a> was originally published in <a href="https://medium.com/havanlabs">HavanLabs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>