<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Antônio Gally on Medium]]></title>
        <description><![CDATA[Stories by Antônio Gally on Medium]]></description>
        <link>https://medium.com/@antoniogally?source=rss-af6c2e201765------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*qc5IjA7J20iCjptfWjo2Dg.jpeg</url>
            <title>Stories by Antônio Gally on Medium</title>
            <link>https://medium.com/@antoniogally?source=rss-af6c2e201765------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 23:19:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@antoniogally/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Screenshots no Browser: Entendendo os desafios e soluções para frontend]]></title>
            <link>https://medium.com/@antoniogally/screenshots-no-browser-entendendo-os-desafios-e-solu%C3%A7%C3%B5es-para-frontend-0c81d387459d?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/0c81d387459d</guid>
            <category><![CDATA[selenium]]></category>
            <category><![CDATA[puppeteer]]></category>
            <category><![CDATA[node]]></category>
            <category><![CDATA[html]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Mon, 24 Mar 2025 01:56:27 GMT</pubDate>
            <atom:updated>2025-03-24T01:56:27.174Z</atom:updated>
            <content:encoded><![CDATA[<p>By Antonio Gally, a cool Software Developer</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*X025TFYhjFIKcGKM" /></figure><h3>Introdução</h3><p>A tecnologia vem avançando bastante em nosso cotidiano, e com isso, o <strong>desenvolvimento frontend</strong> tem se tornado <strong>cada vez mais sofisticado</strong> e poderoso. Como desenvolvedores de interface, temos à nossa disposição uma ampla <strong>variedade de ferramentas</strong> que ampliam nossa autonomia para criar aplicações visuais cada vez mais impressionantes e eficientes.</p><p>Entretanto, mesmo com tantas evoluções tecnológicas, algumas <strong>funcionalidades</strong> aparentemente triviais ainda <strong>representam desafios consideráveis</strong> em nosso dia a dia. Um exemplo claro disso é a <strong>captura de screenshots</strong> ou “prints” diretamente via frontend.</p><p>Embora tirar um print de um elemento HTML <strong>pareça uma tarefa simples</strong> e bastante requisitada em diversas situações práticas — como compartilhamento de resultados, geração de relatórios visuais ou criação de prévias para redes sociais — na prática, <strong>pode ser bastante complexo</strong>.</p><p>Neste artigo, abordarei detalhadamente por que capturar imagens diretamente no navegador não é tão trivial quanto pode parecer inicialmente. Além disso, discutirei os principais trade-offs envolvidos, bem como as limitações e particularidades das principais abordagens existentes atualmente.</p><h3>Captura Client-Side</h3><p>Uma das <strong>formas mais comuns e populares</strong> de realizar prints diretamente no frontend é utilizando bibliotecas client-side. A lógica dessas bibliotecas consiste em converter o elemento HTML desejado em um canvas virtual, que depois é exportado como uma imagem.</p><h4>Como Funciona a Captura Client-Side?</h4><p>Tecnicamente, a captura de um elemento HTML utilizando bibliotecas client-side ocorre em alguns passos principais:</p><ol><li><strong>Clone do Elemento HTML</strong>: A biblioteca realiza um processo de serialização, criando uma cópia do elemento DOM desejado juntamente com suas propriedades e estilos CSS computados. Esse processo é realizado utilizando métodos como <a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle">window.getComputedStyle</a>, que capturam estilos diretamente do navegador. Algumas bibliotecas enfrentam limitações na captura de certas propriedades CSS mais avançadas ou dinâmicas, como animações, sombras complexas ou fontes externas, resultando em diferenças visuais no resultado final.</li><li><strong>Renderização em um Canvas Virtual</strong>: Esse clone é renderizado para um elemento &lt;canvas&gt; oculto ou virtual, usando APIs específicas como <a href="https://developer.mozilla.org/pt-BR/docs/Web/API/CanvasRenderingContext2D">CanvasRenderingContext2D</a>.</li><li><strong>Conversão do Canvas para Imagem</strong>: Uma vez que o canvas virtual é renderizado, a biblioteca usa o método canvas.toDataURL() para gerar uma representação da imagem em formato Base64, podendo ser baixada ou exibida diretamente no navegador.</li></ol><p>Este processo, apesar de parecer simples, pode ser <strong>prejudicado por estilos complexos</strong>,<strong> </strong>elementos externos (como fontes carregadas remotamente) ou recursos gráficos avançados.</p><h4>html2canvas</h4><p>A biblioteca <a href="https://github.com/niklasvh/html2canvas">html2canvas</a> gera uma imagem representando o visual atual do elemento HTML capturando estilos e posicionamentos diretamente em um canvas. No entanto, ela tem limitações em elementos como SVGs complexos, vídeos ou animações dinâmicas.</p><h4>dom-to-image</h4><p>A <a href="https://github.com/tsayen/dom-to-image">dom-to-image</a> utiliza uma abordagem diferente ao transformar diretamente o DOM em uma imagem. Ao invés de renderizar o elemento em um canvas diretamente, ela serializa o DOM em uma representação SVG intermediária, possibilitando uma fidelidade superior, especialmente para gráficos complexos.</p><h3>Prós e Contras Gerais</h3><h4><strong>Prós:</strong></h4><ul><li>Facilidade de implementação.</li><li>Não requer infraestrutura adicional.</li><li>Operação diretamente no navegador.</li></ul><h4>Contras:</h4><ul><li>Dificuldade em capturar elementos dinâmicos (vídeos ou animações).</li><li>Desempenho reduzido em grandes volumes ou complexidade gráfica elevada.</li><li>Possíveis inconsistências visuais dependendo da complexidade do CSS utilizado.</li></ul><h3>Captura usando a API nativa do Navegador: getDisplayMedia</h3><p>A API <a href="https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia">getDisplayMedia</a> é uma funcionalidade nativa dos navegadores modernos, que permite capturar a tela ou uma janela específica diretamente pelo navegador. Diferente da abordagem client-side com bibliotecas, essa API captura o conteúdo real exibido na tela do usuário.</p><h4>Como funciona tecnicamente?</h4><p>A API getDisplayMedia solicita permissão ao usuário para capturar sua tela ou janela selecionada. Uma vez autorizada, retorna um objeto <a href="https://developer.mozilla.org/en-US/docs/Web/API/MediaStream">MediaStream</a>, que pode ser exibido diretamente em um elemento &lt;video&gt; ou processado por APIs adicionais como CanvasCaptureMediaStreamTrack para transformar o vídeo capturado em imagem.</p><p>Passos principais:</p><ol><li><strong>Solicitação de Permissão</strong>: Usuário precisa autorizar explicitamente a captura.</li><li><strong>Captura da Tela ou Janela</strong>: A API retorna um MediaStream contendo o vídeo da tela.</li><li><strong>Processamento do Stream</strong>: O conteúdo do MediaStream é renderizado em um elemento &lt;video&gt; ou &lt;canvas&gt; para ser convertido em imagem posteriormente.</li></ol><h4>Considerações técnicas</h4><ul><li><strong>Alta Fidelidade</strong>: captura exatamente o conteúdo visível ao usuário, incluindo animações e vídeos.</li><li><strong>Permissões</strong>: Exige interação e permissão explícita do usuário, o que pode limitar a experiência em algumas situações.</li><li><strong>Performance</strong>: Pode ser intensivo em termos de desempenho dependendo do processamento exigido</li></ul><h3>Prós e Contras</h3><h4><strong>Prós:</strong></h4><ul><li>Captura precisa e fiel ao visual do usuário.</li><li>Suporte completo a elementos dinâmicos e animações.</li><li>Uso nativo do navegador sem bibliotecas externas.</li></ul><h4><strong>Contras:</strong></h4><ul><li>Necessidade de interação explícita do usuário para autorizar.</li><li>Não permite captura isolada de elementos específicos diretamente (captura geral).</li><li>Pode gerar preocupações de privacidade devido à captura de tela completa ou janelas.</li></ul><h3>Captura Server-Side</h3><p>A captura no lado servidor é uma abordagem que visa superar muitas limitações das soluções client-side. Aqui, a ideia é enviar o conteúdo HTML ao servidor, onde ele será renderizado em um ambiente controlado, usando ferramentas como Puppeteer ou Selenium, para então retornar uma imagem ao usuário.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5PAW62eqIWdMy7g_8iwseQ.png" /></figure><h4>Arquitetura de Implementação</h4><ol><li><strong>Envio do HTML ao Servidor</strong>: A interface frontend envia o HTML do elemento ou página completa para um endpoint no servidor.</li><li><strong>Servidor recebe o HTML</strong>: O servidor recebe o conteúdo HTML através de uma requisição HTTP.</li><li><strong>Criação da instância do Browser</strong>: O servidor inicializa uma instância headless do navegador (por exemplo, Chromium) utilizando <a href="https://pptr.dev/">Puppeteer</a> ou <a href="https://www.selenium.dev/">Selenium</a>.</li><li><strong>Renderização do HTML</strong>: O HTML recebido é carregado nesta instância do navegador, que renderiza o conteúdo exatamente como apareceria para o usuário final.</li><li><strong>Captura do Print</strong>: O navegador tira uma screenshot do conteúdo renderizado.</li><li><strong>Processamento da Imagem</strong>: A imagem capturada pode ser otimizada ou processada no servidor conforme necessário.</li><li><strong>Retorno ao Frontend</strong>: Finalmente, a imagem é enviada de volta ao cliente, podendo ser exibida ou baixada diretamente no navegador do usuário.</li></ol><p>Essa abordagem garante alta fidelidade e controle sobre o ambiente de captura, mas requer uma infraestrutura robusta e maior complexidade técnica para implementação e manutenção.</p><h4>Considerações Técnicas</h4><ul><li><strong>Ambiente controlado</strong>: A renderização ocorre em ambiente previsível, o que garante resultados consistentes entre dispositivos.</li><li><strong>Infraestrutura necessária</strong>: Requer servidores capazes de executar instâncias de navegadores headless, aumentando custos e complexidade operacional.</li><li><strong>Performance</strong>: Dependendo da quantidade e frequência das capturas, pode exigir gerenciamento cuidadoso de recursos para não sobrecarregar o servidor.</li></ul><h3>Prós e Contras</h3><h4><strong>Prós:</strong></h4><ul><li>Alta fidelidade visual, mesmo com elementos complexos como vídeos e animações.</li><li>Maior controle sobre o processo de renderização e captura.</li><li>Resultados consistentes independente do navegador do usuário.</li></ul><h4><strong>Contras:</strong></h4><ul><li>Requer infraestrutura robusta e escalável.</li><li>Complexidade de implementação e manutenção aumentada.</li><li>Maior latência, pois envolve comunicação entre cliente e servidor.</li></ul><h3>Conclusão</h3><p>A melhor abordagem para capturar screenshots dependerá sempre do contexto específico do projeto e das necessidades da aplicação. A solução que oferece maior fidelidade visual, que é a captura no servidor, também tende a ser a menos viável em termos de complexidade e custos operacionais. Recomendo que desenvolvedores testem diversas bibliotecas client-side disponíveis e aceitem que algumas inconsistências podem ocorrer. Contudo, se a captura de imagens for uma funcionalidade crítica para o produto, vale considerar seriamente uma implementação server-side.</p><p>Conta aqui nos comentários se você já teve alguma experiência com exportar imagens direto do HTML! Obrigado pelo leitura :D</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c81d387459d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Are Frontend Developers Using AI in Their Daily Work?]]></title>
            <link>https://medium.com/@antoniogally/how-are-frontend-developers-using-ai-in-their-daily-work-ff18767a38d2?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff18767a38d2</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Fri, 21 Feb 2025 00:14:23 GMT</pubDate>
            <atom:updated>2025-02-21T00:14:23.721Z</atom:updated>
            <content:encoded><![CDATA[<p>By Antonio Gally, a cool Software Developer</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*m4JC5HZfHAgfjp8j" /></figure><h3>Introduction</h3><p>The <a href="https://geekle.us/schedule/react25">Geekle React Summit</a> is one of the largest events for React developers, bringing together experts and companies to share trends and innovations in the ecosystem. In this article, we explore one of the key topics discussed at the event: the impact of <a href="https://www.databricks.com/discover/generative-ai">Generative Artificial Intelligence</a> (GenAI) and <a href="https://www.anthropic.com/research/building-effective-agents#:~:text=building%20effective%20agents.-,What%20are%20agents%3F,-%22Agent%22%20can%20be">Autonomous Agents</a> on software development. We will discuss how these technologies are being applied, their potential benefits, and the challenges they present.</p><h3>About the Event</h3><p>The React Summit organized by Geekle brought together industry professionals to discuss the latest trends in React development and related technologies. One of the main focuses of the event was the rise of “<strong>Agentic AI</strong>,” an approach that enables the creation of specialized autonomous agents capable of executing tasks within the software development lifecycle.</p><p>Talks highlighted how companies are exploring Generative AI to optimize workflows, reduce repetitive workloads for developers, and enhance automation in both frontend and backend development. Practical examples were also presented, demonstrating how these agents can be applied in different areas of software engineering.</p><h3>Impact on the Frontend Team</h3><p>AI is revolutionizing frontend development, assisting with everything from writing code to automating complex workflows. Tools like GitHub Copilot are already widely used to suggest code snippets and accelerate programming, reducing errors and <strong>improving developer productivity</strong>.</p><p>Additionally, solutions like those from <a href="https://www.inngest.com/">Inngest</a> enable the creation of automated workflows that interact with systems in real time, managing processes without the need for manual intervention. This allows developers to focus on creative and strategic aspects while AI agents handle routine tasks such as validations, testing, and deployments.</p><h3>But What Is Agentic AI?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ljcOGPvKWOGfLro3HFW7tg.jpeg" /><figcaption><a href="https://www.landbase.com/blog/agentic-ai-the-future-of-autonomous-decision-making">https://www.landbase.com/blog/agentic-ai-the-future-of-autonomous-decision-making</a></figcaption></figure><p>Agentic AI is a concept that describes artificial intelligence systems capable of <strong>acting autonomously to achieve a goal, making decisions without constant human intervention</strong>. Unlike traditional AI tools that typically provide direct responses or suggestions, AI agents can plan and execute a sequence of actions to solve complex problems. They are designed to interact with systems, interpret data, and adapt their strategies as needed.</p><p>These agents are particularly useful for process automation, decision support, and task management within companies. In a software development environment, for example, an AI agent can monitor system performance, identify and fix issues automatically, or even manage entire workflows, significantly reducing manual workload and increasing operational efficiency.</p><h3>How AI Is Being Used in Software Development</h3><p>Although the adoption of Agentic AI is still in its experimental phase, some companies are exploring its potential to automate processes and enhance operational efficiency.</p><h4>Customer Support Automation</h4><ul><li>Companies like <a href="https://www.anthropic.com/"><strong>Anthropic</strong></a> are developing AI agents capable of performing tasks on computers, including navigation and application launching, to automate technical support.</li><li>Reference: <a href="https://www.anthropic.com/research/building-effective-agents">https://www.anthropic.com/research/building-effective-agents</a></li></ul><h4>IT Process Optimization</h4><ul><li>Companies like <a href="https://www.moveworks.com/"><strong>Moveworks</strong></a> use AI agents to manage and resolve IT issues autonomously, reducing the burden on support teams.</li><li>Reference: <a href="https://www.moveworks.com/us/en/resources/blog/agentic-ai-examples-use-cases">https://www.moveworks.com/us/en/resources/blog/agentic-ai-examples-use-cases</a></li></ul><h4>Data Analysis and Business Intelligence</h4><ul><li><a href="https://www.thoughtspot.com/"><strong>ThoughtSpot</strong></a> explores Agentic AI for data analysis, making data interpretation and insight extraction more accessible and automated.</li><li>Reference: <a href="https://www.thoughtspot.com/data-trends/ai/agentic-ai-examples">https://www.thoughtspot.com/data-trends/ai/agentic-ai-examples</a></li></ul><h4>Cybersecurity</h4><ul><li><a href="https://www.couchbase.com/"><strong>Couchbase</strong></a> develops AI agents for threat detection and response, reducing reaction time to security incidents.</li><li>Reference: <a href="https://www.couchbase.com/blog/agentic-ai/">https://www.couchbase.com/blog/agentic-ai/</a></li></ul><h4>Smart Manufacturing</h4><ul><li><a href="https://incit.com.br/"><strong>INCIT</strong></a> is investigating the use of Agentic AI to optimize industrial processes, including predictive maintenance and quality control.</li><li>Reference: <a href="https://incit.org/pt/thought-leadership/meet-agentic-ai-a-new-manufacturing-frontier/">https://incit.org/pt/thought-leadership/meet-agentic-ai-a-new-manufacturing-frontier/</a></li></ul><h3>Example: AI-Powered Personalized Menu Generator</h3><p>The startup Inngest demonstrated an <a href="https://agentkit.inngest.com/overview">agentic workflow </a>that generates personalized menus based on user preferences:</p><ul><li><strong>Recipe Retrieval</strong>: Queries a database for matching recipes.</li><li><strong>Dietary Restriction Adjustments</strong>: Uses AI to substitute ingredients based on allergies or preferences.</li><li><strong>Menu Generation</strong>: Compiles selected recipes into a cohesive menu.</li><li><strong>Wine Pairing Recommendations</strong>: Suggests appropriate wines for the chosen dishes.</li><li><strong>Shopping List Creation</strong>: Lists all necessary ingredients for the menu.</li></ul><p>This model can be applied in various areas to automate and optimize internal processes in tech companies</p><h3>Conclusion</h3><p>The advancement of Generative AI and Autonomous Agents is redefining software development, although its adoption in production is still limited at the moment. The potential benefits include:</p><ul><li><strong>Increased automation and efficiency.</strong></li><li><strong>Improved integration between AI and development processes.</strong></li><li><strong>Acceleration of innovation and automation of repetitive tasks.</strong></li></ul><p>AI is already widely used in software development, with assistants like GitHub Copilot and ChatGPT aiding in code generation and documentation. <strong>Developer productivity has significantly increased</strong> through these tools, allowing for greater focus on strategic tasks while AI handles repetitive aspects of the development process.</p><h3>Study Materials</h3><ul><li><a href="https://www.thoughtspot.com/data-trends/ai/agentic-ai-examples">What is Agentic AI?</a></li><li><a href="https://www.moveworks.com/us/en/resources/blog/agentic-ai-examples-use-cases">Moveworks Blog on Agentic AI</a></li><li><a href="https://www.wired.com/story/anthropic-ai-agent/">Anthropic and AI Agents</a></li><li><a href="https://incit.org/pt/thought-leadership/meet-agentic-ai-a-new-manufacturing-frontier/">Agentic AI in Industry</a></li><li><a href="https://www.couchbase.com/blog/agentic-ai/">How Couchbase is Applying Agentic AI</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff18767a38d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FCM vs. Expo Server: Which is the Better Option for Push Notifications?]]></title>
            <link>https://medium.com/@antoniogally/fcm-vs-expo-server-which-is-the-better-option-for-push-notifications-2869f3de3eb1?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/2869f3de3eb1</guid>
            <category><![CDATA[expo]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[firebase]]></category>
            <category><![CDATA[fcm]]></category>
            <category><![CDATA[notifications]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Tue, 17 Dec 2024 13:59:15 GMT</pubDate>
            <atom:updated>2024-12-18T20:52:05.096Z</atom:updated>
            <content:encoded><![CDATA[<p>By Antonio Gally, a cool Software Developer</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*aSvg5gSHWIdY_3q0.png" /><figcaption><a href="https://ably.com/push-notifications">https://ably.com/push-notifications</a></figcaption></figure><h3>Introduction</h3><p>We know that Push Notifications are indispensable nowadays. They are responsible for keeping users engaged and informed about updates and promotions in real time. However, choosing the right infrastructure to manage these notifications can be challenging.</p><p>Today, there are three popular solutions available for sending push notifications in React Native applications: <a href="https://firebase.google.com/docs/cloud-messaging">Firebase Cloud Messaging (FCM)</a>, <a href="https://docs.expo.dev/push-notifications/sending-notifications/">Expo Server</a>, and <a href="https://developer.apple.com/documentation/usernotifications">Apple Push Notification services (APNs)</a>. Each offers specific advantages, but which is the best choice for your project?</p><p>In this post, we will examine how <strong>FCM</strong> and <strong>Expo Server</strong> function, compare them in terms of setup, features, costs, and performance, to help you make an informed decision.</p><h3>What are Push Notifications and How Do They Work?</h3><p>The website <a href="https://www.techopedia.com/definition/5732/push-technology">Techopedia</a> provides an objective description of Push Notification technology:</p><blockquote>Push technology is an internet communication system where the transaction request is generated by the central web server or publisher. Push technology is the opposite of pull technology, where the request for information transmission is made by clients or receivers.</blockquote><p>In practice, push notifications are an efficient form of direct communication between apps and users. They allow information to be sent to devices even when the app is not active or open, ensuring that users are informed in real-time about updates, promotions, reminders, or important alerts.</p><p><strong>To understand how they function</strong>, we need to grasp three important concepts:</p><ul><li><a href="https://onesignal.com/blog/what-is-a-push-notifications-service-and-how-does-it-work/"><strong>Operating system push notification service</strong></a> (OSPNS): Each operating system, including iOS, Android, Fire OS, and Windows, has its own service.</li><li><strong>App Publisher</strong>: The app publisher enables their app with one or more OSPNSs and submits it to the app store (Google Play, App Store).</li><li><strong>Client App</strong>: The operating system-specific application installed on a user’s device. It receives the notifications that are sent.</li></ul><p>Once the app is available in the stores and the user installs it, a token is registered by the OSPNS, whether it’s <strong>APN for Apple</strong> or <strong>FCM for Android</strong>. This token is unique per device and can be used to send notifications.</p><p>Let’s take a practical look at what happens when we use Expo’s services for sending notifications:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/919/1*KxIuYFMlGVorBODNMRV5CQ.png" /></figure><p>When our React Native app is launched, it receives a <a href="https://docs.expo.dev/versions/latest/sdk/notifications/#getdevicepushtokenasync"><em>DeviceToken</em></a>, which can be converted into other formats, such as the <a href="https://docs.expo.dev/versions/latest/sdk/notifications/#getexpopushtokenasyncoptions"><em>ExpoPushToken</em></a>. Once this token is generated, we can use it to send notifications via the <a href="https://docs.expo.dev/push-notifications/sending-notifications/"><em>Expo Notification Service</em></a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*my5CjasX-C7nNLe-.png" /></figure><p>Expo provides an abstraction layer that significantly simplifies the process, allowing us to avoid dealing directly with the peculiarities of each platform, such as Android and iOS. However, as with any abstraction layer, it may present limitations in certain scenarios, which we will explore throughout this post.</p><h3>Comparing FCM and Expo Server</h3><p>Both offer solutions for the server-side and client-side, with extensive documentation on how to use them. Naturally, when developing a <a href="https://reactnative.dev/docs/getting-started">React Native</a> app using <a href="https://docs.expo.dev/">Expo</a>, it is common to opt for <a href="https://docs.expo.dev/versions/latest/sdk/notifications/"><em>expo-notifications</em></a>, an integrated library in the Expo SDK that allows for the management of push messages on the user’s device, utilizing native APIs of each operating system.</p><p>FCM (Firebase Cloud Messaging) is widely used in native projects for Android, often written in Java or Kotlin. FCM is Google’s official messaging solution for Android and operates as part of the <a href="https://firebase.google.com/docs">Firebase</a> architecture. When using expo-notifications, it is necessary to <a href="https://docs.expo.dev/versions/latest/sdk/notifications/#configuration">set up a project</a> in <strong>Firebase because it communicates with</strong> <strong>FCM</strong>, which is responsible for sending notifications to Android devices. It’s also important to note that <strong>FCM can be used to send notifications on iOS</strong>, allowing you to configure the notification’s specificities within the same payload, using different keys.</p><p>On iOS, notifications are sent through Apple’s notification service (APNs — Apple Push Notification Service). To integrate with Expo, it’s necessary to generate .p8 certificates, which are stored on Expo’s servers and used to establish communication with APNs.</p><h4>Payload: Structure and Capabilities</h4><p>The <strong>expo-notifications</strong> library operates as an abstraction layer that simplifies the process of sending notifications. It uses the <strong>Expo Push Notification Service (EPNS)</strong>, which is responsible for encapsulating the messages and sending them to the underlying services, such as FCM (for Android) and APNs (for iOS).</p><pre>{<br>  &quot;to&quot;: &quot;ExpoPushToken[xxxxxxxxxxxxxx]&quot;,<br>  &quot;title&quot;: &quot;Notification title&quot;,<br>  &quot;body&quot;: &quot;Notification body&quot;,<br>  &quot;data&quot;: { &quot;key&quot;: &quot;value&quot; }<br>}</pre><p>FCM provides more granular control over the payload, allowing for greater customization and advanced features when sending notifications.</p><pre>{<br>  &quot;to&quot;: &quot;fcm_token_or_topic&quot;,<br>  &quot;notification&quot;: {<br>    &quot;title&quot;: &quot;Notification title&quot;,<br>    &quot;body&quot;: &quot;Notification body&quot;,<br>    &quot;sound&quot;: &quot;default&quot;<br>  },<br>  &quot;data&quot;: {<br>    &quot;key&quot;: &quot;value&quot;<br>  },<br>  &quot;android&quot;: {<br>    &quot;priority&quot;: &quot;high&quot;,<br>    &quot;ttl&quot;: &quot;3600s&quot;<br>  },<br>  &quot;apns&quot;: {<br>    &quot;headers&quot;: {<br>      &quot;apns-priority&quot;: &quot;10&quot;<br>    },<br>    &quot;payload&quot;: {<br>      &quot;aps&quot;: {<br>        &quot;alert&quot;: {<br>          &quot;title&quot;: &quot;Notification title&quot;,<br>          &quot;body&quot;: &quot;Notification message&quot;<br>        }<br>      }<br>    }<br>  }<br>}</pre><h4>Implementation</h4><p>The implementation of each service is also an important point to consider, as both have distinct peculiarities. In this regard, it becomes evident that <strong>Expo Notifications</strong> is the simpler, more practical, and <strong>faster option</strong>. Its integration comes almost “ready-made,” requiring only the configuration of Firebase and Apple Developer for everything to work correctly.</p><p>On the other hand, implementing <strong>FCM</strong> can be considered a bit more labor-intensive, but that doesn’t mean it will be extremely complicated. To use it in your application, you first need to create a <a href="https://docs.expo.dev/develop/development-builds/create-a-build/"><strong>Development Build</strong></a>, as the use of Firebase requires this in the context of a React Native + Expo project. Additionally, you’ll need to configure the FCM library, just as it is necessary to configure expo-notifications in the case of Expo. Beyond these steps, you’ll also need to carry out the same mandatory configurations in Firebase and Apple Developer.</p><p>While the setup for FCM may seem more challenging at first glance, I don’t believe it poses a significant obstacle, especially considering that understanding the push notification ecosystem already requires a certain level of effort and learning. However, I recognize that my opinion might be biased!</p><h4>Further Comparative Details</h4><p>There are many other aspects to consider when comparing notification infrastructures for your app. Below, I will share my use case and my conclusion on the topic. However, for you, dear reader, I will provide a series of useful links so you can delve deeper into your research and decide which option best suits the needs of your project!</p><h3>Use case</h3><p>For the past two weeks, I’ve been dedicated to researching the different services and their particularities, and I share here the frustrating cause that motivated all this work:</p><p>While developing some interesting features for the <a href="https://looqbox.com/">Looqbox</a> app, the need arose to implement a <strong>Badge Counter</strong> — the counter displayed in the upper right corner of the app icon, indicating the number of unread notifications by the user. I began working on some implementations and quickly realized that, to achieve a satisfactory result, the counter would need to be <strong>updated as soon as the app received a notification in the background</strong>. But how to do this? That was the question I asked myself.</p><p>When using <strong>expo-notifications</strong> to manage notifications on the client-side, I realized that the library offers very few resources for handling events triggered upon receiving notifications in the background. The only way I found so far to “listen” to notifications while the app is minimized was through the <a href="https://docs.expo.dev/versions/latest/sdk/task-manager/"><strong>expo-task-manager</strong></a> library, described by Expo as follows:</p><pre>const BACKGROUND_NOTIFICATION_TASK = &#39;BACKGROUND-NOTIFICATION-TASK&#39;;<br><br>defineTask(BACKGROUND_NOTIFICATION_TASK, async ({ data, error }) =&gt; {<br>    const badgeCount = await AsyncStorage.getItem(&#39;badgeCount&#39;);<br>    const newBadgeCount = Number(badgeCount || 0) + 1;<br><br>    setBadgeCountAsync(newBadgeCount);<br>    AsyncStorage.setItem(&#39;badgeCount&#39;, newBadgeCount.toString());<br>});<br><br>registerTaskAsync(BACKGROUND_NOTIFICATION_TASK)<br>  .then(() =&gt; {<br>      console.log(&quot;Notifications.registerTaskAsync success&quot;);<br>  })<br>  .catch((reason) =&gt; {<br>      console.log(&quot;Notifications registerTaskAsync failed&quot;);<br>  });</pre><p>Now, our app should be capable of <strong>reactively updating the badge counter</strong>, right? Actually, no! We still need to add<strong> specific configurations to the notification payload</strong> so that our code can execute in the background and update the badge.</p><p>To start, it is necessary to correctly configure the payload on iOS. This includes adding the key/value pair _contentAvailable: true at the root of the notification object.</p><h4>What is the _contentAvailable key and how does it work?</h4><p>The contentAvailable key is a specific configuration for iOS that allows for the execution of code in the background when a silent notification is received (i.e., a notification that does not directly display alerts, sounds, or badges to the user). When set to true, it informs the operating system that the notification includes content that <strong>should be processed by the app before any user interaction.</strong></p><h4>What about Android?</h4><p>For Android, the situation becomes a bit more complicated and requires more advanced configurations in the notification payload. At this point, <strong>Expo stops providing direct support</strong>, leaving the responsibility entirely up to the developer.</p><p>It’s important to note that we are dealing with notifications presented to the user, not silent notifications or other variants. For a notification on Android to trigger background code execution in the app, it needs to be of the <a href="https://firebase.google.com/docs/cloud-messaging/concept-options#data_messages"><strong>data-only</strong></a> type.</p><p>With Expo, we can send silent notifications or notifications displayed to the user. In our case, we needed a “hybrid” notification, meaning a notification that is <strong>shown to the user and also executes code in the background</strong> without requiring user interaction. <strong>This type of notification is not currently supported by the Expo Push Notification Service (EPNS)</strong>, as Expo limits background code execution to more specific configurations.</p><p>The solution was to migrate to <strong>FCM</strong>, allowing it to initially manage the server-side notification delivery. FCM supports hybrid notifications, where we can send notification data in the data field and simultaneously display a notification to the user. This behavior occurs when you include fields like title and message within the data field of the payload. FCM allows the background code to be triggered while the device displays the notification to the user.</p><pre>{<br>  &quot;to&quot;: &quot;&lt;USER_PUSH_TOKEN&gt;&quot;,<br>  &quot;data&quot;: {<br>    &quot;title&quot;: &quot;New notification&quot;,<br>    &quot;message&quot;: &quot;You have a new message!&quot;,<br>    &quot;extraData&quot;: &quot;Custom fields&quot;<br>  },<br>  &quot;priority&quot;: &quot;high&quot;<br>}</pre><h4>Conclusion of My Use Case:</h4><p>The major difference is that, unlike FCM, Expo does not have native support for sending data in the payload while also displaying the notification and executing background code in such a flexible manner. To achieve this behavior, a more manual approach is necessary, especially for Android, involving the configuration of a data-only payload in FCM or using libraries that offer additional support for these functionalities.</p><h4>My Critique of Expo:</h4><p>How can we make the <strong>Expo payload more flexible</strong> to leverage advanced configurations for Android and iOS? I also critique the <strong>lack of material</strong>, particularly the Expo side documentation regarding simple actions with background tasks, such as updating the Badge Count and specifics for assembling the notification payload. I hope this post helps developers facing the same challenges.</p><h3>Conclusion</h3><p>The decision between Expo Notifications and FCM should not be viewed as a dilemma of “better” or “worse,” but rather as a strategic choice based on the specific requirements of the project and the team’s context.</p><ul><li>If you are building a <strong>simple app</strong> with <strong>basic notification</strong> functionalities and need to <strong>accelerate development</strong> time, <strong>Expo Notifications</strong> is the obvious choice.</li><li>On the other hand, if you are developing a <strong>scalable application</strong> that demands customization, automation, and <strong>high reliability</strong>, <strong>FCM</strong> provides a solid foundation for long-term growth.</li></ul><p>Finally, it’s worth considering that <strong>Expo Notifications uses FCM in its implementation</strong> but adds a layer of abstraction. Thus, if your team starts with Expo and finds that limitations are hindering the app’s growth, migrating to FCM is always a viable alternative.</p><h3>References</h3><ul><li><a href="https://firebase.google.com/docs/cloud-messaging">https://firebase.google.com/docs/cloud-messaging</a></li><li><a href="https://docs.expo.dev/push-notifications/sending-notifications/">https://docs.expo.dev/push-notifications/sending-notifications/</a></li><li><a href="https://developer.apple.com/documentation/usernotifications">https://developer.apple.com/documentation/usernotifications</a></li><li><a href="https://onesignal.com/blog/what-is-a-push-notifications-service-and-how-does-it-work/">https://onesignal.com/blog/what-is-a-push-notifications-service-and-how-does-it-work/</a></li><li><a href="https://docs.expo.dev/versions/latest/sdk/notifications/#getdevicepushtokenasync">https://docs.expo.dev/versions/latest/sdk/notifications/#getdevicepushtokenasync</a></li><li><a href="https://docs.expo.dev/versions/latest/sdk/notifications/">https://docs.expo.dev/versions/latest/sdk/notifications/</a></li><li><a href="https://docs.expo.dev/develop/development-builds/create-a-build/">https://docs.expo.dev/develop/development-builds/create-a-build/</a></li><li><a href="https://docs.expo.dev/versions/latest/sdk/task-manager/">https://docs.expo.dev/versions/latest/sdk/task-manager/</a></li><li><a href="https://developer.apple.com/documentation/usernotifications/pushing-background-updates-to-your-app">https://developer.apple.com/documentation/usernotifications/pushing-background-updates-to-your-app</a></li><li><a href="https://firebase.google.com/docs/cloud-messaging/concept-options#data_messages">https://firebase.google.com/docs/cloud-messaging/concept-options#data_messages</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2869f3de3eb1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Simplify Version Control: Automating Changelogs for Your GitHub Projects]]></title>
            <link>https://medium.com/@antoniogally/changelogger-automation-b6172fa9bb53?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6172fa9bb53</guid>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[ci]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[documentation]]></category>
            <category><![CDATA[changelog]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Tue, 24 Sep 2024 01:44:45 GMT</pubDate>
            <atom:updated>2024-09-24T01:48:12.316Z</atom:updated>
            <content:encoded><![CDATA[<p>By Antonio Gally, a cool Software Developer</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*2xc-G0fi0yMEqEca.png" /><figcaption><a href="https://medium.com/hurb-labs/um-pouco-sobre-github-actions-fe6ab77998ca">https://medium.com/hurb-labs/um-pouco-sobre-github-actions-fe6ab77998ca</a></figcaption></figure><h4>The problem:</h4><p>I needed a way to <strong>keep track of all the changes</strong> happening in my company’s repository. Whenever we had to do a rollout for a specific tag version, we often found ourselves confused about <strong>what exactly that tag represented</strong>. That’s when I thought, “Why not document the changes every time a new tag is created or a pull request is merged into the main branch?”</p><h4>How other companies organize their changelog?</h4><p>During my research, I explored how different projects handle their changelogs. For instance, Angular has a detailed <a href="https://github.com/angular/angular/blob/main/CHANGELOG.md">changelog</a> that categorizes changes into <strong>features, bug fixes, and breaking changes</strong>, making it easy to see <strong>what’s new or updated in each release</strong>. Facebook’s open-source projects, <a href="https://github.com/facebook/react/blob/main/CHANGELOG.md">like React</a>, use a more concise format, listing <strong>key updates</strong> and improvements for each version. Another great example is the <a href="https://keepachangelog.com/">Keep a Changelog</a> initiative, which provides a standard format for documenting changes in a clear and consistent way. These examples inspired me to create a tool that automatically generates changelogs, ensuring all updates are documented and easy to understand.</p><h4>How did I solved this problem?</h4><p>To solve this problem, I needed a solution that was both generic and easy to maintain. I started by organizing all the pull requests that my team was merging into the main branch and asked everyone to document them thoroughly. With this process in place, I created a GitHub Action that monitors every PR merged into the main branch, gathers all relevant details, and automatically writes them into a changelog file.</p><h4>And how it works?</h4><p>The core of the project is a script called changeLogger.js. This script starts by receiving inputs from the workflow and establishing an authenticated connection to the GitHub API. It first retrieves information about the pull request (PR), including all associated commits.</p><p>Next, the script determines the next version tag by starting from the latest tag in your repository. If no tags are found, the script will <strong>default to v0.1.0</strong>. After calculating the next version, it gathers all relevant information into a comprehensive changelog entry.</p><p>The script then locates your existing changelog file and appends the newly generated changelog entry. Once the file is updated, it commits the changes using the execSync function from the child_process module. And just like that, your changelog is up to date!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2-BAYKbKznE0ALmHND5sHw.png" /></figure><h4>And how it look like?</h4><p>You can see some examples in my personal repositories, like <a href="https://github.com/AntonioGally/Portfolio">my portfolio</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*G983LIUSqwN20haj" /></figure><h4>Conclusion</h4><p>And that’s it! This changelog automation has been a game-changer, saving me time when I need to review updates in production or track changes in my personal repositories. You can find detailed technical documentation on how to set it up in your own repository on GitHub. I’d love to hear your feedback, and feel free to contribute to the project as well. Thanks! 😄</p><h4>Links</h4><ul><li><a href="https://github.com/AntonioGally/ag-changelogger">Changelogger repository on github</a></li><li><a href="https://github.com/facebook/react/blob/main/CHANGELOG.md">React changelog</a></li><li><a href="https://github.com/angular/angular/blob/main/CHANGELOG.md">Angular changelog</a></li><li><a href="https://keepachangelog.com/en/1.1.0/">Best practices of a changelog</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6172fa9bb53" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Clean Agile: Developer's Perspective]]></title>
            <link>https://medium.com/@antoniogally/clean-agile-developer-perspective-2743a3277b06?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/2743a3277b06</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[agile-development]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Sat, 02 Mar 2024 22:32:49 GMT</pubDate>
            <atom:updated>2024-03-02T22:33:11.424Z</atom:updated>
            <content:encoded><![CDATA[<p>By Antonio Gally, a cool Software Developer</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SxM7XaDWeM8K4Na1" /><figcaption>DALL·E 2</figcaption></figure><h3>A Coder’s Skepticism Meets Agile</h3><p>“<strong>Agile? Why should I, a developer, learn this Agile thing?</strong>” That was the reaction I had when first introduced to the concept of Agile methodologies. As someone who had read texts like <em>Clean Code</em>, <em>Clean Architecture</em>, and <em>Refactoring</em>, I couldn’t help but wonder, “<strong>Aren’t my coding skills all I need?</strong>”</p><p>Well, my understanding of what it meant to be a programmer was naive. <strong>It’s not just about coding</strong>; <strong>it’s about the</strong> <strong>responsibilities that come with the code we craft</strong>. This is the core message that Uncle Bob drives home in <em>Clean Agile</em>. His passionate argument is not just compelling; it’s a <strong>wake-up call to programmers</strong> everywhere, making the book an interesting read.</p><p>As we turn the page from my personal epiphany to the heart of <em>Clean Agile</em>, it’s important to recognize the book as <strong>more than just a manual on Agile methodologies</strong>. Robert Martin, presents Agile not merely as a set of practices but as a <strong>philosophy that can transform the way we approach software development.</strong></p><h3>What is Agile anyway?</h3><p>At its heart, Agile is about <strong>adaptability, efficiency, and collaboration</strong> in software development. Imagine building software in a way that embraces change, rather than fearing it. Agile methodologies break down the traditional, monolithic approach to project management into iterative cycles, <strong>allowing teams to respond to change quickly and efficiently</strong>.</p><p>Key Points of Agile:</p><ol><li><strong>Iterative Development:</strong> Software is developed in <strong>small, manageable increments</strong>, ensuring rapid delivery and frequent feedback.</li><li><strong>Customer Collaboration:</strong> Working closely with the customer to understand their needs and making adjustments based on their feedback is a cornerstone of Agile.</li><li><strong>Adaptive Planning:</strong> Recognizing that project plans must be flexible and able to <strong>accommodate changes</strong>.</li><li><strong>Continuous Improvement:</strong> Regularly reflecting on the development process to become more effective and efficient.</li><li><strong>Valuing Individuals and Interactions:</strong> Prioritizing people over processes and tools, fostering a culture of collaboration and communication.</li></ol><p>In essence, Agile is not just a methodology but a mindset that values adaptability, customer satisfaction, and continuous improvement. <strong>It’s about finding the most effective way to deliver value to the customer, one step at a time</strong>.</p><h3>And how this reflect in a developer life?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*ftsgC8F2Z7vPgzjB.gif" /></figure><p>In the world of Agile, writing code is similar to crafting a product. <strong>It’s not enough for code to simply ‘work.’</strong> It must be <strong>clean, understandable, and maintainable</strong>. Agile teaches us to take pride in our craftsmanship, ensuring that <strong>every line of code we write today won’t become a burden for the developers of tomorrow</strong>.</p><h4>Adaptability is Key</h4><p>Agile doesn’t just prepare us for change; it encourages us to welcome it. As developers, we learn to design our code to be as flexible as the needs of our customers. <strong>This means building software that can evolve</strong> over time, adapting to new requirements without a complete overhaul.</p><h4>Mitigating Risk with Robust Design:</h4><p>The Agile mindset instills in us the importance of <strong>anticipating and mitigating critical bugs</strong> before they occur. It’s about foreseeing potential issues and coding defensively.</p><h4>Team Synergy:</h4><p>Agile places a strong emphasis on <strong>teamwork and collaboration</strong>. It’s the collective effort of the team that drives the project forward. As developers, we learn to communicate more effectively, <strong>share our knowledge</strong>, and work together towards a common goal, enhancing the overall quality of the product.</p><h3>Achieving an Agile Environment: TDD and Refactoring</h3><h4>Test-Driven Development</h4><p>TDD is more than a practice; it’s a mindset that places <strong>testing at the heart of the development process</strong>. By writing tests before the actual code, developers ensure that each new feature is designed with quality and functionality in mind from the start. This approach leads to cleaner, more reliable code and aligns perfectly with Agile’s emphasis on iterative improvement and customer satisfaction.</p><p>Look at the <strong>three rules of TDD</strong>:</p><ol><li><strong>You must write a failing test before you write any production code</strong></li><li><strong>You must not write more of a test than is sufficient to fail, or fail to compile; and compilation failures are failures</strong></li><li><strong>You must not write more production code than is sufficient to pass the currently failing test</strong></li></ol><p>Following those rules, you can join the <strong>cicle of TDD</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/0*ujrIsEhWQkUQ9961.jpg" /><figcaption><a href="https://www.testingmind.com/how-can-tdd-be-a-game-changer-for-your-softwares-quality/"><em>https://www.testingmind.com/how-can-tdd-be-a-game-changer-for-your-softwares-quality/</em></a></figcaption></figure><h4>Refactoring</h4><p>Refactoring is the art of <strong>improving the structure of existing code without changing its external behavior</strong>. It’s a critical practice for maintaining the health of a codebase, allowing it to evolve and adapt over time while minimizing the risk of introducing bugs. In an Agile environment, where change is constant, <strong>refactoring ensures that the code remains clean, understandable, and easy to modify</strong>.</p><h4>The fear of refactoring</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*4BSo0eVWrkCzbO6A.gif" /></figure><p>Uncle Bob addresses the palpable fear we encounter when refactoring complex code. This apprehension often leads us to leave the code as is, <strong>frozen by the worry of unintentionally breaking something</strong>. However, imagine a scenario where we’re equipped with a robust suite of tests that assure us of the code’s functionality. This underscores the <strong>critical role of Test-Driven Development (TDD) in an Agile environment</strong>. <strong>TDD ensures that our code is never “stalled”</strong> by fear, as it provides the confidence needed to refactor, improve, and evolve our codebase without hesitation.</p><h3>My takeaways</h3><h4>Charts on the wall!</h4><p>In the Agile world, <strong>data</strong> isn’t just numbers; <strong>it’s a narrative of our team’s journey</strong>. Charts and metrics offer a clear window into the rhythm of our work, showcasing the velocity of our deliveries, the allocation of our hours, and the <strong>accuracy of our estimations</strong>. Such visibility isn’t merely about tracking progress; it’s about <strong>empowering the team with the insights needed to navigate challenges, allocate resources wisely, and strategically address technical debt in forthcoming iterations</strong>. By making data a central aspect of our Agile practice, we not only celebrate our achievements but also create a culture of continuous improvement and shared responsibility.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/0*0StmoEE1b3gSfLmz.jpg" /><figcaption><a href="https://kissflow.com/project/agile/benefits-of-burndown-charts/">https://kissflow.com/project/agile/benefits-of-burndown-charts/</a></figcaption></figure><h4>Estimating</h4><p>Agile teams use <strong>story points </strong>to gauge the relative effort and complexity of tasks. By assigning story points to tasks and mapping these against available team hours, Agile teams foster a more <strong>dynamic and realistic understanding of their capacity</strong>. This method not only streamlines the planning process but also enhances team collaboration and consensus, ensuring that estimations reflect a collective judgment rather than isolated guesses. Through this blend of story points and hours, Agile teams achieve a harmonious balance between <strong>predictability and adaptability in their project timelines</strong>.</p><h4>Continuous Delivery</h4><p>In an Agile framework, the essence of Continuous Delivery (CD) lies in the seamless and frequent deployment of updates, ensuring that clients receive timely enhancements without undue delays. However, the foundation of a <strong>successful CD pipeline</strong> is predicated on two critical pillars: <strong>robust testing suites</strong> and a <strong>disciplined approach to refactoring</strong>. Without comprehensive tests, <strong>the code is vulnerable to regressions and bugs slipping through to production</strong>. Similarly, without regular, thoughtful refactoring, the codebase can become a tangled web of technical debt, impeding the swift flow of new features into the hands of users, so be careful if you want to implement a CD pipeline in your codebase, it&#39;s <strong>not that simple.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Im7einADGzXaJtIQ.png" /><figcaption><a href="https://www.altexsoft.com/blog/continuous-delivery-and-integration-rapid-updates-by-automating-quality-assurance/">https://www.altexsoft.com/blog/continuous-delivery-and-integration-rapid-updates-by-automating-quality-assurance/</a></figcaption></figure><h4>Pair programming</h4><p>Here’s the thing, I’ve always hated pair programming, and that’s because I was doing it wrong. Pair Programming stands as a cornerstone of <strong>collaborative coding</strong>, where two developers work together at one workstation — effectively sharing and implementing ideas in real-time. This practice not only <strong>accelerates problem-solving and knowledge transfer but also enhances code quality through immediate peer review</strong>. Implementing Pair Programming within a team involves defining clear roles (the ‘Driver’ writes the code, while the ‘Navigator’ reviews each line and thinks ahead) and rotating pairs to foster diverse skill sets and perspectives.</p><p>That’s it! I loved the book, my head just exploded with it, especially when Bob said this:</p><blockquote>&quot;We program a lot of crap; we accept many defects; we make terrible choices. <strong>Often, we behave like undisciplined teenagers with a new credit card.</strong>&quot;</blockquote><p>This citation makes the most sense, I felt that he was talking to me, crazy stuff!</p><p>Thanks if you read it and let me know in the comments if you think that developers should only be concerned about coding! See you in the next one :D</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2743a3277b06" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Microservices to Monolith: My Migration Journey]]></title>
            <link>https://medium.com/@antoniogally/from-microservices-to-monolith-my-migration-journey-f095f01af681?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/f095f01af681</guid>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[nestjs]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Sun, 17 Dec 2023 04:19:18 GMT</pubDate>
            <atom:updated>2023-12-17T04:19:18.725Z</atom:updated>
            <content:encoded><![CDATA[<p>By Antonio Gally, a cool Software Developer</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TMt8r0B7_g2SMtwf" /><figcaption>DALL·E 2</figcaption></figure><h3>A Newbie’s First Steps</h3><p>Eight months ago, I took the plunge into developing a backend for an ed-tech startup in Brazil. <strong>My experience in backend development was pretty basic at that point</strong>, but I was ready to step up to the challenge. Having dabbled a bit in <strong>Node.js and Express</strong>, they were my go-to tools. So, there I was, setting up an API with Node, genuinely believing Express was the holy grail of backend frameworks. It was an exciting start, fueled by enthusiasm and a bit of naivety about the journey I had embarked on.</p><p>So there I was, diving headfirst into <strong>crafting my very first “robust” API</strong>. It was like a <strong>deep dive into the ocean of backend knowledge</strong> — I was practically living on tech blogs, gobbling up every article on backend development I could find. The backend universe was way vaster than I had imagined, and with each new concept I learned, my excitement just kept growing.</p><p>At that stage, I kinda knew the deal with <strong>Microservices</strong> — who’s using them, how they’re using them, <strong>but the big ‘why’ was still a mystery</strong>. I was totally caught up in that buzz where you want to try out every cool concept you stumble upon. And then, bam! It hit me — <strong>why not go all in and implement a whole microservices architecture into my teeny tiny backend</strong>? I mean, how hard could it be, right? Famous last words, I guess. I had my reasons tho, the product was growing and I was thinking in use python for data analysis and other languages for better performance… The same naivety of thinking that we can build the fastest app with the best technologies in the world, <strong>just in few months</strong>!</p><h3>The Hustle</h3><p>I began by establishing a <strong>gateway service</strong>, referring to everything else as the ‘core’. This phase quickly introduced me to the complexities of backend development. I found myself wrestling with concepts like <strong>proxy, reverse proxy, and CORS policies</strong>. It was a challenging yet enlightening experience. Fortunately, I had chosen to use <strong>Nest JS, which proved to be a significant time-saver</strong>.</p><p>Once the gateway was operational, I initiated a service dedicated to a specific domain within the company that I was calling &quot;<strong>api-game</strong>&quot;. At this point, <strong>everything seemed to be on the right track</strong>: I was dividing the application into distinct domains, a move that felt strategically sound. However, I soon encountered my first major problem — <strong>the database</strong>. In my initial research about microservices, I missed the intricacies of database management. This left me pondering: “I know it’s possible to connect multiple APIs to a single database, but is that the recommended approach?”</p><p><strong>Naturally, the answer was no</strong>. This realization led me to undertake a comprehensive <strong>restructuring of the entire database</strong> <strong>to align it with the microservices architecture</strong>. At this stage, I found myself questioning whether microservices were truly the best approach for our project. The complexity and scale of the restructuring task were daunting, and little did I know, this <strong>was just the tip of the iceberg</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wLmxJPvhq5YDiRpZvEicNQ.jpeg" /><figcaption>That&#39;s me in my natural habitat, looking at five terminals for each request made</figcaption></figure><h4>The first despair</h4><p>The CEO asking about the project and I was like: &quot;Yes it&#39;s amazing! I&#39;m building a monster righ in my apartment, robust enough to handle hundreds of thousands of users!&quot; — Ironically, at that point, we didn’t have any users. Soon enough, <strong>requests for a demo began to surface</strong>. Trying to maintain my composure, I assured them, <strong>“Just give me one week for deployment.”</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*sEQ8RuBrP-5DnXAM.gif" /></figure><p>I was completely lost — wondering if there was some magic way to expose my local development environment to the world with just a few clicks. I felt like calling out for help. My familiarity with Docker and Docker images was there, but <strong>Kubernetes</strong>? I don’t quite recall how I stumbled upon it, but before I knew it, I was deep into <strong>learning everything about Kubernetes</strong>. And then I thought, “This is it! This will solve all my problems!” Little did I know, I was about to grapple with one of the <strong>most complex concepts in modern computing</strong>. It demanded a full course to understand, and I dove right in. I set up a project on <strong>Google Cloud Platform</strong>, configured a private <strong>Registry in Google</strong>, created a <strong>cluster in GKE</strong>, and began wrestling with my <strong>Kubernetes configurations</strong>.</p><p><strong>But what about CI/CD</strong>? I didn’t fancy the idea of manually connecting to my cluster every time I needed to deploy. Enter <strong>Jenkins</strong> — the next concept on my learning journey. Configuring it wasn’t overly complicated, but by this stage, <strong>fatigue had set in</strong>. It had been about three weeks since I last touched any actual coding. My days were consumed with <strong>infrastructure complexities</strong>.</p><p>Overall, here’s what my infra was becoming:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q0VDcPVe_bGhKJSs1_H_aQ.png" /></figure><h3>The limit</h3><p>As I continued refining the infrastructure, I developed solutions like an <strong>api-logs service</strong>, which ensured <strong>traceability and observability</strong>. Things were progressing well, and my focus shifted to <strong>setting up</strong> <strong>DNS</strong> and <strong>SSL/TLS certificates</strong>. However, one concern began to loom over me like a dark cloud: <strong>billing</strong>. I was utilizing<strong> Google’s free credits</strong>, but there was an inevitable moment in the future when I would need to <strong>start paying</strong>. The critical question that kept me up at night was: <strong>How much is this infrastructure actually costing me?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yQjybc2fyeG5-A9Rm2ImvA.png" /></figure><p><strong>“US$ 186.84, plus the Jenkins VM at around US$ 25.00.”</strong> That was the tally. And there I was, facing yet another major hurdle. The question now was how to break it to the stakeholders and the team: our “scalable platform” was on track to cost <strong>upwards of US$ 200.00 per month</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*kGHAoXnLc4eg6C-R" /></figure><p>It became crystal clear to me that <strong>migrating from microservices to a monolithic architecture was not just an option, but a necessity</strong>. The <strong>multitude of tasks</strong> and the <strong>growing complexity</strong> were close to overwhelming, alongside with <strong>billings</strong>. I began the migration process and within a week, I had consolidated everything into a single GitHub repository. The <strong>gateway and logs services were removed</strong>. In the rush of it all, and as always working against time, <strong>I wasn’t able to plan a proper database migration</strong>. Regrettably, this led to the loss of the entire database — a hard but valuable lesson in the importance of careful planning.</p><p>Now, my setup is streamlined: a Next.js interface, a Node.js API, and a MySQL database. That’s it. <strong>No complex, magical interplay between these components</strong>. And the best part? <strong>The cost is just US$ 25.00</strong> to keep everything up and running. This includes built-in CI/CD, database backup and security measures, SSL/TLS, DNS configurations, and comprehensive observability for my API. This simplicity and efficiency mark the happy ending of what was once a complex and costly endeavor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/916/1*n1K3wQl6qULj5mblQScyWQ.png" /><figcaption>Next js, Node js and MySql in sequence</figcaption></figure><p>Of course, <strong>I’m immensely grateful for the opportunity to delve deeper into backend development</strong>. It was a trial by fire that taught me an invaluable lesson: <strong>simplicity is often the key to success, especially in a startup environment</strong>. Sure, crafting a complex system sounds super cool, but in the real world, <strong>what matters most is functionality and performance</strong>. Users want a product that works seamlessly; <strong>they’re not concerned with the technical intricacies behind it</strong>.</p><p><strong>My key takeaway</strong> from this whole experience is <strong>caution</strong>, particularly when it comes to significant decisions that could changes the trajectory of your project. If you’re feeling uncertain, <strong>don’t rush</strong>. Continue learning, <strong>remain patient</strong>, and always be open to exploring alternative solutions.</p><p>Thanks if you got here! ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f095f01af681" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unraveling Fabric: The Future of React Native’s Architecture]]></title>
            <link>https://medium.com/@antoniogally/unraveling-fabric-the-future-of-react-natives-architecture-3fd88de8963a?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/3fd88de8963a</guid>
            <category><![CDATA[fabric]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Mon, 11 Dec 2023 22:47:59 GMT</pubDate>
            <atom:updated>2023-12-11T22:47:59.537Z</atom:updated>
            <content:encoded><![CDATA[<p>By Antonio Gally, a cool Software Developer</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wK1JiuKvFFiILcx4" /><figcaption>Chat GPT</figcaption></figure><p>Welcome back to our deep dive into React Native’s architectures! This post picks up where we left off in our exploration of the <a href="https://medium.com/@antoniogally/exploring-react-natives-architectures-bridge-and-beyond-76e414accf7d"><strong>Bridge architecture</strong></a>, where we delved into its principles and identified key challenges. Now, we turn our attention to an exciting solution: <strong>Fabric</strong>. In this post, I’ll uncover what sets Fabric apart and how it addresses the issues inherent in the Bridge architecture.</p><p><strong>A quick heads-up</strong>: this discussion assumes a certain level of familiarity with React Native. If you’re just starting out, you might find <a href="https://reactnative.dev/docs/getting-started">React Native&#39;s docs</a> more aligned with your current learning stage.</p><h3>Fabric design</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LHI90osDOmSzJy4L.jpg" /></figure><p>Here we can see the diagram that show how fabric works, highlighting its key components. Among these, the most crucial element we’ll focus on is the <strong>JavaScript Interface (JSI)</strong>. JSI revolutionizes the communication process between our JavaScript code and the native side of the application. It’s this pivotal change in interaction dynamics that sets Fabric apart and addresses many of the <strong>limitations seen in the previous Bridge architecture</strong>.</p><h4>JavaScript Interface (JSI)</h4><p>According to the<a href="https://reactnative.dev/architecture/glossary#javascript-interfaces-jsi"> official React Native glossary</a>, JSI is defined as</p><blockquote>A lightweight API to embed a JavaScript engine in a C++ application. Fabric uses it to communicate between Fabric’s C++ core and React.</blockquote><p>At its essence, JSI functions as a <strong>JavaScript object </strong>that <strong>holds references to C++ elements</strong>. This allows for <strong>direct</strong> and reciprocal <strong>access</strong> between the UI manager and the JavaScript code. A significant advantage of JSI is its synchronous operation, which eliminates the need for data serialization. This direct and efficient communication method is a key factor in enhancing performance and responsiveness within the Fabric architecture.</p><p>In <a href="https://youtu.be/UcqRXTriUVI?list=FLHTzExfDML8C28r1eSFa7Jw&amp;t=1303">his insightful talk</a> during the launch of this new architecture, Parashuram presented an example of <strong>JSI code</strong> to illustrate its functionality. Following that, I’ve prepared a simple representation of a JSI code snippet to further demonstrate its practical application in React Native’s Fabric architecture. Here’s how a basic JSI code might look:</p><pre>// JSI representation in C++<br>Camera:HostObject {<br>    Value get(propName) {<br>        switch (propName) {<br>            case &#39;getPictures&#39;:<br>                // Call Android/iOS API<br>                return JavaCameraManager.takePic();<br>        }<br>    }<br>}<br><br>// Accessing a native module using JSI<br>const NativeModule = global.Camera;<br><br>// Using the native module to perform an operation<br>const result = NativeModule.getPictures({video: true});<br><br>console.log(&#39;Result from native module:&#39;, result);</pre><p>Now that we have a clearer understanding of what JSI entails, let’s delve into a practical scenario to <strong>illustrate the inefficiencies in the Bridge</strong> architecture. Consider a <strong>use case</strong> where we need to <strong>take a picture and upload it using a native plugin</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mAw0UpZ8C4XGd8ph.jpg" /><figcaption>Bridge architecture</figcaption></figure><p>In this scenario, our JavaScript code requests the native module to capture a photo. Once the picture is taken, the native side <strong>sends it</strong> back <strong>to the JavaScript</strong> layer <strong>via the Bridge</strong>. However, this process doesn’t end here. We then need to <strong>pass the photo back to the native plugin for uploading</strong>, again <strong>through the Bridge</strong>. This back-and-forth communication, with its associated serialization and deserialization, highlights the inefficiencies and <strong>performance issues</strong> inherent in the Bridge architecture, especially for data-intensive operations like image handling.</p><p>In contrast to the Bridge architecture, JSI eliminates the need for data serialization. With JSI, we can <strong>interact directly with the camera</strong> and the native module, bypassing the Bridge entirely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*scEZZIIDMznGB2Sa.jpg" /><figcaption>Fabric architecture</figcaption></figure><p>JSI facilitates shared memory access between Native code and JavaScript. This means our<strong> picture reference is simultaneously accessible to both environments</strong>. Similarly, native modules can be directly invoked and managed within the JavaScript code. This shared memory approach not only streamlines the process but also significantly <strong>enhances performance</strong>, especially in data-intensive operations like handling and uploading images.</p><h4>New Renderer</h4><p>In Fabric architecture, React Native introduces a new renderer, which plays a pivotal role in transforming React logic into visual elements on the <a href="https://reactnative.dev/architecture/glossary#host-platform">host platform</a>. This transformation process is known as the <strong>render pipeline</strong>. It’s a series of steps that the renderer follows, both for initial rendering of the UI and for any subsequent updates to the UI state. In this section, we’ll delve into the intricacies of the render pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tRZEQG8CNQ-BmjIr.jpg" /><figcaption><a href="https://reactnative.dev/architecture/render-pipeline">https://reactnative.dev/architecture/render-pipeline</a></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/467/1*vEhNida_jldO5Pq2eXBxXg.png" /></figure><p>The <strong>Render</strong> phase plays a critical role in creating two distinct trees: the <a href="https://reactnative.dev/architecture/glossary#react-element-tree-and-react-element">React Element Tree</a> and the <a href="https://reactnative.dev/architecture/glossary#react-shadow-tree-and-react-shadow-node">React Shadow Tree</a>. The React Element Tree is composed of all our components, organized by <strong>React’s Reconciliation algorithm</strong>. Corresponding to each element in this tree, React Native constructs a <strong>Shadow Node</strong>. These Shadow Nodes together form the Shadow Tree, which carries additional information, particularly regarding <strong>styling</strong>, <strong>for the native side</strong>. This phase ensures that both the logical structure of the React components and their native styling attributes are systematically prepared for the subsequent rendering stages.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/467/1*ctME83SeKmYU1ExduBfTfA.png" /></figure><p><strong>The Commit phase</strong> follows the Render phase and involves two critical actions. First, it <strong>calculates the positioning</strong> of elements using the styles determined in the previous phase. This ensures that each component is correctly styled and positioned according to the layout defined by the React Element Tree and the additional styling information in the Shadow Tree.</p><p>Secondly, this phase introduces a step called ‘<strong>Tree Promotion</strong>.’ In light of JSI’s interaction with C++ references, React Native emphasizes immutability more than ever. This means that with each state update, a new tree is created. The Tree Promotion step is pivotal here, as it designates the newly created tree as the ‘next tree,’ signifying that it represents the latest state update in the application. This process not only keeps the UI in sync with the app’s state but also optimizes performance by ensuring that only the most recent updates are rendered.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/571/1*moS6EdWK2KgwRbdl9a6ABA.png" /></figure><p>The final phase in the update pipeline is the Mount phase, which comprises several key steps:</p><ol><li><strong>Tree Diffing:</strong> This crucial step involves calculating the differences between the <strong>‘previously rendered tree’</strong> and the <strong>‘next tree’</strong>, and it’s executed entirely in C++. The outcome is a series of atomic mutation operations intended for the host views, such as createView, updateView, removeView, and deleteView. Additionally, during this step, the React Shadow Tree undergoes a flattening process. This is designed to minimize the creation of unnecessary host views.</li><li><strong>Tree Promotion (Next Tree → Rendered Tree):</strong> In this step, the ‘next tree’ is atomically promoted to become the ‘previously rendered tree.’ This promotion is vital as it ensures that the next Mount phase computes a diff against the correct tree, maintaining the continuity and accuracy of the application’s state and UI.</li><li><strong>View Mounting:</strong> Finally, the atomic mutation operations identified in the Tree Diffing step are applied to the corresponding host views. This process occurs on the UI thread of the host platform, effectively bringing the calculated changes to life on the screen.</li></ol><h3>Conclusion</h3><p>We’ve seen how <strong>Fabric’s renderer</strong> streamlines the process of transforming React components into native views through its efficient <strong>Render, Commit, and Mount phases</strong>. The Render phase prepares the <strong>React Element Tree and Shadow Tree</strong>, setting the stage for accurate UI rendering. The Commit phase, with its focus on layout calculations and Tree Promotion, ensures that the application’s state is accurately reflected in the UI. Finally, the Mount phase, through Tree Diffing and View Mounting, brings the calculated changes to life on the screen.</p><p>Central to this enhanced process is <strong>JSI</strong>, a game-changer in how <strong>JavaScript communicates with native modules</strong>. By allowing direct interaction and shared memory, JSI overcomes the performance bottlenecks of the traditional Bridge architecture, marking a significant leap in React Native’s evolution.</p><p>Through these advancements, Fabric and JSI collectively usher in a new era of efficiency and performance in React Native applications, demonstrating the framework’s ongoing commitment to innovation and improvement.</p><h4>Links</h4><ul><li><a href="https://medium.com/@wmpasindu/yoga-in-react-native-understanding-the-flexbox-layout-system-b79eec835fa5">React Native Yoga</a></li><li><a href="https://reactnative.dev/docs/javascript-environment">JavaScript Environment</a></li><li><a href="https://engineering.fb.com/2019/07/12/android/hermes/">Meta engineering blog about Hermes</a></li><li><a href="https://reactnative.dev/architecture/overview">React Native Docs for Fabric</a></li><li><a href="https://overreacted.io/react-as-a-ui-runtime/#renderers">React renderer</a></li><li><a href="https://medium.com/mindful-engineering/fabric-architecture-react-native-a4f5fd96b6d2">React Fabric Overview</a></li><li><a href="https://www.freecodecamp.org/news/how-react-native-constructs-app-layouts-and-how-fabric-is-about-to-change-it-dd4cb510d055/">React Native layout building</a></li><li><a href="https://youtu.be/UcqRXTriUVI?si=D-3LaEqfhDO6qpke">React Native’s New Architecture — Parashuram N — React Conf 2018</a></li><li><a href="https://youtu.be/fOOEIVjqWYg?si=3uHk5u_mUG4SxZgB">New React Native architecture — Roundtable discussion</a></li><li><a href="https://youtu.be/Q6TkkzRJfUo?si=Ktxym7U2jbA48IfJ">Bringing the New React Native Architecture to the OSS Community | Nicola Corti | App.js Conf 2022</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3fd88de8963a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exploring React Native’s Architectures: Bridge and Beyond]]></title>
            <link>https://medium.com/@antoniogally/exploring-react-natives-architectures-bridge-and-beyond-76e414accf7d?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/76e414accf7d</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[bridge]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Mon, 27 Nov 2023 12:56:26 GMT</pubDate>
            <atom:updated>2023-11-27T12:56:26.113Z</atom:updated>
            <content:encoded><![CDATA[<p>By Antonio Gally, a cool Software developer</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lepKX3bZXRmmSHfs.png" /><figcaption><a href="https://uds.com.br/blog/react-native-o-que-e/">https://uds.com.br/blog/react-native-o-que-e/</a></figcaption></figure><p>When it comes to the architecture of any technology, things usually get a bit more complicated, but it’s always worth exploring. In this post, we’re going to take a deep dive into the two architectures of React Native, exploring technical diagrams and schemes in detail. This is an advanced post about React Native, aimed at those who already have some familiarity with the framework.</p><p>If you’re just beginning to understand how React Native works, this post might not be the best starting point (yet). So, for those ready to delve into the complexities of React Native architectures, let’s get started on this technical journey!</p><h3>Why two architectures?</h3><p>React Native was initially built on the Bridge architecture, which faced <strong>performance issues</strong>. In response, Facebook started developing a new architecture called Fabric in 2018, aiming to replace Bridge. Fabric began its rollout in 2021, first being used in Facebook’s internal apps. However, according to the official <a href="https://reactnative.dev/architecture/overview">React Native documentation</a>, Fabric is still in the rollout phase and not yet fully deployed in production. As of now, new <strong>React Native apps still predominantly use the Bridge architecture</strong>.</p><h3>Bridge</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CKrD6Nui2x6uB9QM.jpg" /></figure><p>In this diagram, we can see three principal threads that exists when we run our app using Bridge’s architecture. Let’s talk about the responsability of each of them:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PrHVuC1KnVfC2ErJ1rS9HA.png" /></figure><ul><li><strong>Js Thread</strong> will run all our React code</li><li><strong>Shadow Thread</strong> will create native styles and positions from our components</li><li><strong>Main Thread</strong> will draw our UI and listen to events</li></ul><h4>JS Thread</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*imo9iPmYrCgKb3JE.jpg" /></figure><blockquote>The JS Thread runs our React code, bundled by Metro Bundler and interpreted by either the JSC or Hermes JavaScript engine.</blockquote><p>All of our React code runs in the JS (JavaScript) Thread, undergoing a bundling process with <a href="https://metrobundler.dev/docs/concepts">Metro Bundler</a>. This process generates a JS Bundle, which is then ready to be interpreted by a <a href="https://www.geeksforgeeks.org/introduction-to-javascript-engines/">JavaScript Engine</a>. This engine can be the browser’s default <a href="https://developer.apple.com/documentation/javascriptcore">JavaScriptCore (JSC)</a> or <a href="https://reactnative.dev/docs/hermes">Hermes</a>, an enhanced engine specifically created for React Native by Facebook’s team.</p><h4>Shadow Thread</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A0Kib9uKOqv9V4Bv6qhMSg.png" /></figure><blockquote>The Shadow thread in React Native transforms our flexbox layout into a format understood by native platforms (Android/iOS) using the Yoga layout engine.</blockquote><p>Although we write our layout in flexbox style, the host platforms (Android/iOS) have their own distinct layout systems and don’t inherently follow flexbox rules. To bridge this gap, React Native employs the Shadow thread. This thread processes the layout dimensions and positions from our flexbox code, creating a layout tree (<a href="https://reactnative.dev/architecture/glossary#react-shadow-tree-and-react-shadow-node">React Shadow Tree</a>) that corresponds to the native system’s requirements. At its core, the Shadow thread utilizes <a href="https://yogalayout.dev/">Yoga</a>, a layout engine that effectively translates our flexbox-based layout into a format compatible with the native operating systems.</p><h4>Main Thread</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HZU2rAZFv6h1nQdB128d3A.png" /></figure><blockquote>It converts layout instructions into visual components, handles user interactions and events for responsiveness, and manages Native Modules for integrating native platform features.</blockquote><p>The Main Thread plays a crucial role in React Native’s architecture. Its primary responsibility is to render the Shadow Tree, an operation that forms the basis of what is referred to as the ‘<a href="https://reactnative.dev/architecture/glossary#host-view-tree-and-host-view">Host View Tree</a>’ in the Fabric architecture. Essentially, this thread takes the layout calculations and instructions prepared by the Shadow thread and turns them into actual visual components on the screen.</p><p>Beyond UI rendering, the Main Thread handles user interactions and events, like taps and swipes, ensuring responsive and interactive user experiences.</p><p>Additionally, the Main Thread manages Native Modules. These modules enable access to native platform features, such as the device’s camera or push notifications, and are essential for integrating platform-specific functionalities not directly available in JavaScript.</p><p>After discussing those three threads in the <strong>Bridge architecture</strong>, let’s now explore the <strong>Bridge</strong> itself. How exactly does <strong>JavaScript communicate</strong> with native code, and vice versa?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wqeSAyiBFyclUf1A.jpg" /></figure><blockquote>The Bridge in React Native is a message queue system that utilizes JSON messages for communication between JavaScript and native platforms.</blockquote><p>The Bridge is a fundamental architecture in React Native, enabling the <strong>communication between JavaScript code and the native components</strong> of a mobile application. It operates asynchronously, utilizing JSON objects for a bidirectional exchange of information between JavaScript and the native environment. Key characteristics of the Bridge include:</p><ul><li><strong>Batched Bridge:</strong> Rather than sending operations individually, React Native batches them together before sending them over the Bridge. This approach significantly <strong>optimizes performance</strong> by reducing the communication overhead.</li><li><strong>Serializability:</strong> All data transmitted across the Bridge must be serialized. This means complex JavaScript objects are <strong>converted into strings</strong>, sent across the Bridge, and then deserialized or parsed on the receiving side.</li><li><strong>Asynchronous Nature:</strong> The Bridge’s operations are inherently asynchronous, meaning they don’t occur instantaneously. This characteristic ensures that the <strong>JavaScript thread remains unblocked</strong>, allowing the UI and other processes to run smoothly without waiting for the Bridge operations to complete.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pms_AEthXh6VB6kF.jpg" /><figcaption>Event flow on Bridge’s architecture</figcaption></figure><h3>The Bridge’s problem</h3><p>Understanding that every interaction in React Native, from events to screen updates, requires data to be serialized, passed through the Bridge, and then deserialized — in an asynchronous manner — leads us to the crux of the issue: <strong>performance</strong>. Consider a scenario where your app needs to display a large amount of data, constantly updating in response to numerous events. In this situation, the Bridge becomes a bottleneck. The process of serializing, transmitting, and then deserializing vast amounts of data can lead to noticeable delays. The result? Your screen might temporarily go blank during heavy data updates, a clear indicator of performance strain in the Bridge architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*59EknEKVip6J68_o.jpg" /></figure><p><a href="https://youtu.be/UcqRXTriUVI?list=FLHTzExfDML8C28r1eSFa7Jw&amp;t=740">In a talk by Parashuram</a>, an engineer on the React Native team, he provides a practical example of the performance challenges associated with the Bridge architecture. In his presentation, he discusses various aspects of React Native, with a particular focus on handling data asynchronously. Parashuram emphasizes an important point:</p><blockquote>‘Not everything needs to be asynchronous!’</blockquote><p>He explains that in an asynchronous environment, like that of React Native’s Bridge, <strong>native events</strong>, once initiated, <strong>cannot be canceled</strong>. This limitation means there’s an inherent delay in responsiveness. Consequently, the more data or events being processed asynchronously, the slower the response time becomes, impacting the app’s overall performance.</p><p>Given these challenges, the team at Facebook embarked on developing an entirely new architecture named Fabric, aimed at overcoming the limitations of the traditional Bridge. I’ll be dedicating an upcoming post exclusively to exploring Fabric and its advancements.</p><p>If you’ve read this far, thank you for your interest and engagement! I’d love to hear your thoughts, so please feel free to leave a comment and share this article with others. Your support and feedback are greatly appreciated! Thanks a lot! ❤</p><h4>Reference Links</h4><ul><li><a href="https://medium.com/@Blochware/breaking-down-the-bridge-how-react-natives-js-to-native-communication-works-f98c9f88784a#:~:text=A%20Glimpse%20into%20The%20Bridge%E2%80%99s,a%20brief%20breakdown%3A%20Batched%20Bridge">Breaking down the bridge</a></li><li><a href="https://dev.to/mfrachet/understanding-the-react-native-bridge-concept-1k90#:~:text=React%20Native%20deals%20with%20two,way%20for%20bidirectional%20and">React Native Bridge concept</a></li><li><a href="https://www.geeksforgeeks.org/what-is-a-bridge-in-react-native/">What is Bridge in react native</a></li><li><a href="https://dev.to/wjimmycook/how-the-react-native-bridge-works-and-how-it-will-change-in-the-near-future-4ekc#:~:text=The%20React%20Native%20Bridge%20allows,How%20does%20the%20bridge%20work">How Bridge works</a></li><li><a href="https://github.com/facebook/react-native/tree/main/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge">Bridge Code</a></li><li><a href="https://medium.com/@wmpasindu/yoga-in-react-native-understanding-the-flexbox-layout-system-b79eec835fa5">React Native Yoga</a></li><li><a href="https://www.freecodecamp.org/news/how-react-native-constructs-app-layouts-and-how-fabric-is-about-to-change-it-dd4cb510d055/">React Native layout building</a></li><li><a href="https://ag-rn-presentation.netlify.app/">My presentation</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76e414accf7d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementing React redux]]></title>
            <link>https://medium.com/@antoniogally/implementing-react-redux-e641405a8c9c?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/e641405a8c9c</guid>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[redux]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Mon, 20 Mar 2023 01:10:51 GMT</pubDate>
            <atom:updated>2023-03-20T01:13:25.109Z</atom:updated>
            <content:encoded><![CDATA[<h4>React Redux implementation tutorial, using it as a global state manager with Hooks</h4><p>By Antônio Gally, React Frontend developer at <a href="https://www.looqbox.com/">Looqbox — BI Platform</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2DNKy3eF9Pn5fJ8HWghxxw.jpeg" /><figcaption><a href="https://waftengine.org/public/blog/1B5EE4D5D773F8A-RR.jpg">https://waftengine.org/public/blog/1B5EE4D5D773F8A-RR.jpg</a></figcaption></figure><p>Hello there! I did a small tutorial to implement redux nowadays, using the best practices that we have, making it simple and organized. After we configure our redux, I&#39;ll show you how to use it with hooks that redux provides to us. Let me know if you liked! Thanks for being here :D</p><h3>Implementing Redux</h3><p>Starting from scratch, I&#39;ll create a new project with:</p><pre>yarn create react-app my-redux-app --template=typescript</pre><p>With the created project, we need to add our dependencies:</p><pre>yarn add redux react-redux @reduxjs/toolkit</pre><h4>Directory tree</h4><p>Then, we can start to create the structure. To do that we need to understand how redux works. In a simple way, redux need&#39;s <strong>actions</strong>, <strong>store </strong>and<strong> reducers</strong>. To explain all these tree guys, <a href="https://blog.logrocket.com/understanding-redux-tutorial-examples/#:~:text=The%20way%20Redux%20works%20is,actions%2C%20store%2C%20and%20reducers.">this article</a> will help a lot. Knowing the prerequisites, we now have:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*HiQtVdQaX75b_wX_EitRwQ.png" /></figure><h4>Redux types</h4><p>With the right files, we can start to create the type of user state that we want to store on our redux. If we wanted to have another information about the user, we could add more objects inside userReducerType , for example a userMetaData</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c87a85a2f3b1f61bae519096c86e15ea/href">https://medium.com/media/c87a85a2f3b1f61bae519096c86e15ea/href</a></iframe><h4>Redux actions</h4><p>The actions are just a plain javaScript object that must have a type and a payload or data inside. We&#39;re just making it dynamic passing the user data through him as a function.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/646c46250b3c9ba5cac85d404ea0f67c/href">https://medium.com/media/646c46250b3c9ba5cac85d404ea0f67c/href</a></iframe><h4>Redux reducer</h4><p>To finish our user storage on redux, we need a <strong>reducer</strong>. The literal definition of a reducer is that he is a function that receives one state and one action. The state is our user storage data for example, and the action is the return of our user.actions itself. Inside of the reducer function, we can make changes in that state according to each type that we pass on our <strong>action</strong> object, like SET_USER_INFO.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5bd69ca1d418ae54353b9a58e2e635c5/href">https://medium.com/media/5bd69ca1d418ae54353b9a58e2e635c5/href</a></iframe><h4>Redux store</h4><p>Now we have our user reducer running! The last thing to do is actually configure our <strong>store</strong>. Redux&#39;s store is complicated 😳, but all we need to know (now) is that redux need to assemble all the reducers of our application and apply them all into a store that will exist outside of our components, like a guard watching everything from outside. This gif will illustrate better:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yYkitaR24SuFNXYyTxL1xA.gif" /><figcaption><a href="https://redux.js.org/tutorials/essentials/part-1-overview-concepts">https://redux.js.org/tutorials/essentials/part-1-overview-concepts</a></figcaption></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c3da471166c99e7757094afb2424c5dd/href">https://medium.com/media/c3da471166c99e7757094afb2424c5dd/href</a></iframe><h3>Using Redux</h3><p>With our store working well, we just need to wrap up on some part of our react app. Mostly, we put on index.tsx</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6390f3f4ec415b5eb004bfbaad2c64b0/href">https://medium.com/media/6390f3f4ec415b5eb004bfbaad2c64b0/href</a></iframe><p>😎 Yes, we have a up and running redux on our app, if you have the <a href="https://chrome.google.com/webstore/detail/redux-devtools/lmhkpmbekcpmknklioeibfkpmmfibljd">Redux dev tools extension</a> on your chrome, you&#39;ll see the redux structure like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QJRK9-RopmSKmw5r6aAH_A.png" /></figure><h4>How to use</h4><p>All right, but how can we use this beauty 🤔. With useSelector and useDispatch of course! In older eras of redux, we had a guy called connect, mapStateToProps, mapDispatchToProps and stuff, but nowadays we have hooks, and hooks are great so let&#39;s use it 🤟</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b4c02e1492c2c84b076491cafd997032/href">https://medium.com/media/b4c02e1492c2c84b076491cafd997032/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_rousd5t_1Y9g9sp7b8bfQ.png" /></figure><h3>Summary</h3><h4>Final words</h4><p>I presented here a small tutorial to show you how we can configure our react-redux state manager keeping it organized and scalable. After the configuration is ready, we saw how to use two of five hooks that Redux have, using them to manipulate the data that we want inside of our store. Thanks a lot for read this medium post! Hope see you in many others :D</p><h4>Links</h4><ul><li><a href="https://redux.js.org/introduction/getting-started">Redux&#39;s tutorial</a></li><li><a href="https://redux.js.org/tutorials/essentials/part-1-overview-concepts">Redux concepts</a></li><li><a href="https://blog.logrocket.com/understanding-redux-tutorial-examples">logrocket&#39;s tutorial</a></li><li><a href="https://chrome.google.com/webstore/detail/redux-devtools/lmhkpmbekcpmknklioeibfkpmmfibljd">React Redux DevTools</a></li><li><a href="https://github.com/AntonioGally/JS_ES6_Learning/tree/master/react/react-redux">Github repository</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e641405a8c9c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Frontend Documentation]]></title>
            <link>https://medium.com/@antoniogally/frontend-documentation-ff88ccf4f5f3?source=rss-af6c2e201765------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff88ccf4f5f3</guid>
            <category><![CDATA[storybook]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[documentation]]></category>
            <dc:creator><![CDATA[Antônio Gally]]></dc:creator>
            <pubDate>Sat, 03 Dec 2022 17:23:15 GMT</pubDate>
            <atom:updated>2022-12-03T17:23:15.616Z</atom:updated>
            <content:encoded><![CDATA[<p>By Antônio Gally, React Frontend developer at <a href="https://www.looqbox.com/">Looqbox — BI Platform</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ntJCQbzni7exxxSPBf0JIg.png" /></figure><p>I was doing my presentation for the <a href="https://reactconf.com.br/">Brazilian React Conference</a> and I thought that I could process all the information, and publish here in medium :]. So enjoy and please let me know your feedback here in the comments section below or in any social media.</p><h4>What is it?</h4><blockquote>Documentation is a material that provides official information or evidence or that serves as a record.</blockquote><p>That&#39;s what the google says, and it&#39;s pretty accurate… If you see from a frontend perspective, we can generate a lot of MDX, MD files, etc… Each one telling <strong>some truth</strong> about one part of <strong>your product</strong>. But I have another way to describe as well:</p><blockquote>Frontend documentation is one way that we have to maintain and keep our frontend scalable.</blockquote><p>If you think about large companies and big Frontend projects, automatically you&#39;ll think something about guidelines and rules that every Frontend developer will need to follow, and we can considerate these guidelines and rules as documentation for example.</p><h4>How can I actually document my Frontend?</h4><p>For this specific question, I saw an <a href="https://mdapp.medium.com/how-to-document-front-end-software-products-e1f5785279bb">amazing article</a> that explained step-by-step this hole process, but I&#39;ll put my experiences here.</p><p>So, our Frontend needed to be restructured for a lot of reasons, and for help me to keep up the changes, I started to draw on <a href="https://miro.com/"><strong>Miro</strong></a> every new process that we did. I remember that we was applying a lot of design patterns, and for help us to structure this new design pattern, we always used Miro. I&#39;ll give you an example of a simple todo list application using <a href="https://medium.com/gbtech/orchestration-pattern-3d8f5abc3be3">orchestrators</a> and <a href="https://refactoring.guru/design-patterns/command">commands</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RTGF8bQM8Vvz8J3BNxNoCQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*koXo2g9BVPaAqFewM282MA.png" /></figure><p>With this application, we can document the hole process using Miro and this help us a lot to understand what is running in the background of each event. Here&#39;s the <a href="https://github.com/AntonioGally/desing-pattern-example"><strong>repository link</strong></a> :]</p><p>For document my visual components, for example, add button or remove button, I prefer to use <a href="https://storybook.js.org/">Storybook</a>. I did this choice because the Storybook is a huge platform on our community and has a differential too when we talk about interactivity with our components, we can even implement tests using Storybook&#39;s tools and addons, gathering documentation and testing in just one library. They have a lot of examples and I&#39;ve prepared a list of big documentations that where built on Storybook.</p><ul><li><a href="https://react.carbondesignsystem.com/?path=/story/getting-started-welcome--welcome">IBM (Carbon)</a></li><li><a href="https://main--5d559397bae39100201eedc1.chromatic.com/?path=/story/playground--details-page">Shopfy</a></li><li><a href="https://master--628d031b55e942004ac95df1.chromatic.com/?path=/docs/concepts-introduction--page">Microsoft (Fluent UI)</a></li><li><a href="https://ui.thinkcompany.dev/?path=/story/storybook-welcome--page">Think Company</a></li><li><a href="https://chakra-ui.netlify.app/?path=/story/accordion--default">Chakra UI</a></li><li><a href="https://main--61a90feace7802003a4d9c45.chromatic.com/?path=/story/components-actionlist--default">Github</a></li></ul><p>Following the simple todo list app, I&#39;ll do a documentation for the components using Storybook:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jrpiR7a4BxzVNsoYNhVqLA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/458/1*S3Zmn3htmowDjXvLyWm6YA.png" /></figure><h4>Final words</h4><p>I presented to you two types of documentation: Process documentation and Visual Components documentation. There are a lot of softwares and tools we can use to help us on that subject, I used <strong>Miro </strong>and<strong> Storybook. </strong>We need to remember that documentation itself isn&#39;t just a tool that we can use to write some docs. Documentation could be a piece of paper that you write some fact about your product… We&#39;re just making it scalable using powerful softwares. Hope you liked this article! See you later (hopefully) :]</p><h4>Links</h4><ul><li><a href="https://github.com/AntonioGally/desing-pattern-example">Simple todo-list app repository</a></li><li><a href="https://css-tricks.com/front-end-documentation-style-guides-and-the-rise-of-mdx/">Front-End Documentation, Style Guides and the Rise of MDX</a></li><li><a href="https://mdapp.medium.com/how-to-document-front-end-software-products-e1f5785279bb">How to Document Front End Software Products</a></li><li><a href="https://aviyel.com/post/1178/the-do-s-and-don-ts-of-front-end-documentation">The Do’s and Don’ts of Front-End Documentation</a></li><li><a href="https://flatlogic.com/blog/writing-documentation-for-your-javascript-project/">Writing Documentation for Your JavaScript Project</a></li><li><a href="https://blog.shimin.io/4-ways-to-make-your-front-end-doc-site-more-useful/">4 Ways to Make Your Front-End Documentation Actually Useful</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff88ccf4f5f3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>