<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Gayan Sandamal on Medium]]></title>
        <description><![CDATA[Stories by Gayan Sandamal on Medium]]></description>
        <link>https://medium.com/@gayansandamal?source=rss-a0534a2ebbda------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*kpaf6b5Jps8gbO_8pAzrIw@2x.jpeg</url>
            <title>Stories by Gayan Sandamal on Medium</title>
            <link>https://medium.com/@gayansandamal?source=rss-a0534a2ebbda------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 16:38:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gayansandamal/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How to Foster Growth, Not Blame: Embracing Clean Code Practices in Development]]></title>
            <link>https://medium.com/@gayansandamal/how-to-foster-growth-not-blame-embracing-clean-code-practices-in-development-e9334c1aa5f8?source=rss-a0534a2ebbda------2</link>
            <guid isPermaLink="false">https://medium.com/p/e9334c1aa5f8</guid>
            <category><![CDATA[code-practices]]></category>
            <category><![CDATA[growth-mindset]]></category>
            <category><![CDATA[embracing-yourself]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[clean-code-practices]]></category>
            <dc:creator><![CDATA[Gayan Sandamal]]></dc:creator>
            <pubDate>Tue, 26 Nov 2024 08:50:03 GMT</pubDate>
            <atom:updated>2024-11-26T08:50:03.235Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1YW9McHB8a5Y4qXau4YwlQ.png" /><figcaption>Generated using Dall-E 3</figcaption></figure><p>In the software development world, I’ve witnessed a disturbing trend: both juniors and even experienced developers being blamed when they write messy, unreadable code. This reaction often stems from frustration over the time and effort needed to fix or improve the code. However, this response does nothing but create a negative environment, where developers are afraid to ask questions or make mistakes.</p><p>Rather than pointing fingers, we need to focus on mentorship and growth. To help our peers and juniors understand the importance of clean, maintainable code and providing the support they need to improve.</p><p>In this article, I’ll explore why blame has no place in development and how we, as developers, can encourage a culture of learning and collaboration to create cleaner, more efficient codebases. Let’s dive into how we can approach code quality with empathy, positivity and a focus on growth.</p><h3>The Problem with Blame</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*9TLV6x7DFkJMgDJg" /><figcaption>Generated using Dall-E 3</figcaption></figure><p>Blaming a developer, whether junior or senior, for messy code creates an environment of fear and negativity. It’s easy to fall into the trap of pointing out mistakes and calling out “bad” code. However, what’s often overlooked is that messy code is usually the result of time constraints, inexperience or simply a lack of knowledge about best practices. Not a lack of effort or dedication.</p><p>Instead of reacting with frustration or blame, we should treat these situations as opportunities for mentoring. By focusing on guidance and education, we can help everyone improve their coding practices and ultimately produce better software.</p><h3>Shift Focus From Blame to Guidance</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*we8HJEQtXZOYGI_g" /><figcaption>Generated using Dall-E 3</figcaption></figure><p>Rather than blaming, approach the situation as an opportunity to guide and mentor. Instead of simply pointing out mistakes, offer constructive feedback. Help your peers and juniors understand why clean, maintainable code is important and provide actionable advice on how to improve.</p><p>For example, if you see repeated code, suggest how modularization could improve efficiency. If a function is overly complex, offer ways to refactor it for clarity. Teach, don’t criticize.</p><h3>Highlight the Long-Term Benefits of Clean Code</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*Qx9rii8cKSczFUs9" /><figcaption>Generated using Dall-E 3</figcaption></figure><p>Explain why clean code matters, not just for today but for the long-term health of the project. Code that is readable, modular, and well-structured is easier to maintain, debug, and extend as the project grows. This is especially important in large teams or when the project needs to scale.</p><p>Help them see how adopting good coding practices, like <a href="https://medium.com/@gayansandamal/understanding-the-difference-between-dry-and-wet-code-practices-why-dry-is-the-better-approach-ae4e591c0f06">DRY (Don’t Repeat Yourself)</a>, will save time and reduce the risk of introducing bugs later.</p><h3>Encourage Refactoring and Iterative Improvement</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*UIlgmV3H1-iaYs26" /><figcaption>Generated using Dall-E 3</figcaption></figure><p>Remind everyone that clean code is an ongoing process, not something that happens overnight. Encourage regular refactoring as part of the development cycle. Refactoring helps developers improve the design of the code without changing its functionality. Which is an essential habit for growing and evolving codebases.</p><p>Make it clear that it’s okay to iterate and improve over time. Encourage developers to review their code, learn from past mistakes and aim to do better with each commit.</p><h3>Lead by Example</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*rRJBS5nwgYPxlUcl" /><figcaption>Generated using Dall-E 3</figcaption></figure><p>One of the most effective ways to teach clean coding practices is by leading through example. When you write clean, organized and maintainable code, it sets a standard for others to follow. Share your strategies for keeping code modular, well-commented and well-structured.</p><p>When others see the benefits of clean code in action, they’re more likely to adopt those practices themselves.</p><h3>Foster a Culture of Continuous Learning</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*tXVEXku-gdGKWLvg" /><figcaption>Generated using Dall-E 3</figcaption></figure><p>A culture of continuous improvement benefits everyone. Encourage learning through regular code reviews, pair programming and knowledge-sharing sessions. The more developers see each other as collaborators rather than critics, the more open they’ll be to feedback and the faster they’ll learn.</p><p>Introduce tools, like linters or create coding standards to help enforce best practices. This can serve as a safety net for juniors and provide guidance for everyone on the team.</p><h3>Conclusion: Growth Over Blame</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*cMRFJVGQzYT6Sl3i" /><figcaption>Generated using Dall-E 3</figcaption></figure><p>We’ve all been there. Writing messy code in the past or running into roadblocks while learning. Instead of reacting with blame, let’s focus on fostering growth, offering guidance and creating an environment where we all learn from each other.</p><p>In the end, we’re all working toward the same goal: building quality software that is maintainable, scalable and bug-free. By emphasizing mentorship and clean coding practices, we can help our peers, juniors or even seniors to improve and create software that we’re proud of.</p><p><strong>Let’s build a culture of support, not blame.</strong></p><p>I’d love to hear your thoughts! Fellow developers and mentors, how do you handle messy code and foster a culture of growth in your teams? Let’s share ideas and learn from each other! 😊👩💻👨💻</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9334c1aa5f8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding the Difference Between DRY and WET Code Practices: Why DRY is the Better Approach]]></title>
            <link>https://medium.com/@gayansandamal/understanding-the-difference-between-dry-and-wet-code-practices-why-dry-is-the-better-approach-ae4e591c0f06?source=rss-a0534a2ebbda------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae4e591c0f06</guid>
            <dc:creator><![CDATA[Gayan Sandamal]]></dc:creator>
            <pubDate>Thu, 21 Nov 2024 18:07:38 GMT</pubDate>
            <atom:updated>2024-11-21T18:07:38.366Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ewn2b1nYTOCq5nUDPFMVg.png" /><figcaption>Generated using <a href="https://openai.com/index/dall-e-3/">https://openai.com/index/dall-e-3/</a></figcaption></figure><p>In the world of software development, code quality is paramount. Writing clean, maintainable, and efficient code is essential for ensuring that a project can grow and evolve without becoming tangled in unnecessary complexity. One fundamental principle that developers rely on is the idea of <strong>reusability</strong>. Two well-known practices, <strong>DRY (Don’t Repeat Yourself)</strong> and <strong>WET (Write Everything Twice)</strong>, stand as opposing approaches to this principle. In this article, we’ll explore these concepts, their differences, and the significant benefits of adhering to the DRY principle.</p><h3>What is DRY Code? 🌵</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sFh4L3wykXv4vDmqZk03Rw.png" /><figcaption>Generated using <a href="https://openai.com/index/dall-e-3/">https://openai.com/index/dall-e-3/</a></figcaption></figure><p>The DRY principle, which stands for <strong>Don’t Repeat Yourself</strong>, emphasizes the importance of eliminating repetition in code. In a DRY codebase, every piece of knowledge or logic should exist in a single place. If a particular functionality is needed in more than one location, the code is modularized and reused rather than being duplicated.</p><h4>Key Characteristics of DRY Code:</h4><ol><li><strong>Modularity:</strong> Code is split into smaller, reusable functions, classes or modules.</li><li><strong>Single Source of Truth:</strong> There is only one place where a certain piece of logic or data is defined. This ensures that changes are easy to implement and propagate.</li><li><strong>Refactorability:</strong> Code is written in such a way that new features or modifications can be made without creating redundancy or breaking existing functionality.</li></ol><h3>What is WET Code? 🌊</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yka8Ab2M7GVlJDB-5Vdtwg.png" /><figcaption>Generated using <a href="https://openai.com/index/dall-e-3/">https://openai.com/index/dall-e-3/</a></figcaption></figure><p>In contrast to DRY, <strong>WET</strong> code stands for <strong>Write Everything Twice</strong>, although some people jokingly refer to it as <strong>We Enjoy Typing</strong> or <strong>Waste Everyone’s Time</strong>. WET is characterized by <strong>duplicated code</strong>, where similar logic is repeated across multiple parts of the codebase. While this might seem quicker or easier in the short term, it can create long-term issues that make the code harder to maintain and extend.</p><h4>Key Characteristics of WET Code:</h4><ol><li><strong>Duplication:</strong> The same code or logic is written multiple times in different places.</li><li><strong>Increased Risk of Errors:</strong> Making a change in one place might require you to make the same change in several other places, increasing the risk of bugs if any update is forgotten.</li><li><strong>Difficulty in Maintenance:</strong> Code becomes harder to understand, debug, and extend due to the repetition. Every modification potentially introduces inconsistency across the codebase.</li></ol><h3>The Differences Between DRY and WET 🧐</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MdLPmlb5K4z0uV4D2zckQg.png" /><figcaption>Generated using <a href="https://openai.com/index/dall-e-3/">https://openai.com/index/dall-e-3/</a></figcaption></figure><p>The distinction between DRY and WET comes down to how they handle <strong>repetition</strong>:</p><ul><li><strong>DRY Code:</strong> Focuses on eliminating duplication by abstracting out common functionality into functions, classes or modules. DRY code is easier to maintain and scale because there’s only one place to update when changes are needed.</li><li><strong>WET Code:</strong> Embraces duplication, where developers might copy and paste blocks of code. This approach can lead to code rot over time, as changes need to be applied in multiple places, increasing the risk of inconsistencies or bugs.</li></ul><p>Here’s a quick example to illustrate the difference:<br>WET Code Example:</p><pre>const calculateTotalPrice = (itemPrice, taxRate) =&gt; {<br>  let total = itemPrice + (itemPrice * taxRate);<br>  return total;<br>}<br><br>const calculateTotalPriceWithDiscount = (itemPrice, taxRate, discount) =&gt; {<br>  let total = (itemPrice - discount) + ((itemPrice - discount) * taxRate);<br>  return total;<br>}</pre><p>In the WET approach, we are duplicating the same logic to calculate the total price in both functions. If the tax calculation needs to change, we must make the change in both places.</p><p>DRY Code Example:</p><pre>const calculateTotalPrice = (itemPrice, taxRate) =&gt; {<br>  return itemPrice + (itemPrice * taxRate);<br>}<br><br>const calculateTotalPriceWithDiscount = (itemPrice, taxRate, discount) =&gt; {<br>  let discountedPrice = itemPrice - discount;<br>  return calculateTotalPrice(discountedPrice, taxRate);<br>}</pre><p>In this DRY approach, we’ve moved the common tax calculation into the calculateTotalPrice function, allowing for code reuse. Now, if the tax calculation logic needs to change, we only need to update it in one place.</p><h3>Benefits of DRY Code</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S4peSl60tcL2V6zuCm4Eew.png" /><figcaption>Generated using <a href="https://openai.com/index/dall-e-3/">https://openai.com/index/dall-e-3/</a></figcaption></figure><h4>1. Reduced Redundancy and Improved Maintainability</h4><p>The primary advantage of adhering to the DRY principle is <strong>reduced redundancy</strong>. By avoiding duplicated code, you ensure that the logic resides in a single location. If a bug or enhancement arises, you only need to modify the logic in one place, reducing the risk of inconsistencies. This leads to easier maintenance and fewer opportunities for errors.</p><h4>2. Easier Refactoring</h4><p>In large applications, code refactoring is inevitable. If you’ve used DRY practices, refactoring becomes much easier since you don’t have to worry about updating multiple places where similar logic is written. By having a central location for shared code, refactoring efforts are more manageable and less risky.</p><h4>3. Better Scalability</h4><p>As projects grow, the complexity increases. DRY code is inherently more scalable because the codebase doesn’t become cluttered with repetitive logic. You can extend the functionality of the application without worrying about breaking any duplicated code across different modules or files.</p><h4>4. Improved Readability and Understanding</h4><p>DRY code is generally cleaner and easier to read. Instead of sifting through repeated blocks of logic, developers can quickly understand the core concepts and focus on what’s unique to each function or module. This makes the codebase more accessible to new developers and improves collaboration across teams.</p><h4>5. Testing Efficiency</h4><p>When code is modularized and reused, it’s easier to write tests. You can create unit tests for individual functions or modules, ensuring that specific functionality works as intended. In WET code, testing can become cumbersome as you may need to write redundant tests for each piece of duplicated code.</p><h3>When WET May Be Acceptable</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iQQE5NH8jioWOrrr1nNkCA.png" /></figure><p>While DRY is generally the recommended approach, there are cases where WET might be acceptable or even preferred:</p><ol><li><strong>Prototyping or Quick Hacks:</strong> During rapid prototyping or when creating a proof of concept, it might be faster to write code without worrying too much about repetition. However, this should not be a long-term solution.</li><li><strong>Performance Considerations:</strong> In some performance-critical areas, avoiding abstraction might lead to performance benefits, though this is rare and should be considered with caution.</li><li><strong>Complexity:</strong> In certain situations, abstractions can lead to unnecessary complexity, especially when the logic is so simple that creating a function for it adds overhead.</li></ol><h3>Conclusion</h3><p>The DRY principle is a cornerstone of good software development practice, enabling cleaner, more maintainable, and scalable code. While WET code might seem like a shortcut in the short term, it can lead to significant technical debt down the line. By embracing DRY, developers ensure that their code is more modular, readable and easier to test and maintain, ultimately reducing the risk of errors and improving productivity.</p><p>So, remember: <strong>Don’t Repeat Yourself</strong>, and your future self will thank you for it 😉</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae4e591c0f06" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inheritance in Component Libraries: A Double-Edged Sword — with Vue.js & React Native Examples]]></title>
            <link>https://medium.com/@gayansandamal/inheritance-in-component-libraries-a-double-edged-sword-with-vue-js-react-native-examples-0e01f556e19c?source=rss-a0534a2ebbda------2</link>
            <guid isPermaLink="false">https://medium.com/p/0e01f556e19c</guid>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[component-libraries]]></category>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[design-principles]]></category>
            <category><![CDATA[inheritance]]></category>
            <dc:creator><![CDATA[Gayan Sandamal]]></dc:creator>
            <pubDate>Wed, 12 Jun 2024 19:34:30 GMT</pubDate>
            <atom:updated>2024-06-12T19:34:30.702Z</atom:updated>
            <content:encoded><![CDATA[<h3>Inheritance in Component Libraries: A Double-Edged Sword — with Vue.js &amp; React Native Examples</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_YEMuPHpVWGZaklCIT_i_g.png" /><figcaption>Generated using FlowGPT</figcaption></figure><p>Component libraries are the building blocks of modern web development, offering reusable UI elements that streamline the development process. Inheritance, a fundamental object-oriented programming concept, plays a crucial role in creating these libraries. But like any powerful tool, inheritance can be a double-edged sword. In this article, we’ll delve into the pros and cons of overuse of inheritance when developing component libraries, helping you make informed decisions for your projects.</p><h3>The Benefits of Inheritance: A Foundation for Reusability 🐣</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ioL0tTCrEyWj8Cu5kA-mZQ.png" /><figcaption>Originally on <a href="https://seleniumautomationtester.wordpress.com/2017/03/09/inheritance-in-java/">Inheritance in Java</a></figcaption></figure><p>Inheritance allows us to create a base component with core functionalities and styles. Subclasses then inherit these functionalities while adding their own specific features. This approach offers several advantages:</p><ul><li><strong>Reduced Code Duplication:</strong> By leveraging a base component, developers avoid rewriting common code across multiple components. This saves time, reduces the codebase size, and improves maintainability.</li><li><strong>Consistent Behaviour:</strong> Inheritance promotes code consistency by ensuring subclasses inherit the base component’s behaviour. This simplifies understanding and usage for other developers working with the library.</li><li><strong>Extensibility:</strong> New features can be introduced in the base component, automatically propagating to all inheriting components. This promotes a more modular and adaptable library.</li></ul><h3><strong>The Pitfalls of Inheritance: When Less Becomes More 🥹</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*leBpbH_hvLoK7IDaAvB9GQ.png" /><figcaption>Originally on <a href="https://www.uxdesigninstitute.com/blog/improve-ux-design/">Less is more: How stripping back can improve UX Design</a></figcaption></figure><p>While inheritance offers significant benefits, excessive use can lead to unforeseen complexities:</p><ul><li><strong>Tight Coupling:</strong> Overly complex inheritance hierarchies can create tightly coupled components. Changes in a base component can have unintended consequences for all its descendants, making maintenance and updates cumbersome.</li><li><strong>Fragile Base Classes:</strong> If a base class becomes overloaded with functionalities, it might become inflexible and difficult to modify without breaking existing components.</li><li><strong>The “Is-A” Relationship Trap:</strong> Inheritance should reflect a true “is-a” relationship. Forcing components into an inheritance hierarchy just for code reuse can lead to convoluted and unintuitive class structures.</li></ul><h3><strong>Alternatives to Inheritance: Exploring Other Options</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4kNaaeRWt4Xh9sfw2coCmQ.png" /><figcaption>Originally on <a href="https://blog.depositphotos.com/back-to-basics-10-composition-rules-in-photography.html">Back to Basics</a></figcaption></figure><p>When considering reusability in component libraries, inheritance is not the only option:</p><ul><li><strong>Composition:</strong> Break down functionalities into smaller, independent components. Instead of inheritance, components can be composed by including one another, promoting loose coupling and flexibility.</li><li><strong>Mixins:</strong> Mixins allow components to share specific functionalities without establishing a strict inheritance relationship. This promotes code reuse while maintaining component independence.</li><li><strong>Utility Classes:</strong> For simple styling variations, consider using utility classes instead of creating separate components through inheritance. This reduces code bloat and improves maintainability.</li></ul><h3><strong>Finding the Optimal Balance: A Context-Driven Approach ⚖️</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zd6PaM2URgW0UH6jo1F9kQ.png" /><figcaption>Originally on <a href="https://dragonflycoachingllc.medium.com/finding-the-right-balance-710b6f772368">Finding The Right Balance</a></figcaption></figure><p>The decision to use inheritance for component reuse should be a balanced one, taking into account project specifics:</p><ul><li><strong>Complexity of Components:</strong> For simple components with a clear “is-a” relationship, inheritance can be an efficient way to promote code reuse.</li><li><strong>Maintainability:</strong> Prioritize component hierarchies that are easy to understand and maintain. If inheritance makes the structure complex, consider alternative approaches.</li><li><strong>Flexibility:</strong> Choose techniques that allow for future growth and adaptation of your component library.</li></ul><h3>Let’s See Some Real-life Examples</h3><h4>Bad Way: Overusing Inheritance 👎</h4><p><strong><em>Using Vue.Js Examples</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GXxbmxqtSKD_ljVTpAeNdg.png" /><figcaption>Vue.js Options API Example for Overuse of Inheritance</figcaption></figure><p><strong><em>Using React Native Examples</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gRCnV3Sfo_fkuJsUa_pmfQ.png" /><figcaption>React Native Example for Overuse of Inheritance</figcaption></figure><p><strong>Issues:</strong></p><ul><li>Tight coupling: Changes to BaseButton.vue (e.g., adding a new prop) affect all inheriting components.</li><li>Fragile base class: If BaseButton.vue becomes overloaded with props and styles, it becomes inflexible.</li></ul><h4>Good Way: Using Composition and Utility Classes 👍 (Using Vue.Js)</h4><p><strong><em>Using Vue.Js Examples</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j5vx-K0ckk5lJILBuyqBag.png" /><figcaption>Vue.js Options API Example for The Use of Compositions &amp; Utility Classes</figcaption></figure><p><strong><em>Using React Native Examples</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X1TkiqXC7lLClRXNkoTEPA.png" /><figcaption>React Native Example for The Use of Utility Classes</figcaption></figure><p><strong>Benefits:</strong></p><ul><li>Loose coupling: Changes to `Button.vue` don’t directly affect inheriting components.</li><li>Flexibility: Utility classes allow for easy customization of button styles.</li></ul><h3><strong>Conclusion: Inheritance — A Tool, Not a Crutch ☝️</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f3B0S0-Fs716mM66zzdvUA.png" /><figcaption>Originally on <a href="https://tenor.com/">Tenor</a></figcaption></figure><p>Inheritance is a powerful tool for building component libraries. However, its overuse can lead to maintenance headaches and inflexible structures. By understanding its advantages and limitations, and exploring alternative approaches like composition and mixins, you can create well-structured, reusable, and maintainable component libraries for your web projects.</p><h3>Let’s Discuss! 👇</h3><p>Share your experiences with inheritance in component libraries! When do you find it most beneficial? What alternative strategies have you found successful? Let’s keep the conversation going in the comments below!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0e01f556e19c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Sketch to Ship: Why Wireframes and Prototypes Are Your Frontend’s Best Friends]]></title>
            <link>https://medium.com/@gayansandamal/from-sketch-to-ship-why-wireframes-and-prototypes-are-your-frontends-best-friends-685412eff98a?source=rss-a0534a2ebbda------2</link>
            <guid isPermaLink="false">https://medium.com/p/685412eff98a</guid>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[wireframing]]></category>
            <category><![CDATA[prototyping]]></category>
            <dc:creator><![CDATA[Gayan Sandamal]]></dc:creator>
            <pubDate>Thu, 06 Jun 2024 19:51:37 GMT</pubDate>
            <atom:updated>2024-06-06T19:51:37.146Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u-NZgJJPBbkJ5SQ0mHeEaQ.jpeg" /><figcaption>Generated using <a href="https://www.memecreator.org/">https://www.memecreator.org/</a></figcaption></figure><p>As a UI/UX enthusiast and a seasoned frontend developer, I’ve witnessed firsthand the transformative power of wireframes and prototypes in the development process. While some might see them as an unnecessary hurdle, these low-fidelity tools hold the key to crafting user-centric, efficient, and ultimately, delightful applications.</p><h3>Building a Strong Foundation: The Power of Wireframes 💪</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H0VTeHWAAdZ8mVpn2LMPzg.png" /><figcaption>Originally published on “What is wireframe? by Eniola Sola-Kehinde” [<a href="https://bootcamp.uxdesign.cc/wireframes-5d63f9d760a8">https://bootcamp.uxdesign.cc/wireframes-5d63f9d760a8</a>]</figcaption></figure><p>Think of wireframes as the blueprints for your application. They’re stripped-down sketches that map out the core UI elements, layout, and information hierarchy. Here’s how wireframes empower your frontend development journey:</p><ul><li><strong>Clarity of Vision:</strong> Before diving into code, wireframes establish a clear understanding of the application’s purpose and user flow. This shared vision amongst stakeholders (designers, developers, product managers) minimizes confusion and ensures everyone’s on the same page.</li><li><strong>Early Feedback and Iteration:</strong> Wireframes are easily modifiable, allowing for quick feedback and iteration cycles. Gathering user input and testing different layouts at this stage is significantly cheaper and faster than making changes to a fully-fledged application.</li><li><strong>Focus on Functionality:</strong> Unburdened by visual aesthetics, wireframes force the focus on core functionality and user interactions. This ensures the user journey is well-defined and intuitive before any visual elements are added.</li></ul><h3>Taking it Up a Notch: The Magic of Prototypes 🪄</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*bA63Bayc9QSkx5U6MlNzRw.png" /><figcaption>Originally published on “The Importance of Prototyping in UX Designing by <a href="https://mockitt.wondershare.com/author/stephen-mwangi.html">Stephen Mwangi</a>” [<a href="https://mockitt.wondershare.com/ui-ux-design/prototype-is.html">https://mockitt.wondershare.com/ui-ux-design/prototype-is.html</a>]</figcaption></figure><p>Prototypes build upon the foundation laid by wireframes, adding a layer of interactivity to simulate the actual user experience. Here’s how prototyping empowers your frontend development:</p><ul><li><strong>Improved User Testing:</strong> Prototypes allow users to interact with the application in a basic form, providing valuable insights into usability issues and potential areas of improvement. This user testing early in the development cycle leads to a more user-friendly final product.</li><li><strong>Identifying Interaction Flaws:</strong> Prototypes reveal potential inconsistencies in user flows and interaction patterns. Ironing these out early on prevents costly rework during frontend development.</li><li><strong>Enhanced Communication with Stakeholders:</strong> A functional prototype allows stakeholders to visualize the overall user experience. This fosters better communication and alignment between developers, designers, and product managers.</li></ul><h3>Beyond the Benefits: A Developer’s Perspective 🧐</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*whHK7suWlw-jWyuMoNKHwA.gif" /><figcaption>Originally published on “Why Does Every Voice Matter? The Importance of Hearing Different Perspectives by Shafi Sahal” [<a href="https://medium.com/curious/why-does-every-voice-matter-the-importance-of-hearing-different-perspectives-eeba740955ab">https://medium.com/curious/why-does-every-voice-matter-the-importance-of-hearing-different-perspectives-eeba740955ab</a>]</figcaption></figure><p>As a frontend developer myself, I can’t stress enough the advantages of wireframes and prototypes:</p><ul><li><strong>Reduced Development Time:</strong> Having a clear roadmap with defined functionalities saves countless hours during development. It eliminates the need to constantly rethink layouts and user flows as the project progresses.</li><li><strong>Fewer Revisions and Bug Fixes:</strong> Early identification of user flow issues and interaction inconsistencies leads to fewer revisions and bug fixes down the line, streamlining the development process.</li><li><strong>Increased Confidence and Ownership:</strong> Working with well-defined wireframes and prototypes allows developers to approach the project with greater confidence and ownership. It fosters a sense of clarity and purpose, leading to better code quality.</li></ul><h3><strong>The Art of Balance: When Less is More ⚖️</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/564/0*gqOBE1uVhbI_W0pV" /><figcaption>Originally published on <a href="https://journal.projectnord.com/blog/about-minimalism">https://journal.projectnord.com/blog/about-minimalism</a></figcaption></figure><p>It’s important to remember that wireframes and prototypes are meant to be low-fidelity representations. Don’t get bogged down by creating pixel-perfect mockups. The focus should be on structure, function, and user flow.</p><h3>The Final Verdict: A Collaborative Endeavor 🤗</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*Yx-uTx_ihxRBJK58" /></figure><p>The true power of wireframes and prototypes lies in their ability to bridge the gap between design and development. By fostering collaboration and communication, these tools pave the way for a more efficient, user-centric, and ultimately, successful product.</p><p>So, the next time you embark on a frontend development project, remember this: a little time invested in wireframes and prototypes can save you a lot of headaches down the road. Let’s create applications that are not just visually appealing, but also intuitive, functional, and a joy for users to interact with!</p><h3>Let’s Discuss! 👇</h3><p>What are your thoughts on the role of wireframes and prototypes in the frontend development process? Do you have any specific techniques or tools you find particularly helpful? Share your experiences and insights in the comments below! Whether you’re a seasoned developer, a budding designer, or simply someone passionate about creating great applications, your voice adds to the conversation. Let’s keep learning and pushing the boundaries of user-centric development together!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=685412eff98a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blurring the Lines: Building Web Apps with React Native and react-native-web]]></title>
            <link>https://medium.com/@gayansandamal/blurring-the-lines-building-web-apps-with-react-native-and-react-native-web-4b827453f2a0?source=rss-a0534a2ebbda------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b827453f2a0</guid>
            <dc:creator><![CDATA[Gayan Sandamal]]></dc:creator>
            <pubDate>Thu, 16 May 2024 07:51:56 GMT</pubDate>
            <atom:updated>2024-05-16T10:25:23.822Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HkpDMLtbMKFfMW61R7nKHw.png" /><figcaption>Generated using (<a href="https://flowgpt.com/chat/chatgpt-4-image-creator">https://flowgpt.com/chat/chatgpt-4-image-creator</a>)</figcaption></figure><p><a href="https://reactnative.dev/">React Native</a> has become synonymous with building native mobile applications using <a href="https://en.wikipedia.org/wiki/JavaScript">JavaScript</a> and <a href="https://react.dev/">React</a>. But what if you could leverage that same expertise to create web applications? Enter <a href="https://necolas.github.io/react-native-web/">react-native-web</a>, a powerful node module that lets you run React Native components directly in the browser.</p><h3>Why React Native for Web? 🤔</h3><p>There are several compelling reasons to consider React Native for web development:</p><p><strong>Shared Codebase:</strong> If you’re already using React Native for your mobile app, <a href="https://necolas.github.io/react-native-web/">react-native-web</a> allows you to reuse a significant portion of your codebase for your web application. This translates to faster development times and reduced maintenance overhead.</p><p><strong>Familiar Framework:</strong> React Native developers already comfortable with the React syntax and component-based architecture can seamlessly transition to building web apps with <a href="https://necolas.github.io/react-native-web/">react-native-web</a>. This reduces the learning curve and allows developers to focus on core functionality.</p><p><strong>Native-like Performance:</strong> React Native is known for its ability to deliver a native-like user experience on mobile devices. <a href="https://necolas.github.io/react-native-web/">react-native-web</a> leverages many of the same principles to create performant and responsive web applications.</p><h3>Getting Started with react-native-web 🎬</h3><p>Setting up a React Native project with <a href="https://necolas.github.io/react-native-web/">react-native-web</a> is relatively straightforward. Here’s a basic outline:</p><ol><li><strong>Install Dependencies: </strong>Install the necessary packages using npm or yarn:<br><strong>Bash</strong><br><em>npm install react-native react-native-web</em></li><li><strong>Configure Project: </strong>Update your project’s entry point (e.g., index.js) to render your React Native components using react-dom:<br><strong>JavaScript</strong><br><em>import React from ‘react’;<br>import { render } from ‘react-dom’;<br>import App from ‘./App’; // Your main React Native component<br>render(&lt;App /&gt;, document.getElementById(‘root’));</em></li><li><strong>Leverage Web-Specific Components:</strong> While most React Native components work seamlessly with <a href="https://necolas.github.io/react-native-web/">react-native-web</a>, some functionalities might require web-specific alternatives. Consider libraries like <a href="https://www.npmjs.com/package/react-native-elements">react-native-elements</a> or <a href="https://github.com/react-native-web-community">react-native-web-community</a> for additional components optimized for the web.</li></ol><h3>Things to Consider 🧐</h3><p>While <a href="https://necolas.github.io/react-native-web/">react-native-web</a> offers a compelling approach to web development with React Native, there are some limitations to keep in mind:</p><ol><li><strong>Not a Silver Bullet:</strong> Not all React Native components translate perfectly to the web. You might encounter compatibility issues or require additional work for optimal performance.</li><li><strong>Limited Third-Party Support:</strong> Libraries and tools designed specifically for React Native might not have web equivalents. You may need to explore web-specific alternatives.</li><li><strong>Styling Differences:</strong> Styling techniques used in React Native might require adjustments for the web. Be prepared to adapt your styling approach using CSS or web-specific libraries.</li></ol><h3>Conclusion 🤗</h3><p><a href="https://necolas.github.io/react-native-web/">react-native-web</a> provides a unique opportunity to leverage your React Native expertise for web development. While it’s not a one-size-fits-all solution, it offers a compelling path for building performant and reusable web applications with React Native. So, if you’re looking to explore new frontiers with your React Native knowledge, react-native-web is definitely worth considering!</p><h3>Let’s Discuss! 👇</h3><p>Have you experimented with react-native-web for web development? What were your experiences? Do you see potential benefits or drawbacks to this approach?<br>Share your thoughts and insights in the comments below!<br>Whether you’re a React Native veteran, a web development enthusiast, or simply curious about the possibilities, your voice adds to the conversation. Let’s keep exploring the ever-evolving landscape of web development together! 🎉</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b827453f2a0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Fond Reunion with Vue.js: Lessons Learned from a React Exploration]]></title>
            <link>https://medium.com/@gayansandamal/a-fond-reunion-with-vue-js-lessons-learned-from-a-react-exploration-eb38c209cd8f?source=rss-a0534a2ebbda------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb38c209cd8f</guid>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Gayan Sandamal]]></dc:creator>
            <pubDate>Sat, 04 May 2024 22:24:06 GMT</pubDate>
            <atom:updated>2024-05-04T22:24:06.581Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FWDVwj6MLM0eEvEC1SDblg.jpeg" /><figcaption>Generated using <a href="https://perchance.org/ai-text-to-image-generator">https://perchance.org/ai-text-to-image-generator</a></figcaption></figure><p>For over half a decade, Vue.js was my programming soulmate. Its simplicity, elegance, and lightning-fast rendering kept me in a state of developer bliss. Then, ambition struck. The allure of React Native, the ability to build mobile apps with familiar React code, lured me away. But sometimes, love takes you on a detour to truly appreciate what you have.</p><h3>React’s Rectangle Ride</h3><p>The initial foray into React was exciting. Building mobile apps with React Native felt strangely familiar, and the vast React ecosystem offered a treasure trove of libraries and resources. React Queries became a new best friend, simplifying data fetching woes. Yet, a nagging feeling persisted.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zM6QIkmNx8-u_Drx7jokvA.png" /><figcaption>Originally on <a href="https://www.reddit.com/r/vuejs/comments/126nd9m/saw_this_on_twitter_last_night/">https://www.reddit.com/r/vuejs/comments/126nd9m/saw_this_on_twitter_last_night/</a></figcaption></figure><h3>Missing Vue’s Magic Touch</h3><p>While React had its strengths, something felt…off. The developer experience, once so smooth with Vue, became a tad clunky. The clear syntax and intuitive data binding of Vue, features I once took for granted, were sorely missed. And don’t even get me started on the occasional rendering quirks that plagued some React projects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QT4PiEJsdnKdtnahLTc4Rg.jpeg" /><figcaption>Originally on <a href="https://www.reddit.com/r/harrypotter/comments/e6qcik/sorry_if_its_already_been_posted_the_first_hp/">https://www.reddit.com/r/harrypotter/comments/e6qcik/sorry_if_its_already_been_posted_the_first_hp/</a></figcaption></figure><h3>The Warm Embrace of Vue</h3><p>The realization dawned: Vue wasn’t just a framework; it was a philosophy that resonated with me. Returning to Vue felt like slipping on a comfortable old sweater — familiar, comforting, and oh-so-productive. The blazing-fast rendering speeds made development a breeze, and the elegant syntax sparked joy with every line of code written.</p><h3>Beyond the Framework Wars</h3><p>This isn’t a Vue vs. React showdown. Both frameworks are phenomenal in their own right. But for me, Vue offered a perfect synergy between developer experience, performance, and a community that felt more welcoming and approachable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cC1R31tdf_JvEtHKt3afKg.jpeg" /><figcaption>Originally on <a href="https://imgflip.com/memegenerator/Sparta-Leonidas">https://imgflip.com/memegenerator/Sparta-Leonidas</a></figcaption></figure><h3>A Lesson Learned</h3><p>The journey into React, while educational, solidified my appreciation for Vue. It’s a reminder that the “best” framework is subjective. It’s about finding the tool that empowers you to create efficiently and joyfully.</p><p><strong>So, to my fellow developers</strong>: Don’t be afraid to experiment! Explore different frameworks, but also trust your gut. If a framework doesn’t spark joy, there’s no shame in returning to a familiar friend. After all, the most important thing is to build amazing applications, and the right framework can make all the difference in that journey.</p><p>P.S. While React Native may not have been my soulmate, the knowledge gained will undoubtedly enrich my future projects because I keep developing with React Native for mobile development for sure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wbxitjFJDP9Smx1GTNYDUw.jpeg" /><figcaption>Originally on <a href="https://imageresizer.com/meme-generator/edit/mr-bean-happy-face">https://imageresizer.com/meme-generator/edit/mr-bean-happy-face</a></figcaption></figure><p>There’s always something to learn in the ever-evolving world of web development!</p><p>I’d love to hear your thoughts! Have you ever switched between front-end frameworks? What factors influence your choice of framework? Did you resonate with my experience, or did your journey take a different turn?</p><p>Share your experiences and insights in the comments below! Whether you’re a Vue champion, a React enthusiast, or simply curious about the landscape, your voice adds to the conversation.</p><p>Let’s keep the discussion going and help each other navigate the ever-evolving world of web development!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb38c209cd8f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>