<?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[zen8labs - Medium]]></title>
        <description><![CDATA[zen8labs engineering blogs - Medium]]></description>
        <link>https://medium.com/zen8labs?source=rss----5a9c5b7a91ad---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>zen8labs - Medium</title>
            <link>https://medium.com/zen8labs?source=rss----5a9c5b7a91ad---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 22:22:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/zen8labs" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[What is the UX Honeycomb?]]></title>
            <link>https://medium.com/zen8labs/what-is-the-ux-honeycomb-abcb334f5dba?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/abcb334f5dba</guid>
            <category><![CDATA[it-consulting]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[honeycomb]]></category>
            <category><![CDATA[ux-ui-design-thinking]]></category>
            <category><![CDATA[zen8labs]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Mon, 30 Jun 2025 02:17:08 GMT</pubDate>
            <atom:updated>2025-06-30T02:17:08.314Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xCoouInUj93qGQz3.png" /></figure><h3>Spoiler: It’s Not About Bees</h3><p>The UX Honeycomb is a slick visual framework with seven key facets that define a stellar user experience. Think of it as a honeycomb-shaped cheat sheet for building products people love. It’s sweet, structured, and if you ignore it, you might get stung (aka your product flops).</p><p>Picture a shiny honeycomb diagram (use Morville’s original or whip up your own for some brand flair):</p><ul><li><strong>Useful</strong>: Does your product solve a real problem, or is it just digital eye candy?</li><li><strong>Usable</strong>: Is it easy to navigate, or does it feel like solving a Rubik’s cube blindfolded?</li><li><strong>Desirable</strong>: Does it look sexy enough to make users swoon at first glance?</li><li><strong>Findable</strong>: Can users find what they need, or are they lost in a digital maze?</li><li><strong>Accessible</strong>: Can <em>everyone</em> use it, including those with different abilities?</li><li><strong>Credible</strong>: Does it scream “trustworthy” or “sketchy scam alert”?</li><li><strong>Valuable</strong>: Does it deliver for users <em>and</em> the business, or is it just a pipe dream?</li></ul><p>It’s simple but packs a punch, covering all the bases of UX without leaving you drowning in jargon. In my blog, I will give you an insight into your own honeycomb environment.</p><h3>Building a UX Research process with Honeycomb (No superpowers required)</h3><p>Here’s how to weave the Honeycomb into your research process without losing your sanity:</p><h4>1. Nail down your research goals: Don’t just wing it</h4><p>Grab a coffee (or a kombucha if you’re fancy), sit down, and ask: Which parts of the honeycomb do we need to zoom in on?</p><ul><li><strong>Redesigning a product?</strong> Focus on <strong>Desirable</strong> (is it pretty?) and <strong>Usable</strong> (is it painless to use?). Nobody wants an ugly, clunky interface.</li><li><strong>Launching new features?</strong> Prioritize <strong>Useful</strong> (does it solve a problem?) and <strong>Valuable</strong> (is it worth the dev team’s blood, sweat, and tears?). Don’t let your engineers build something users shrug at with a “What’s this for?”</li><li><strong>Working on an info-heavy site?</strong> Start with <strong>Findable</strong> (can users find stuff?) and <strong>Accessible</strong> (can everyone use it?). No one wants to play “Where’s Waldo” on your website.</li></ul><h4>2. Pick the right research methods: No, you can’t just interview everyone</h4><p>Each honeycomb facet needs its own research vibe. Here’s a quick cheat sheet so you’re not guessing:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XcwZ80rvQpc9a5hdGGNItg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n9NGoUvSVM0VjN3-.png" /></figure><h4>3. Gather and Sort Data: Don’t let insights bury you</h4><p>When data comes flooding in like a tsunami, organize it by the seven Honeycomb facets. This keeps things clear and shows you what’s rocking and what’s a hot mess.</p><p>Pro tip: Make a Honeycomb Insights Board (sounds fancy, but it’s just a board with sections). Assign each facet a section and slap on sticky notes with your findings. If a section’s empty, that’s your cue to dig deeper (or grab another coffee).</p><h4>4. Turn Insights into Action: Don’t Just Sit on Your Data</h4><p>Research isn’t just for pretty reports no one reads. Make it count:</p><ul><li><strong>Prioritize fixes</strong> for the weakest facets. If your product looks great but users can’t find the signup button, tackle <strong>Findable</strong> first.</li><li><strong>Share clear recommendations</strong> with your design and product teams. Skip the buzzwords and say, “This button’s invisible — fix it!”</li><li><strong>Guide future designs</strong> with the Honeycomb as your compass. It’ll keep you from wandering into UX chaos.</li></ul><h3>Why bother with the UX Honeycomb? Because it’s awesome</h3><ul><li><strong>Comprehensive</strong>: It covers the whole UX spectrum, not just whether your product’s easy to use.</li><li><strong>Easy to explain</strong>: Makes it simple to get non-UX folks (like your boss) on board without their eyes glazing over.</li><li><strong>Actionable</strong>: Turns your research into clear next steps, so you’re not drowning in data with no plan.</li></ul><h3>Don’t do UX without your Honeycomb!</h3><p>The UX Honeycomb is like that reliable friend who always has your back: simple, trustworthy, and keeps you from missing the big stuff. Whether you’re in a scrappy startup or a corporate giant, this model ensures you don’t skip any critical UX angles.</p><p>So, next time you’re planning a UX research project, think Honeycomb! And if it all goes haywire, don’t blame the bees and start over, reach out to my colleagues at <a href="https://www.zen8labs.com/#contact">zen8labs</a>, we can help you to sort out the honey from the bees</p><p><em>Ngan Anh Le, UI/UX designer</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=abcb334f5dba" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/what-is-the-ux-honeycomb-abcb334f5dba">What is the UX Honeycomb?</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A deep dive into Inheritance in Odoo 17]]></title>
            <link>https://medium.com/zen8labs/a-deep-dive-into-inheritance-in-odoo-17-25a9c9550bbd?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/25a9c9550bbd</guid>
            <category><![CDATA[odoo]]></category>
            <category><![CDATA[it-consulting]]></category>
            <category><![CDATA[inheritance]]></category>
            <category><![CDATA[zen8labs]]></category>
            <category><![CDATA[odoo-17]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Fri, 27 Jun 2025 02:16:43 GMT</pubDate>
            <atom:updated>2025-06-27T02:16:43.173Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vIGxraGWwftusMYz.png" /></figure><h3>Introduction</h3><p>Odoo’s modular architecture is one of the main reasons for its flexibility and popularity. A crucial feature that makes this modularity possible is inheritance. Inheritance in <a href="https://www.odoo.com/">Odoo</a> allows developers to customize and extend existing models and views without altering the core codebase, ensuring upgradability and clean code management.</p><p>In my blog, I shall explore two major types of inheritance in Odoo 17:</p><ul><li><strong>Model Inheritance</strong>: Reusing or extending data models</li><li><strong>View Inheritance</strong>: Modifying user interfaces dynamically</li></ul><h3>Model Inheritance</h3><p>In Odoo supports three types of model inheritance:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r7nq4Mi14VwtOVtoZZg3cw.png" /></figure><p>Let’s look at each specific area in detail.</p><h4>1.Classical Inheritance</h4><p>This method allows you to create a new model that inherits all fields and methods from another model. You use both _name and _inherit.</p><p>Use Case: When you want to build a new model that is structurally similar to an existing one, but with its own identity.</p><h4>Example:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/0*pzmeOE7ilydIWHMu.png" /></figure><p>The library.ebook model inherits all fields and methods from library.book, but it also adds a new field (file_format) and overrides the method.</p><h4>2.Extension Inheritance</h4><p>In this case, you’re not creating a new model — you are extending an existing model by adding or modifying fields or methods. You only define _inherit.</p><p>Use Case: When you want to add features to existing models (e.g., add new fields to res.partner, product.template, etc.)</p><h4>Example</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/0*kIWRulQRGC_UTCAO.png" /></figure><p>Now all partner records (res.partner) will have a new field and method without altering the original core model.</p><h4>3.Delegation Inheritance</h4><p>This type of inheritance uses the _inherits attribute and is based on composition, not class-style inheritance. You define a many2one field linking to another model and delegate access to its fields.</p><p>Use Case: When you want to use another model field without merging into the same table.</p><h4>Example:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/603/0*G1bEOHZFoEi1bh0i.png" /></figure><p>The library.book model inherits fields like name and nationality from library.author via the author_id field, while keeping their data in separate tables.</p><h3>View Inheritance</h3><p>Odoo views are defined using XML. View inheritance allows you to extend existing UI views — you don’t need to override the whole view; just define what you want to insert, change, or remove.</p><p>Use Case: Add fields, buttons, or tabs to a standard Odoo form or tree view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/601/0*f-SXXQuFDQtRoYPM.png" /></figure><p>These have some key attributes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qCOOCRhObIPRUotRBU-zHQ.png" /></figure><h4>Alternative Syntax</h4><p>Sometimes, you can use an alternative simplified structure:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/386/0*zU795cWdXYEWMZao.png" /></figure><p>Both formats are valid; use whichever gives you better control depending on the structure of the parent’s view.</p><h3>Final thoughts</h3><p>Inheritance in Odoo 17 is designed to empower developers to write modular, scalable, and upgrade-safe code. Once you understand when to use each inheritance strategy, you can customize virtually any part of Odoo without ever touching the core modules.</p><p>Whether you’re adding a custom field to a form view, extending a core model, or creating a new model that is built on existing logic — whatever your project, then you should reach out to my colleagues at <a href="https://www.zen8labs.com/#contact%22%EF%B7%9FHYPERLINK%20%22https://www.zen8labs.com/#contact">zen8labs</a> — we are the team that will help you to create something awesome.</p><p><em>Duong Phi, Software Engineer</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25a9c9550bbd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/a-deep-dive-into-inheritance-in-odoo-17-25a9c9550bbd">A deep dive into Inheritance in Odoo 17</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond the hype: My deep dive into building real trust in AI]]></title>
            <link>https://medium.com/zen8labs/beyond-the-hype-my-deep-dive-into-building-real-trust-in-ai-ce2977a98552?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/ce2977a98552</guid>
            <category><![CDATA[zen8labs]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[hype]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[it-consulting]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Thu, 26 Jun 2025 02:17:09 GMT</pubDate>
            <atom:updated>2025-06-26T02:17:08.708Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UlNeGzqpec-OQbeR.png" /></figure><p>Artificial Intelligence (AI). It is no longer the stuff of science fiction, is it? It is woven into the fabric of our daily lives, from the subtle ways our social media feeds are curated to the significant decisions being made in healthcare, finance, and even justice. The advancements are breathtaking, offering potential solutions to some of our most complex challenges. Yet, amidst this whirlwind of innovation, a persistent question echoes in my mind, and I know I’m not alone: how do we genuinely trust these increasingly autonomous and influential systems?</p><p>It’s a question that goes far beyond mere functionality. An AI can perform its task perfectly, but if its processes are opaque, its recommendations biased, or its actions unaccountable, then trust remains elusive. I’ve been doing a lot of thinking about this, spurred on by some excellent discussions and frameworks I’ve come across. It’s becoming clearer than ever that building trustworthy AI isn’t an afterthought; it’s a foundational necessity. It requires a deliberate, multi-faceted approach, a commitment to weaving in principles that foster confidence and reliability.</p><p>So, I wanted to delve deeper into what such a framework might look like, exploring the pillars that I believe are critical to constructing AI systems that aren’t just intelligent, but are also deserving of our collective trust.</p><h3>1. Ethics: The moral compass of AI</h3><p>At the very heart of trustworthy AI, as I see it, lies Ethics. This isn’t just about a philosophical debate; it’s about the practical, intentional embedding of human values into the design, development, and deployment of AI. We’re talking about fundamental principles like fairness, non-maleficence (do no harm), autonomy, justice, and beneficence (do good).</p><p>But what does this mean in practice? Consider an AI system designed to assist in hiring processes. If it’s trained predominantly on historical data from a company or industry where certain demographic groups were underrepresented in particular roles, the AI might inadvertently learn and perpetuate these biases. It could systematically downgrade applications from qualified candidates simply because their profiles don’t match the historically dominant patterns. An ethical approach here would demand proactive measures: ensuring the training data is as diverse and representative as possible, implementing fairness metrics to audit the AI’s recommendations for bias, and perhaps even designing the AI to flag or counteract potential biases it detects.</p><p>Another example is in healthcare AI. Imagine an AI diagnostic tool. An ethical imperative would be to ensure patient privacy is paramount, that the tool doesn’t exacerbate health disparities (e.g., by performing less accurately on certain populations due to underrepresentation in training data), and that patients understand how AI contributes to their diagnosis, preserving their autonomy in making informed decisions about their care. It also means having very serious conversations about what happens if the AI is wrong. Who is harmed? How is that harm mitigated? This requires diverse voices in the room during the AI’s conception — ethicists, sociologists, domain experts, and representatives from affected communities — not just engineers and data scientists.</p><h3>2. Responsibility: Knowing who’s accountable</h3><p>Together with ethics is Responsibility. If AI systems are to be trusted, there must be clear lines of accountability for their actions and impacts. This, to me, is about ensuring there’s always human oversight and that we can answer the crucial question: “Who is responsible when things go wrong?” Or even when they go right, who ensures they continue to go right?</p><p>Take autonomous vehicles, for instance. This is a classic case where responsibility can become incredibly complex. If an autonomous car makes an error that leads to an accident, who is accountable? Is it the manufacturer for a flaw in the algorithm? The owner for improper use or maintenance? The software developers who wrote the specific problematic code? Or perhaps even the regulatory bodies for inadequate safety standards? A robust responsibility framework would seek to delineate these roles and responsibilities before widespread deployment. It might involve establishing clear legal liabilities, mandating certain levels of human monitoring (“human-on-the-loop” for critical decisions), and ensuring that there are mechanisms for redress when harm occurs.</p><p>In a business context, responsibility might mean designating specific roles within an organization to oversee AI governance, risk management, and ethical compliance related to AI systems. For example, an AI used for loan approvals needs a human underwriter who is ultimately responsible for the decision, even if the AI provides a strong recommendation. This person must have the authority and ability to question, override, or investigate the AI’s output. It’s about ensuring that AI augments human decision-making, rather than completely supplanting it in high-stakes scenarios without a clear chain of command. This means a Chief AI Ethics Officer, or a similar role might become as commonplace as a Chief Financial Officer.</p><h3>3. Transparency: Lifting the veil on AI operations</h3><p>Next up is Transparency. I believe that for people to trust AI, they need a degree of visibility into how these systems work, what data they are using, and the logic behind their decisions. It’s about dispelling the “black box” mystique that often surrounds AI, especially the more complex models.</p><p>Transparency can operate on several levels:</p><ul><li><a href="https://www.techtarget.com/searchcio/tip/AI-transparency-What-is-it-and-why-do-we-need-it"><strong>Data transparency</strong></a>: What data was the AI trained on? Is this data representative? Does it contain known biases? For instance, if an AI is used in the criminal justice system to predict recidivism, transparency would demand disclosure of the historical datasets used, which are often known to reflect societal biases. Knowing this allows for critical evaluation of the AI’s potential fairness.</li><li><strong>Algorithmic transparency</strong>: While not everyone needs to understand the intricate mathematical details, a high-level understanding of how the algorithm functions should be accessible. Is it a rule-based system, a decision tree, a neural network? What are its known limitations?</li><li><strong>Decision transparency</strong>: When an AI makes a specific decision — say, flagging a financial transaction as potentially fraudulent — can it provide reasons for that particular outcome?</li></ul><p>Imagine an AI that curates your news feed. Transparency here would mean understanding why you’re seeing certain stories over others. Is it based purely on your past reading history, your stated interests, what’s trending in your network, or sponsored content? A transparent system might offer controls to adjust these factors or at least insights into the “recipe” of your feed. Similarly, if an e-commerce AI recommends a product, transparency would involve clarifying if that recommendation is purely algorithmic or if it’s influenced by promotional agreements.</p><p>Of course, there’s a balance to be struck. Full algorithmic transparency could expose proprietary information or create security vulnerabilities if malicious actors understand exactly how to game the system. However, the goal should be to maximize comprehensibility without compromising essential security or intellectual property.</p><h3>4. Governance: The rules of the AI road</h3><p>Ethics, responsibility, and transparency are vital, but they need a framework to operate within. That’s where Governance comes in. To me, governance provides the structure — the policies, procedures, standards, and oversight mechanisms — to ensure that AI systems are developed and used in a way that is consistent with our ethical principles and societal expectations.</p><p>Internal governance within an organization might involve establishing an AI ethics board or review committee, developing codes of conduct for AI development and deployment, implementing rigorous risk assessment protocols, and conducting regular audits of AI systems. For example, a bank deploying an AI chatbot for customer service would need internal governance to ensure the chatbot provides accurate information, handles customer data securely, and has clear escalation paths to human agents when it can’t resolve an issue or when a customer is distressed. They would also need to regularly review conversation logs (with appropriate privacy safeguards) to ensure quality and identify emerging problems.</p><p>External governance, on the other hand, involves broader industry standards, certifications, and government regulations. We’re seeing this emerge with initiatives like the EU AI Act, which attempts to categorize AI systems by risk and impose different levels of obligations. For high-risk AI systems, such as those used in critical infrastructure or medical devices, stringent external governance, including third-party certification and ongoing monitoring, will likely become the norm. This is similar to how we regulate pharmaceuticals or aviation — acknowledging the potential benefits while managing the significant risks.</p><p>Effective governance isn’t a one-time setup; it’s an ongoing process of monitoring, evaluating, and adapting as AI technology evolves and its societal impact becomes clearer.</p><h3>5. Explainability: Understanding the “why” behind AI decisions</h3><p>Finally, there’s Explainability, often referred to as XAI (Explainable AI). This tackles the “black box” problem more directly by providing insights into how an AI arrives at its decisions, even in complex systems like deep learning neural networks. If we can’t understand, at some level, why an AI made a particular choice, it’s incredibly difficult to trust it, debug it if it’s wrong, or ensure it’s fair.</p><p>Consider an AI system used in medical diagnostics that identifies potential cancerous cells in medical images. If the AI flags an area as suspicious, a doctor needs to understand what features in the image led to that conclusion. Was it the texture, the shape, the size of certain cells, or a combination? Explainability techniques can provide this by, for example, highlighting the specific pixels or regions in the image that most influenced the AI’s decision. This allows the human expert to verify the AI’s reasoning and combine it with their own expertise.</p><p>In finance, if an AI model denies a credit application, an explainable system should be able to articulate the primary reasons. Perhaps it was a high debt-to-income ratio, a short credit history, or recent missed payments. This not only builds trust but also empowers the applicant to understand the decision and potentially take steps to improve their financial situation. Techniques like LIME (Local Interpretable Model-agnostic Explanations) or SHAP (SHapley Additive exPlanations) aim to provide these kinds of insights by showing which input features contributed most significantly to a particular output.</p><p>While perfect explainability for the most sophisticated AI models is still an active area of research, the pursuit is crucial. Even partial explanations or an understanding of feature importance can significantly enhance trust and utility.</p><h3>Why this holistic approach matters more than ever</h3><p>Thinking about these five pillars — Ethics, Responsibility, Transparency, Governance, and Explainability — it’s clear that none of them exist in isolation. They are interconnected and interdependent. An ethical framework is toothless without responsible individuals and governance structures to enforce it. Transparency is a prerequisite for both accountability and understanding the explanations an AI might offer.</p><p>The reason I feel so strongly about this holistic approach is that the stakes are incredibly high. When AI is used in critical areas like healthcare, finance, employment, and the justice system, the consequences of untrustworthy AI can be severe: reinforcing societal biases, eroding public confidence, causing tangible harm to individuals, and potentially hindering the adoption of AI in areas where it could bring immense good.</p><p>Conversely, by proactively building AI on a foundation of trust, we can unlock its transformative potential to solve pressing global problems, create new opportunities, and enhance human capabilities in ways we are only just beginning to imagine. It’s about fostering an ecosystem where innovation and ethical considerations advance hand in hand.</p><h3>The journey ahead</h3><p>Building trustworthy AI is not a destination but a continuous journey. It requires ongoing dialogue, collaboration between technologists, policymakers, ethicists, businesses, and the public. It demands humility, a willingness to learn from mistakes, and a steadfast commitment to aligning artificial intelligence with human values.</p><p>For me, grappling with these concepts isn’t just an academic exercise. It’s about envisioning the kind of future we want to build with these powerful tools. A future where AI empowers us, where it’s a force for good, and where it earns our trust not through hype, but through demonstrable integrity and respect for humanity.</p><p>I’m keen to keep learning and discussing this. If you want to find out more about my work, then you stay tuned to this <a href="https://www.zen8labs.com/insights/">blog channel</a>, here is where you will learn about the awesome stuff zen8labs is doing. But for now, I will ask you: What are your experiences or concerns about building trust in AI?</p><p><em>Viet Nguyen, Head of Delivery at zen8labs</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce2977a98552" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/beyond-the-hype-my-deep-dive-into-building-real-trust-in-ai-ce2977a98552">Beyond the hype: My deep dive into building real trust in AI</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to master MVI with Reducers in Android]]></title>
            <link>https://medium.com/zen8labs/how-to-master-mvi-with-reducers-in-android-38a97f3403b4?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/38a97f3403b4</guid>
            <category><![CDATA[mvi]]></category>
            <category><![CDATA[zen8labs]]></category>
            <category><![CDATA[it-consulting]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[reducer]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Wed, 25 Jun 2025 02:17:07 GMT</pubDate>
            <atom:updated>2025-06-25T02:17:07.488Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>State management is one of the most critical challenges in Android development. Here at <a href="https://www.zen8labs.com/">zen8labs</a>, my colleagues and I adopt the Model-View-Intent (MVI) architecture to keep our applications scalable, maintainable, and predictable. One of the core components of MVI is the Reducer, responsible for transforming events into state updates in a pure and predictable manner. In my blog for you, we will take a deep dive into:</p><ul><li>What is an MVI?</li><li>Understanding Reducers in MVI</li><li>Implementing MVI with Jetpack Compose (Example: Counter App)</li></ul><p>By the end of this tutorial, you will have a fully functional Counter App, where users can increment, decrement, and reset a counter using MVI with Jetpack Compose.</p><h3>What is an MVI?</h3><p><a href="https://www.geeksforgeeks.org/model-view-intent-mvi-pattern-in-reactive-programming-a-comprehensive-overview/">MVI</a> is a unidirectional state management pattern where:</p><ul><li>User actions trigger events.</li><li>Reducers process events and update the state.</li><li>Side Effects handles API calls, database operations, and UI interactions.</li></ul><h3>Why use MVI?</h3><ul><li><strong>Predictability</strong> — The state is updated in a controlled way.</li><li><strong>Testability</strong> — Since reducers are pure functions, they can be easily tested.</li><li><strong>Maintainability</strong> — UI logic and business logic are separated.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GV4usCJIOm0XTkaT.png" /></figure><h3>Understanding reducers in MVI</h3><p>A Reducer is a pure function that:</p><ul><li>Takes the current state and events.</li><li>Returns to a new, immutable state.</li><li>Optionally triggers side effects.</li></ul><p>A Reducer does not:</p><ul><li>Modify existing state directly.</li><li>Perform network or database operations.</li><li>Interact with UI components.</li></ul><p>By keeping reducers pure and predictable, debugging becomes easier, and testability is improved.</p><h4>Example: Counter App using MVI with jetpack compose</h4><p>We will build a Counter App where users can:</p><ul><li><strong>Increment</strong> the Counter</li><li><strong>Decrement</strong> the Counter</li><li><strong>Reset</strong> the Counter</li></ul><h4>1. Define the ViewState</h4><pre>The CounterViewState holds the current state of the counter. <br>@Immutable <br>data class CounterViewState( <br>    val count: Int = 0 <br>)</pre><h4>2. Define events</h4><p>Each user action in MVI is represented as an event.</p><pre>@Immutable <br>sealed class CounterEvent { <br>    data object Increment : CounterEvent() <br>    data object Decrement : CounterEvent() <br>    data object Reset : CounterEvent() <br>}</pre><h4>3. Define Side Effects</h4><p>Side effects are one-time actions like showing a Snackbar.</p><pre>Side effects are one-time actions like showing a Snackbar. <br>@Immutable <br>sealed class CounterSideEffect { <br>    data class ShowErrorPopup(val message: String) : CounterSideEffect() <br>}</pre><h4>Why use SideEffects?</h4><ul><li>They separate <strong>UI interactions</strong> from state updates.</li><li>This keeps the Reducer <strong>pure and testable</strong>.</li></ul><h4>4. Implement the Reducer</h4><p>A Reducer takes the current state and an event, then returns a new state.</p><pre>CounterReducer {<br><br>fun reduce( <br>        previousState: CounterViewState, <br>        event: CounterEvent <br>    ): Pair&lt;CounterViewState, CounterSideEffect?&gt; { <br>        return when (event) { <br>            is CounterEvent.Increment -&gt; { <br>                previousState.copy(count = previousState.count + 1) to CounterSideEffect.LogEvent(&quot;Incremented to ${previousState.count + 1}&quot;) <br>            } <br>            is CounterEvent.Decrement -&gt; { <br>                if (previousState.count &gt; 0) { <br>                    previousState.copy(count = previousState.count - 1) to CounterSideEffect.LogEvent(&quot;Decremented to ${previousState.count - 1}&quot;) <br>                } else { <br>                    previousState to CounterSideEffect.ShowErrorPopup(&quot;Count cannot be negative&quot;) <br>                } <br>            } <br>            is CounterEvent.Reset -&gt; { <br>                CounterViewState(count = 0) to CounterSideEffect.LogEvent(&quot;Counter reset to 0&quot;) <br>            } <br>            is CounterEvent.Error -&gt; { <br>                previousState.copy() to CounterSideEffect.ShowErrorPopup(event.message) <br>            } <br>        } <br>    } <br>}</pre><h4>5. Implement the ViewModel</h4><p>The ViewModel acts as the bridge between UI and Reducer.</p><pre>class CounterViewModel : ViewModel() { <br>    private val reducer = CounterReducer() <br>    private val _state = MutableStateFlow(CounterViewState()) <br>    val state = _state.asStateFlow() <br>    private val _sideEffect = Channel&lt;CounterSideEffect&gt;(Channel.BUFFERED) <br>    val sideEffect = _sideEffect.receiveAsFlow() <br>    fun sendEvent(event: CounterEvent) { <br>        val (newState, effect) = reducer.reduce(_state.value, event) <br>        _state.value = newState <br>        effect?.let { sendSideEffect(it) } <br>    } <br>    private fun sendSideEffect(effect: CounterSideEffect) { <br>        _sideEffect.trySend(effect).onFailure { <br>            println(&quot;⚠️ Failed to send SideEffect: ${it?.message}&quot;) <br>        } <br>    } <br>    override fun onCleared() { <br>        super.onCleared() <br>        _sideEffect.close() <br>    }}</pre><p>Why should you use MutableStateFlow for State? – It ensures real-time UI updates when the state changes.</p><p>Why should you use Channel for SideEffects? – SideEffects should only be received once, and Channel ensures that.</p><h4>6. Implement the Jetpack Compose UI</h4><p>Finally, we have created a Composable UI that listens to ViewModel state and side effects.</p><pre>@OptIn(ExperimentalMaterial3Api::class) <br>    @Composable <br>    fun CounterScreen() { <br>        val snackBarHostState = remember { SnackbarHostState() } <br>        val state by viewModel.state.collectAsState() <br> <br>        LaunchedEffect(Unit) { <br>            viewModel.sideEffect.collect { effect -&gt; <br>                when (effect) { <br>                    is CounterSideEffect.ShowErrorPopup -&gt; { <br>                        snackBarHostState.showSnackbar(effect.message) <br>                    } <br>                } <br>            } <br>        } <br> <br>        Scaffold( <br>            topBar = { <br>                TopAppBar(title = { Text(&quot;Counter App&quot;) }) <br>            }, <br>            snackbarHost = { SnackbarHost(snackBarHostState) } <br>        ) { padding -&gt; <br>            Box( <br>                Modifier <br>                    .fillMaxSize() <br>                    .padding(padding) <br>            ) { <br>                Column( <br>                    modifier = Modifier.fillMaxSize(), <br>                    horizontalAlignment = Alignment.CenterHorizontally, <br>                    verticalArrangement = Arrangement.Center <br>                ) { <br>                    Text(text = &quot;Count: ${state.count}&quot;, fontSize = 24.sp) <br>                    Spacer(modifier = Modifier.height(16.dp)) <br>                    Row { <br>                        Button(onClick = { viewModel.sendEvent(CounterEvent.Increment) }) { <br>                            Text(&quot;Increment&quot;) <br>                        } <br>                        Spacer(modifier = Modifier.width(16.dp)) <br>                        Button(onClick = { viewModel.sendEvent(CounterEvent.Decrement) },) { <br>                            Text(&quot;Decrement&quot;) <br>                        } <br>                        Spacer(modifier = Modifier.width(16.dp)) <br>                        Button(onClick = { viewModel.sendEvent(CounterEvent.Reset) }) { <br>                            Text(&quot;Reset&quot;) <br>                        } <br>                    } <br>                } <br>            } <br>        } <br>    }</pre><h3>Conclusion</h3><p>Leveraging MVI architecture to build scalable, maintainable, and predictable Android applications is something that we do daily at zen8labs. By embracing unidirectional data flow, we ensure that our apps remain robust and testable while keeping the UI and business logic neatly separated.</p><p>With MVI, you now have a powerful and structured way to handle state in Jetpack Compose. Whether you’re working on a simple counter app or a complex enterprise project, this approach scales effortlessly. However if your next project requires the best in the business to help you, then ask us <a href="https://www.zen8labs.com/#contact">here</a>, together we can create an awesome project together!</p><p><em>Duc Duong — Mobile Engineer</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38a97f3403b4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/how-to-master-mvi-with-reducers-in-android-38a97f3403b4">How to master MVI with Reducers in Android</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to identify locators for elements on a website]]></title>
            <link>https://medium.com/zen8labs/how-to-identify-locators-for-elements-on-a-website-7bfabc3a46fc?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/7bfabc3a46fc</guid>
            <category><![CDATA[elementor]]></category>
            <category><![CDATA[locator]]></category>
            <category><![CDATA[selenium]]></category>
            <category><![CDATA[zen8labs]]></category>
            <category><![CDATA[it-consulting]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Tue, 24 Jun 2025 10:27:12 GMT</pubDate>
            <atom:updated>2025-06-24T10:27:12.371Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*F4EzPhmthetUsQz5.png" /></figure><p>In the previous <a href="https://www.zen8labs.com/insights/quality-assurance/how-to-create-the-environment-for-selenium-tools/">section</a>, we set up the environment along with the necessary components to practice writing automation code. In this lesson, I will take the time to explore a very important part of automated testing — which is how to identify locators for elements on a website.</p><h3>1. So, what are locators?</h3><p>A locator is a piece of code, or an expression used to identify and locate a specific element on a website or application, serving the purpose of automated testing such as interaction, verification, or data extraction from that element.</p><h4>How to identify locators on a website</h4><p>Step 1: On the website, right-click and select Inspect or press the F12 key on the keyboard</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yCv5EQWmCZhc9HQW.png" /></figure><p>Step 2: Click on the icon shown (or use the shortcut Ctrl + Shift + C)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uXPf6681E-87VdAe.png" /></figure><p>Step 3: Move the mouse cursor to the element you want to identify the locator for, then left-click to select it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qqr4b4AtOInJ2jXz.png" /></figure><p>The locator will be highlighted in the Elements tab of the Inspect tool.</p><h3>2. Commonly used locators</h3><h4>2.1 ID</h4><p>Using locators by ID is the simplest and most convenient method. Each element on a website usually has a unique ID. However, not all developers assign IDs to every element because it takes time and is often unnecessary for most elements on the page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/0*QMC1x5VnGvSntFnC.png" /></figure><p>Above is an example of a locator using ID. You can see the element has id=”field-email”. To locate this element, we use the following locator syntax</p><pre>WebElement IdMail = driver.findElement(By.id(&quot; field-email &quot;));</pre><h4>2.2 Name</h4><p>Similar to ID, the Name attribute is also used as a locator. However, Name is not mandatory, so we cannot always rely on it to identify elements.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/0*_CRTO0U1Y6DZHmMn.png" /></figure><p>As seen in the example above, we identify the Name as “email.” We can declare the locator using the following syntax:</p><pre>WebElement NameMail = driver.findElement(By.name(&quot; field-email &quot;));</pre><h4>2.3 Classname</h4><p>Classname is an attribute of an HTML element used to assign one or more CSS classes or for JavaScript to identify and interact with that element. For example:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pJljYKJXuvyFNnB3.png" /></figure><p>As in the example above, with the classname = “o_data_row,” we can use the following syntax to identify the locator by classname:</p><pre>WebElement clsName = driver.findElement(By.className(&quot; o_data_row &quot;));</pre><p>However, this method is rarely used because classnames are often shared by multiple elements, so it does not guarantee uniqueness when used as a locator.</p><h4>2.4 Linktext</h4><p>Link text usually appears in HTML &lt;a&gt; tags as a hyperlink. Identifying link text is quite straightforward. Below is an example of link text and how to declare the corresponding locator:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/0*UFGw4lcn3zmmoVgu.png" /></figure><p>Syntax:</p><pre>WebElement link=driver.findElement(By.linktext(&quot;Trang chủ&quot;)); <br><br>WebElement link=driver.findElement(By.linktext(&quot;Giới thiệu&quot;));</pre><h4>2.5 PartialLinkText</h4><p>Unlike LinkText, which requires an exact match of the entire displayed text, PartialLinkText only needs to match a part of that text.</p><pre>WebElement link=driver.findElement(By.linktext(&quot;Trang&quot;)); <br><br>WebElement link=driver.findElement(By.linktext(&quot;Giới&quot;));</pre><p>With PartialLinkText, when multiple tags contain similar text, the automation tool will by default select the first element it finds.</p><h4>2.6 CSS selector</h4><p>CSS Selector is one of the most popular and effective methods for locating elements in Selenium, favored for its concise syntax, readability, and fast execution speed on most modern browsers. CSS Selector allows flexible identification of elements through ID, class, attributes, order position, and parent-child relationships, making test cases clearer and easier to maintain.</p><p>Additionally, CSS Selectors can be tested directly in the browser using DevTools, saving debugging time. However, CSS Selectors also have some limitations, such as being unable to traverse up to parent elements (no support for accessing parent or ancestor), cannot filter by text content, and cannot handle complex logical conditions like AND, OR, or negation. Therefore, testers need to be aware of these constraints when choosing the most suitable locator method for each case.</p><p>Common types of CSS Selectors include:</p><ul><li>ID</li><li>Class</li><li>Tag</li><li>Tag + Class</li><li>Multiple Classes</li><li>Attribute</li><li>Attribute + Specific Value</li><li>Parent &gt; Child relationship</li><li>Sibling (adjacent elements)</li><li>Position (nth-child, nth-of-type, etc.)</li></ul><p>Below is an example of an HTML snippet:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/759/0*yeSVvUnWOLOKtN1p.png" /></figure><p>We can declare it using the following syntax:</p><pre>// 1. ID Selector <br>     WebElement inputById = driver.findElement(By.cssSelector(&quot;#username&quot;)); <br> <br>// 2. Class Selector <br>     WebElement inputByClass = driver.findElement(By.cssSelector(&quot;.input-password&quot;)); <br> <br>// 3. Tag Selector <br>     WebElement firstInput = driver.findElement(By.cssSelector(&quot;input&quot;)); <br> <br>// 4. Tag + Class <br>      WebElement inputTagClass = driver.findElement(By.cssSelector(&quot;input.input-password&quot;)); <br> <br>// 5. Multiple class <br>      WebElement buttonMultiClass = driver.findElement(By.cssSelector(&quot;.btn.submit-btn&quot;)); <br> <br>// 6. Attribute Selector <br>      WebElement inputByAttr = driver.findElement(By.cssSelector(&quot;input[name=&#39;password&#39;]&quot;)); <br> <br> // 7. Attribute (partial match) <br>      WebElement inputContains = driver.findElement(By.cssSelector(&quot;input[placeholder*=&#39;đăng&#39;]&quot;)); <br> <br> // 8. Selecting the direct child element <br>      WebElement buttonDirectChild = driver.findElement(By.cssSelector(&quot;.login-form &gt; button&quot;)); <br> <br>// 9. Sibling selector  <br>        WebElement secondInput = driver.findElement(By.cssSelector(&quot;input + input&quot;)); <br> <br>// 10. nth-child selector <br>        WebElement nthChildInput = driver.findElement(By.cssSelector(&quot;.login-form input:nth-child(2)&quot;));</pre><h4>2.7 Xpath</h4><p>XPath is considered the most precise and flexible method for locating elements, capable of accurately identifying almost all types of elements. However, XPath expressions tend to be long and difficult to write, especially with complex or absolute XPath.</p><p>In some cases, XPath can also execute slower compared to CSS Selectors.</p><p>Below is an example of XPath:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*x98oBKAhtAuIBEMZ.png" /></figure><p>Syntax:</p><pre>// --- Relative XPath --- <br>// 1. Input Username (by id) <br>       WebElement inputUsernameRel = driver.findElement(By.xpath(&quot;//input[@id=&#39;username&#39;]&quot;)); <br> <br>// 2. Input password <br>        WebElement inputPasswordRel = driver.findElement(By.xpath(&quot;//input[@class=&#39;input-password&#39; and @type=&#39;password&#39;]&quot;)); <br> <br>// 3. Button Login <br>        WebElement btnLoginRel = driver.findElement(By.xpath(&quot;//button[text()=&#39;Đăng nhập&#39;]&quot;)); <br> <br>// 4. Button login (by class has &#39;submit-btn&#39;) <br>        WebElement btnLoginClassRel = driver.findElement(By.xpath(&quot;//button[contains(@class, &#39;submit-btn&#39;)]&quot;)); <br> <br>// 5. Input pass (It is the second child of the div with class &quot;login-form&quot;) <br>        WebElement inputPasswordPosRel = driver.findElement(By.xpath(&quot;//div[@class=&#39;login-form&#39;]/input[2]&quot;)); <br> <br>// --- Absolute XPath --- <br>// Assuming the DOM structure is as follows, the absolute XPath could be: <br>// /html/body/div[@class=&#39;login-form&#39;]/input[1] <br>        WebElement inputUsernameAbs = driver.findElement(By.xpath(&quot;/html/body/div[@class=&#39;login-form&#39;]/input[1]&quot;)); <br> <br>// /html/body/div[@class=&#39;login-form&#39;]/input[2] <br>        WebElement inputPasswordAbs = driver.findElement(By.xpath(&quot;/html/body/div[@class=&#39;login-form&#39;]/input[2]&quot;)); <br> <br>// /html/body/div[@class=&#39;login-form&#39;]/button <br>        WebElement btnLoginAbs = driver.findElement(By.xpath(&quot;/html/body/div[@class=&#39;login-form&#39;]/button&quot;));</pre><h4>How to determine XPath in the browser:</h4><p>Step 1: Open Chrome Developer Tools</p><ul><li>Press F12 or right-click on the page → select Inspect.</li></ul><p>Step 2: Select the element to get the XPath</p><ul><li>In DevTools, click the arrow icon at the top left (Select Element).</li><li>Click on the element on the webpage you want to get the XPath for.</li></ul><p>Step 3: Copy the XPath</p><ul><li>In the Elements panel, the selected element will be highlighted.</li><li>Right-click on that element → choose Copy → Copy XPath. <br>You can copy either the relative XPath or the full XPath (absolute path).</li></ul><p>Step 4: Paste the XPath into your code</p><ul><li>Simply paste the copied XPath into your Selenium script.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sMGcMdFEqcuF5iTH.png" /></figure><h3>Conclusion</h3><p>Above, we have learned about locators and elements in <a href="https://www.selenium.dev/">Selenium</a> — important tools that help accurately locate and interact with web elements. Choosing the right locator contributes to improving the efficiency and stability of automated test scripts. Hopefully, this knowledge will support everyone in developing more professional test scripts. Stay in this space, the <a href="https://www.zen8labs.com/insights/">zen8labs blog</a> has a range of topics for you to learn from, hence you need to be here. Especially when in the next lesson, we will explore how to use the basic functions of WebElement in Selenium.</p><p><em>Viet-Anh Nguyen, Quality Assurnce Engineer</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7bfabc3a46fc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/how-to-identify-locators-for-elements-on-a-website-7bfabc3a46fc">How to identify locators for elements on a website</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What are the top business analysis trends for 2025?]]></title>
            <link>https://medium.com/zen8labs/what-are-the-top-business-analysis-trends-for-2025-48563c9d338d?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/48563c9d338d</guid>
            <category><![CDATA[business-analyst]]></category>
            <category><![CDATA[it-consulting]]></category>
            <category><![CDATA[2025]]></category>
            <category><![CDATA[zen8labs]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Mon, 23 Jun 2025 10:27:33 GMT</pubDate>
            <atom:updated>2025-06-23T10:27:04.025Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Q1xiu6DDMUTAqQeU.png" /></figure><p>In the rapidly landscape of business technology and strategy, the Business Analysts (BA) occupy a crucial role in the organization. In 2025, the scope and capabilities of BA will be redefined by the trends you will see in my blog. I will take a quick step into each area to help you understand the impact that they will have on the role of a Business Analyst.</p><h3>1. Artificial intelligent and automation</h3><p>Generative AI is ready to revolutionize business operations beyond simple automation. It is stepping into strategy sessions, helping create predictive models, automating processes, and even brainstorming new business solutions.</p><p>The pivotal differentiator will be not just implementing AI in general but effectively integrating AI technologies like natural language processing (NLP), computer vision, speech recognition, machine learning (ML), and robotic process automation (RPA) into current business workflows to boost efficiency.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*l4jmLDOp75XSIHBD.png" /></figure><p>In <a href="https://www.zen8labs.com/">zen8labs</a>, we encourage all employees to use AI in their daily work to save time and labor power. Besides, we also invest heavily in AI literacy programs, which ensure members can effectively collaborate with AI tools rather than being placed.</p><p>How a BA can prepare:</p><ul><li>Learn Generative AI tools</li><li>Develop prompt engineering skills</li><li>Audit AI outputs</li></ul><h3>2. Agile and adaptive frameworks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gW21u1XU6UXMKBSC.png" /></figure><p>Implementing Agile practices on a larger scale for big projects and organizations has become crucial. While Scrum continues to lead, hybrid frameworks (Agile + Waterfall) and scaled methods (such as SAFe and LeSS) are expected to grow in popularity.</p><p>How a BA can prepare:</p><ul><li>Practice Agile and some adaptive frameworks</li><li>Collaborate across the team</li><li>Get certificate in Agile</li></ul><h3>3. Sustainability and Environment, Social and Governance (ESG) Initiatives</h3><p>Sustainability is shifting from being a mere corporate social responsibility checkbox. It is now becoming a fundamental part of core business strategy. Sustainability is no longer optional; companies are embedding it into their operational goals.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DpmeDehMAZKLtkk3.png" /></figure><p>How a BA can prepare:</p><ul><li>Help design processes and solutions that align with sustainability goals</li><li>Measure and report on ESG metrics</li><li>Identify cost savings through sustainable practices</li></ul><h3>4. Cybersecurity</h3><p>Cybersecurity is a major concern due to the rise in data breaches, particularly as businesses become more dependent on digital solutions. Organizations will recognize cybersecurity as a strategic business function, rather than merely an IT concern.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wPO0J_CgZtmdO85Q.png" /></figure><p>How a BA prepare:</p><ul><li>Become partners with security teams</li><li>Focus on compliance, especially data privacy</li></ul><h3>5. Working in a remote and hybrid world</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Xx1pzJwmZyGlvqPK.png" /></figure><p>Remote work has become the standard gradually, demanding creative approaches to collaboration and virtual engagement. Hybrid work models are still developing to support work. Besides, Virtual facilitation and collaboration tools will remain essential for gathering requirements and managing projects/products with distributed teams.</p><p>How a BA prepare:</p><ul><li>Learn to use tools like <a href="https://miro.com/?gclsrc=aw.ds&amp;&amp;utm_source=google&amp;utm_medium=cpc&amp;utm_campaign=S%7CGOO%7CBRN%7CWW%7CEN-EN%7CBrand%7CExact&amp;utm_adgroup=&amp;adgroupid=142344724793&amp;utm_custom=18261731950&amp;utm_content=667973353903&amp;utm_term=miro&amp;matchtype=e&amp;device=c&amp;location=1028580&amp;gad_source=1&amp;gad_campaignid=18261731950&amp;gbraid=0AAAAACtKBmnwhJRWa23Sw_VFIEKG9fiAV&amp;gclid=CjwKCAjw87XBBhBIEiwAxP3_A0gUL_RxwDA3TZDcFUZ6pHS0IdhENCCGMmd_AzjIh3CjG0etsxxaXxoCnN4QAvD_BwE">Miro</a>, Microsoft Teams and other virtual methods</li><li>Learn effective ways to engage and communicate with remote stakeholders</li></ul><h3>Conclusion</h3><p>The business analysis trends of 2025 highlight the growing role of business analysts, emphasizing the importance of ongoing learning and adaptability. By acquiring new skills and utilizing advanced tools and methodologies, business analysts can establish themselves as key leaders in driving innovation and supporting their organizations in achieving their goals. I hope that you are now aware of the range that these trends are facing, but if you want to help to continue to grow, then <a href="https://www.zen8labs.com/#contact">contact us</a></p><p><em>Cai Nguyen, Business Analyst</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=48563c9d338d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/what-are-the-top-business-analysis-trends-for-2025-48563c9d338d">What are the top business analysis trends for 2025?</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Making customers happy: How to use Kano Analysis in project management]]></title>
            <link>https://medium.com/zen8labs/making-customers-happy-how-to-use-kano-analysis-in-project-management-556894435da6?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/556894435da6</guid>
            <category><![CDATA[zen8labs]]></category>
            <category><![CDATA[kano]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[it-consulting]]></category>
            <category><![CDATA[gui̇de]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Mon, 23 Jun 2025 10:08:48 GMT</pubDate>
            <atom:updated>2025-06-23T10:08:48.444Z</atom:updated>
            <content:encoded><![CDATA[<p>These days, just finishing a project on time and within budget isn’t enough. To really succeed, you need to make customers happy and keep them coming back. That’s where the Kano Model can help. It’s a useful tool that I and my colleagues at <a href="https://www.zen8labs.com/">zen8labs</a> use to understand what customers want and decide which features are most important to make them satisfied. Think of it as a guide to make sure your project not only does what it needs to do but also makes your users happy.</p><h3>What is Kano Analysis?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_qlka_EaDVcE98as.png" /></figure><p>The Kano Model, created by Professor Noriaki Kano in the 1980s, is a way to sort customer preferences into five different groups:</p><ul><li><strong>Basic needs (Must-have):</strong> These are the things that customers expect as a minimum. If you don’t have them, customers will be very unhappy. But having them doesn’t necessarily make customers super happy — it just stops them from being unhappy. <em>Example: A web application must have a login page.</em></li><li><strong>Performance needs (More is better):</strong> The better you are at meeting these needs, the happier your customers will be. If you don’t meet them, customers will be unhappy. <em>Example: How fast a website loads.</em></li><li><strong>Excitement needs (Pleasant surprises):</strong> These are features that customers don’t expect, but they make them very happy. Customers might not even know they want these features until they see them! These kinds of features can give you an advantage over your competitors. <em>Example: A cool animation in a user interface.</em></li><li><strong>Indifferent needs:</strong> These features don’t really affect whether customers are happy or unhappy. Customers don’t care much if you include them or not. <em>Example: A report format that’s rarely used.</em></li><li><strong>Reverse needs:</strong> Adding these features could actually make some customers unhappy because they don’t find them useful. <em>Example: Too many ways to customize something.</em></li></ul><h3>Why is Kano Analysis important for project managers?</h3><p>Using Kano Analysis can give project managers several benefits:</p><ul><li><strong>Focus on what’s important:</strong> By putting features into different groups based on what customers want, project managers can focus on the most important things. This helps the team spend time on what really matters to customers.</li><li><strong>Happier customers:</strong> Understanding what makes customers happy allows teams to create features that improve the overall experience, which leads to happier and more loyal customers.</li><li><strong>Use resources wisely:</strong> By finding out which features aren’t really needed, teams can use their time and money more effectively and avoid wasting resources on things that don’t matter much.</li><li><strong>Stand out from the crowd:</strong> By focusing on features that excite customers, project managers can help their products be different and attract customers in a crowded market.</li></ul><h3>How to Use Kano Analysis in your projects</h3><p>Here are the basic steps to use Kano Analysis:</p><ol><li><strong>Collect customer feedback:</strong> <a href="https://www.microsoft.com/en-us/research/articles/lots-of-ideas-but-not-sure-how-to-prioritize-the-kano-model-can-help/">Talk to customers</a>, send out surveys, or have group discussions to find out what they value most in your product or service.</li><li><strong>Group customer needs:</strong> Use the Kano model to put the customer needs into the five different groups: Basic, Performance, Excitement, Indifferent, and Reverse.</li><li><strong>Decide what to work on:</strong> Based on the groups, decide which features to develop or improve. Start with the <strong>Must-have</strong> and <strong>More is better needs</strong>, then think about the <strong>Excitement</strong> features.</li><li><strong>Test and improve:</strong> As you create features, keep getting feedback from customers to make sure you’re meeting their expectations and changing things as needed.</li><li><strong>Review regularly:</strong> Keep checking your Kano Analysis to keep up with changes in customer preferences and market trends, so your project stays focused on making customers happy.</li></ol><h3>Conclusion</h3><p>In today’s world, where customer experience is very important, using Kano Analysis can help our project be successful and make customers happy in the long run. By focussing on the needs of the customer within the 5 needs model, you’ll be able to achieve great success. However, remember to take the time to get feedback from the customer to know that their needs are being met. At <a href="https://www.zen8labs.com/#contact">zen8labs</a>, we use it as a part of our project management, in order to focus on the customer and go above and beyond their expectations. This allows us to create something awesome for our customers!</p><p><em>Phuong Nguyen, Quality Assurance Engineer</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=556894435da6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/making-customers-happy-how-to-use-kano-analysis-in-project-management-556894435da6">Making customers happy: How to use Kano Analysis in project management</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to improve your performance in Flutter: Tips and best practices]]></title>
            <link>https://medium.com/zen8labs/how-to-improve-your-performance-in-flutter-tips-and-best-practices-cd722f94cec0?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/cd722f94cec0</guid>
            <category><![CDATA[mobile-development]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[it-consulting]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[zen8labs]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Fri, 20 Jun 2025 02:16:38 GMT</pubDate>
            <atom:updated>2025-06-20T02:16:38.055Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SiR7y3I-BiWEZ2ZI.png" /></figure><p>Flutter has transformed the landscape of cross-platform app development, enabling developers to craft beautiful, fast, and responsive applications for mobile, web, and desktop from a single codebase. However, to ensure a seamless user experience, performance optimization is paramount. In my blog, I will expand on my previous <a href="https://www.zen8labs.com/insights/programming/how-to-make-flutter-keys-and-use-cases/">blog</a> and provide you with some steps that can turn these into actionable strategies and best practices to enhance performance in Flutter applications, covering key areas like rendering, state management, and more.</p><h3>1. Rendering performance</h3><p>Flutter’s rendering engine is renowned for delivering smooth animations and transitions. However, unoptimized rendering can lead to janky frames and a subpar user experience. One powerful tool to improve rendering performance is the <a href="https://api.flutter.dev/flutter/widgets/RepaintBoundary-class.html">Repaint Boundary</a> widget.</p><h4>How it works</h4><p>The RepaintBoundary widget isolates parts of the widget tree, limiting the scope of repaints. When a change occurs, only the widgets within the boundary are repainted, sparing static elements from unnecessary redraws.</p><h4>Example</h4><pre>RepaintBoundary( <br>  child: Container( <br>    decoration: BoxDecoration( <br>      image: DecorationImage( <br>        image: AssetImage(&#39;assets/background.jpg&#39;), <br>        fit: BoxFit.cover, <br>      ), <br>    ), <br>  ), <br>)</pre><p>In this case, a static background image wrapped in RepaintBoundary won’t repaint when dynamic content above it changes, boosting performance.</p><h3>2. Efficient widget construction</h3><p>Widgets are the foundation of Flutter’s UI, and optimizing their construction can yield significant performance gains. Enter <strong>const constructors</strong>.</p><h4>Why it matters</h4><p>Widgets created with const are instantiated at compile-time rather than runtime, reducing overhead during app execution. This is ideal for static widgets like icons, text, or layout elements that don’t change.</p><h4>Implementation</h4><pre>const Text( <br>  &#39;Welcome to Flutter!&#39;, <br>  style: TextStyle(fontSize: 20), <br>)</pre><p>By using const, Flutter avoids rebuilding this widget unnecessarily, saving resources.</p><h3>3. State management</h3><p>As apps grow in complexity, managing state efficiently becomes critical to avoid performance pitfalls like excessive rebuilds. Solutions such as the Provider package can streamline state management.</p><h4>Benefits</h4><p>The <strong>Provider</strong> allows you to manage a higher state in the widget tree and selectively rebuild only the widgets that depend on that state, minimizing redundant updates.</p><h4>Example</h4><pre>class CounterModel with ChangeNotifier { <br>  int _count = 0; <br>  int get count =&gt; _count; <br>  void increment() { <br>    _count++; <br>    notifyListeners(); <br>  } <br>} <br> <br>Consumer&lt;CounterModel&gt;( <br>  builder: (context, counter, child) =&gt; Text(&#39;Count: ${counter.count}&#39;), <br>)</pre><p>Here, only the Text widget rebuilds when the counter changes, not the entire tree.</p><h3>4. Avoiding unnecessary rebuilds</h3><p>The build method in Flutter widgets runs whenever a widget updates. Frequent or heavy rebuilds can degrade performance. Techniques like memoization and caching can help.</p><h4>How to optimize</h4><p>Memoization caches the results of expensive computations, reusing them when inputs remain unchanged. You can implement this manually or use packages like memoize.</p><h4>Example</h4><pre>int expensiveCalculation(int input) { <br>  // Simulate heavy work <br>  return input * 2; <br>} <br> <br>final memoizedCalc = memoize(expensiveCalculation); <br> <br>Widget build(BuildContext context) { <br>  return Text(&#39;Result: ${memoizedCalc(5)}&#39;); <br>}</pre><p>This ensures the calculation isn’t repeated unless the input changes.</p><h3>5. Optimizing lists and grids</h3><p>Large lists or grids can strain performance if all items are built at once. Flutter’s ListView.builder and GridView.builder offer a solution.</p><h4>Why they are better?</h4><p>These widgets use lazy loading, constructing only the items currently visible on the screen, which reduces memory usage and enhances scrolling performance.</p><h4>Example</h4><pre>ListView.builder( <br>  itemCount: 1000, <br>  itemBuilder: (context, index) =&gt; ListTile( <br>    title: Text(&#39;Item $index&#39;), <br>  ), <br>)</pre><p>Only the visible items are rendered, making it ideal for long lists.</p><h3>6. Image optimization</h3><p>Images can slow down your app if not handled properly. Optimizing image loading and display is key to maintaining performance.</p><h4>Tips</h4><ul><li>Use the <strong>cached_network_image</strong> package to cache images fetched from the web, reducing load times.</li><li>Resize images to match their display size using the width and height properties.</li></ul><h4>Example</h4><pre>CachedNetworkImage( <br>  imageUrl: &#39;https://example.com/image.jpg&#39;, <br>  width: 100, <br>  height: 100, <br>  placeholder: (context, url) =&gt; CircularProgressIndicator(), <br>)</pre><p>This caches the image and scales it appropriately, saving memory and time.</p><h3>7. Improving app startup time</h3><p>A slow startup can frustrate users. Techniques like code splitting, lazy loading, and the compute function can speed things up.</p><h4>Implementation</h4><p>The compute function offloads heavy tasks to a separate isolate, keeping the main thread responsive.</p><h4>Example</h4><pre>Future&lt;int&gt; heavyTask(List&lt;int&gt; data) async { <br>  return data.reduce((a, b) =&gt; a + b); <br>} <br> <br>void loadData() async { <br>  final result = await compute(heavyTask, [1, 2, 3, 4, 5]); <br>  print(&#39;Result: $result&#39;); <br>}</pre><p>This keeps the UI smooth during startup.</p><h3>8. Efficient Animations</h3><p>Animations enhance UX but can tax performance if overdone. Use AnimationController and Tween for efficiency.</p><h4>Example</h4><pre>class MyWidget extends StatefulWidget { <br>  @override <br>  _MyWidgetState createState() =&gt; _MyWidgetState(); <br>} <br> <br>class _MyWidgetState extends State&lt;MyWidget&gt; with SingleTickerProviderStateMixin { <br>  late AnimationController _controller; <br>  late Animation&lt;double&gt; _animation; <br> <br>  @override <br>  void initState() { <br>    super.initState(); <br>    _controller = AnimationController( <br>      duration: Duration(seconds: 1), <br>      vsync: this, <br>    ); <br>    _animation = Tween&lt;double&gt;(begin: 0, end: 1).animate(_controller); <br>    _controller.forward(); <br>  } <br> <br>  @override <br>  Widget build(BuildContext context) { <br>    return FadeTransition( <br>      opacity: _animation, <br>      child: Text(&#39;Hello!&#39;), <br>    ); <br>  } <br>}</pre><p>This creates a smooth fade-in effect without performance overhead.</p><h3>9. Best Practices and Tips</h3><p>Here are a few additional tips to ensure your Flutter app runs at peak performance:</p><ul><li><strong>Minimize Overdraw:</strong> Reduce the number of layers in your widget tree. Use tools like the performance overlay to monitor overdraw.</li><li><strong>Reduce Build Complexity:</strong> Split large widgets into smaller ones to limit the scope of rebuilds.</li><li><strong>Test on Real Devices:</strong> Emulators might not accurately represent performance on actual devices. Regularly test on low-end hardware to ensure smooth performance across the board.</li><li><strong>Keep Dependencies Updated:</strong> Flutter and its plugins are frequently updated with performance improvements. Keeping your dependencies current can yield automatic benefits.</li></ul><h3>10. Testing and Profiling</h3><p>Identifying bottlenecks requires testing and profiling. Flutter’s DevTools suite is perfect for this.</p><h4>How to Use</h4><ul><li>Open DevTools via flutter run –profile.</li><li>Use the “Performance” tab to analyze frame times and spot jank.</li><li>Check the “Memory” tab for leaks or excessive allocations.</li></ul><p>Regular profiling ensures your optimizations are effective.</p><h3>Conclusion</h3><p>Optimizing performance in Flutter involves a holistic approach — tackling rendering, widget efficiency, state management, and beyond, taking the time to make sure you deal with the frequent updates can help to improve performance enhancements and fixes. However by applying these tips that I have given you such as using RepaintBoundary, leveraging const constructors, managing state wisely, and profiling with DevTools — you can build apps that are fast, fluid, and user-friendly. Start implementing these best practices today and watch your Flutter apps shine. I know Flutter is an interesting platform, but there are many others you can learn about from my colleagues where we share <a href="https://www.zen8labs.com/insights/">insights</a> on all things IT, to allow everyone to create something awesome!</p><p><em>Thanh Nguygen, Mobile Engineer</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd722f94cec0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/how-to-improve-your-performance-in-flutter-tips-and-best-practices-cd722f94cec0">How to improve your performance in Flutter: Tips and best practices</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Leveraging AI to enhance customer engagement in ESG training]]></title>
            <link>https://medium.com/zen8labs/leveraging-ai-to-enhance-customer-engagement-in-esg-training-3965be28e041?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/3965be28e041</guid>
            <category><![CDATA[zen8labs]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[esg]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[it-consulting]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Thu, 19 Jun 2025 02:39:48 GMT</pubDate>
            <atom:updated>2025-06-19T02:39:48.712Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*M5PZnR_pPznWZ8Qr.png" /></figure><p>In the rapidly evolving corporate world, organizations are increasingly recognizing the importance of Environmental, Social, and Governance (ESG) principles. As a result, ESG training programs are becoming a critical part of employee education, especially in enterprises. zen8labs partnered with an innovative e-learning platform provider that specializes in delivering ESG training to large enterprises. The client wanted to enhance user engagement and ensure that employees not only completed the training but also internalized ESG principles and applied them in their work environments. By leveraging AI technologies, zen8labs helped this client transform their platform to boost learner engagement and knowledge retention.</p><h3>The challenges</h3><p>The client’s e-learning platform was well-established in delivering comprehensive ESG training. However, they faced a few challenges that hindered user engagement:</p><ol><li><strong>Low completion rates</strong>: Despite offering in-depth content, many employees did not complete their ESG training modules, reducing the overall effectiveness of the program.</li><li><strong>Lack of personalized learning experiences</strong>: The platform followed a one-size-fits-all approach, and learners were not receiving content tailored to their specific roles or levels of ESG understanding.</li><li><strong>Limited feedback loop</strong>: The platform lacked real-time feedback mechanisms that could help employees track their progress and improve retention of key ESG concepts.</li><li><strong>Engagement fatigue</strong>: Repetitive content and a lack of interactive elements made users lose interest, leading to disengagement.</li></ol><p>To address these challenges, the client turned to <a href="https://www.zen8labs.com/">zen8labs</a> to integrate AI-driven solutions that would personalize the learning experience and significantly enhance user engagement.</p><h3>The Solution: AI-enhanced learning and engagement</h3><p>zen8labs implemented several AI technologies to address the client’s challenges, with the goal of increasing engagement, improving learning outcomes, and ensuring more employees successfully completed their ESG training.</p><p><strong>AI-driven personalization:</strong> Using machine learning algorithms, zen8labs developed a recommendation engine that personalized the learning path for each employee based on their previous performance, role, and learning preferences. By analyzing user data, the AI system identified which ESG topics were more relevant to each individual and tailored the content accordingly. For instance, managers received more strategic insights into governance, while employees in sustainability roles received specialized training on environmental practices.</p><p>This tailored approach ensured that each learner was engaged with content that was directly relevant to their daily tasks, increasing motivation and improving knowledge retention.</p><p><strong>Chatbots for interactive learning and instant feedback</strong>: To increase interactivity, zen8labs integrated AI-powered chatbots into the e-learning platform. These chatbots served as virtual teaching assistants, answering learners’ questions in real time and offering additional explanations on ESG concepts. This feature helped create a more engaging learning environment, allowing employees to get instant clarifications without leaving the platform.</p><p>Additionally, the chatbots provided real-time feedback based on user performance, offering suggestions for improvement and tracking progress over time. This timely feedback loop allowed users to reflect on their learning journey and stay motivated to complete their courses.</p><p><strong>Gamification with AI</strong>: zen8labs incorporated gamification elements powered by AI to make the ESG training more engaging. The AI-driven system created personalized challenges, quizzes, and competitions for employees, allowing them to test their knowledge in an interactive and enjoyable way. Employees earned points, badges, and certificates as they completed modules and quizzes, which were then shared on internal social platforms to encourage friendly competition among teams. AI was used to dynamically adjust the difficulty level of the quizzes based on the employee’s progress, ensuring that they were constantly challenged without feeling overwhelmed.</p><p><strong>Predictive analytics to drive completion</strong>: Using predictive analytics, zen8labs developed <a href="https://www.ibm.com/think/topics/ai-model">AI models</a> that could anticipate when a user was likely to drop off during the training course. The system then triggered automated interventions such as reminder notifications, personalized encouragement messages, or tips to re-engage learners. By analyzing past behavior patterns, the AI could proactively target users who were at risk of disengagement, helping to improve overall course completion rates.</p><p><strong>Data-Driven insights for continuous improvement</strong>: zen8labs also implemented an AI-powered analytics dashboard for administrators and managers. This dashboard provided detailed insights into learner engagement, progress, and completion rates. It also highlighted specific ESG topics where employees struggled, allowing the client to adjust the content or delivery methods as needed. AI-driven data analysis helped the client identify areas for improvement in their training program, making it more effective over time.</p><h3>Results</h3><p>The implementation of AI in the client’s e-learning platform led to significant improvements in user engagement and training outcomes:</p><ol><li><strong>Increased engagement</strong>: Learners spent more time on the platform, with 40% higher interaction rates due to the personalized learning paths and gamified elements.</li><li><strong>Improved completion rates</strong>: The completion rate for ESG training courses increased by 35%, driven by AI-powered reminders, personalized content, and interactive features.</li><li><strong>Higher knowledge retention</strong>: Post-training assessments showed a 50% improvement in knowledge retention, as employees could apply learned concepts through real-time interactions and tailored feedback.</li><li><strong>Better employee satisfaction</strong>: Employee feedback surveys revealed a 60% increase in satisfaction with the ESG training, with many citing the interactive, personalized experience as the main factor.</li><li><strong>Data-driven improvements</strong>: The real-time analytics dashboard helped the client continuously refine and adapt the training material based on AI-powered insights, ensuring the content remained relevant and engaging.</li></ol><h3>Lessons learned</h3><ol><li><strong>AI enables personalization at scale</strong>: The ability to offer personalized learning experiences at scale can dramatically improve engagement and completion rates. The success of this approach highlights the importance of leveraging AI to understand individual learner needs and adapt content accordingly.</li><li><strong>Gamification drives motivation</strong>: Gamification elements like challenges, badges, and leaderboards significantly enhance user engagement. AI can personalize these elements based on learner performance, making the learning process more enjoyable and rewarding.</li><li><strong>Real-Time feedback fuels engagement</strong>: Providing learners with instant feedback is critical to keeping them motivated and focused. AI-driven chatbots and performance analytics offer valuable, timely insights that encourage learners to stay on track.</li><li><strong>Predictive analytics improves retention</strong>: Proactively identifying and intervening with learners at risk of disengagement ensures that they stay committed to the training process. Predictive AI models help spot these opportunities early on.</li></ol><h3>The future of AI in E-learning</h3><p>The success of this case study opens doors for further innovation in AI-powered e-learning. In the future, AI could drive even more personalized learning experiences, incorporating augmented reality (AR) or virtual reality (VR) to create immersive ESG training environments. As AI continues to evolve, the potential for smarter, more adaptive learning platforms is limitless, now is the time to unlock your potential, reach out to zen8labs, now is your chance to create something awesome!</p><p><em>Tom Nguyen, CEO at zen8labs</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3965be28e041" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/leveraging-ai-to-enhance-customer-engagement-in-esg-training-3965be28e041">Leveraging AI to enhance customer engagement in ESG training</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Uncovering the hidden potential of $attrs & $listeners in Vue.js]]></title>
            <link>https://medium.com/zen8labs/uncovering-the-hidden-potential-of-attrs-listeners-in-vue-js-6e1ac05923df?source=rss----5a9c5b7a91ad---4</link>
            <guid isPermaLink="false">https://medium.com/p/6e1ac05923df</guid>
            <category><![CDATA[zen8labs]]></category>
            <category><![CDATA[listener]]></category>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[it-consulting]]></category>
            <category><![CDATA[attr]]></category>
            <dc:creator><![CDATA[zen8labs]]></dc:creator>
            <pubDate>Tue, 17 Jun 2025 02:40:19 GMT</pubDate>
            <atom:updated>2025-06-17T02:40:19.578Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RgoiQO87muwN5cLl.png" /></figure><p>Vue.js developers frequently rely on props and event emissions to facilitate communication between components. However, two lesser-known properties $attrs and $listeners offer powerful alternatives that can streamline component composition and improve maintainability. In my blog I am going to help you to understand these properties and how they can help developers reduce unnecessary prop drilling and enhance component flexibility.</p><h3>What are $attrs and $listeners?</h3><ul><li><strong>$attrs</strong>: Contains attributes passed to a component that are not explicitly defined as props.</li><li><strong>$listeners</strong>: Holds event listeners passed from a parent component.</li></ul><p>These properties are particularly useful in wrapper components and <a href="https://dev.to/tefoh/hoc-in-vue-3-higher-order-components-2boe">higher-order components</a> (HOCs), where dynamically forwarding attributes and events are beneficial. They allow for a cleaner component structure, reducing redundancy and increasing modularity.</p><h3>Why should you use $attrs and $listeners?</h3><h4>1. Reducing prop drilling</h4><p>Instead of manually passing props through multiple layers of components, $attrs can automatically propagate them to child components, minimizing the amount of explicit prop forwarding required.</p><h4>2. Enhancing reusability</h4><p>Using $listeners, you can create components that dynamically handle events without explicitly defining every event listener, making them more flexible and easier to reuse across projects.</p><h4>3. Improving maintainability</h4><p>By leveraging $attrs and $listeners, your codebase remains cleaner, with fewer tightly coupled components, leading to easier debugging and scaling.</p><h3>Practical example: A Smarter input component</h3><p>Let’s create a &lt;BaseInput&gt; component that wraps a native &lt;input&gt; element:</p><pre>&lt;template&gt; <br>  &lt;input v-bind=&quot;$attrs&quot; v-on=&quot;$listeners&quot; /&gt; <br>&lt;/template&gt; <br> <br>&lt;script&gt; <br>export default { <br>  inheritAttrs: false, // Prevents attributes from binding to the root element <br>}; <br>&lt;/script&gt;</pre><h4>Breakdown of the implementation</h4><ul><li>v-bind=&quot;$attrs&quot; ensures all extra attributes (e.g., placeholder, type, disabled) are forwarded to the &lt;input&gt;.</li><li>v-on=&quot;$listeners&quot; allows event listeners (e.g., @focus, @input) to be passed automatically.</li><li>inheritAttrs: false prevents attributes from being automatically applied to the root &lt;template&gt; tag, giving developers full control over where attributes are bound.</li></ul><h3>Usage example</h3><pre>&lt;BaseInput placeholder=&quot;Enter text&quot; @input=&quot;handleInput&quot; /&gt;</pre><p>This enables a dynamic, reusable input component that seamlessly forwards attributes and event listeners.</p><h3>Real-World Use Case: Dynamic Wrapper Component</h3><p>Imagine you need a generic wrapper for multiple HTML elements. Instead of explicitly defining attributes and events, you can leverage $attrs and $listeners for a more dynamic approach.</p><pre>&lt;template&gt; <br>  &lt;component :is=&quot;tag&quot; v-bind=&quot;$attrs&quot; v-on=&quot;$listeners&quot; class=&quot;common-style&quot; /&gt; <br>&lt;/template&gt;</pre><pre>&lt;script&gt; <br>export default { <br>  props: { <br>    tag: { <br>      type: String, <br>      default: &#39;div&#39;, <br>    }, <br>  }, <br>}; <br>&lt;/script&gt;</pre><h4>Usage Example</h4><pre>&lt;Wrapper tag=&quot;button&quot; @click=&quot;handleClick&quot;&gt;Click Me&lt;/Wrapper&gt;</pre><p>By doing this, the component becomes extremely versatile, automatically inheriting attributes and events from the parent.</p><h3>Advanced Use Case: Composing Reusable UI Libraries</h3><p>When building design systems or UI libraries, $attrs and $listeners can enable seamless integration with different components without tightly coupling logic.</p><p>For example, consider a custom button component:</p><pre>&lt;template&gt; <br>  &lt;button class=&quot;btn&quot; v-bind=&quot;$attrs&quot; v-on=&quot;$listeners&quot;&gt; <br>    &lt;slot&gt;&lt;/slot&gt; <br>  &lt;/button&gt; <br>&lt;/template&gt; <br> <br>&lt;script&gt; <br>&lt;/script&gt;</pre><p>By utilizing $attrs and $listeners, this button component can accept any attributes (disabled, aria-*, etc.) and events (@click, @mouseover, etc.) without explicitly defining them, making it highly reusable and flexible.</p><h3>Best Practices for Using $attrs and $listeners</h3><ul><li><strong>Use </strong>inheritAttrs<strong>: false</strong> when applying $attrs to non-root elements to prevent unintended attribute bindings.</li><li><strong>Always consider event delegation</strong> when using $listeners, ensuring events are properly handled and not lost in deeply nested structures.</li><li><strong>Combine </strong>$attrs<strong> with computed properties</strong> to apply transformations before forwarding attributes.</li><li><strong>Document component behavior clearly</strong> so that team members understand how attributes and events are being handled.</li><li><strong>Test component functionality thoroughly</strong> to ensure that events and attributes are being forwarded correctly in different scenarios.</li></ul><h3>Common Mistakes to Avoid</h3><ol><li><strong>Forgetting to set inheritAttrs: false:</strong> This may cause unexpected attributes to bind to the wrong element.</li><li><strong>Overusing $listeners:</strong> While powerful, avoid excessive reliance on $listeners when direct event binding is more appropriate.</li><li><strong>Not handling event bubbling properly:</strong> Ensure that event listeners are correctly delegated to avoid unexpected behavior.</li><li><strong>Ignoring attribute filtering:</strong> Sometimes, $attrs might contain unwanted attributes; filtering them using computed properties is a good practice.</li></ol><h3>Conclusion</h3><p>Vue.js provides $attrs and $listeners as powerful tools to streamline component composition. By leveraging these properties, developers can:</p><ul><li>Avoid unnecessary prop drilling</li><li>Enhance component flexibility</li><li>Improve code maintainability</li><li>Facilitate seamless UI component development</li><li>Build highly dynamic and reusable Vue.js components</li></ul><p>If you haven’t used $attrs and $listeners before, start integrating them into your Vue.js projects today! If you wish to continue to push the boundaries on your coding approach, then reach out to us at <a href="https://www.zen8labs.com/#contact">zen8labs</a> – speak to us and together, we can create something awesome!</p><p><em>Tuan Nguyen, Software Enginee</em>r</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e1ac05923df" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zen8labs/uncovering-the-hidden-potential-of-attrs-listeners-in-vue-js-6e1ac05923df">Uncovering the hidden potential of $attrs &amp; $listeners in Vue.js</a> was originally published in <a href="https://medium.com/zen8labs">zen8labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>