<?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 Nima Habibkhoda on Medium]]></title>
        <description><![CDATA[Stories by Nima Habibkhoda on Medium]]></description>
        <link>https://medium.com/@nima.2004hkh?source=rss-8c0b558e8a11------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*6wkMB2mTzPUu9--ffCRQXg.jpeg</url>
            <title>Stories by Nima Habibkhoda on Medium</title>
            <link>https://medium.com/@nima.2004hkh?source=rss-8c0b558e8a11------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 05:56:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nima.2004hkh/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[Frontend Evolution in the AI Revolution]]></title>
            <link>https://medium.com/@nima.2004hkh/frontend-evolution-in-the-ai-revolution-257ce065f5c8?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/257ce065f5c8</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-revolution]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Mon, 15 Jan 2024 14:26:03 GMT</pubDate>
            <atom:updated>2024-01-15T14:26:03.823Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g3ddrA48opBqesHKPjBodw.jpeg" /></figure><p>“<strong><em>It is just my opinion about AI</em></strong>”</p><p>The tale of AI in software engineering is a fascinating one, combining technological advancement with human brilliance. It’s a story that began some decades ago but really gathered traction in the early twenty-first century. This was a period when the globe saw tremendous advances in algorithms, an explosion of data, and a leap in computer capacity, paving the way for AI to make a big entrance into the field of software engineering.</p><h4>The Early Days and the Turning Point</h4><p>Imagine a world where software development is entirely manual, with every line of code painstakingly written by human hands. This was the reality until AI began to show its potential. The turning point came with the development of machine learning models, particularly deep learning, which could analyze and learn from data at an unprecedented scale. This wasn’t just a step forward; it was a giant leap that opened up new possibilities.</p><p><strong>Coding with a Companion:</strong> Picture a tool like GitHub’s Copilot, powered by OpenAI’s Codex, sitting beside you, suggesting code snippets, and offering solutions. This is not just about speed; it’s about enhancing the creative process of coding.</p><p><strong>A New Era of Testing:</strong> AI-driven testing tools are like having a detective in your team, one that can predict where bugs are likely to hide and automatically create scenarios to catch them. This means more reliable software and more time for developers to focus on innovation.</p><p><strong>Crafting Personalized Experiences:</strong> AI in software engineering is like a skilled artist, capable of painting unique, dynamic user experiences that adapt in real-time. It’s about understanding and responding to each user’s needs, creating a more intuitive and engaging interaction.</p><p><strong>Streamlining Development: </strong>Imagine having a crystal ball that could predict the best way to allocate resources or the most efficient development path. AI-driven predictive analytics turn this fantasy into reality, guiding teams with data-driven insights.</p><p><strong>Guardians of Cybersecurity:</strong> AI in security is like a vigilant guardian, always on the lookout for potential threats, ready to act in milliseconds. It’s about staying one step ahead in the ever-evolving landscape of cybersecurity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X9xC42TgwvIqP4cs9i54eg.jpeg" /></figure><h3>Adapting as Frontend Engineers for Enhanced Job Security</h3><h4><strong>Understanding the Concerns About Job Security</strong></h4><p>The apprehension among frontend engineers regarding AI stems from a fundamental fear: <strong>the risk of being replaced by machines</strong>. This fear is not unfounded, as AI’s capabilities in automating tasks, including coding, have grown exponentially. AI tools can now convert design mockups into code, optimize performance issues, and even suggest design improvements. Such advancements naturally lead to concerns about the redundancy of human skills in these areas.</p><p>The root of this anxiety lies in the rapid pace of AI development. Frontend engineers witness AI handling increasingly complex tasks, tasks that were once the exclusive domain of skilled professionals. The worry is that as AI continues to evolve, it might encroach upon more creative and nuanced aspects of frontend development.</p><h4>Why AI Won’t Render Frontend Engineers Obsolete</h4><p>However, these fears, while understandable, don’t capture the whole picture. AI, at its core, is a tool designed to augment human capabilities, not replace them. In the context of frontend development, AI excels at handling repetitive, time-consuming tasks, but it lacks the innate creativity, critical thinking, and emotional intelligence that human developers bring to the table.</p><p>Frontend development is not just about writing code; it’s about understanding and translating the human experience into a digital format. It involves empathy, design intuition, and an understanding of user psychology, areas where AI cannot compete with humans. Moreover, the very nature of front-end development is dynamic, constantly evolving with new design trends, user preferences, and accessibility standards. Navigating these shifting sands requires a human touch and an understanding of the context and culture that AI is far from achieving.</p><h4>The Symbiotic Future of AI and Frontend Development</h4><p>The integration of AI into front-end development is not a harbinger of obsolescence for developers but a beacon of progress. It presents an opportunity to elevate the role of the frontend engineer, from a coder to an innovator and strategist. By embracing AI, continually learning, and focusing on uniquely human skills and creativity, frontend developers can not only secure their place in the future of software development but also drive it forward. The future of frontend development, augmented by AI, is not just about smarter interfaces; it’s about a smarter approach to human-computer interaction, one that is more intuitive, efficient, and profoundly human.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=257ce065f5c8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Breaking Digital Chains: Navigating Towards a DRM-Free Software Future]]></title>
            <link>https://medium.com/@nima.2004hkh/breaking-digital-chains-navigating-towards-a-drm-free-open-source-future-24eb4ff6438e?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/24eb4ff6438e</guid>
            <category><![CDATA[drm]]></category>
            <category><![CDATA[free-software]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[better-world]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Tue, 09 Jan 2024 11:29:33 GMT</pubDate>
            <atom:updated>2024-02-07T14:23:48.357Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*KBU2VxFXwCmecyBwihN5YQ.jpeg" /></figure><p>In an era where digital content has become ubiquitous, Digital Restrictions Management (DRM) has emerged as a standard practice among software companies. Designed to combat piracy and protect intellectual property, DRM often comes at a significant cost to user freedom and the open-source ethos. This article delves into how DRM restricts user autonomy and diverges from the principles of free software, while also exploring viable pathways towards a more open and DRM-free digital world.</p><h4>History</h4><p>The history of Digital Restrictions Management (DRM) is closely intertwined with the evolution of digital media and the internet. DRM’s roots can be traced back to the early days of software development in the 1980s and 1990s when simple forms of copyright were used, such as serial keys or physical hardware checks, to prevent unauthorized copying of software and video games. However, it was the late 1990s and early 2000s, with the rapid rise of the internet and digital media, that saw DRM become more sophisticated and widespread. Music and movie industries began implementing robust DRM systems to combat the surge in digital piracy facilitated by file-sharing platforms like Napster.</p><p>The emergence and growth of DRM sparked a counter-movement known as ‘copyleft’, which aimed to stop people from making nonfree versions of free software. This movement, led by figures like Richard Stallman and organizations such as the Free Software Foundation, advocated for the rights of users to freely use, study, modify, and distribute software. Copyleft licenses, like the GNU General Public License (GPL), emerged as a direct response to the restrictive nature of DRM, providing a legal framework for ensuring software remained free and open.</p><p>The tension between DRM and copyleft highlighted a significant ideological divide within the digital world. On one side, large software and media companies, along with groups like the Recording Industry Association of America (RIAA) and the Motion Picture Association of America (MPAA), pushed for stringent DRM to protect their copyrights and revenue. On the other side, open-source advocates, digital rights activists, and some artists and academics argued that DRM infringed on user freedoms, stifled innovation, and hindered the free exchange of knowledge and culture. This ongoing conflict reflects broader debates about intellectual property, digital rights, and the nature of ownership in the digital age.</p><h4>DRM: A Barrier to Freedom and Innovation</h4><p>DRM, by its very nature, is antithetical to the principles of free software. It imposes restrictions on how users can interact with software, curbing the freedom to modify, share, or even fully control the software they legally own. This not only suffocates innovation but also violates user privacy and security. Big corporations often wield DRM as a tool to maintain control over their products, leading to a consumer landscape where ownership is increasingly vague.</p><p>Among the most vocal opponents of Digital Rights Management (DRM) are individuals and organizations who have consistently highlighted its negative implications for digital rights and user freedom. <strong>Cory Doctorow</strong>, an author, blogger, and digital rights activist, has been a prominent figure in this battle. Doctorow has not only written extensively about the dangers of DRM in his books and articles but has also delivered influential speeches at various technology and digital rights forums. His arguments often center around DRM’s contravention of user privacy, its detrimental effects on innovation, and its role in perpetuating corporate control over technology and culture.</p><p>Additionally, the <strong>Free Software Foundation</strong> (FSF), led by <strong>Richard Stallman</strong>, has been a key player in advocating for software freedom, directly opposing the principles of DRM. Stallman and the FSF have championed the cause of open-source software and have been pivotal in developing the concept of ‘copyleft’, a method used to resist the proprietary nature of DRM. Their work has not only improved the open-source community but has also provided a philosophical and practical framework for understanding and combating the restrictions imposed by DRM.</p><p>Together, these individuals and organizations form a diverse front against DRM, drawing from a rich tapestry of legal, technical, and philosophical perspectives. Their efforts represent a sustained commitment to ensuring that the digital world remains open, innovative, and free from undue restrictions.</p><h4>The Open Source Alternative</h4><p>Contrasting sharply with DRM-restricted software is the open-source movement. Open-source software champions transparency, collaboration, and free redistribution of software. This paradigm not only fosters innovation but also empowers users to understand and control the software they use. The open-source community demonstrates that robust, secure, and profitable software can exist without restrictive DRM.</p><h4>Challenges in the Transition</h4><p>Transitioning away from DRM is not without challenges. For one, there’s a deeply entrenched ecosystem built around DRM-supported software, with significant financial interests at stake. Additionally, convincing users accustomed to DRM-laden products to shift towards open-source alternatives requires overcoming a mix of inertia, lack of awareness, and misconceptions about the reliability and quality of open-source software.</p><h4>Pathways to a DRM-Free World</h4><ol><li><strong>Advocacy and Education</strong>: Raising awareness about the limitations and risks associated with DRM, and educating users about the benefits of open-source alternatives.</li><li><strong>Legislative Action</strong>: Lobbying for laws that protect user rights and promote transparency in software, potentially limiting or regulating the use of DRM.</li><li><strong>Supporting Open Source Projects</strong>: Encouraging the use and development of open-source software through funding, contributions, and community building.</li><li><strong>Promoting Ethical Business Models</strong>: Exploring and adopting business models that align with open-source principles while remaining financially viable.</li><li><strong>Building Community Trust</strong>: Demonstrating the reliability, security, and superiority of open-source software to build trust among users.</li></ol><h4>Conclusion</h4><p>The journey towards a DRM-free, open-source future is not merely a technical challenge but a cultural shift. It requires a collective effort from users, developers, and policymakers to realign the digital landscape with the ethos of freedom, transparency, and user empowerment. The path forward is complex but not impassable, and the rewards — a more open, innovative, and user-centric digital world — are well worth the effort.</p><h4>Resources:</h4><ul><li>Doctorow, C. (2004). “The Coming War on General Purpose Computing”. A speech addressing the societal impacts of DRM.</li><li>Stallman, R. (2010). “The Right to Read”. An article on the FSF website discusses DRM’s implications.</li><li>Lessig, L. (2004). “Free Culture: How Big Media Uses Technology and the Law to Lock Down Culture and Control Creativity”. A book examining the impact of DRM on culture.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=24eb4ff6438e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Soft Bun JS: A Journey into Reactivity]]></title>
            <link>https://medium.com/codex/soft-bun-js-a-journey-into-reactivity-73492fd1cf73?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/73492fd1cf73</guid>
            <category><![CDATA[svelte]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[reactivity]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Mon, 17 Jul 2023 21:27:22 GMT</pubDate>
            <atom:updated>2023-07-20T11:47:49.312Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*laMKGatkgoKQMwJwwhK-9g.jpeg" /></figure><p>Soft Bun is a lightweight and framework-agnostic reactivity system implemented in TypeScript. Soft Bun allows you to define reactive dependencies within your state objects by using the unique identifier $ to indicate variables derived from other variables in the state. By leveraging Proxies, Soft Bun tracks changes to the state and automatically recalculates dependent properties, enabling dynamic updates and simplifying complex computations. With its focus on simplicity and flexibility, Soft Bun empowers JavaScript/TypeScript developers to incorporate reactivity into their projects with ease.</p><p><a href="https://github.com/nimahkh/soft_bun">https://github.com/nimahkh/soft_bun</a></p><h3>The Story Behind Soft Bun: A Journey into Reactivity</h3><p>Every great project has a story behind it, and Soft Bun is no exception. The creation of this reactivity system was driven by a personal passion for baking bread and a desire to explore the world of reactivity in JavaScript and TypeScript.</p><p>The inspiration for Soft Bun came from an unlikely source: Rich Harris’s presentation on Svelte and its reactivity system. Rich Harris’s insights and demonstrations showcased the power and elegance of reactive programming, and it left a lasting impression on me.</p><p>As I started exploring the world of reactivity, I realized that many existing reactivity systems were tightly coupled with specific frameworks or libraries such as React, Vue, and Svelte. While these systems worked well within their respective ecosystems, they often lacked flexibility and were challenging to integrate into projects that didn’t align with those frameworks.</p><p>Motivated by this observation, I set out to create a reactivity system that was framework-agnostic and could be easily implemented in any JavaScript or TypeScript project. This system would empower developers to leverage the power of reactivity without being tied to a specific framework or library.</p><p>I chose to name the project “Soft Bun” as an homage to my love for baking bread. Soft bun represents a perfect blend of simplicity and delight, characteristics I sought to embody in the reactivity system I was building.</p><p>With a clear vision in mind, I began developing Soft Bun as a pure TypeScript core that could be seamlessly integrated into any project. I focused on making the code concise, yet robust, leveraging TypeScript’s type system to ensure type safety and enhance developer productivity.</p><p>Throughout the development process, I experimented with different approaches, learned from various reactivity systems, and refined the implementation. I aimed to strike a balance between simplicity and functionality, providing a lightweight yet powerful reactivity solution.</p><p>Soft Bun is now an open-source project, and I encourage developers to explore its code, share their thoughts, and contribute to its growth. I believe that by collaborating and sharing knowledge, we can improve Soft Bun and empower developers around the world to build more reactive and dynamic applications.</p><p>I am going to introduce the Soft Bun reactivity system, explain its code and ideology, and provide examples of how to use it.</p><h3>Understanding Reactivity</h3><p>Reactivity refers to the ability of a system to automatically track dependencies between variables and expressions and update them when their dependencies change. In traditional JavaScript, assigning a variable to another variable creates a static relationship, meaning changes to the original variable won’t affect the assigned variable. Soft Bun introduces reactivity to enable dynamic relationships between variables.</p><p>For example, let’s consider the following code snippet:</p><pre>var a = 2;<br>var b = 1 + a;<br>a = 3;<br>console.log(b) //3</pre><p>In traditional JavaScript, we would expect b to retain its initial value of 3 because it was assigned the value of 1 + a at the time of assignment. However, in a reactive system, we would expect b to automatically update to reflect the new value of a, resulting in b being 4 after a is changed to 3.</p><p>Soft Bun provides a solution to handle such reactive relationships between variables and expressions, allowing for automatic updates when dependencies change.</p><p>You can read more about <a href="https://en.wikipedia.org/wiki/Reactive_programming">Reactive Programming here</a>.</p><h3>How Soft Bun is solving the issue?</h3><p>To demonstrate the usage of Soft Bun, let’s explore a couple of examples:</p><pre>import SoftBun from &#39;soft_bun&#39;;<br><br>const data = { a: 1, b: 1, c: { d: 2, k: 4 } };<br>const softbun = new SoftBun(data);<br><br>softbun.reactive(&#39;c.d&#39;, &#39;2 + $b&#39;);<br>softbun.reactive(&#39;c.k&#39;, &#39;5 * $a * $b&#39;);<br><br>console.time(&#39;Task&#39;);<br>softbun.state.a = 3;<br>softbun.state.b = 4;<br>for (let i = 0; i &lt; 100000; i++) {<br>  softbun.state.b += 4;<br>}<br>for (let i = 0; i &lt; 100000; i++) {<br>  softbun.state.a += 4;<br>}<br>console.timeEnd(&#39;Task&#39;);<br>console.log(softbun.state);</pre><p>In this example, we create a reactive object r based on the initial data object. We define two reactive dependencies using the reactive method: c.d depends on b, and c.k depends on a and b. The dependencies are expressed using expressions with variables prefixed by $.</p><p>We then modify the values of a and b and perform some calculations. The console.log(r.state) statement outputs the final state object, which reflects the automatic updates based on the reactive dependencies.</p><h3>Example 2: Reactive Concatenation</h3><pre>import SoftBun from &#39;soft_bun&#39;;<br><br>interface IAddress {<br>  postal: string;<br>  city: string;<br>  house_number: number;<br>}<br><br>interface IPerson {<br>  name: string;<br>  family: string;<br>  address: IAddress;<br>  age: number;<br>}<br><br>const data2: IPerson = {<br>  name: &#39;Nima&#39;,<br>  family: &#39;HKH&#39;,<br>  age: 30,<br>  address: {<br>    postal: &#39;2A&#39;,<br>    city: &#39;Amsterdam&#39;,<br>    house_number: 3,<br>  },<br>};<br><br>const person = new SoftBun(data2);<br><br>person.reactive(&#39;full_name&#39;, &#39;$name $family&#39;);<br>console.log(person.state);<br>person.state.name = &#39;John&#39;;<br>person.state.family = &#39;Doe&#39;;<br>console.log(person.state);</pre><p>In this example, we define a more complex state object representing a person’s information. We create a reactive object person based on the initial data object. We then define a reactive dependency full_name, which concatenates the name and family properties using the expression $name $family.</p><p>After modifying the name and family properties, we observe the updated person.state object, which reflects the changes propagated through the reactive dependency.</p><h3>Deeper in Soft Bun</h3><p>The system leverages the use of a unique identifier, the $ symbol, to indicate variables that are derived from other variables within the state object.</p><p>When you call the reactive method, you pass in a key and an expression. The key represents the target variable that will be reactive, and the expression defines how that variable is computed based on other variables within the state object.</p><p>For example, let’s consider the following code snippet:</p><pre>import SoftBun from &#39;soft_bun&#39;;<br><br>const data = { a: 1, b: 1, c: { d: 2, k: 4 } };<br>const r = new SoftBun(data);<br><br>r.reactive(&#39;c.d&#39;, &#39;2 + $b&#39;);<br>r.reactive(&#39;c.k&#39;, &#39;5 * $a * $b&#39;);</pre><p>In this example, we have a state object data with properties a, b, and c. By calling the reactive method, we define reactive dependencies for c.d and c.k based on other variables ($b, $a, and $b, respectively) within the state object.</p><p>Soft Bun uses a Proxy object to intercept property accesses and mutations within the state object. When you access a reactive property (e.g., r.state.c.d), the get handler of the Proxy intercepts the access and returns a new Proxy object for any nested objects within the state. This allows Soft Bun to track nested reactive dependencies as well.</p><p>When you mutate a reactive property (e.g., r.state.a = 3), the set handler of the Proxy is triggered. Soft Bun updates the value of the property and then triggers an update process. It identifies all the dependent properties that were defined through the reactive method and recalculates their values based on the updated state.</p><p>Soft Bun achieves this by maintaining a data structure (reactive_keys) that keeps track of the reactive dependencies and their expressions. When a reactive property is mutated, Soft Bun identifies the dependencies associated with that property and reevaluates their expressions using the current state values. It then updates the corresponding properties accordingly.</p><p>This reevaluation and update process happens recursively, ensuring that any nested reactive dependencies are also recalculated and updated.</p><p>The combination of the unique identifier $ to indicate reactive dependencies, the use of Proxy to intercept property accesses and mutations, and the recursive update mechanism allows Soft Bun to provide a reactive system that dynamically updates dependent properties based on changes in the state.</p><p>By understanding and utilizing Soft Bun’s reactivity system, you can build applications that respond to changes in state and automatically recalculate derived values, simplifying complex computations and enabling dynamic UI updates.</p><p>Soft Bun aims to provide a flexible and framework-agnostic solution for reactivity in JavaScript and TypeScript projects, allowing developers to harness the power of reactivity without being tied to a specific framework’s implementation.</p><h3>Conclusion</h3><p>Soft Bun provides a simple yet powerful reactivity system for JavaScript and TypeScript projects. By allowing the definition of reactive dependencies, Soft Bun enables automatic updates and recalculations, similar to popular frameworks like React or Vue.js.</p><p>In this article, we explored the Soft Bun code, its ideology, and how to use it in your projects.</p><p>Give Soft Bun a try in your projects and experience the convenience of reactive programming firsthand. Happy coding!</p><p><a href="https://github.com/nimahkh/soft_bun">https://github.com/nimahkh/soft_bun</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=73492fd1cf73" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/soft-bun-js-a-journey-into-reactivity-73492fd1cf73">Soft Bun JS: A Journey into Reactivity</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Containerizing Frontend: Enhancing Developer Experience and Real-time Updates (HMR Webpack)]]></title>
            <link>https://medium.com/codex/containerizing-frontend-enhancing-developer-experience-and-real-time-updates-hmr-webpack-ac1932baa519?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac1932baa519</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[containerization]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[frontend-development]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Mon, 22 May 2023 09:04:20 GMT</pubDate>
            <atom:updated>2023-05-22T20:46:22.383Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*tSvctaDwgVIqolEBqt8g2Q.jpeg" /></figure><p><em>Note: This containerization setup is intended for development purposes and is not suitable for production environments.</em></p><p>In the fast-paced world of web development, maintaining a consistent and reliable development environment is crucial for a smooth workflow. I recently embarked on a journey to containerize my project using Docker, and the results have been nothing short of remarkable. In this article, I will share my experience and the benefits of containerizing a Frontend project specifically for development purposes.</p><h3>Why Containerizing? Benefits for Developer Experience</h3><p>Containerization, with the help of tools like Docker, allows us to package our applications and their dependencies into isolated environments called containers. By containerizing our project, we create an environment that can be consistently replicated across different machines and operating systems. This brings several benefits to the developer experience:</p><ol><li><strong>Consistency</strong>: Containerization ensures that all developers working on the project have the same dependencies, configurations, and runtime environment. It eliminates the dreaded “works on my machine” scenario and promotes consistency across the team.</li><li><strong>Isolation</strong>: Each container provides a self-contained environment, isolated from the host system and other containers. This prevents conflicts between different projects and enables developers to experiment and make changes without impacting the stability of their local machines.</li><li><strong>Portability</strong>: With containers, we can easily move the entire development environment to different machines or share it with other team members. This eliminates the time-consuming setup process and reduces the onboarding time for new developers joining the project.</li><li><strong>Reproducibility</strong>: Containers ensure that the development environment remains consistent over time. Even as the project evolves, any team member can spin up the container and get the exact same environment that was used during development, enabling easier debugging and issue resolution.</li></ol><p>Now, let’s dive into the technical details of how I containerized my project using Docker.</p><h3>Explanation</h3><p>To containerize my project, I utilized a Dockerfile and a docker-compose.yml file. Let’s break down each part and understand their purpose and responsibilities.</p><h3>Dockerfile</h3><p>The Dockerfile is a blueprint that defines the steps required to build the Docker image for our project. Here’s a breakdown of the Dockerfile sections:</p><pre># Use an official Node.js runtime as the base image<br>FROM node:18<br># Set the working directory<br>WORKDIR /usr/src/app<br># Copy the package.json and package-lock.json to the working directory<br>COPY package*.json ./<br><br>COPY .npmrc .npmrc<br># Install the dependencies<br>RUN npm ci<br># Copy the rest of the application code to the working directory<br>COPY . .<br>EXPOSE 3000<br>CMD [&quot;npm&quot;, &quot;run&quot;, &quot;dev&quot;]</pre><p>The Dockerfile consists of the following sections:</p><ul><li><strong>Base Image</strong>: We start by specifying the base image we want to use, which is an official Node.js runtime in this case.</li><li><strong>Working Directory</strong>: We set the working directory inside the container where our application code will reside.</li><li><strong>Copy Dependencies</strong>: We copy the package.json and package-lock.json files to the working directory.</li><li><strong>Environment Variables</strong>: We set environment variables required for the build process and copy the .npmrc file for authentication or registry configurations.</li><li><strong>Dependency Installation</strong>: We run npm ci to install the project dependencies inside the container.</li><li><strong>Copy Application Code</strong>: We copy the remaining application code to the working directory in the container.</li><li><strong>Port Exposure</strong>: We expose port 3000 to allow communication with the Frontend development server running inside the container.</li><li><strong>Command Execution</strong>: The CMD instruction specifies the command to be executed when the container starts, which in this case is npm run dev.</li></ul><h3>docker-compose.yml</h3><p>The docker-compose.yml file defines a multi-container environment for our development setup. Let’s explore its contents:</p><pre>version: &quot;3.9&quot;<br>services:<br>  frontend:<br>    image: webpack<br>    build: .<br>    ports:<br>      - &quot;3000:3000&quot;<br>    environment:<br>      - CHOKIDAR_USEPOLLING=true<br>    restart: always<br>    tty: true<br>    stdin_open: true<br>    volumes:<br>      - .:/usr/src/app<br>      - node_modules:/usr/src/app/node_modules<br>      - ./webpack/.cache:/usr/src/app/webpack/.cache<br>      - ./usr/src/app:/bindmount:rw<br>    networks:<br>      - frontend-network<br>    command: npm run dev<br>volumes:<br>  node_modules:<br>  <br>networks:<br>  frontend-network</pre><p>The docker-compose.yml file defines a service called frontend, representing our project. Key sections include:</p><ul><li><strong>Base Image</strong>: The image field specifies the base image to use for the service. In this case, it references a custom image named webpack.</li><li><strong>Build Context</strong>: The build field specifies the build context for the service, indicating that Docker should build an image based on the instructions defined in the Dockerfile.</li><li><strong>Port Mapping</strong>: The ports section maps the host machine&#39;s port 3000 to the container&#39;s port 3000 for accessing the application.</li><li><strong>Environment Variables</strong>: The environment field sets environment variables specific to the service.</li><li><strong>Volumes</strong>: The volumes section creates data volumes and mounts them into the container, enabling live-reloading and preserving data between container restarts.</li><li><strong>Networks</strong>: The networks section allows specifying network configurations for the service.</li><li><strong>Command Execution</strong>: The command field specifies the command to be executed when the container starts, which in this case is npm run dev.</li></ul><p>The - ./webpack/.cache:/usr/src/app/webpack/.cache line in the volumes section of the docker-compose.yml file is responsible for creating a bind mount between the host machine and the container. Let&#39;s take a closer look at what this line does:</p><ul><li>- ./webpack/.cache refers to the directory on the host machine.</li><li>:/usr/src/app/webpack/.cache specifies the corresponding directory inside the container where the bind mount will be mounted.</li></ul><p>By creating this bind mount, any files or changes made in the ./webpack/.cache directory on the host machine will be reflected in the /usr/src/app/webpack/.cache directory inside the container, and vice versa.</p><p>The purpose of this bind mount is to cache webpack build artifacts. Webpack generates various files during the build process, and caching them can improve build performance. By persisting the cache between container runs, subsequent builds can benefit from the cached assets, reducing the time needed for compilation.</p><p>Using a bind mount for the webpack cache allows for efficient sharing and synchronization of the cache data between the host and the container. It ensures that the cache remains consistent and can be reused across different development sessions or container rebuilds.</p><p>Overall, the - ./webpack/.cache:/usr/src/app/webpack/.cache bind mount in the docker-compose.yml file helps optimize the build process by utilizing a shared cache directory between the host machine and the containerized project.</p><p><a href="https://webpack.js.org/configuration/cache/#cachecachelocation">https://webpack.js.org/configuration/cache/#cachecachelocation</a></p><h3>Overcoming Webpack HMR Communication Issue</h3><p>During the containerization process, I encountered a challenge related to Webpack’s Hot Module Replacement (HMR). Initially, HMR was not able to recompile the project after the initial build, preventing real-time updates in the development environment. This obstacle posed a significant hurdle to achieving a seamless development experience. However, through careful investigation and experimentation, I was able to identify a solution that resolved the issue.</p><p>The key to addressing the Webpack HMR communication problem lies in the configuration of the Docker networking. By default, Docker assigns IP addresses to containers dynamically. However, in some cases, this dynamic IP assignment can lead to compatibility issues with WebSocket connections, which are essential for HMR to function correctly.</p><p>To ensure proper communication between the Webpack HMR and the containerized project, I made a modification to the docker-compose.yml file. Specifically, I added the following lines under the networks section:</p><pre>networks:<br>  frontend-network:<br>    driver: bridge<br>    ipam:<br>      driver: default<br>      config:<br>        - subnet: 172.16.238.0/24</pre><p>By including the ipam section with a defined subnet, I ensured that the IP addresses assigned to the containers within the frontend-network are compatible with the requirements of Webpack HMR. This modification allowed HMR to function correctly, triggering recompilation and providing real-time updates during the development process.</p><p>It’s worth noting that the specific subnet 172.16.238.0/24 mentioned in the example can be adjusted as needed to avoid conflicts with other networks in your environment.</p><p>By overcoming this Webpack HMR communication issue, I was able to achieve a seamless development experience with real-time updates and enhanced productivity. It’s important to thoroughly investigate and experiment with potential solutions to overcome obstacles during the containerization process. This way, we can ensure a smooth and efficient development workflow for the entire team.</p><h3>Conclusion</h3><p>Containerizing our Frontend project for development purposes using Docker has transformed my development experience and provided numerous benefits. With containerization, I’ve achieved a consistent and reproducible environment that ensures all team members have the same setup. The isolated nature of containers prevents conflicts and allows for seamless collaboration and experimentation. Furthermore, the portability of containerized projects simplifies onboarding and sharing among team members.</p><p>By following the steps outlined in this article and utilizing the provided Dockerfile and docker-compose.yml, you can easily containerize your project and unlock a more efficient and enjoyable development workflow.</p><p>Give it a try, and embrace the power of containerization for your projects!</p><p>Happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac1932baa519" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/containerizing-frontend-enhancing-developer-experience-and-real-time-updates-hmr-webpack-ac1932baa519">Containerizing Frontend: Enhancing Developer Experience and Real-time Updates (HMR Webpack)</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unlocking Growth Through Continuous Discovery: A Practical Guide for Product Development]]></title>
            <link>https://medium.com/design-bootcamp/unlocking-growth-through-continuous-discovery-a-practical-guide-for-product-development-8522b3d8d379?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/8522b3d8d379</guid>
            <category><![CDATA[continuous-discovery]]></category>
            <category><![CDATA[agile-development]]></category>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Tue, 16 May 2023 22:59:18 GMT</pubDate>
            <atom:updated>2023-05-18T01:46:33.160Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/676/1*nrdGGfyXTWAGH9uy9cU4zQ.png" /></figure><p>In today’s fast-paced and competitive market, delivering successful products requires more than just churning out features and capabilities. It demands a deep understanding of user needs, a laser focus on outcomes, and a commitment to continuous learning and improvement. This is where the concept of continuous discovery emerges as a game-changer for product teams.</p><p>Continuous discovery is a mindset and a set of habits that prioritize user-centricity, data-driven decision-making, and iterative development. It shifts the emphasis from simply delivering outputs to delivering meaningful outcomes for both users and the business. By embracing continuous discovery, product teams can create products that not only meet user needs but also drive tangible results for the organization.</p><p>In this guide, inspired by the teachings of the book “<a href="https://amzn.eu/d/6nzrBtm">Continuous Delivery Habits,</a>” we will explore the world of continuous discovery and dive into the essential habits that underpin its success. By explaining the concepts, sections, and chapters in a smooth and understandable way, this guide aims to provide a solid foundation of knowledge for readers.</p><p><a href="https://amzn.eu/d/6nzrBtm">Continuous Discovery Habits: Discover Products that Create Customer Value and Business Value</a></p><p>It’s important to note that while this guide will cover key aspects and practical strategies of continuous discovery, it is not intended to replace the comprehensive insights and depth of knowledge found in the book itself. Reading the book “Continuous Delivery Habits” will provide a deeper understanding of the concepts and enable readers to fully grasp the nuances and intricacies of continuous discovery.</p><p>Part 1 of this guide will establish a solid foundation by explaining the what and why of continuous discovery. We will examine the critical distinction between output-driven and outcome-driven approaches and highlight the benefits of adopting continuous discovery as a core principle.</p><p>Part 2 will introduce the continuous discovery habits that enable outcome-driven product development. We will explore how to shift focus from outputs to outcomes, emphasizing the importance of identifying user jobs-to-be-done, defining desired outcomes, and developing outcome-based metrics. We will also discuss the significance of continuous validation and the role it plays in achieving the desired outcomes.</p><p>At the end of the article, we will provide an action plan: “Applying Continuous Discovery Habits.” This actionable framework will serve as a practical guide for readers to implement continuous discovery habits in their own product development processes. By following this plan, readers can take the knowledge gained from this guide and apply it effectively in their day-to-day work.</p><p>Whether you are a product manager, designer, engineer, or part of a cross-functional team, this guide, inspired by the teachings of the book “Continuous Delivery Habits,” will provide you with valuable insights and practical strategies to transform your product development approach. However, to fully grasp the depth and breadth of continuous discovery, we encourage readers to explore the book itself.</p><p>Get ready to embark on a journey that will revolutionize the way you approach product development. Let’s dive into the world of continuous discovery and unlock the power of outcome-driven innovation together!</p><p><strong>PART 1: WHAT IS CONTINUOUS DISCOVERY?</strong></p><p><strong>Chapter One</strong>: The What and Why of Continuous Discovery</p><p>In this chapter, we explore the fundamental concepts of continuous discovery and its significance in building successful products. We distinguish between output-driven and outcome-driven product development approaches, highlighting the importance of incorporating continuous discovery habits into the process.</p><p>Output-driven development focuses on delivering specific features or capabilities without considering their overall impact on users or the business. Success is measured based on the completion of work, rather than the outcomes achieved.</p><p>Contrarily, outcome-driven development centers around understanding user needs and designing products or services that help them achieve their goals. Success is measured by the impact on users and the business, as well as the attainment of desired outcomes. This approach necessitates continuous discovery, learning, and data-driven decision-making to understand user needs, validate assumptions, and deliver value.</p><p>In summary, output-driven development emphasizes delivering features, while outcome-driven development prioritizes delivering value to users and the business. Continuous discovery habits are vital in the outcome-driven approach, enabling teams to stay focused on desired outcomes, iterate rapidly, and fulfill user needs while achieving business objectives.</p><p><strong>PART 2: THE CONTINUOUS DISCOVERY HABITS Chapter Three:</strong> Focusing on Outcomes Over Outputs</p><p>The chapter argues that many product teams tend to be <strong>output-driven</strong>, focusing on delivering a set of features or capabilities, rather than being <strong>outcome-driven</strong>, focusing on delivering value to the user and the business.</p><p>To become outcome-driven, it is recommended that product teams:</p><ol><li><strong>Identify the user’s job to be done: </strong>start by understanding what job the user is trying to accomplish and what outcomes they are trying to achieve.</li><li><strong>Define the desired outcomes: </strong>define the desired outcomes for the user and the business, and use these outcomes to guide product development efforts.</li><li><strong>Develop outcome-based metrics: </strong>develop metrics that are tied to the desired outcomes and can be used to measure progress.</li><li><strong>Prioritize based on outcomes: </strong>prioritize opportunities based on their potential impact on the desired outcomes.</li><li><strong>Validate assumptions: </strong>use continuous discovery to validate assumptions about user needs and behavior and to iterate on the product until the desired outcomes are achieved.</li></ol><p>The chapter also stresses the importance of creating a culture of learning and experimentation within the team, where failure is seen as an opportunity to learn and improve. By focusing on outcomes rather than outputs, product teams can create products that are truly valuable to users and the business, and they can continuously learn and iterate to improve those products over time.</p><p><strong>Chapter Four:</strong> Visualizing What You Know</p><p>create a visual representation of what the product team knows about their users and their needs. This could involve creating a user persona or a user journey map that outlines the key characteristics, behaviors, and pain points of the user.</p><p>To create the user persona or user journey map, the product team could:</p><ol><li><strong>Conduct user research: </strong>gather data through user interviews, surveys, or other methods to understand user needs, pain points, and behaviors.</li><li><strong>Synthesize the data: </strong>analyze the data to identify patterns and insights that can be used to inform the persona or journey map.</li><li><strong>Create the persona or journey map: </strong>create a visual representation of the user’s characteristics, behaviors, and pain points, and how they interact with the product at different stages of their journey.</li><li><strong>Share the persona or journey map: </strong>share the persona or journey map with the rest of the team and stakeholders to ensure everyone has a clear understanding of the user’s needs and how they relate to the product.</li></ol><p>Creating a visual representation of what the product team knows about their users and their needs can help the team develop a shared understanding of the user and create empathy for their needs. It can also help the team identify opportunities for product improvement and prioritize product development efforts based on user needs.</p><p><strong>Chapter Five:</strong> Continuous Interviewing</p><p>By implementing a continuous interviewing practice, your team can stay connected with user needs, uncover pain points, and gather valuable insights that drive product improvements. It allows for ongoing learning and ensures that user feedback remains an integral part of your product development lifecycle.</p><ol><li><strong>Define the purpose and objectives:</strong> Clearly define the goals and objectives of the user interviews. Determine what specific insights you aim to gather and how they will inform your product decisions.</li><li><strong>Identify target users:</strong> Identify the specific user segments or personas that you want to interview. Determine the criteria for selecting participants who represent your target audience.</li><li><strong>Plan the interview format and questions:</strong> Decide on the interview format, whether it’s in-person, remote, or through other means like surveys or phone calls. Develop a set of interview questions that will help you gain the desired insights.</li><li><strong>Recruit participants:</strong> Recruit participants who match your target user criteria. Use a variety of methods, such as user research platforms, social media, or existing user databases, to find suitable participants.</li><li><strong>Conduct interviews:</strong> Schedule and conduct the interviews with the recruited participants. Follow the interview format and ask the prepared questions while also allowing for open-ended discussions. Take detailed notes or record the interviews (with participant consent) for later analysis.</li><li><strong>Analyze and synthesize insights:</strong> After the interviews, analyze and synthesize the collected data. Look for patterns, common themes, and recurring feedback to identify valuable insights. Use these insights to inform your product decisions and prioritize feature development.</li><li><strong>Iterate and repeat:</strong> Incorporate the learnings from the interviews into your product development process. Continuously iterate on your product based on user feedback, and schedule follow-up interviews to track changes in user needs and assess the impact of product updates.</li></ol><p><strong>Chapter Six:</strong> Mapping the Opportunity Space</p><p>By following these action items, you can effectively map the opportunity space, identify valuable opportunities, and align your product development efforts with user needs, market trends, and business objectives. This helps ensure that you are focused on the right areas for innovation and growth.</p><ol><li><strong>Identify relevant stakeholders:</strong> Identify the key stakeholders who should be involved in the opportunity mapping process. This may include team members from different departments, subject matter experts, or representatives from customer-facing roles.</li><li><strong>Gather data and insights:</strong> Collect relevant data and insights about your target market, industry trends, customer feedback, and competitive landscape. Conduct user research, market analysis, and gather internal knowledge to inform the opportunity mapping process.</li><li><strong>Create an opportunity map template:</strong> Develop a visual template or framework that will serve as the foundation for mapping the opportunity space. This could be a canvas, diagram, or any other format that helps organize information and visualize the different dimensions of opportunities.</li><li><strong>Define opportunity dimensions:</strong> Identify the key dimensions or factors that contribute to opportunities in your specific context. These dimensions may vary depending on your industry, product, or market. Common dimensions may include user needs, pain points, market gaps, emerging technologies, regulatory changes, or business objectives.</li><li><strong>Populate the opportunity map:</strong> Collaboratively populate the opportunity map with the relevant information gathered from research and stakeholder input. Consider using sticky notes, digital tools, or visual software to capture and organize ideas and insights.</li><li><strong>Analyze and prioritize opportunities:</strong> Analyze the populated opportunity map and identify the most promising and high-impact opportunities. Consider the alignment with strategic goals, potential user value, feasibility, and business impact when prioritizing opportunities.</li><li><strong>Validate assumptions and refine the map:</strong> Continuously validate assumptions and refine the opportunity map based on user feedback, market dynamics, and ongoing research. Iterate on the map to reflect new insights and evolving priorities.</li><li><strong>Communicate and socialize the opportunity map:</strong> Share the opportunity map with the relevant stakeholders to ensure alignment and create a shared understanding of the identified opportunities. Present the map in a visually appealing and engaging manner to facilitate discussion and collaboration.</li><li><strong>Incorporate opportunities into product planning:</strong> Use the opportunity map to inform product planning and decision-making processes. Integrate the identified opportunities into your roadmap, backlog, or other product management tools to guide future development efforts.</li></ol><p><strong>Chapter Seven:</strong> Prioritizing Opportunities, Not Solutions</p><p>By following these action items, you can establish a systematic approach to prioritize opportunities based on their potential impact and alignment with user needs and business goals. This ensures that your product development efforts are focused on the most valuable opportunities and increases the likelihood of delivering meaningful outcomes to your users and business.</p><ol><li><strong>Review the opportunity map:</strong> Start by reviewing the opportunity map created in Chapter Six. Ensure that it includes a comprehensive list of opportunities based on user needs, market trends, and business objectives.</li><li><strong>Define prioritization criteria:</strong> Determine the criteria that will be used to evaluate and prioritize opportunities. These criteria can include factors such as potential impact on user value, alignment with business goals, technical feasibility, market demand, and resource requirements.</li><li><strong>Conduct a collaborative prioritization session:</strong> Facilitate a collaborative session with key stakeholders, such as product managers, designers, developers, and relevant business stakeholders. Present the opportunity map and guide the group through a discussion to collectively prioritize the opportunities.</li><li><strong>Use a prioritization framework:</strong> Consider using a prioritization framework or technique, such as the MoSCoW method (Must-Have, Should-Have, Could-Have, Won’t-Have), the ICE method (Impact, Confidence, Effort), or a value-vs-effort matrix. Apply the chosen framework to assess and rank the opportunities based on the defined criteria.</li><li><strong>Evaluate dependencies and constraints:</strong> Take into account any dependencies or constraints that may impact the prioritization of opportunities. Consider technical dependencies, resource availability, market timing, or any other relevant constraints that may affect the feasibility and implementation of certain opportunities.</li><li><strong>Validate assumptions and gather feedback:</strong> Continuously validate assumptions associated with the prioritized opportunities. Seek user feedback, conduct further research, or run experiments to gain insights that can help refine the prioritization and ensure its alignment with user needs and expectations.</li><li><strong>Document and communicate the prioritized opportunities:</strong> Document the prioritized opportunities and the rationale behind their ranking. Clearly communicate the priorities to the entire team and relevant stakeholders to ensure shared understanding and alignment.</li><li><strong>Adjust and update prioritization regularly:</strong> Recognize that priorities can evolve over time. Continuously reassess and update the prioritization as new information becomes available, market conditions change, or user needs evolve.</li></ol><p><strong>Chapter Eight:</strong> Supercharged Ideation</p><ol><li>Conduct collaborative ideation sessions: Organize brainstorming sessions with cross-functional team members to generate a wide range of ideas and potential solutions.</li><li>Create an ideation framework: Develop a structured framework or method to guide the ideation process and ensure that all relevant perspectives are considered.</li><li>Encourage wild ideas and diverse thinking: Foster an environment where team members feel comfortable sharing unconventional or “out-of-the-box” ideas, allowing for creative solutions to emerge.</li><li>Prioritize and refine ideas: Evaluate and prioritize the generated ideas based on predefined criteria and feasibility. Refine the selected ideas to enhance their potential impact and align them with user needs.</li></ol><p><strong>Chapter Nine:</strong> Identifying Hidden Assumptions</p><ol><li>Identify assumptions: Make a list of assumptions underlying the current product or potential solutions. These assumptions could be related to user behavior, market conditions, or technological constraints.</li><li>Question and challenge assumptions: Facilitate discussions and critical thinking exercises to question and challenge the identified assumptions. Encourage the team to consider alternative perspectives and gather evidence to validate or invalidate the assumptions.</li><li>Prioritize high-risk assumptions: Identify the assumptions that carry the highest risks or uncertainties. Focus efforts on testing and validating these assumptions to reduce the overall risk associated with the product development process.</li><li>Design experiments to validate assumptions: Develop experiments or research activities to gather data and insights that can either confirm or disprove the identified assumptions. Use qualitative and quantitative research methods to gain a deeper understanding of user behavior and validate assumptions.</li></ol><p><strong>Chapter Ten:</strong> Testing Assumptions, Not Ideas</p><ol><li>Define testable hypotheses: Clearly articulate the assumptions as testable hypotheses. Formulate them in a way that allows for specific and measurable validation.</li><li>Design and conduct experiments: Develop experiments or tests to validate the hypotheses and collect data. Utilize techniques such as A/B testing, user interviews, surveys, or prototype testing to gather evidence and insights.</li><li>Analyze and interpret results: Analyze the data collected from the experiments and interpret the findings. Determine whether the assumptions were validated, invalidated, or require further testing and iteration.</li><li>Iterate based on insights: Use the insights gained from testing assumptions to inform the next steps in the product development process. Iterate on the product, features, or solutions based on the validated assumptions and user feedback.</li></ol><p><strong>Chapter Eleven:</strong> Measuring Impact</p><ol><li>Define key metrics and goals: Determine the key metrics that align with the desired outcomes identified earlier in the continuous discovery process. Set clear goals for each metric to measure the impact of the product or feature.</li><li>Establish measurement mechanisms: Implement systems or tools to track and collect relevant data to measure the identified metrics. Ensure data integrity and accuracy by setting up proper tracking and measurement processes.</li><li>Regularly analyze and review data: Continuously analyze the collected data to assess the impact of the product or feature. Review the metrics against the established goals and identify areas of success or areas that require improvement.</li><li>Use data-driven insights for decision-making: Utilize the data and insights obtained from the measurement process to make informed decisions about future product iterations, improvements, or pivots. Leverage the data to support prioritization and resource allocation.</li></ol><p><strong>Chapter Twelve:</strong> Managing the Cycles</p><ol><li>Implement iterative development cycles: Establish a framework for iterative development cycles, such as Agile or Lean methodologies. Define the key stages and activities within each cycle, including planning, execution, feedback collection, and iteration.</li><li>Set realistic timeframes and goals: Determine appropriate timeframes for each development cycle that allow for meaningful progress and iteration. Set clear goals for each cycle that align with the overall product vision and desired outcomes.</li><li>Foster collaboration and communication: Encourage</li></ol><p>effective collaboration and communication among team members throughout the development cycles. Facilitate regular stand-up meetings, retrospectives, and feedback sessions to ensure alignment and continuous improvement. 4. Monitor and adapt: Continuously monitor the progress and performance of each development cycle. Collect feedback from team members and stakeholders, and make necessary adjustments to optimize the cycles for better outcomes.</p><p><strong>Chapter Thirteen:</strong> Show Your Work</p><ol><li>Establish a culture of transparency: Foster a culture where sharing work and progress is encouraged and valued. Create an environment where team members feel comfortable sharing their work, insights, and challenges openly.</li><li>Showcase ongoing efforts: Regularly share updates on the progress, learnings, and results of the product development efforts with stakeholders and the broader organization. Use various channels such as demos, presentations, reports, or internal communication platforms to showcase the work.</li><li>Seek feedback and collaboration: Actively seek feedback from stakeholders, users, and other teams. Engage in discussions, gather insights, and collaborate on refining and improving the work based on the received feedback.</li><li>Encourage learning and knowledge sharing: Promote a learning culture by encouraging team members to share their knowledge, experiences, and lessons learned. Facilitate knowledge-sharing sessions, workshops, or internal resources to disseminate valuable insights across the team and the organization.</li></ol><p><strong>PART 3: DEVELOPING YOUR CONTINUOUS DISCOVERY HABITS Chapter Fourteen:</strong> Start Small, and Iterate</p><ol><li>Break down initiatives into smaller increments: Decompose larger initiatives or features into smaller, manageable increments. Start with a minimum viable product (MVP) or a basic version that fulfills core user needs and iteratively build upon it.</li><li>Collect user feedback early: Release the initial version or increments to a limited set of users and gather their feedback. Incorporate user insights and iterate on subsequent versions based on the feedback received.</li><li>Embrace an iterative mindset: Encourage team members to adopt an iterative approach to development, recognizing that it’s an ongoing process of learning and improvement. Emphasize the value of quick iterations, feedback loops, and continuous learning.</li><li>Continuously refine and expand: Use the feedback and insights gathered from users to refine and expand the product or feature. Iterate on the solution based on user needs and emerging opportunities, gradually improving and expanding its functionality.</li></ol><p>By implementing these action items, you can effectively apply the principles and practices outlined in each chapter, enabling continuous discovery and improvement within your product development process.</p><h3>Action Plan: Applying Continuous Discovery Habits</h3><p>Let’s say you are a product manager working on a mobile banking app. You want to apply the continuous discovery habits to improve the app’s user experience and drive business growth.</p><ol><li>Identify the user’s job to be done: Start by understanding what job the users are trying to accomplish with the mobile banking app. Conduct user research, interviews, and surveys to gather insights into their needs, pain points, and goals. For example, users may want to easily check their account balance, transfer funds, or pay bills.</li><li>Define the desired outcomes: Based on the user research, define the desired outcomes for both the users and the business. For instance, one desired outcome could be to increase user engagement and satisfaction by improving the app’s usability and simplifying common tasks.</li><li>Develop outcome-based metrics: Develop metrics that are tied to the desired outcomes. For the example mentioned earlier, metrics could include user engagement metrics like the number of active users, frequency of app usage, and user satisfaction ratings.</li><li>Prioritize based on outcomes: Prioritize product development opportunities based on their potential impact on the desired outcomes. For example, if improving the account balance checking feature aligns with the desired outcomes, prioritize that over other less impactful features.</li><li>Validate assumptions: Use continuous discovery techniques to validate assumptions about user needs and behavior. Conduct usability tests, gather feedback through user interviews or surveys, and iterate on the product until the desired outcomes are achieved. For instance, conduct user interviews to understand how users currently check their account balance and identify any pain points or areas for improvement.</li></ol><p>By following these continuous discovery habits, you can drive the iterative development of the mobile banking app, focus on delivering outcomes for users, and achieve business objectives. Remember to continuously learn from user feedback, analyze metrics, and iterate on the product to ensure it meets user needs and drives tangible results.</p><h3>Conclusion</h3><p>In conclusion, continuous discovery is a transformative approach to product development that puts users at the center and focuses on delivering meaningful outcomes. Throughout this guide, we have explored the essential habits that underpin continuous discovery, drawing inspiration from the teachings of the book “Continuous Delivery Habits.”</p><p>While this guide has provided valuable insights and practical strategies, it is important to remember that continuous discovery is a vast and dynamic field. To fully grasp its intricacies and unlock its full potential, we encourage you to delve deeper into the subject matter by reading the book “Continuous Delivery Habits.” By doing so, you will gain a comprehensive understanding of the concepts, methodologies, and real-world examples that can further enhance your continuous discovery journey.</p><p>As you continue your product development endeavors, we hope that the knowledge and insights shared in this guide will serve as a solid foundation for integrating continuous discovery habits into your workflow. Remember to prioritize user-centricity, data-driven decision-making, and iterative development. Embrace the mindset of continuous learning and improvement, and foster a culture that values outcomes over outputs.</p><p>Thank you for joining me on this journey into the world of continuous discovery. I hope that this guide has inspired you to think differently about product development and equipped you with the tools and knowledge to create remarkable products that truly resonate with users. Embrace the power of continuous discovery, and let it fuel your pursuit of innovation and success.</p><p>Here’s to a future of user-centric, outcome-driven product development. Happy discovering!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8522b3d8d379" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/unlocking-growth-through-continuous-discovery-a-practical-guide-for-product-development-8522b3d8d379">Unlocking Growth Through Continuous Discovery: A Practical Guide for Product Development</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Separating Monolith Laravel + VueJS to Backend and Frontend with Webpack5]]></title>
            <link>https://medium.com/codex/separating-monolith-laravel-vuejs-to-backend-and-frontend-with-webpack5-e34956b936d1?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/e34956b936d1</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[webpack]]></category>
            <category><![CDATA[monolithic-architecture]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Wed, 04 May 2022 12:59:27 GMT</pubDate>
            <atom:updated>2022-05-09T09:12:08.820Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cf0-o8wAHSSV31xLyxXGSQ.png" /><figcaption>Decoupling Monolith to Backend — Frontend</figcaption></figure><p>We in <a href="https://trengo.com/">Trengo</a> decided to decouple the Monolith architecture into Backend and Frontend and I was honored to do so. For sure it depends on the project potential, I believe it is useful to know how we discovered the rabbit holes and how you can solve them.<br>I am Nima and welcome to my blog.</p><h3>The problem</h3><p>It is up to you and your team structure to work on a Monolith architecture or a Backend Frontend or Microfrontend, etc… I am not going to explain the pros and cons, but if you decided to separate your Laravel+Vuejs Monolith into backend and frontend, it would be a good article for you.<br>If you have a Monolith architecture, probably you have a Monorepo that would cause chaos in big teams. Having your separate repository would be very helpful from the CI/CD and technical perspectives.</p><h3>Solutions</h3><p>The first phrase that you will search is “<a href="https://laracasts.com/discuss/channels/laravel/can-i-completely-separate-vuejs-front-end-to-laravel-back-end">Can I completely separate Vue.js Front-end to Laravel Back-end</a>” which the answer is “Yes”, but how?<br>We found four solutions:<br>Separating with <strong>Webpack5</strong> — Separating with Vite — Separating with <strong>Webpack4</strong> — Separating with<strong> Laravel-mix</strong> itself.<br>There are pros and cons here, I will explain why we choose Webpack5, but it is totally up to you.</p><h4>Laravel-mix</h4><p>It is useless to separate the Monolith architecture with Laravel-mix when we are not going to use most of the features in it. Laravel-Mix is very powerful only if you are going to have a Monolith app with Laravel. A lot of Webpack configuration, which is very time-consuming to configure, also you can not upgrade your Webpack version from 4 to 5 or 5 to 6 in the future by yourself till the Laravel-Mix gives updates which means you can not be updated with the latest technologies.</p><h4><strong>Webpack4</strong></h4><p>Webpack is a good solution to replace it with Laravel-Mix, but which version? as Webpack said, always try to use the latest version if you want to have a performed application. Webpack 4 has too much interference with new technologies such as module federation, a conflict between sass-loader@11.0.0 and vue@2.6.12 that will throw this.getOptions() the error that is handled in Webpack 5, etc… If you care about application updates, I would highly recommend choosing other options.</p><h4>Vite</h4><p>Maybe you heard about <a href="https://vitejs.dev/">Vite</a>,</p><blockquote>Vite is a build tool that aims to provide a faster and leaner development experience for modern web projects</blockquote><p>I have had good experiences with Vite, it helped me a lot to configure my application with fewer efforts. but why did we not choose it for our Vue project?</p><blockquote>Caution: if you have a list of routes in .js it will try to build all the routes in develop mode, depending on your project it would take a lot of minutes.</blockquote><p>Vite is not mature yet and you can not count on it in production mode (2022). you can not be denied the Vite performance, but also for legacy codes and structures, you will face some bigger issues. If you want to enjoy its power, it would be a good tip to use dynamic import to help code splitting and SplitChunk more.<br>Whereas the Vite is so powerful, it was not suitable for our project and legacy structure, but if I want to embark on a new project from scratch, definitely I will use Vite.</p><h3>Webpack 5</h3><p>It is very gratifying there is a wide variety of libraries to choose from. Webpack 5 is the best library based on our project, a big project with a lot of configuration on Laravel-Mix which needs to migrate to the new bundler.<br>We will not have any problem with PostCss or bundling the router.js, of course, the Webpack HMR ( Hot module Reload ) is not very fast as it is using the socket.js to make it real-time, but I will show you that it is two times faster than Laravel-Mix 5.</p><h3>Step by Step</h3><p>It is time to dive into the code and find the rabbit holes. First of all, we have to find all the challenges to find a solution for them. I will list some possibilities based on my experience.</p><h4>I am using Laravel routes instead of REST</h4><p>I would highly recommend migrating to REST at first, it is the most important part of the migration. E.g. We have a ‘/authenticate/login’ route that handles the user login process, in this case, the best approach is to migrate it into ‘/api/authenticate/login’ that will accept JSON parameters and will respond to JSON as well. if your entire application is not in REST, so let’s create a refactor card in your task management system with a “critical” badge.</p><h4>I have an “index.blade.php” instead of index.html</h4><p>We will handle it later with Webpack, the only thing is to copy/paste the entire file into a new index.html, that is it, let Webpack handle it.</p><h4>How to handle environments?</h4><p>All the “env” variables will change from “import.meta.EnvName” into “process.env.EnvName” which means we have to replace all of them and also create a “.env” file in the root of the project with desired variables.</p><h4>What about the “import” method?</h4><p>Only replace “import(…).default’ with ‘require(…).default’.</p><h4>Will our codebase change?</h4><p>Of course not, if you have a standard code base, you will have no issue.</p><h3>How to configure Webpack5 on Vuejs 2?</h3><p>It is pretty straightforward, I would highly recommend decoupling “development” and “production” configurations, like that you will have better dominance over each environment configuration. It is very usual to have a conflict between these two env.<br>Let’s start by creating a new directory named your application (E.g myapp ) and create the directory structure as below:</p><pre>.<br>|-- README.md<br>|-- package.json<br>|-- public<br>|-- src<br>-- webpack<br>    |-- paths.js<br>    |-- webpack.common.js<br>    |-- webpack.config.dev.js<br>    `-- webpack.config.prod.js</pre><p>It is time to install dependencies.</p><pre>npm i -D @webpack-cli/serve clean-webpack-plugin compression-webpack-plugin copy-webpack-plugin css-minimizer-webpack-plugin dotenv-webpack html-webpack-plugin optimize-css-assets-webpack-plugin speed-measure-webpack-plugin terser-webpack-plugin webpack webpack-bundle-analyzer webpack-cli webpack-dev-server webpack-hot-middleware webpack-merge css-loader vue-loader esbuild-loader </pre><p>I tried to install all the devDependencies, if some of them were not installed, we will do it further. <br>Now let’s see what “webpack.common.js” looks like.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/423f019bda089d9a491bbfb17beb30a1/href">https://medium.com/media/423f019bda089d9a491bbfb17beb30a1/href</a></iframe><p>It is too long, yes, I know, I am not going to explain loaders as you can find them in Medium or their Git repositories, for this reason, I tried to put comments if it was necessary, but let’s do a quick recap.</p><p><strong>SpeedMeasurePlugin</strong>: This plugin will help us to measure Webpack performance. It is so useful to find out which loader has a lack of performance. we should wrap it around our configuration.</p><p><strong>Entry</strong>: The entry should address the main javascript file which is running the Vuejs application.</p><p><strong>ProvidePlugin</strong>:</p><blockquote>Automatically load modules instead of having to import or require them everywhere.</blockquote><p>If you are working with an underscore library like “lodash” or “Jquery” which has a special syntax that is not ordinary for Webpack and is not imported inside the files, you have to provide them inside this plugin.</p><p><strong>CopyWebpackPlugin</strong>: This plugin is so useful for us because we have the “public” folder from “Laravel” and we will need it after decoupling. As you know, Laravel-mix has been connected ‘public’ to the “Vuejs” application. Because of that, after the migration, none of the images or any assets will load correctly, because Webpack has no access to the “public” folder ( out of the folder scope ), this plugin will try to make this connection.</p><p><strong>ESBuild</strong>: It is time to replace the babel-loader with ES-build to speed up our Webpack build. no more explanation, let’s read the documentation: <a href="https://github.com/privatenumber/esbuild-loader">https://github.com/privatenumber/esbuild-loader</a></p><p>We are good now, let’s build up the development. it is so simple.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4e52ea2ae3b3270009404fc013bde8d1/href">https://medium.com/media/4e52ea2ae3b3270009404fc013bde8d1/href</a></iframe><p>As it is so simple, I just want to explain HotModuleReplacementPlugin and source-map.</p><p><strong>HotModuleReplacementPlugin</strong>: Or HMR is a plugin that will reload the page anytime we save our changes in IDE, the benefit related to other watchers is state persistence which means your states will persist after each reloads as the plugin will reload only the specific and related DOM.</p><p><strong>devtool</strong>: Perhaps it is not so clear at first. Let’s see what Devtool is inside the Webpack documentation.</p><blockquote>The source-map-loader extracts existing source maps from all JavaScript entries. This includes both inline source maps as well as those linked via URL. All source map data is passed to webpack for processing as per a chosen <a href="https://webpack.js.org/configuration/devtool/">source map style</a> specified by the devtool option in <a href="https://webpack.js.org/configuration/">webpack.config.js</a>.</blockquote><p>The most used would be debugging the code in the browser, source-maps are not transpile yet and you can see your Vuejs codes in them to find which part has a bug. as it will reduce the performance, the best practice is to keep it only in development mode. you can find a list of different source-maps here: <a href="https://webpack.js.org/configuration/devtool/">https://webpack.js.org/configuration/devtool/</a></p><p>I prefer to use “inline-source-map” which will give me enough details and will increase my build and rebuild time in development mode.</p><p>So exciting for production? so let’s go.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/170df6549fad84cdb934b74b365b41ae/href">https://medium.com/media/170df6549fad84cdb934b74b365b41ae/href</a></iframe><p>At first, you will see that devtool is false, it does make sense to not provide the debuggable version in production as it will increase the bundle size, build time, and also the client will not need it.</p><p><strong>splitChunks</strong>:In the optimization phase, we are using splitChunks which is increasing the performance too much by splitting the bundle into separated modules, <a href="https://webpack.js.org/plugins/split-chunks-plugin/">https://webpack.js.org/plugins/split-chunks-plugin/</a></p><p><strong>TerserPlugin</strong>: Anybody knows the Terser plugin affects the performance, Terser is using a lot of algorithms to minify the javascript code into the most minified version as much as possible. <a href="https://webpack.js.org/plugins/terser-webpack-plugin/">https://webpack.js.org/plugins/terser-webpack-plugin/</a></p><p>The only thing that remains, is paths.js</p><pre>const paths = require(&#39;path&#39;)<br><br>module.exports = {<br>// Source files<br>src: paths.resolve(__dirname, &#39;../src&#39;),<br><br>// Production build files<br>build: paths.resolve(__dirname, &#39;../dist&#39;),<br><br>// Static files that get copied to build folder<br>public: paths.resolve(__dirname, &#39;../public&#39;),<br>}</pre><p>It is too simple and needs no explanation. 😄</p><p>Mostly done, let&#39;s modify our package.json</p><pre>&quot;scripts&quot;: {<br>  &quot;dev&quot;: &quot;webpack server --mode=development --config ./webpack/webpack.config.dev.js&quot;,<br>  &quot;build&quot;: &quot;webpack --mode=production --config ./webpack/webpack.config.prod.js&quot;,<br>  &quot;serve:dev&quot;: &quot;pm2 start ecosystem.config.js --env development&quot;,<br>  &quot;serve:prod&quot;: &quot;pm2 start ecosystem.config.js --env production&quot;<br>},</pre><p>It is so clear, only I want to explain the “serve:dev and prod”. I prefer to use PM2 as our process manager, if you are not familiar with it, I would highly recommend taking a look at its documentation: <a href="https://pm2.keymetrics.io/">https://pm2.keymetrics.io/.</a> the “ecosystem.config.js” is the main configuration file or PM2 to define different behaviours on production or development, you can check the built project on your local machine by running “serve:dev” and it is actually the same as the production, it is very important to try to make both dev and production environment same to decrease bugs.</p><p><strong>ecosystem.config.js</strong></p><pre>module.exports = {<br>    script: &#39;serve&#39;,<br>env_development: {<br>    NODE_ENV: &#39;development&#39;,<br>    PM2_SERVE_PATH: &#39;./dist&#39;,<br>    PM2_SERVE_PORT: 3000,<br>    PM2_SERVE_SPA: &#39;true&#39;,<br>},<br>env_production: {<br>    NODE_ENV: &#39;production&#39;,<br>    PM2_SERVE_PATH: &#39;./dist&#39;,<br>    PM2_SERVE_PORT: 8080,<br>    PM2_SERVE_SPA: &#39;true&#39;,<br>},<br>deploy: {<br>        development: {<br>          host: [&#39;localhost&#39;, &#39;127.0.0.1&#39;],<br>        },<br>        production: {<br>          host: [&#39;production.domain&#39;, &#39;production IPAddress&#39;],<br>        },<br>    },<br>};</pre><h3>Time to deal with numbers</h3><p>Now it is time to review the benchmark of the new Webpack configuration with the current Laravel-mix project. Of course, it is related to your project. These benchmarks are related to a big project with a lot of files.</p><p><strong>Laravel Mix Build time — 3.30 minutes</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tP7frhYzI6Td2W_4fSBqrA.png" /></figure><p><strong>Webpack5 Build time — 1.9461 minutes</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pYi-fpVLsVJKo3cRbHpGTQ.png" /></figure><p>You can see it is almost two times faster. but <strong>it is not</strong> the only benchmark, I have another interesting benchmark on running tests</p><p><strong>Laravel-mix — 6.44 second</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JQDB7_sfSUHLW-RliVDUcA.png" /></figure><p><strong>Webpack 5–3.318 seconds</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g7wV37a1yL5POOGe-FibSQ.png" /></figure><p>The result is the same as above. we experienced better performance in Trengo which these changes.</p><h3>Conclusion</h3><p>Choosing the best module bundler is dependent on your project, there is no specific recipe to increase your project performance, for some projects, Laravel-mix is the best, or maybe Vite. The most important thing is to know your projects and the rabbit holes inside them. For E.g. in the Laravel Monolith project if you are using direct routers like: ‘authenticate/forget-password’ you have to change it to a REST API, and handle everything with JWT or other encryptions.</p><p><strong>One important thing</strong> is to copy the whole entire master.blade.php to “public/index.html” inside the new structure which is the main HTML template.<br>There is no other thing to mention, enjoy your coding 😉</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e34956b936d1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/separating-monolith-laravel-vuejs-to-backend-and-frontend-with-webpack5-e34956b936d1">Separating Monolith Laravel + VueJS to Backend and Frontend with Webpack5</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Am I a senior Front-End developer?]]></title>
            <link>https://medium.com/codex/am-i-a-senior-front-end-developer-6596142bf647?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/6596142bf647</guid>
            <category><![CDATA[soft-skills]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[hard-skills]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Sat, 02 Apr 2022 19:20:03 GMT</pubDate>
            <atom:updated>2022-04-07T12:05:38.169Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rXIk5c8EWv_C2-52q_zr_Q.jpeg" /></figure><p>Hello everybody, I am Nima a Front-end developer on Trengo.com.<br>I want to share with you my experiences with the Seniority level, it does not mean that I am (not) a Senior developer, but I found the path somewhat good. let me explain the path.</p><h3>How can we evaluate our seniority level?</h3><h3>A true story</h3><p>Let me start with a true story about the past when I experienced being a CTO in 2012, it was my first official role in a company. before that, I was a freelancer, without any teamwork experience. Bad experiences will give you good insights into the future. I was 21 and the company had no technical team till that day, I had this opportunity to convince them that I am a good developer, I was a Java and PHP developer at that time, and in my opinion, it was a reason why they convinced with my skills. There was no technical guy to interview me. I can say that I was the first technical person in the team that could interview others that were better than me. At that time I understood, that my seniority level would evaluate by the company level. It was not a good choice for me to be a CTO and that was the reason the candidates were better than me. Some years further I went to an interview as a candidate and it was so funny, they rejected me because my level was more than a senior developer, but it wasn’t, the interviewer had a wrong attitude. So you can not be sure that you are a Senior developer everywhere, there are a lot of factors that influence the seniority level.</p><h3>Interviewer influences</h3><p>This is a term I came up with. Company decisions are very effective, you need to be sure there is a person that is better than you ( not even the same as you ) if you want to evaluate our seniority level. At most interviews, you will know the name of the interviewer, it would be helpful if you look at her/his Linkedin page.</p><h3>Hard skills</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nD8V1oSZ5BLQTMwccsOK6A.jpeg" /></figure><p>As you can guess, “Hard skills” are very important, IMO it is half of the way.<br>Hard skills are learned abilities acquired and enhanced through practice, repetition, and education. Hard skills are essential because they increase employee productivity and efficiency and subsequently improve employee satisfaction. “<a href="https://www.investopedia.com/terms/h/hard-skills.asp#:~:text=Hard%20skills%20are%20learned%20abilities,and%20subsequently%20improve%20employee%20satisfaction.">investopedia</a>“.<br>Hard skills can be a good indicator of being a senior. who has more abilities, would have the chance to evaluate as a Senior in the company. At most, developers misunderstood the meaning of “more abilities”, usually the interviewer will count the skills that you have mastery on them, not a bunch of skills that you are a beginner in them. so be careful about what you are writing in your CV.</p><h4>How can I improve my “Hard skills”?</h4><p>I would highly recommend you to pass “Udemy” and “Frontend masters” courses and define your project on Github by what has been learned. It would be the start, having mastery of design patterns, algorithms, problem-solving ( you can try <a href="https://leetcode.com/">https://leetcode.com/</a> ), implementing pixel-perfect designs, delivering implementation with fewer bugs, software design approaches, and writing tests are the factors that will distinguish you from the others. What I want to mention is don’t look for many programming languages, languages are only tools, you need to know concepts and knowledge of software engineering.<br>As there are tons of resources to learn from, it is difficult to choose the best one, it depends on the developer&#39;s seniority level, you have to find out what is the question exactly? <br>Let’s start with some fundamental examples:</p><p><strong>Fundamental problems (Level 1):</strong><br><strong>E.g:</strong> How can I pass the value from a Vue child component to the parent? <br>These kinds of problems are related to the fundamentals, you have to pass basic courses or read the Vuejs documentation at first. <br><strong>Note</strong>: When you buy a vacuum cleaner, you have to read the manual and documentation before starting, otherwise, you will face some problems. so keep in mind, being a software engineer, is harder than working with a vacuum cleaner ;)</p><p><strong>Level 2 problems: </strong><br><strong>E.g:</strong> Needs to create a React native bottom sheet with Typescript.<br>There are multiple plugins and tools to create a nice React native bottom sheet. are all of them useful and will cover your needs? <strong>of course not</strong>, so you need to know how are they working, then you can write your “bottom sheet” with Typescript. To start, you can read the Github source, ( this is a famous one: <a href="https://github.com/gorhom/react-native-bottom-sheet">https://github.com/gorhom/react-native-bottom-sheet</a> ). <br>Video and courses are not useful to solve these kinds of problems as you need to customize your solution.</p><p><strong>Level 3 problems: <br>E.g:</strong> How to implement Microfrontend with Vite and Svelte in best practice?<br>This is a programming deep challenge ( architecture problems ), you need to read related and technical books or articles, also I would highly recommend you to have a mentor that can guide you with best practices. <br><strong>Note: </strong>One mentor can not help you with everything, it is better to have a mentor for every specific section.</p><h3>Soft skills</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/1*v2ejP5agZK86JqwtR-Y4JA.jpeg" /></figure><p><strong>“Soft skills</strong>, also known as <strong>common skills</strong> or <strong>core skills</strong>, are skills able in all professions. These include critical thinking, problem-solving, public speaking, professional writing, teamwork, digital literacy, leadership, professional attitude, work ethic, career management, and intercultural fluency. This is in contrast to hard skills, which are specific to individual professions.” <a href="https://en.wikipedia.org/wiki/Soft_skills">Wikipedia</a><br>As the “soft skill” is a wide knowledge I just can share my experiences with you about them.<br>These are some titles that you have to be an expert on it: Teamwork, leadership, professional attitude, and public speaking are the most important things. <br><strong>Teamwork</strong>: Having good collaboration in projects, meetings and other stuff in the team is a big point.</p><p><strong>How can you improve it? <br>- </strong>Do not hesitate to ask questions.<br>- Ask your colleagues’ strength to help you with problems.<br>- Clarify the tasks and organize meetings for this purpose. <br>- Organize pair programming sessions with your colleagues.</p><p><strong>Digital literacy</strong>:<br>Don’t be afraid to use new technologies, it does not mean experiencing new programming languages ( Do not switch between languages too much), it means increasing your knowledge to use new tools and courage to work with new frameworks/libraries/architecture/techniques to increase your confidence.</p><p><strong>Leadership</strong>:<br>There are 9 famous steps to improve your leadership skills, let’s take a look at them together. <br>- <strong>Practice discipline: </strong><br>A good leader has good discipline, If you are naturally disordered, you may shorten your workload.<br>- <strong>Take on more projects:</strong> <br>having more responsibility would help you to be more disciplined.<br>- <strong>Learn to follow:<br></strong>A true leader has no problem transferring control to another person if necessary, try to be transparent with your team.<br>- <strong>Develop situational awareness:</strong> <br>A good leader could see big problems before they occur, it will help others to trust you more.<br>- <strong>Inspire others</strong>: <br>Inspiration is one of the most important things that makes you a good leader, a good leader tries to encourage the team to learn more and be more energetic.<br>- <strong>Keep learning: <br></strong>You have to be the most up-to-date on the team. No matter how good you are at coding, try to stay up to date and enhance your experience.<br>- <strong>Resolve conflicts: <br></strong>Every team has a lot of conflicts due to different cultures and personalities, a good leader can resolve these types of conflicts in the team.<br>- <strong>Be a discerning listener.</strong><br>- <strong>Empower your teammates.</strong></p><p>If you like to improve your leadership skills, highly recommend you to read some self-help books like <strong>How to Win Friends and Influence People</strong> by <strong>Dale Carnegie</strong> which is<strong> </strong>the most famous confidence-boosting book.</p><h3>Conclusion:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*IXFieQb7pO1asRxVJVGI3A.gif" /></figure><p>If you want to be a Senior Front-End developer, you have to improve your Soft and Hard Skills. There is a famous Front-End roadmap which you can improve your hard skills with: <a href="https://roadmap.sh/frontend">https://roadmap.sh/frontend</a> , I strongly recommend you have a to-do list and try to achieve them. Rate them based on their priority of your office needs. Categorize your problems and try to find the best way to solve them.<br>Acquiring soft skills is a bit difficult, it depends on your personality and efforts. IMO It would be very useful to ask a leader to help you achieve your goals as a mentor.</p><p>I hope the article was useful and enjoyed it 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6596142bf647" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/am-i-a-senior-front-end-developer-6596142bf647">Am I a senior Front-End developer?</a> was originally published in <a href="https://medium.com/codex">CodeX</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 write Vuejs efficient unit test by Laravel-mix]]></title>
            <link>https://medium.com/@nima.2004hkh/how-to-write-vuejs-efficient-unit-test-by-laravel-mix-e19385f1f4?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/e19385f1f4</guid>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[laravel-mix]]></category>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[laravel]]></category>
            <category><![CDATA[unit-test-tools]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Tue, 14 Dec 2021 19:03:57 GMT</pubDate>
            <atom:updated>2021-12-15T18:29:36.957Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to write effective Vue.js unit tests with Laravel-mix</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*_h8MejZQWnPbtSTC1kkorg.png" /></figure><p>One of the more interesting challenges I have encountered while working at <a href="https://trengo.com/">Trengo</a>, a omnichannel communication platform that unifies all messaging channels into one single view, was embarking Unit test in Vue that is configured by Laravel-Mix. It is a little complicated for a developer that only had experience with Vue-cli. I hereby would like to share my challenges and how I addressed these.</p><h4>What are the testing tools?</h4><p>Vue has some recommendations for testing tools that I agree with, both have some advantages and disadvantages, we will talk about them further.</p><ol><li><strong>Vue Testing Library</strong></li></ol><p>If you are a React/Svelte developer, perhaps you’ve heard about <a href="https://testing-library.com/">Testing Library</a> more. Simple and complete testing utilities that encourage good testing practices. It would be a good start for all level developers. It has “jest” on top of itself, and you don’t need to install any dependencies besides the library.</p><p><strong>2. Vue Test Utils</strong></p><p><a href="https://vue-test-utils.vuejs.org/">Vue Test Utils</a> is the official unit testing utility library for Vue. Most Vue developers know this package more than “Vue Testing Library’’. You have to install “jest” beside it and everything is ready. It is very straightforward and easy to start coding with Vue Test Utils, you can mock and make async tests easily with the built-in API.</p><h4>Advantages and Disadvantages ?</h4><ul><li><strong>Easy to code</strong> <strong>:</strong> In my opinion, both of them are straightforward and easy to code, perhaps Vue test utils needs more configuration.</li><li><strong>Official :</strong> I prefer to choose official libraries for any kind of projects, you do not need to worry about support and community.</li><li><strong>Handing over capability</strong> <strong>:</strong> Handing over capability is super important, most of Vuejs developers know “Vue test utils” and also most of the official tutorials are based on it. you can start testing with this tutorial: <a href="https://www.vuemastery.com/courses/unit-testing/what-to-test">https://www.vuemastery.com/courses/unit-testing/what-to-test</a></li><li><strong>Community</strong> <strong>:</strong> Today as I am writing this article, “Vue test utils” has 3.4K and “Vue testing library” has 759 stars on GitHub, also “Vue test utils” has 500 questions in Stack overflow, whereas “Vue testing library” has 21. It proves that “Vue test utils” has the biggest community.</li><li><strong>Documentation</strong> <strong>:</strong> Both have good documentation, it is up to developer’s experience that will determine the quality of the tests. If you are not familiar with Unit tests, I would recommend “Vue test utils” that has good examples inside and outside of documentation.</li><li><strong>API</strong> <strong>:</strong> “Vue testing library” has some fancy API to write tests. E.g. you can use the “data-test” attribute inside your component DOM and fetch your DOM by its value and will remove this attribute after build on production. So, the end user will not see anything inside the browser inspector related to “data-test”, it was our only challenge to choose between “Vue test utils” or “Vue testing library”.</li></ul><h4>How to remove ‘data-test’ attribute in Vue test utiles and Laravel-Mix?</h4><p>My colleague shared a youtube video presented by Vue core member Rahul Kadyan which shows the exact use case for removing “data-test” attributes. In this video you can see how easy it is to remove attributes after building the project, but not so useful when we are using Laravel-Mix.</p><p>First step is to write a function to remove ‘data-’ attributes. I found the “vue-remove-attributes” library that is doing it for us.</p><p>The next step is to override “compilerOptions” related to “vue-loader” options inside our webpack configuration. So this would be our webpack configuration code:</p><pre>const <strong><em>Mix </em></strong>= require(&#39;laravel-mix&#39;);<br>const createAttributeRemover = require(&#39;vue-remove-attributes&#39;);</pre><pre><strong><em>Mix</em></strong>.options({<br>  vue: {<br>    compilerOptions: {<br>      modules: [createAttributeRemover(&#39;data-test&#39;)],<br>    },<br>  },<br>});</pre><h4>Conclusion</h4><p>Both libraries are phenomenal, it depends on your project, team and use cases. As uncle Bob said:</p><blockquote>The tests need to be written in a timely fashion. Unit tests should be written just before the production code that makes them pass. If you write tests after the production code, then you may find the production code to be hard to test. You may decide that some production code is too hard to test. You may not design the production code to be testable.</blockquote><p>So it is very important to choose the best library that supports all of your use-cases. Be sure about the library and be cautious about changing it, because they’re probably a lot of required changes.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e19385f1f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementing Micro-frontend services + Vue 2 (What is and how)]]></title>
            <link>https://medium.com/@nima.2004hkh/implementing-micro-frontend-services-vue-2-what-is-and-how-c3be318a3b02?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/c3be318a3b02</guid>
            <category><![CDATA[javascrip]]></category>
            <category><![CDATA[vue-2]]></category>
            <category><![CDATA[micro-frontends]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Sun, 15 Aug 2021 18:42:34 GMT</pubDate>
            <atom:updated>2021-08-15T19:34:36.638Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2jM8fjMityMN7juKl-fqhw.jpeg" /><figcaption>Implementing Micro-frontend services + Vue 2</figcaption></figure><p>Web technology is growing up day by day and what is important is to be updated with the stream. one of them, is “Microfrontend”, that is an approach to split your front-end app into individual “microapps” that will working together regardless of their library or framework. it is possible to have an app that is including Vuejs + Reactjs + Pure HTML + Svelte , and each project is lunch on their ports with specific address.</p><p>So far, our applications were Monolith or Front-Back, today, with the help of Webpack5 it is possible to have “microapps” beside of them. take a look at the chart below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*35CH3rrumv-HwWExeml-lA.png" /><figcaption><a href="https://micro-frontends.org/">https://micro-frontends.org/</a></figcaption></figure><h3><strong>Check my repository</strong></h3><p>You can clone the samples in the link below :</p><p><a href="https://github.com/nimahkh/vue2_microfrontend">GitHub - nimahkh/vue2_microfrontend</a></p><h3><strong>Let’s dive into the code</strong></h3><p>Earlier I wrote an article about “How to implement Micro Frontends with Reactjs and qiankun”, you can read it here :</p><p><a href="https://dev.to/nimahkh/how-to-implement-micro-frontend-with-reactjs-and-qiankun-9f2">How to implement Micro Frontends with Reactjs and qiankun</a></p><p>What I want to show you, is how to configure your “Vue2” project to handle “microapps” together. my hypothesis is to have a main project that will call multiple components from another “microapp” as components. The main advantage of Microfrontend in my example is structuring the main project with stores individually on another git repository and focus on it without considering the component’s functionality performance. So we will have multiple git projects that are working separately without any hash conflicts when developers are coding parallel on “Main” and “Account” project (These are our two projects that we will connect them together further). <br>The main key of the our configuration is “Modulefederation” plugin in webpack 5 .</p><p>“Multiple separate builds should form a single application. These separate builds should not have dependencies between each other, so they can be developed and deployed individually.<br>This is often known as Micro-Frontends, but is not limited to that.” <br><a href="https://webpack.js.org/concepts/module-federation/">https://webpack.js.org/concepts/module-federation/</a></p><h4>First step — installing Vue2</h4><p>At first I will create “Main” app in our project folder :</p><pre>mkdir vuejs_mfe &amp;&amp; cd $_<br>mkdir Main &amp;&amp; cd $_</pre><p>Now we can install all the dependencies that we need, I want to work with Tailwindcss, Webpack5, Vue2, Vuex as state management.</p><pre>yarn add vue@^2.6.12 vuex@^3.6.2 @babel/core@^7.11.0 babel-loader@^8.1.0 vue-router@^3.5.1</pre><pre>yarn add autoprefixer css-loader file-loader html-webpack-plugin mini-css-extract-plugin postcss postcss-loader style-loader tailwindcss url-loader vue-loader vue-template-compiler webpack webpack-cli webpack-dev-server --dev</pre><p>Now add scripts block in package.json</p><pre>...<br>&quot;scripts&quot;: {</pre><pre>&quot;start&quot;: &quot;webpack-cli serve&quot;,</pre><pre>&quot;build&quot;: &quot;webpack --mode production&quot;,</pre><pre>&quot;clean&quot;: &quot;rm -rf dist&quot;</pre><pre>},<br>...</pre><p>It seems OK now, we have to create our Webpack, index.html and Tailwind configuration.</p><blockquote>webpack.config.js</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/858cef81afd53e95bfa3e44d2bf5bf57/href">https://medium.com/media/858cef81afd53e95bfa3e44d2bf5bf57/href</a></iframe><p>The most important blocks are “devserver” and “ModuleFederationPlugin” .</p><p><strong>Devserver</strong>: <br>This part is so important to give allow to serve our entry on specific IP addresses, basically this part is handling CORS issue and serving our entry on dev mode.</p><p><strong>ModuleFederationPlugin:<br>“</strong>ModuleFederationPlugin” is Webpack’s new feature to make the application into “microapp” . it has several parts : <br>“name” : name of our “microapp”<br>“filename” : microapp’s entry file name<br>“remotes” : other “microapps” addresses to fetch and use them in our code<br>“exposes” : the components and files that you want to share it from “microapp”<br>“shared” : the libraries that you want to overrides to nested container.<br>Here I decided to share “Vue, Vue-router, Vuex , Tailwindcss” to make all the apps, compatible together.</p><blockquote>index.html</blockquote><p>create a index.html file inside root of Main folder, this is the template that webpack will write on.</p><pre>&lt;!DOCTYPE html&gt;</pre><pre>&lt;html lang=&quot;&quot;&gt;</pre><pre>&lt;head&gt;</pre><pre>&lt;meta charset=&quot;utf-8&quot;&gt;</pre><pre>&lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;</pre><pre>&lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,initial-scale=1.0&quot;&gt;</pre><pre>&lt;title&gt;Main&lt;/title&gt;</pre><pre>&lt;/head&gt;</pre><pre>&lt;body&gt;</pre><pre>&lt;noscript&gt;</pre><pre>&lt;strong&gt;We&#39;re sorry but &lt;%= htmlWebpackPlugin.options.title %&gt; doesn&#39;t work properly without JavaScript enabled. Please enable it to continue.&lt;/strong&gt;</pre><pre>&lt;/noscript&gt;</pre><pre>&lt;div id=&quot;app&quot;&gt;&lt;/div&gt;</pre><pre>&lt;!-- built files will be auto injected --&gt;</pre><pre>&lt;/body&gt;</pre><pre>&lt;/html&gt;</pre><blockquote>Tailwind, Postcss</blockquote><p>So now, we have to install Tailwind on our project, so create tailwind.config.js and postcss.config.js in root of the Main application</p><blockquote>tailwind.config.js</blockquote><pre>module.exports = {</pre><pre>purge: [&#39;./index.html&#39;, &#39;./src/**/*.{vue,js,ts,jsx,tsx}&#39;],</pre><pre>darkMode: false, // or &#39;media&#39; or &#39;class&#39;</pre><pre>theme: {</pre><pre>extend: {},</pre><pre>},</pre><pre>variants: {</pre><pre>extend: {},</pre><pre>},</pre><pre>plugins: [],</pre><pre>}</pre><blockquote>postcss.config.js</blockquote><pre>module.exports = {</pre><pre>plugins: {</pre><pre>tailwindcss: {},</pre><pre>autoprefixer: {},</pre><pre>},</pre><pre>}</pre><blockquote>Main project structure</blockquote><p>I decided to use Domain-driven Design known as DDD file structure because it is too straightforward and you can handle your “Atomic” design pattern easily when all the domains are related together so I found that it is a good combination of them, it will give you “update” and “replacing” possibility with less impact.</p><pre>├── index.html<br>├── package.json<br>├── postcss.config.js<br>├── src<br>│   ├── assets<br>│   │   └── css<br>│   │       └── style.css<br>│   ├── components<br>│   │   └── main<br>│   │       ├── index.js<br>│   │       └── main.component.vue<br>│   ├── index.js<br>│   ├── main.js<br>│   └── routes<br>│       └── index.js<br>├── tailwind.config.js<br>├── webpack.config.js<br>└── yarn.lock</pre><p>As you see inside src/components we have a main folder that means that it is about main screen, and there is one index.js folder that is our main index, what does main.component.vue doing? it will imported into index and index will export it as default, I did it as a sample, but you can import multiple components inside index and export them immediately as an object to use them anywhere , like utils and etc… for our certain component. <br>As we wrote everything in our webpack.config.js , so I will just show you the main.component.vue code and for rest of them , please take a look at the repository to find out whats up there.</p><blockquote>Write main.component.vue</blockquote><pre>&lt;template&gt;<br>  &lt;div<br>    class=&quot;flex items-center justify-center justify-self-center m-auto flex-col w-3/4 rounded shadow-lg border-1 border-light-blue-500 border-opacity-1 min-h-full&quot;<br>  &gt;<br>    &lt;div class=&quot;grid grid-cols-1 divide-y divide-light-blue-500 w-full shadow&quot;&gt;<br>      &lt;div class=&quot;w-3/4 pb-5 flex flex-row justify-around m-auto mt-5&quot;&gt;<br>        &lt;div class=&quot;flex flex-row&quot;&gt;<br>          &lt;span&gt; How many Todo I have? &lt;/span&gt;<br>          &lt;span class=&quot;ml-2&quot;&gt; <strong>&lt;counter /&gt;</strong> &lt;/span&gt;<br>        &lt;/div&gt;<br>        &lt;div&gt;<strong>&lt;todo-input /&gt;</strong>&lt;/div&gt;<br>      &lt;/div&gt;</pre><pre>&lt;div class=&quot;w-full pt-5 pb-5&quot;&gt;<br>        <strong>&lt;todo-list /&gt;</strong><br>      &lt;/div&gt;<br>    &lt;/div&gt;</pre><pre>&lt;router-view /&gt;<br>  &lt;/div&gt;<br>&lt;/template&gt;</pre><pre>&lt;script&gt;<br>export default {};<br>&lt;/script&gt;</pre><p>WHAAATTTTTT? how is it possibleee? wait a second,<br>Yes, it is not possible to use bold components like <strong>&lt;counter/&gt; </strong>without declaration, but I defined them inside the main.js that you will take a look at below :</p><pre>import Vue from &#39;vue&#39;</pre><pre>import VueRouter from &#39;vue-router&#39;</pre><pre>import App from &#39;./components/main&#39;</pre><pre>import routes from &#39;./routes&#39;</pre><pre>import routes1 from &#39;account/Routes&#39;</pre><pre>import store from &quot;account/Store&quot;</pre><pre>import &#39;@assets/css/style.css&#39;</pre><pre>Vue.use(VueRouter)</pre><pre>const router = new VueRouter({</pre><pre>routes: routes.concat(routes1)</pre><pre>})<br></pre><pre>Vue.component(&quot;counter&quot;, () =&gt; import(&quot;account/Content&quot;));</pre><pre>Vue.component(&quot;todo-input&quot;, () =&gt; import(&quot;account/TodoInput&quot;));</pre><pre>Vue.component(&quot;todo-list&quot;, () =&gt; import(&quot;account/TodoList&quot;));</pre><pre>export default new Vue({</pre><pre>store,</pre><pre>router,</pre><pre>render: h =&gt; h(App)</pre><pre>}).$mount(&#39;#app&#39;)</pre><p>Ok, now it make sense, we have to import components asynchronously, because at first we have to download the entry file and then webpack will produce them into our project so we will have access to components, from “account” remote, but still it will not work, because we have to create “account” project and serve it on “loclhost:3001” as we defined at webpack.</p><blockquote>Create account project</blockquote><p>Beside of “main” create “account” folder:</p><pre>mkdir account &amp;&amp; cd $_</pre><p>Setup Vuejs and package.json same as “Main” project, then create “webpack.config.js” :</p><pre>const path = require(&quot;path&quot;);<br>const {<br>    VueLoaderPlugin<br>} = require(&quot;vue-loader&quot;);<br>const MiniCssExtractPlugin = require(&quot;mini-css-extract-plugin&quot;);<br>const HtmlWebpackPlugin = require(&quot;html-webpack-plugin&quot;);<br>const {<br>    ModuleFederationPlugin<br>} = require(&quot;webpack&quot;).container;<br>const deps = require(&#39;./package.json&#39;).dependencies</pre><pre>module.exports = (env = {}) =&gt; ({<br>    mode: &quot;development&quot;,<br>    cache: false,<br>    devtool: &quot;source-map&quot;,<br>    optimization: {<br>        minimize: false,<br>    },<br>    target: &quot;web&quot;,<br>    entry: path.resolve(__dirname, &quot;./src/index.js&quot;),<br>    output: {<br>        path: path.resolve(__dirname, &quot;./dist&quot;),<br>        publicPath: &#39;<a href="http://localhost:3001/&#39;">http://localhost:3001/&#39;</a>,<br>        filename: &#39;static/js/[name].js&#39;,<br>        chunkFilename: &#39;static/js/[name].js&#39;<br>    },<br>    resolve: {<br>        extensions: [<br>            &#39;.tsx&#39;,<br>            &#39;.ts&#39;,<br>            &#39;.mjs&#39;,<br>            &#39;.js&#39;,<br>            &#39;.jsx&#39;,<br>            &#39;.vue&#39;,<br>            &#39;.json&#39;,<br>            &#39;.wasm&#39;<br>        ],<br>        alias: {<br>            vue: &quot;vue/dist/vue.runtime.esm.js&quot;,<br>            &quot;@&quot;: path.resolve(__dirname, &quot;./src&quot;)<br>        },<br>    },<br>    module: {<br>        rules: [{<br>                test: /\.vue$/,<br>                use: &quot;vue-loader&quot;,<br>            },<br>            {<br>                test: /\.png$/,<br>                use: {<br>                    loader: &quot;url-loader&quot;,<br>                    options: {<br>                        esModule: false, // 这里设置为false<br>                        name: &#39;[name].[ext]&#39;,<br>                        limit: 8192<br>                    }<br>                },<br>            },<br>            {<br>                test: /\.(png|jpe?g|gif|webp)(\?.*)?$/,<br>                use: [<br>                    /* config.module.rule(&#39;images&#39;).use(&#39;url-loader&#39;) */<br>                    {<br>                        loader: &#39;url-loader&#39;,<br>                        options: {<br>                            limit: 4096,<br>                            esModule: false,<br>                            fallback: {<br>                                loader: &#39;file-loader&#39;,<br>                                options: {<br>                                    name: &#39;static/img/[name].[hash:8].[ext]&#39;,<br>                                    esModule: false<br>                                }<br>                            }<br>                        }<br>                    }<br>                ]<br>            },<br>            {<br>                test: /\.css$/,<br>                use: [{<br>                        loader: MiniCssExtractPlugin.loader,<br>                        //options: { hmr: !env.prod },<br>                    },<br>                    &quot;css-loader&quot;,<br>                    &quot;postcss-loader&quot;<br>                ],<br>            },<br>        ],<br>    },<br>    resolve: {<br>        alias: {<br>            &quot;<a href="http://twitter.com/assets">@assets</a>&quot;: path.resolve(__dirname, &#39;src/assets&#39;)<br>        }<br>    },<br>    plugins: [<br>        new MiniCssExtractPlugin({<br>            filename: &quot;[name].css&quot;,<br>        }),<br>        new ModuleFederationPlugin({<br>            name: &quot;account&quot;,<br>            filename: &quot;accountRemoteEntry.js&quot;,<br>            remotes: {<br>                layout: &quot;main@<a href="http://localhost:3002/mainRemoteEntry.js">http://localhost:3002/mainRemoteEntry.js</a>&quot;,<br>            },<br>            exposes: {<br>                &quot;./Content&quot;: &quot;./src/components/Content.vue&quot;,<br>                &quot;./TodoList&quot;: &quot;./src/components/TodoList.vue&quot;,<br>                &quot;./TodoInput&quot;: &quot;./src/components/TodoInput.vue&quot;,<br>                &quot;./Routes&quot;: &quot;./src/routes&quot;,<br>                &quot;./Store&quot;: &quot;./src/store&quot;,<br>            },<br>            shared: {<br>                vue: {<br>                    eager: true,<br>                    singleton: true,<br>                    requiredVersion: deps.vue<br>                },<br>                &quot;vue-router&quot;: {<br>                    eager: true,<br>                    singleton: true,<br>                    requiredVersion: deps[&quot;vue-router&quot;]<br>                },<br>                vuex: {<br>                    eager: true,<br>                    singleton: true,<br>                    requiredVersion: deps.vuex<br>                },<br>                tailwindcss: {<br>                    eager: true,<br>                    singleton: true,<br>                    requiredVersion: deps.tailwindcss<br>                }<br>            }<br>        }),<br>        new HtmlWebpackPlugin({<br>            template: path.resolve(__dirname, &quot;./index.html&quot;),<br>        }),<br>        new VueLoaderPlugin(),<br>    ],<br>    devServer: {<br>        contentBase: path.join(__dirname),<br>        compress: true,<br>        port: 3001,<br>        hot: true,<br>        headers: {<br>            &quot;Access-Control-Allow-Origin&quot;: &quot;*&quot;,<br>            &quot;Access-Control-Allow-Methods&quot;: &quot;GET, POST, PUT, DELETE, PATCH, OPTIONS&quot;,<br>            &quot;Access-Control-Allow-Headers&quot;: &quot;X-Requested-With, content-type, Authorization&quot;,<br>        },<br>    },<br>});</pre><p>The most important thing is “ModuleFederationPlugin” configs, as you see, we exported the components that we want to use them inside our “Main” project, soooo like that, we have ability to use components of other projects inside “account” or any project that we will have. do not look to the “account” as a “component manager” that has a lot of components to serve inside the other projects, if you need something like this, it is better to publish the project as a library on npm server or bitdev, but look at it as a project that is working individually, but beside of that , we have ability to use its components somewhere else too .</p><p>So after starting both of the projects, you will have these results :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*syTiGqwXvpav13tdzc6fLA.png" /><figcaption>Main project</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YEJxXsWU4KQ2UYsjxLeUoA.png" /><figcaption>Account project</figcaption></figure><p>We have unstylish components inside “Account” that has too different from “Main” , but they are two separated projects that are served on two different server and ip.</p><blockquote>Micro-frontends are not trying to replace components</blockquote><p>If you need to know much more about “Micro-frontend” I suggest you to follow “Luca” article</p><p><a href="https://medium.com/@lucamezzalira/i-dont-understand-micro-frontends-88f7304799a9">I don’t understand micro-frontends.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c3be318a3b02" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to implement Micro Frontend with Reactjs and qiankun]]></title>
            <link>https://medium.com/@nima.2004hkh/how-to-implement-micro-frontend-with-reactjs-and-qiankun-606d01ab9599?source=rss-8c0b558e8a11------2</link>
            <guid isPermaLink="false">https://medium.com/p/606d01ab9599</guid>
            <category><![CDATA[micro-frontends]]></category>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[qian-kun]]></category>
            <dc:creator><![CDATA[Nima Habibkhoda]]></dc:creator>
            <pubDate>Sat, 02 Jan 2021 18:48:34 GMT</pubDate>
            <atom:updated>2021-01-04T07:17:53.125Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*dL5n7xYkBd6mGefbGVZ6rQ.png" /></figure><p>&lt;Hello world/&gt;</p><p>Maybe you don’t know what is Micro Frontend and why we have to use it, because it is a new technology on frontend. there are few plugins and articles about it, and I think it is better to focus on some plugins that have no documents.</p><p>There is a good source about use cases and motivations of <strong>Micro frontend</strong>:</p><p><a href="https://micro-frontends.org/">Micro Frontends</a></p><p>What I want to write about, is <strong>Qiankun</strong></p><p><a href="https://qiankun.umijs.org/">qiankun</a></p><h3>Our Scenario</h3><p>Imagine that we have a project named mf-productthat will work like a basket, we will add some products in our basket (Dummy products) and DVA will reduce states to show them on our frontend.</p><p><a href="https://github.com/dvajs/dva">dvajs/dva</a></p><p>Now we want to implement it into parent project that is micro-frontend and we have to show the mf-product in #mf-container DOM. it is easy , isn’t it? but how?</p><p>I just know that mf-product is runing on localhost:8001 and we can fetch it from there.</p><p>You can pull the project from : <a href="https://github.com/nimahkh/micro-frontend">https://github.com/nimahkh/micro-frontend</a></p><h3>Start</h3><p>First we have to install qiankun</p><pre>mkdir micro-front &amp;&amp; cd micro-front &amp;&amp; yarn add qiankun</pre><p>Then we will create our package.json to see what we need for start.</p><pre>{<br>  &quot;name&quot;: &quot;micro-front&quot;,<br>  &quot;version&quot;: &quot;1.0.0&quot;,<br>  &quot;description&quot;: &quot;&quot;,<br>  &quot;main&quot;: &quot;index.js&quot;,<br>  &quot;scripts&quot;: {<br>    &quot;test&quot;: &quot;echo \&quot;Error: no test specified\&quot; &amp;&amp; exit 1&quot;<br>  },<br>  &quot;devDependencies&quot;: {<br>    &quot;<a href="http://twitter.com/babel/core">@babel/core</a>&quot;: &quot;^7.7.2&quot;,<br>    &quot;npm-run-all&quot;: &quot;^4.1.5&quot;,<br>    &quot;<a href="http://twitter.com/babel/plugin-transform-react-js">@babel/plugin-transform-react-js</a>x&quot;: &quot;^7.7.0&quot;,<br>    &quot;<a href="http://twitter.com/babel/preset-env">@babel/preset-env</a>&quot;: &quot;^7.7.1&quot;,<br>    &quot;babel-loader&quot;: &quot;^8.0.6&quot;,<br>    &quot;css-loader&quot;: &quot;^3.2.0&quot;,<br>    &quot;html-webpack-plugin&quot;: &quot;^3.2.0&quot;,<br>    &quot;less-loader&quot;: &quot;^6.2.0&quot;,<br>    &quot;style-loader&quot;: &quot;^1.0.0&quot;,<br>    &quot;webpack&quot;: &quot;^4.41.2&quot;,<br>    &quot;webpack-cli&quot;: &quot;^3.3.10&quot;,<br>    &quot;webpack-dev-server&quot;: &quot;^3.9.0&quot;,<br>    &quot;cross-env&quot;: &quot;^7.0.2&quot;<br>  },<br>  &quot;dependencies&quot;: {<br>    &quot;qiankun&quot;: &quot;^2.3.5&quot;,<br>    &quot;react&quot;: &quot;^16.13.1&quot;,<br>    &quot;react-dom&quot;: &quot;^16.13.1&quot;,<br>    &quot;vue&quot;: &quot;^2.6.11&quot;<br>  }<br>}</pre><p><strong>Why we need these packages?</strong></p><p>We need babel for transpiling our es6 codes and also we need webpack and less for lunching our main project. the main project is the project that will load mf-product from port 8001 into 8000 at div with #mf-container DOM.</p><pre>$ yarn #install dependencies</pre><p><strong>Create </strong><strong>main Project</strong></p><pre>$ vim index.html</pre><p>Put the codes below in index.html</p><pre>&lt;!DOCTYPE html&gt;<br>&lt;html lang=&quot;en&quot;&gt;</pre><pre>&lt;head&gt;<br>  &lt;meta charset=&quot;UTF-8&quot;&gt;<br>  &lt;title&gt;Example&lt;/title&gt;<br>&lt;/head&gt;</pre><pre>&lt;body&gt;<br>  &lt;div class=&quot;mainapp&quot;&gt;<br>    &lt;header class=&quot;mainapp-header&quot;&gt;<br>      &lt;h1&gt;Micro Frontend&lt;/h1&gt;<br>    &lt;/header&gt;<br>    &lt;div class=&quot;mainapp-main&quot;&gt;<br>      &lt;ul class=&quot;mainapp-sidemenu&quot;&gt;<br>        &lt;li onclick=&quot;push(&#39;/mf-product&#39;)&quot;&gt;Products&lt;/li&gt;<br>      &lt;/ul&gt;<br>      &lt;main id=&quot;mf-container&quot;&gt;&lt;/main&gt;<br>    &lt;/div&gt;<br>  &lt;/div&gt;</pre><pre>&lt;script&gt;<br>    function push(subapp) { history.pushState(null, subapp, subapp) }<br>  &lt;/script&gt;<br>&lt;/body&gt;</pre><pre>&lt;/html&gt;</pre><p>The script part will redirect to links.</p><p>Now we need index.js file to register our Micro Apps, here we will introduce to the application that we have a project that is lunched on port 8001 and I want to show it on #mf-container that has a url equal to mf-product</p><pre>import {<br>  registerMicroApps,<br>  start,<br>  setDefaultMountApp,<br>  prefetchApps,<br>  addGlobalUncaughtErrorHandler,<br>} from &quot;qiankun&quot;;<br>import render from &quot;./render/ReactRender&quot;;<br>render({ loading: true });</pre><pre>const loader = (loading) =&gt; render({ loading });<br>registerMicroApps([<br>  {<br>    name: &quot;mf-product&quot;, // app name registered<br>    entry: &quot;//localhost:8001&quot;,<br>    container: &quot;#mf-container&quot;,<br>    loader,<br>    activeRule: &quot;/mf-product&quot;,<br>  },<br>]);<br>prefetchApps([{ name: &quot;mf-product&quot;, entry: &quot;//locahost:7101&quot; }]);<br>start();<br>setDefaultMountApp(&quot;/mf-product&quot;);<br>addGlobalUncaughtErrorHandler((event) =&gt; console.log(event));</pre><p><strong>Oh Man</strong> , what is Render?</p><blockquote><strong>nothing, it is just a loader with Reactjs , and it is why we need babel</strong>.</blockquote><p>create render folder and create one file named: ReactRender.jsx</p><pre>import React from &quot;react&quot;;<br>import ReactDOM from &quot;react-dom&quot;;</pre><pre>function Render(props) {<br>  const { loading } = props;</pre><pre>return (<br>    &lt;&gt;<br>      {loading &amp;&amp; &lt;h4 className=&quot;subapp-loading&quot;&gt;Loading...&lt;/h4&gt;}<br>      &lt;div id=&quot;mf-container&quot; /&gt;<br>    &lt;/&gt;<br>  );<br>}</pre><pre>export default function render({ loading }) {<br>  const container = document.getElementById(&quot;mf-container&quot;);<br>  ReactDOM.render(&lt;Render loading={loading} /&gt;, container);<br>}</pre><p>Now we are showing one simple loading until sub app fetched. after fetching the sub app (the application that we want to show it) we have to render it on mf-container .</p><p>Just we need to setup our webpack.config.js for lunching the project :</p><pre>const HtmlWebpackPlugin = require(&quot;html-webpack-plugin&quot;);<br>const { name } = require(&quot;./package&quot;);</pre><pre>module.exports = {<br>  entry: &quot;./index.js&quot;,<br>  devtool: &quot;source-map&quot;,<br>  devServer: {<br>    open: true,<br>    port: &quot;8000&quot;,<br>    clientLogLevel: &quot;warning&quot;,<br>    disableHostCheck: true,<br>    compress: true,<br>    headers: {<br>      &quot;Access-Control-Allow-Origin&quot;: &quot;*&quot;,<br>    },<br>    historyApiFallback: true,<br>    overlay: { warnings: false, errors: true },<br>  },<br>  output: {<br>    publicPath: &quot;/&quot;,<br>  },<br>  mode: &quot;development&quot;,<br>  resolve: {<br>    extensions: [&quot;.js&quot;, &quot;.jsx&quot;, &quot;.ts&quot;, &quot;.tsx&quot;],<br>  },<br>  module: {<br>    rules: [<br>      {<br>        test: /\.jsx?$/,<br>        exclude: /node_modules/,<br>        use: {<br>          loader: &quot;babel-loader&quot;,<br>          options: {<br>            presets: [&quot;<a href="http://twitter.com/babel/preset-env">@babel/preset-env</a>&quot;],<br>            plugins: [&quot;<a href="http://twitter.com/babel/plugin-transform-react-js">@babel/plugin-transform-react-js</a>x&quot;],<br>          },<br>        },<br>      },<br>      {<br>        test: /\.(le|c)ss$/,<br>        use: [&quot;style-loader&quot;, &quot;css-loader&quot;, &quot;less-loader&quot;],<br>      },<br>    ],<br>  },<br>  plugins: [<br>    new HtmlWebpackPlugin({<br>      filename: &quot;index.html&quot;,<br>      template: &quot;./index.html&quot;,<br>      minify: {<br>        removeComments: true,<br>        collapseWhitespace: true,<br>      },<br>    }),<br>  ],<br>};</pre><p>It is very easy, I am not going to explain it. just we are trying to transpile and compile our plugins and finaly run the main on port 8000.</p><p><strong>Now what?</strong></p><p>We need to pull the project that we want to implement it on main.</p><p>Change your directory to root project (where package.json is), then pull the project.</p><pre>git pull <a href="https://github.com/nimahkh/mf-product">https://github.com/nimahkh/mf-product</a></pre><p>Our project is created with UMI, so I will explain in two ways, one with UMI and one with pure React.</p><h3>UMI</h3><p>it is not important what we did, and what are our components, just we have to describe our .umirc.js</p><pre>import { name } from &quot;./package.json&quot;;<br>import { slave } from &quot;umi-plugin-qiankun&quot;;</pre><pre>export default {<br>  base: name,<br>  publicPath: &quot;/mf-product/&quot;,<br>  outputPath: &quot;./dist&quot;,<br>  mountElementId: &quot;mf-product&quot;,<br>  plugins: [<br>    [<br>      slave,<br>      {<br>        keepOriginalRoutes: true<br>      }<br>    ],<br>    [<br>      &quot;umi-plugin-react&quot;,<br>      {<br>        title: &quot;mf-product&quot;,<br>        antd: true,<br>        dva: {<br>          always: true,<br>          hmr: true<br>        },<br>        dynamicImport: true,<br>        routes: {<br>          exclude: [<br>            /models\//,<br>            /services\//,<br>            /model\.(t|j)sx?$/,<br>            /service\.(t|j)sx?$/<br>          ]<br>        }<br>      }<br>    ]<br>  ]<br>};</pre><p>just we have to install umi-plugin-qiankun</p><pre>$ yarn add @umijs/plugin-qiankun</pre><h3>Pure React</h3><p>At first we have to ovveride webpack with wired or rescript, I am going to do it with rescript. first create .rescriptsrc.js</p><pre>const { name } = require(&#39;./package&#39;);</pre><pre>module.exports = {<br>  webpack: config =&gt; {<br>    config.output.library = `${name}-[name]`;<br>    config.output.libraryTarget = &#39;umd&#39;;<br>    config.output.jsonpFunction = `webpackJsonp_${name}`;<br>    config.output.globalObject = &#39;window&#39;;</pre><pre>return config;<br>  },</pre><pre>devServer: _ =&gt; {<br>    const config = _;</pre><pre>config.headers = {<br>      &#39;Access-Control-Allow-Origin&#39;: &#39;*&#39;,<br>    };<br>    config.historyApiFallback = true;</pre><pre>config.hot = false;<br>    config.watchContentBase = false;<br>    config.liveReload = false;</pre><pre>return config;<br>  },<br>};</pre><p>This code will create output library from your package.json name property.</p><p>Now inside your package.json , change start command inside scripts block : “start”: “rescripts start” .</p><p>Add .env inside root directory:</p><pre>SKIP_PREFLIGHT_CHECK=true<br>BROWSER=none<br>PORT=7100<br>WDS_SOCKET_PORT=7100</pre><p>We are near to end, just we have to create public-path.js.</p><h4>why?</h4><p>We have to introduce to qiankun that we have global variable with name of our app to load it.</p><p>src/public-path.js</p><pre>if (window.__POWERED_BY_QIANKUN__) {<br>  // eslint-disable-next-line no-undef<br> __webpack_public_path__ = window.__INJECTED_PUBLIC_PATH_BY_QIANKUN__;<br>}</pre><p>Now just change index.js of the application like below:</p><p>src/index.js</p><pre>import &#39;./public-path&#39;;<br>import React from &#39;react&#39;;<br>import ReactDOM from &#39;react-dom&#39;;<br>import App from &#39;./App&#39;;<br>import * as serviceWorker from &#39;./serviceWorker&#39;;</pre><pre>function render(props) {<br>  const { container } = props;<br>  ReactDOM.render(&lt;App /&gt;, container ? container.querySelector(&#39;#root&#39;) : document.querySelector(&#39;#root&#39;));<br>}</pre><pre>function storeTest(props) {<br>  props.onGlobalStateChange((value, prev) =&gt; console.log(`[onGlobalStateChange - ${props.name}]:`, value, prev), true);<br>  props.setGlobalState({<br>    ignore: props.name,<br>    user: {<br>      name: props.name,<br>    },<br>  });<br>}</pre><pre>if (!window.__POWERED_BY_QIANKUN__) {<br>  render({});<br>}</pre><pre>export async function bootstrap() {<br>  console.log(&#39;[react16] react app bootstraped&#39;);<br>}</pre><pre>export async function mount(props) {<br>  console.log(&#39;[react16] props from main framework&#39;, props);<br>  storeTest(props);<br>  render(props);<br>}</pre><pre>export async function unmount(props) {<br>  const { container } = props;<br>  ReactDOM.unmountComponentAtNode(container ? container.querySelector(&#39;#root&#39;) : document.querySelector(&#39;#root&#39;));<br>}</pre><pre>// If you want your app to work offline and load faster, you can change<br>// unregister() to register() below. Note this comes with some pitfalls.<br>// Learn more about service workers: <a href="https://bit.ly/CRA-PWA">https://bit.ly/CRA-PWA</a><br>serviceWorker.unregister();</pre><p><strong>It is done dude!</strong></p><p>Now come to see what we did, but there is no scripts block in main package.json, so come to add it</p><pre>&quot;scripts&quot;: {<br>    &quot;start:product&quot;: &quot;cd mf-product  &amp;&amp; yarn start&quot;,<br>    &quot;start:main&quot;: &quot;webpack-dev-server&quot;,<br>    &quot;start&quot;: &quot;npm-run-all --parallel start:*&quot;,<br>    &quot;start:main-m&quot;: &quot;cross-env MODE=multiple webpack-dev-server&quot;,<br>    &quot;start:multiple&quot;: &quot;run-p start:main-m start:product&quot;,<br>    &quot;test&quot;: &quot;echo \&quot;Error: no test specified\&quot; &amp;&amp; exit 1&quot;<br>  }</pre><p><strong>YESSSSSS</strong>!, now just run</p><pre>$ yarn start</pre><p>Now you can check localhost:8000 and you will see the mf-project in our main layout, also you can check localhost:8001 to see that mf-product is working on it’s port.</p><p>It is very nice, isn’t it?</p><p>I hope that I explained it clearly.</p><p>&lt;good by world /&gt;</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=606d01ab9599" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>