<?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 Rajdeep Chandra on Medium]]></title>
        <description><![CDATA[Stories by Rajdeep Chandra on Medium]]></description>
        <link>https://medium.com/@rajrock38?source=rss-438ef6e1dba6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*IwYLhTQna_p0b2QsZ2llSA.jpeg</url>
            <title>Stories by Rajdeep Chandra on Medium</title>
            <link>https://medium.com/@rajrock38?source=rss-438ef6e1dba6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 05:18:14 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rajrock38/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[The Backbone of Design Systems: Why Maintenance is the Real MVP]]></title>
            <link>https://rajrock38.medium.com/the-backbone-of-design-systems-why-maintenance-is-the-real-mvp-950bf7456471?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/950bf7456471</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[web-components]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Tue, 06 Jan 2026 11:26:46 GMT</pubDate>
            <atom:updated>2026-01-06T11:26:46.388Z</atom:updated>
            <content:encoded><![CDATA[<p>Design systems are often celebrated for their most visible parts — shiny new components, thoughtfully crafted tokens, beautifully themed UIs. They’re the things we demo, document, and screenshot. The things that make our portfolios look good.</p><p>But if you’ve worked on a design system that’s meant to <em>scale</em>, you eventually uncover a less glamorous — yet far more important — truth:</p><p><strong>It’s not the features that carry your system forward. It’s the maintenance.</strong></p><h3>The Myth of “The Next Feature”</h3><p>In design systems, we often equate progress with output:<br>A shiny new button component.<br>A fresh spacing token.<br>A new visual theme that aligns with a rebrand.</p><p>These are the kinds of things that get showcased in release notes, design review decks, and conference talks. They’re measurable. They’re visual. They feel like progress — and they are, to an extent.</p><p>But if you zoom out and look at what <em>actually</em> sustains a design system over time, a different picture emerges.</p><p>The most meaningful progress often comes from the work that doesn’t get a version number or a blog post. It’s the kind of work that quietly prevents disasters, improves developer experience, and ensures your system is usable six months — or six years — from now.</p><p>Consider these examples:</p><h4>Dependency Hygiene Isn’t Optional</h4><p>Updating dependencies might sound trivial until it’s not. A stale dependency can introduce silent bugs, break builds, or block consumers from upgrading. Keeping them fresh means you spot breaking changes early — when the blast radius is small — rather than weeks later, when multiple teams are impacted.</p><p>We once caught a minor breaking change in a transitive dependency that would’ve silently broken theme inheritance across 40+ packages. Had we not been regularly maintaining our lockfiles and test matrix, it would have taken days to debug.</p><h4>Renovate Isn’t “Set and Forget”</h4><p>Tools like <strong>Renovate</strong> or <strong>Dependabot</strong> promise automated updates — but without tuning, they’ll spam your repo or miss important upgrades.</p><p>We realised <strong>Dependabot</strong> wasn’t handling monorepos well and often skipped patch-level updates we needed. Switching to Renovate and configuring update groups, commit body rules, and onboarding configs made our maintenance PRs manageable and useful — not noisy and ignored.</p><p>It’s automation, but done <em>intentionally</em>.</p><h4>Test Cleanup = Faster Feedback</h4><p>As your system grows, tests become your lifeline. But when test files follow different patterns, use different helpers, or assume different environments, they turn into a liability.</p><p>We invested time in aligning our test setups — shared fixtures, unified linting rules, consistent file naming. The payoff? New contributors could write reliable tests without copy-pasting from five different places, and our CI failures became easier to trace and fix.</p><h4>Storybook Is a Living Source of Truth</h4><p>Storybook isn’t just for designers — it’s your public API for components. But when stories are inconsistent or manually crafted without conventions, they become hard to trust or automate.</p><p>By adopting a consistent structure (same args, decorators, layout behavior), we unlocked auto-generated documentation and even component-level test coverage. That consistency also helped us identify where usage patterns weren’t standardized — a clue to underlying design drift.</p><h4>Performance Dashboards Prevent Fire Drills</h4><p>Performance often becomes an afterthought — until it’s not. We maintained dashboards tracking bundle size, render time, and interaction latency across components. They weren’t glamorous. But they alerted us when a refactor doubled the footprint of a core button, or when a theme update caused layout jank.</p><p>You don’t need a fire to appreciate the value of a smoke detector.</p><p><em>These Are the Real Multipliers</em></p><p>This kind of work rarely wins applause. No one’s standing up at All Hands to say, “Shoutout to the engineer who standardised 53 describe() blocks in our test suite.”</p><p>But it’s this foundational maintenance — not shiny features — that enables velocity, confidence, and scale. It creates a system that’s:</p><ul><li><strong>Resilient</strong> when pressure increases</li><li><strong>Clear</strong> when others contribute</li><li><strong>Predictable</strong> when things break</li></ul><p>And that’s the kind of progress that compounds.</p><h3>Reliability Is the Real Velocity</h3><p>There’s a common misconception that maintenance slows a team down. That doing the “boring stuff” takes away from innovation.</p><p>The opposite is true.</p><p>Maintenance <em>unlocks</em> velocity. It reduces friction. It makes your system dependable. And that dependability is what lets your team ship faster, iterate confidently, and onboard new contributors with ease.</p><ul><li>When every test file follows the same pattern, writing tests becomes second nature.</li><li>When your Storybook stories follow a convention, docs become effortless to maintain.</li><li>When your release process is smooth, updates stop feeling like risk.</li></ul><p>The key isn’t fancy tooling. It’s <strong>predictable structure</strong>.</p><h3>Want to Move Fast? First, Make It Boring</h3><p>Stability isn’t sexy. But it’s the best investment you can make.</p><p>Teams that treat maintenance as optional eventually pay the price in fire drills, broken builds, and frustrated consumers.</p><p>Teams that build with consistency, automation, and clarity? They scale with ease.</p><p>So yes — keep building beautiful things. But don’t let that blind you to the hidden engine that makes it all possible.</p><h3>Maintenance Is Momentum</h3><p>Design systems aren’t one-time projects. They’re evolving platforms. And the true mark of a healthy system isn’t how many components it has — it’s how confidently those components can grow and change over time.</p><p><strong>Maintain often.</strong><br><strong>Maintain early.</strong><br><strong>Maintain like it matters.</strong></p><p>Because it does.</p><p><strong><em>Thanks for reading.</em></strong><em><br>If you’re working on a design system and find yourself wrestling with the invisible work — test infra, dependency rot, automation quirks — I’d love to hear how you’re approaching it. Drop a comment or message me. Let’s normalize making the boring stuff beautiful. ✌️</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=950bf7456471" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Future of Design Systems: Context, Content, and User Awareness]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">Design systems are evolving. What started as a way to standardize colors, typography, and components is entering a new phase&#x200A;&#x2014;&#x200A;one that&#x2026;</p><p class="medium-feed-link"><a href="https://rajrock38.medium.com/the-future-of-design-systems-context-content-and-user-awareness-31f2204b5ff3?source=rss-438ef6e1dba6------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://rajrock38.medium.com/the-future-of-design-systems-context-content-and-user-awareness-31f2204b5ff3?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/31f2204b5ff3</guid>
            <category><![CDATA[design-system-tips]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Fri, 22 Aug 2025 14:48:36 GMT</pubDate>
            <atom:updated>2025-08-22T14:48:36.335Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Must know JS questions for interviews]]></title>
            <link>https://rajrock38.medium.com/must-know-js-questions-for-interviews-c4eb1f7277a7?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4eb1f7277a7</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[questions]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[tutorial]]></category>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Mon, 20 May 2024 06:01:35 GMT</pubDate>
            <atom:updated>2024-05-20T06:01:35.566Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vcIObAUJNkDGM3UX.jpg" /></figure><h3>1. How closure affects the garbage collection of JavaScript?</h3><p>Closures can affect garbage collection in JavaScript by extending the lifetime of variables that are captured by the closure. A closure is a function that retains access to its lexical scope, even when the function is executed outside that scope. This means that if a function inside another function captures variables from its parent scope, those variables will not be garbage collected as long as the inner function (closure) exists.</p><p>For example:</p><pre><br>function outerFunction() {<br> let capturedVariable = “I’m captured”;<br> return function innerFunction() {<br> console.log(capturedVariable);<br> }<br>}<br><br>const closure = outerFunction();<br>// Even after outerFunction execution is done, capturedVariable is not garbage collected because innerFunction still references it.<br>closure();</pre><p>In this example, <strong>capturedVariable</strong> is kept in memory as long as `<strong>innerFunction</strong>` exists because `<strong>innerFunction</strong>` forms a closure over `<strong>capturedVariable</strong>`.</p><h3>2. Why only variables created with `var` keyword are hoisted and initialized with `undefined`?</h3><p>In JavaScript, variable declarations using `var` are hoisted to the top of their containing function or global scope, and they are initialized with `undefined`. This behavior stems from the design of JavaScript’s variable scoping and hoisting mechanisms.</p><pre><br>console.log(a); // undefined<br>var a = 5;</pre><p>Here’s what happens behind the scenes:<br>1. The variable declaration `var a;` is hoisted to the top of its scope.<br>2. The variable `a` is initialized with `undefined`.<br>3. The assignment `a = 5;` occurs where it appears in the code.</p><p>On the other hand, variables declared with `let` and `const` are also hoisted but are not initialized. They are in a “temporal dead zone” from the start of the block until the declaration is encountered:</p><pre>console.log(b); // ReferenceError: Cannot access ‘b’ before initialization<br>let b = 5;</pre><h3>3. How hoisting works in JavaScript if it is interpreted?</h3><p>JavaScript is an interpreted language, but modern JavaScript engines like V8 (used in Chrome and Node.js) actually use a mix of interpretation and Just-In-Time (JIT) compilation for performance. Hoisting is a result of the way JavaScript engines parse and execute code in two phases: the creation phase and the execution phase.</p><p>During the creation phase:<br>- The engine parses the code and sets up the scope.<br>- All variable and function declarations are hoisted to the top of their scope.</p><p>During the execution phase:<br>- The code is executed line by line.<br>- Variable assignments and other expressions are evaluated.</p><pre><br>function foo() {<br> console.log(bar); // undefined due to hoisting<br> var bar = 10;<br>}<br>foo();<br></pre><h3>4. How does `Promise.all` work behind the scenes in a single-threaded JavaScript environment?</h3><p>`Promise.all` takes an iterable of promises and returns a single promise that resolves when all of the promises in the iterable have resolved or rejects when any of the promises reject. Here’s a simplified version of what happens behind the scenes:</p><p>1. `Promise.all` iterates over the iterable of promises.<br>2. For each promise, it attaches a `then` handler to capture the resolved value or a `catch` handler to capture the rejection.<br>3. It keeps track of how many promises have been resolved.<br>4. When all promises have resolved, it resolves the returned promise with an array of the resolved values.<br>5. If any promise rejects, it immediately rejects the returned promise with the reason for the first rejection encountered.</p><p>Even though JavaScript is single-threaded, it can handle asynchronous operations using the event loop and microtask queue. Promises use the microtask queue, which allows them to be resolved or rejected as soon as possible after the current operation completes.</p><pre><br>Promise.all([promise1, promise2, promise3])<br> .then(values =&gt; {<br> // values is an array of resolved values<br> })<br> .catch(error =&gt; {<br> // error is the reason of the first rejected promise<br> });<br></pre><h3>5. Why does function currying have no official reference on MDN, and what are the right use cases for function currying?</h3><p>Function currying may not have an extensive reference on MDN because it is a functional programming concept rather than a JavaScript-specific feature. Currying transforms a function that takes multiple arguments into a sequence of functions that each take a single argument.</p><pre><br>function curry(fn) {<br> return function curried(…args) {<br> if (args.length &gt;= fn.length) {<br> return fn.apply(this, args);<br> } else {<br> return function(…nextArgs) {<br> return curried.apply(this, args.concat(nextArgs));<br> };<br> }<br> };<br>}<br><br>function add(a, b) {<br> return a + b;<br>}<br>let curriedAdd = curry(add);<br>console.log(curriedAdd(1)(2)); // 3</pre><p>Currying can be useful for:<br>- Creating higher-order functions.<br>- Partially applying functions, which can be useful in functional programming to create reusable, specialized functions from more general ones.<br>- Enhancing code readability and maintainability by breaking down functions into simpler, composable parts.</p><p>In summary, currying is a powerful technique in functional programming that, while not unique to JavaScript, can be effectively used in JavaScript to improve code flexibility and reusability.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4eb1f7277a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Engineering with empathy: Spectrum Design Web Engineering culture]]></title>
            <link>https://rajrock38.medium.com/engineering-with-empathy-spectrum-design-web-engineering-culture-2ae16455b16c?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ae16455b16c</guid>
            <category><![CDATA[web-components]]></category>
            <category><![CDATA[css]]></category>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Tue, 14 May 2024 12:21:33 GMT</pubDate>
            <atom:updated>2024-05-14T12:21:33.326Z</atom:updated>
            <content:encoded><![CDATA[<h3>Engineering with empathy: Spectrum Design Web Engineering</h3><h3><strong>What is a Design Engineer’s role at Adobe Spectrum Engineering?</strong></h3><p>A Design Engineer position within Adobe’s Spectrum team entails a pronounced emphasis on strategic planning and collaborative initiatives. The role delineates a heightened focus on devising and executing strategic plans, along with fostering collaboration across multifunctional teams.</p><p>Design Engineers within Adobe’s Spectrum Web Components (SWC) team are instrumental in the development and maintenance of foundational web components that underpin the user interface across Adobe’s diverse range of products. The role extends beyond mere coding; it encompasses the strategic planning, architectural design, and implementation of these components, ensuring they meet the highest standards of <strong>performance</strong>, <strong>scalability</strong>, and <strong>usability</strong>.</p><p>One of the primary responsibilities of Design Engineers on the SWC team is to architect and build web components that serve as the building blocks for various product teams within Adobe. This involves understanding the requirements of different products, designing components that are flexible and reusable, and implementing them in a way that promotes consistency and efficiency.</p><h3>What do a Senior/Staff Design Engineer work on?</h3><p>Becoming a Senior Design Engineer at Adobe’s Spectrum team is not just a promotion; it’s a transition into a role that requires a shift in mindset and approach. Moving to a Senior/Staff Design Engineer means taking on more ambiguous, strategic, and impactful work. It’s about understanding the big picture, collaborating effectively, and leading with empathy.</p><p>In this new role, you’re no longer just focused on shipping products; you’re also thinking strategically. You’re diving into projects that have a significant impact on the company’s revenue and overall goals. It’s about aligning your work with the broader objectives of the team and the organization.</p><p>One key aspect of a Senior Design Engineer is understanding what your business wants to work on and what the goals are for the group. This requires clear communication and a deep understanding of the company’s priorities.</p><p>In addition to working on big initiatives, a Senior Design Engineer is also responsible for ensuring that the projects they’re involved in are running smoothly. This means keeping a close eye on the status of the projects, ensuring that everyone is unblocked, and that the team is healthy and humming along.</p><h3>How do Engineers at Spectrum CSS team collaborates with Spectrum Web Components Engineering Team?</h3><p>Moreover, Engineers on the Spectrum CSS team are tasked with managing the CSS aspects of these components. This involves translating design tokens into CSS code and ensuring that the CSS is applied to the web components correctly. They are also responsible for maintaining a consistent design language across products by cascading these CSS styles effectively.</p><p>By working closely with product teams, UX designers, and other stakeholders, Design Engineers on both teams ensure that the web components and CSS they develop not only meet the functional requirements but also align with Adobe’s design principles and brand guidelines. This collaboration is essential for delivering a cohesive and seamless user experience across all Adobe products.</p><h3>How do Design Engineers maintains the core library flexible?</h3><p>One of the key responsibilities of Design Engineers is to ensure that the systems they build are flexible and adaptable. The Engineering team design systems with scalability and modularity in mind, allowing for easy integration of new features and technologies. This flexibility is crucial in today’s rapidly evolving technological landscape, where the ability to quickly pivot and adapt to change is essential for success.</p><h4>Transitioning Away from Individual Contributor Mindset:</h4><p>Senior/Staff Design Engineers undergo a mindset shift from being focused on individual contributions to prioritising broader strategic goals and outcomes. Instead of seeking gratification from writing and committing code, they focus on driving overall team and organisational success. This shift enables them to better align their efforts with the strategic direction of the company and contribute more effectively to long-term goals.</p><h3>How do Design Engineers help in maintaining collaboration with other product teams at Adobe?</h3><p>Within the Spectrum Web Components (SWC) team at Adobe, Design Engineers play a crucial role in collaborating with other product teams to identify cross-organization solutions. They actively engage with teams working on various Adobe products to understand their challenges, requirements, and technological needs. By leveraging their expertise and knowledge of industry trends, Design Engineers identify opportunities where solutions developed within the SWC team can be applied to solve problems across multiple products.</p><p>One way Design Engineers contribute to this collaboration is by actively participating in discussions and meetings with product teams. They offer insights and suggestions on how SWC components and CSS can be used to address specific needs or enhance existing features in other products. This collaboration not only helps in unblocking teams facing technical challenges but also fosters a culture of knowledge sharing and innovation across the organization.</p><p>Additionally, Design Engineers in the SWC team are proactive in sharing updates and enhancements to SWC components with other product teams. This ensures that teams are aware of the latest developments and can leverage them to improve the user experience of their products. Design Engineers also work closely with product teams to address any issues or bugs related to SWC components, providing timely solutions and ensuring smooth integration into their products.</p><h3>Wagging the dog:</h3><p>In conclusion, being a Design Engineer in the Spectrum team is like being a conductor in a symphony orchestra — technical skills are just the tip of the iceberg. It’s about harmonizing with your team members, understanding their rhythms, and leading the performance with empathy and finesse. By tuning into the needs of others, orchestrating collaboration, and conducting with empathy, Design Engineers can create a masterpiece of innovation and teamwork that resonates throughout the company.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ae16455b16c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Art of Dependency Locking with yarn.lock]]></title>
            <link>https://rajrock38.medium.com/the-art-of-dependency-locking-with-yarn-lock-e518e9c7dfa1?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/e518e9c7dfa1</guid>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Wed, 24 Apr 2024 08:32:40 GMT</pubDate>
            <atom:updated>2024-04-24T08:32:40.428Z</atom:updated>
            <content:encoded><![CDATA[<p>In the realm of software development, managing dependencies is a critical aspect of ensuring a project’s stability and security. One key practice that has gained prominence in recent years is dependency locking. Dependency locking involves fixing the version of a software dependency to a specific version number or range, ensuring that the same version is used consistently across all environments. This practice helps to prevent compatibility issues and security vulnerabilities that can arise from using different versions of dependencies. In this blog, we will delve into the importance of dependency locking, its benefits, and how it can be effectively implemented in your projects.</p><h3>Objective</h3><p>It is generally considered good practice to push the yarn.lock file to your GitHub repository, especially for projects that use Yarn as a package manager. This file contains a detailed list of dependencies and their specific versions, ensuring that everyone working on the project uses the same versions of dependencies. However, there are pros and cons to this practice:</p><h3>Pros:</h3><h4><strong>Dependency Locking</strong>:</h4><p>The yarn.lock file locks the versions of dependencies, ensuring that all team members and CI/CD pipelines install the same versions. This prevents issues caused by different dependency versions.</p><h4><strong>What is Dependency Locking?</strong></h4><p>Dependency locking is the process of fixing the version of a software dependency to a specific version number or range. This ensures that the same version of the dependency is used across all environments, including development, testing, and production. Dependency locking is commonly used in package managers like Yarn, npm, and pip to manage dependencies in software projects.</p><p>When you install dependencies using a package manager, it generates a lock file (e.g., yarn.lock, package-lock.json, pip.lock) that records the exact versions of dependencies installed. This lock file is then committed to version control along with your project code. When another developer or CI/CD pipeline installs dependencies, the package manager reads the lock file and installs the exact same versions of dependencies recorded in the lock file.</p><h4><strong>Dependency locking provides several benefits:</strong></h4><ol><li><strong>Consistency</strong>: Ensures that all team members and environments use the same versions of dependencies, reducing the risk of compatibility issues.</li><li><strong>Reproducibility</strong>: Allows you to reproduce the exact dependency tree used during development, testing, or deployment, ensuring consistent behavior across environments.</li><li><strong>Security</strong>: Helps prevent security vulnerabilities by ensuring that all dependencies are locked to specific, known versions.</li><li><strong>Efficiency</strong>: Can speed up dependency installation by skipping the process of fetching package metadata from the registry, as the necessary information is already in the lock file.</li></ol><h3>Cons:</h3><ol><li><strong>File Conflicts</strong>: The yarn.lock file can sometimes lead to conflicts in version control systems, especially in large teams where multiple developers are working on the same file simultaneously.</li><li><strong>File Size</strong>: The yarn.lock file can increase the size of your repository, especially for projects with many dependencies. This can impact cloning and checkout times for new contributors.</li><li><strong>Misleading Sense of Security:</strong> While locking dependencies is beneficial, it’s essential to continue monitoring for security vulnerabilities and update dependencies regularly.</li><li><strong>Potential for Outdated Dependencies</strong>: Developers might be less inclined to update dependencies if they are locked in the yarn.lock file, leading to outdated dependencies and potential security vulnerabilities.</li></ol><h3>Example:</h3><p>Consider a scenario where a team is working on a web application using React. If the yarn.lock file is not committed to the repository, different team members may inadvertently install different versions of React or its dependencies. This can lead to subtle bugs or compatibility issues that are hard to debug.</p><p>On the other hand, if the yarn.lock file is committed, all team members will install the exact same versions of React and its dependencies. This ensures consistency across environments and reduces the likelihood of unexpected issues.</p><p>In conclusion, while there are some drawbacks to committing the yarn.lock file, the benefits of ensuring consistent and reproducible builds usually outweigh the potential downsides.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e518e9c7dfa1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Integrating Stylelint into Your GitHub Workflow: Ensuring Consistency and Quality in Your CSS Code]]></title>
            <link>https://rajrock38.medium.com/integrating-stylelint-into-your-github-workflow-ensuring-consistency-and-quality-in-your-css-code-d9e4f07703f2?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9e4f07703f2</guid>
            <category><![CDATA[eslint]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[css]]></category>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Wed, 19 Apr 2023 12:42:26 GMT</pubDate>
            <atom:updated>2023-04-19T12:42:26.864Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*ckvDKw9sXD8KVgtB.jpg" /></figure><p>Maintaining a consistent and high-quality coding style across your CSS files is crucial to ensuring your web application’s visual and functional integrity. However, as your codebase grows, keeping track of and enforcing a consistent CSS style can be challenging. That’s where Stylelint comes in. Stylelint is a powerful linter that can help you catch errors and inconsistencies in your CSS code before they cause issues in production.</p><p>In this tutorial, we’ll walk you through how to add Stylelint to your GitHub workflow. We’ll start by creating a YAML file in your repository’s .github/workflows folder that defines the workflow logic. Next, we&#39;ll add the necessary dependencies to your repository and create a .stylelintrc file that contains the configuration for Stylelint. With these steps in place, Stylelint will automatically check your CSS files for errors and inconsistencies every time you push or pull request to your repository.</p><p>So, let’s get started and see how you can easily integrate Stylelint into your GitHub workflow and ensure your CSS code’s consistency and quality.</p><p>First, you need to create a .github/workflows folder in your GitHub repository if you haven&#39;t already. Then create a new YAML file in the folder and give it a name that describes its purpose. For example, stylelint.yml.</p><p>In the newly created YAML file, you need to define the workflow that will run <a href="https://stylelint.io/">Stylelint</a>. Here is an example of what the YAML file could look like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/579/1*jIYemjng6q7Jd-2yyVT9BQ.png" /></figure><p>This YAML file contains three main sections: name, on, and jobs. The name section is used to give the workflow a descriptive name. In this case, we’re calling it Stylelint.</p><p>The on section is used to specify when the workflow should run. In this example, the workflow will run when a push or pull request is made to the repository.</p><p>The jobs section is where the workflow logic is defined. In this example, we have one job called stylelint that runs on the ubuntu-latest operating system. This job contains three steps:</p><ol><li>Checkout: This step checks out the repository so that it can be used in subsequent steps.</li><li>Install dependencies: This step installs any required dependencies for Stylelint, which in this example are installed using npm.</li><li>Run Stylelint: This step runs Stylelint on all .css files in the repository.</li></ol><p>Once you have created the YAML file and defined the workflow, you need to add the necessary dependencies to your repository. To do this, create a package.json file in the root of your repository (if you don&#39;t have one already) and add the following dependencies:</p><pre>{<br>  &quot;devDependencies&quot;: {<br>    &quot;stylelint&quot;: &quot;^13.13.1&quot;,<br>    &quot;stylelint-config-standard&quot;: &quot;^22.0.0&quot;<br>  }<br>}</pre><p>This will install Stylelint and the standard configuration for Stylelint. You can modify the configuration as per your requirements.</p><p>Finally, you need to create a .stylelintrc file in the root of your repository. This file contains the configuration for Stylelint. Here is an example of what the file could look like:</p><pre>{<br>  &quot;extends&quot;: &quot;stylelint-config-standard&quot;,<br>  &quot;rules&quot;: {<br>    &quot;indentation&quot;: 2,<br>    &quot;string-quotes&quot;: &quot;double&quot;,<br>    &quot;color-hex-length&quot;: &quot;long&quot;<br>  }<br>}</pre><p>This configuration extends the standard Stylelint configuration and modifies three rules: indentation, string quotes, and color hex length. You can modify this configuration according to your needs.</p><p>Once you have completed these steps, commit the changes to your repository and push them to GitHub. The workflow will now run automatically whenever a push or pull request is made to the repository, and Stylelint will check your CSS files for errors and warnings.</p><p>Thanks for reading. For any questions please reach out to me at rajrock38@gmail.com</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9e4f07703f2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lost your uncommitted changes in Git? There is a FIX!!]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://rajrock38.medium.com/lost-your-uncommitted-changes-in-git-there-is-a-fix-2357ef58466?source=rss-438ef6e1dba6------2"><img src="https://cdn-images-1.medium.com/max/650/1*MQ4qfrgjdpvLjjiu-HUH7A.jpeg" width="650"></a></p><p class="medium-feed-snippet">Well to be honest we all have a tendency to close the laptop after a day&#x2019;s work without committing the changes to GIT and there can be n&#x2026;</p><p class="medium-feed-link"><a href="https://rajrock38.medium.com/lost-your-uncommitted-changes-in-git-there-is-a-fix-2357ef58466?source=rss-438ef6e1dba6------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://rajrock38.medium.com/lost-your-uncommitted-changes-in-git-there-is-a-fix-2357ef58466?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/2357ef58466</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[fix]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Fri, 03 Feb 2023 07:03:18 GMT</pubDate>
            <atom:updated>2023-02-03T07:03:18.351Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Follow this approach to sta recession-proof in 2023]]></title>
            <link>https://rajrock38.medium.com/follow-this-approach-to-sta-recession-proof-in-2023-2a0adb3f147f?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/2a0adb3f147f</guid>
            <category><![CDATA[recession]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Sun, 22 Jan 2023 04:19:04 GMT</pubDate>
            <atom:updated>2023-01-22T04:20:15.785Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ftIbv8m-h1h_I2KOjc01qA.png" /></figure><h3>Follow this approach to stay recession-proof in 2023</h3><p>As the global economy continues to fluctuate, it’s important for software engineers to take steps to ensure that they remain recession-proof. Here are some strategies that software engineers can use to stay competitive and secure during times of economic uncertainty:</p><h3>Continuously develop and improve skills:</h3><p>A software engineer can stay current on the latest technologies by attending industry conferences, taking online courses, or pursuing certifications.</p><p>For example, a software engineer who specializes in Java development can attend a conference on the latest Java updates and take a course on Java frameworks such as Spring or Hibernate.</p><h3>Network and build relationships:</h3><p>A software engineer can build a strong network by attending industry events, joining professional associations, and connecting with other software engineers on LinkedIn.</p><p>For example, a software engineer can attend a local meetup for software developers and connect with other engineers working in similar fields.</p><h3>Be flexible and adaptable:</h3><p>A software engineer can be flexible by being open to new job opportunities and different types of work.</p><p>For example, a software engineer who typically works on web applications can consider taking on a contract role working on mobile app development to gain new skills and experience.</p><h3>Be proactive and take initiative:</h3><p>A software engineer can be proactive by reaching out to potential employers and submitting job applications.</p><p>For example, a software engineer can research companies in their area that are hiring for software development roles and send in a tailored resume and cover letter.</p><h3>Be creative and innovative:</h3><p>A software engineer can use their skills and knowledge to identify new opportunities and come up with innovative ideas.</p><p>For example, a software engineer can use their knowledge of machine learning to propose a new project to their employer that uses AI to improve the company’s product or service.</p><h3>Start your own business:</h3><p>A software engineer can start their own software business by identifying a problem in the market and developing a solution.</p><p>For example, a software engineer can start a business that creates software to automate repetitive tasks for small businesses to save them time and money.</p><h3>Diversify:</h3><p>A software engineer can diversify their income stream by taking on side projects, consulting work, or freelance jobs.</p><p>For example, a software engineer can work on a freelance project for a company on the weekends, which will give them an extra source of income.</p><h3>Be financially savvy:</h3><p>A software engineer can be financially savvy by setting up an emergency fund, paying off debt, and saving for retirement.</p><p>For example, a software engineer can set up automatic savings plan to put a certain amount of money into their emergency fund every month.</p><h3>Be open to relocating:</h3><p>A software engineer can be open to relocating to new locations by researching job opportunities in different regions.</p><p>For example, a software engineer can research job opportunities in cities known for having a thriving tech industry such as San Francisco, New York or Seattle.</p><h3>Best resources in the internet to improve front end development skills:</h3><p>There are many resources available on the internet to help improve front-end development skills. Here are some of the best resources that I would recommend:</p><ol><li><a href="https://www.freecodecamp.org/"><strong>FreeCodeCamp</strong></a>: This is a non-profit organization that offers a comprehensive curriculum of interactive coding challenges and projects for front-end development. It covers HTML, CSS, JavaScript, and other front-end technologies.</li><li><a href="https://developer.mozilla.org/en-US/"><strong>MDN Web Docs</strong></a>: Mozilla Developer Network (MDN) offers a wealth of information on web development, including detailed documentation on HTML, CSS, JavaScript, and other front-end technologies. It’s a great resource for both beginners and experienced developers.</li><li><a href="https://www.codecademy.com/"><strong>Codecademy</strong></a>: Codecademy is an online learning platform that offers interactive coding courses for front-end development. It covers HTML, CSS, JavaScript, and other front-end technologies, with a focus on hands-on learning.</li><li><a href="https://www.w3schools.com/"><strong>W3Schools</strong></a>: W3Schools is a website that offers tutorials and reference materials for web development. It covers a wide range of front-end technologies, including HTML, CSS, JavaScript, and others.</li><li><a href="http://www.youtube.com/"><strong>YouTube</strong></a>: YouTube is a great resource for learning front-end development, with many developers sharing their knowledge and experience through video tutorials. Look for channels that focus on front-end development, such as Traversy Media or freeCodeCamp.</li><li><a href="https://css-tricks.com/"><strong>CSS-Tricks</strong></a>: CSS-Tricks is a website that offers articles, tutorials, and reference materials for CSS development. It’s a great resource for both beginners and experienced developers looking to improve their CSS skills.</li><li><a href="https://frontendmasters.com/"><strong>Frontend Masters</strong></a>: Frontend Masters is an online learning platform that offers advanced courses on front-end development. It covers a wide range of front-end technologies and is aimed at experienced developers looking to take their skills to the next level.</li><li><a href="http://www.github.com/"><strong>GitHub</strong></a>: GitHub is a platform that allows developers to share and collaborate on code. It’s a great resource for finding open-source projects and libraries related to front-end development, and for learning from the code of experienced developers.</li></ol><p>These resources can help you to improve your front-end development skills and stay current with the latest technologies and best practices. It’s important to note that practice and hands-on experience are essential to truly master the skills, so make sure to apply what you learn on real projects.</p><h3>Best Youtube channels to prepare for Frontend Interview:</h3><p>Here are some examples of YouTube channels that are great for preparing for front-end development interviews:</p><ol><li><a href="https://www.youtube.com/@TraversyMedia"><strong>Traversy Media</strong></a>: This channel offers a wide range of tutorials on front-end development, including HTML, CSS, JavaScript, and other technologies. The videos are organised and easy to follow, making them great for preparing for interviews.</li><li><a href="https://www.youtube.com/@freecodecamp"><strong>freeCodeCamp</strong></a>: This channel offers a comprehensive curriculum of interactive coding challenges and projects for front-end development. It covers HTML, CSS, JavaScript, and other front-end technologies, and is great for preparing for interviews.</li><li><a href="https://www.youtube.com/@learncodeacademy"><strong>LearnCode.academy</strong></a>: This channel offers a wide range of tutorials on front-end development, including HTML, CSS, JavaScript, and other technologies. The channel is organised and easy to follow, making it great for preparing for interviews.</li><li><a href="https://www.youtube.com/@developedbyed"><strong>Dev Ed</strong></a>: This channel offers a wide range of tutorials on front-end development, including HTML, CSS, JavaScript, and other technologies. The channel is organised and easy to follow, making it great for preparing for interviews.</li><li><a href="https://www.youtube.com/@NetNinja"><strong>The Net Ninja</strong></a>: This channel offers a wide range of tutorials on front-end development, including HTML, CSS, JavaScript, and other technologies. The channel is organised and easy to follow, making it great for preparing for interviews.</li><li><a href="https://www.youtube.com/@programmingwithmosh"><strong>Programming with Mosh</strong></a>: This channel offers a wide range of tutorials on front-end development, including HTML, CSS, JavaScript, and other technologies. The channel is organised and easy to follow, making it great for preparing for interviews.</li></ol><p>These channels offer a variety of content and cover different aspects of front-end development. They are great for preparing for interviews by helping you to brush up on your skills, stay current with the latest technologies, and gain a deeper understanding of the field.</p><h3>Best Youtube Channels to learn Data Structures and Algorithms</h3><ol><li><a href="https://www.youtube.com/watch?v=8hly31xKli0&amp;ab_channel=freeCodeCamp.org"><strong>Data Structures and Algorithms</strong>:</a> This channel offers a wide range of tutorials on data structures, algorithms, and coding interviews. It covers a variety of data structures and algorithms, including arrays, linked lists, trees, and graphs.</li><li><a href="https://www.youtube.com/c/TheCodingInterview?app=desktop"><strong>Coding Interview University</strong></a>: This channel offers a comprehensive curriculum on data structures, algorithms, and coding interviews. It covers a variety of data structures and algorithms, including arrays, linked lists, trees, and graphs. It also provides tips and tricks on how to approach coding interviews.</li></ol><h3>Best Youtube Channels to learn JavaScript</h3><ol><li><a href="https://www.youtube.com/@javascriptmastery"><strong>JavaScript Mastery</strong></a>: This channel offers a wide range of tutorials on JavaScript, covering everything from the basics to advanced topics. It’s great for preparing for JavaScript interviews by helping you to brush up on your skills and stay current with the latest technologies.</li><li><a href="https://www.youtube.com/@freecodecamp"><strong>freeCodeCamp</strong></a>: This channel offers a comprehensive curriculum of interactive coding challenges and projects for data structures, JavaScript and React.</li><li><a href="https://www.youtube.com/@akshaymarch7"><strong>Namaste JavaScript</strong></a>: This channel offers a wide range of JavaScript tutorials explained specfically for the frontend interviews at big tech companies. Very well explained with examples and in Lehmann’s terms.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2a0adb3f147f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[High Contrast Mode in Web-Accessibility]]></title>
            <link>https://medium.com/design-bootcamp/high-contrast-mode-in-web-accessibility-b54b681ec336?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/b54b681ec336</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[browsers]]></category>
            <category><![CDATA[web]]></category>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Thu, 19 Jan 2023 17:58:45 GMT</pubDate>
            <atom:updated>2023-01-21T00:05:09.022Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2qxl9X0zssuYPsIG680dvA.jpeg" /><figcaption>Source: Goole</figcaption></figure><p>High contrast mode is a feature that allows users to increase the contrast of elements on their screen, making it easier to read text and distinguish between different elements. This can be particularly helpful for users with visual impairments such as color blindness or low vision. High contrast mode can be found in most operating systems and web browsers as a built-in feature.</p><p>When high contrast mode is turned on, the operating system or browser will adjust the colors of elements on the screen, such as text, backgrounds, and images, to make them more distinct from one another. This can make it easier for users with visual impairments to read text, navigate websites, and use apps and software.</p><p>In web browsers, the High Contrast mode can be enabled through the browser’s accessibility settings or by using keyboard shortcuts. Some browsers also have extensions that allow users to enable high contrast mode on specific websites.</p><p>It’s worth mentioning that High contrast mode is not a one-size-fits-all solution, users might prefer different color schemes, and it’s important to test our website with different color schemes, and also to provide a way for users to switch back to their preferred color scheme.</p><h3>How a web developer will make sure that they have covered this during code development?</h3><ol><li>Use appropriate color contrast ratios: Web developers should ensure that the colors used for text and background elements meet the recommended color contrast ratio guidelines, which are defined by the Web Content Accessibility Guidelines (WCAG). This will make it easier for users with visual impairments to read text and distinguish between different elements on the page.</li><li>Test with different color schemes: Developers should test their website with different color schemes and different devices, this will ensure that the website looks and behaves correctly with high-contrast mode enabled, and that the website is accessible for users with visual impairments.</li><li>Provide a high-contrast mode toggle: Developers should provide a way for users to switch back to the default or their preferred color scheme, this can be done by adding a toggle button or link that the user can click to enable and disable the high-contrast mode.</li><li>Use appropriate semantic HTML: Developers should use appropriate semantic HTML elements such as headings, buttons, and links to make it easier for assistive technologies to understand the structure of the page, this will help users with visual impairments to navigate the page more easily.</li><li>Use ARIA attributes: Developers should use ARIA attributes to provide additional information about the elements on the page, this will help users with visual impairments to understand the purpose of the elements on the page and interact with them more easily.</li><li>Test with real users: Developers should test the website with real users with visual impairments to get feedback and make sure that the website is accessible and user-friendly.</li></ol><p>It’s worth noting that accessibility is an ongoing process, and testing and updating the website for accessibility should be an integral part of the development process.</p><h3>Example:</h3><h4>HTML:</h4><pre>&lt;button id=&quot;toggle-high-contrast&quot;&gt;Toggle High Contrast&lt;/button&gt;</pre><h4>CSS:</h4><pre>/* Default styles */<br>body {<br>    color: #000;<br>    background-color: #fff;<br>}<br><br>/* High-contrast styles */<br>.high-contrast {<br>    color: #fff;<br>    background-color: #000;<br>}</pre><h4>JavaScript:</h4><pre>// Get the toggle button<br>var toggleButton = document.getElementById(&quot;toggle-high-contrast&quot;);<br><br>// Add a click event listener to the toggle button<br>toggleButton.addEventListener(&quot;click&quot;, function() {<br>    // Get the body element<br>    var body = document.getElementsByTagName(&quot;body&quot;)[0];<br>    // Toggle the &quot;high-contrast&quot; class on the body element<br>    body.classList.toggle(&quot;high-contrast&quot;);<br>});</pre><p>In this example, the HTML defines a button with an id of “toggle-high-contrast”, which can be used to toggle the high-contrast mode. The CSS defines the default styles for the body element, as well as the high-contrast styles. The JavaScript is used to toggle the “high-contrast” class on the body element when the toggle button is clicked.</p><p>This is just one way to implement a high-contrast mode toggle, and it can be adapted to suit different needs. It’s worth mentioning that this is a simple example, in a real-world scenario, you should also take into consideration, the user’s preferences, and provide a way for the user to save their preferences.</p><p>It’s important to note that this example is provided for demonstration purposes only, and that there are many other ways to implement a high-contrast mode toggle, and this code should be tested and modified to suit our particular needs.</p><h3>What is forced-color-adjust?</h3><p>The forced-color-adjust CSS property is used to control the color adjustment of an element, including its children. It allows authors to override the user&#39;s preferences and force a specific color adjustment on the page.</p><p>This property can take one of two values: auto or none.</p><ul><li>When set to auto, the browser will use the user&#39;s color preferences, as set in the operating system or browser settings.</li><li>When set to none, the browser will ignore the user&#39;s preferences and use the colors specified in the CSS.</li></ul><h3>For example:</h3><pre>body {<br>    forced-color-adjust: none;<br>}</pre><p>This will force the browser to use the colors specified in the CSS, even if the user has set a different color scheme in their operating system or browser settings. It’s worth noting that forced-color-adjust is a relatively new property and support may vary among browsers. Also, it&#39;s considered to be an accessibility feature, so it&#39;s not recommended to use this property without good reason, as it might be confusing to users, especially those with visual impairments.</p><h3>What is it used for?</h3><p>The forced-color-adjust CSS property is mainly used for accessibility purposes. It allows developers to provide a specific color scheme for users with visual impairments, even if the user has set different color preferences on their operating system or browser.</p><p>For example, a developer could use this property to force a high-contrast color scheme on their website for users who have difficulty distinguishing between different colors. This would make it easier for those users to read text and navigate the site.</p><p>Additionally, the property can also be used to override the browser’s default color settings and ensure that a website’s design is consistent across different platforms and devices.</p><p>It’s worth noting, however, that using the forced-color-adjust property should be done with caution and consideration, as it can override the user&#39;s preferences and cause confusion or frustration. It&#39;s always recommended to provide an option for users to switch back to the default or their preferred color scheme.</p><h3>How can we test it in chrome?</h3><p>There are a few ways to test the forced-color-adjust property in Chrome:</p><ol><li><strong>Use the Developer Tools</strong>: Open the Developer Tools by right-clicking on the page and selecting “Inspect” or by pressing “Ctrl + Shift + I” on Windows or “Cmd + Shift + I” on Mac. Once the Developer Tools are open, you can toggle the forced-color-adjust property in the &quot;Elements&quot; tab by selecting the element you want to test and modifying the CSS in the &quot;Styles&quot; section.</li><li><strong>Use a Chrome Extension:</strong> There are several Chrome extensions available that allow you to test different color schemes, including high-contrast modes. One such extension is “Accessibility Developer Tools” which allows you to simulate various visual impairments and test our website’s accessibility.</li><li><strong>Test on a different device:</strong> The forced-color-adjust property can also be tested on different devices, such as smartphones, tablets, and laptops. This allows you to test how the website looks and behaves with different color schemes and settings.</li></ol><p>It’s also good practice to test our website with different screen readers, keyboard navigation and different devices to ensure accessibility compliance.</p><p>It’s worth mentioning that it’s important to test our website with real users with visual impairments to get feedback and make sure that our design is accessible and user-friendly.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b54b681ec336" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/high-contrast-mode-in-web-accessibility-b54b681ec336">High Contrast Mode in Web-Accessibility</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[Step by step guide on how to create a VS code Extension in 2023]]></title>
            <link>https://rajrock38.medium.com/step-by-step-guide-on-how-to-create-a-vs-code-extension-in-2023-e41db6148d5d?source=rss-438ef6e1dba6------2</link>
            <guid isPermaLink="false">https://medium.com/p/e41db6148d5d</guid>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[vscode-extension]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[vscode]]></category>
            <dc:creator><![CDATA[Rajdeep Chandra]]></dc:creator>
            <pubDate>Wed, 11 Jan 2023 17:52:42 GMT</pubDate>
            <atom:updated>2023-01-11T17:52:42.763Z</atom:updated>
            <content:encoded><![CDATA[<h3>Step by step guide on how to create a VS code extension in 2023</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-dUY0HFxKiVOznomOvE6_w.png" /><figcaption>Source: Google</figcaption></figure><p>We all have some or the other problems when we try to code things in VS code. Some things we want the ESLint to catch , some manual tasks needs to be auto completed and some bugs which can be automatically be fixed and more advanced we would someone would like our code to be auto written(chat GPT-3 is already doing it). So its a good time to also know how to create a VS Code extension from scratch to be in the game.</p><p>Here is a step-by-step guide on how to create a Visual Studio Code (VS Code) extension:</p><ol><li>Install the necessary tools: To create a VS Code extension, you’ll need to have Node.js and npm (or yarn) installed on your computer. You can download Node.js from the official website, and npm will be installed automatically along with it.</li><li>Create a new project: Open a terminal window and create a new folder for your extension. Inside that folder, run the command npm init (or yarn init) to create a new package.json file. This file will contain all the necessary metadata for your extension, such as its name and version number.</li><li>Install the VS Code extension generator: To make it easier to create a new extension, you can use the VS Code extension generator. To install it, run the command npm install -g yo generator-code.</li><li>Create a new extension: Run the command yo code in the root of your project, this will start the extension generator and it will guide you through the process of creating your extension. You&#39;ll be prompted to enter the name and identifier of your extension, as well as its description and other information.</li><li>Add functionality to your extension: Once the extension generator is finished, you’ll find a new folder named “src” in your project. This folder contains the main code of your extension, including a file named extension.ts or extension.js that contains a skeleton of a class that represents your extension. You can add new functionality to this class, or create new files as needed.</li><li>Test your extension: You can test your extension by running the command npm run watch (or yarn watch) in the terminal. This command will start a local development server and launch a new instance of VS Code with your extension installed. You can make changes to your code and see the results in real-time.</li><li>Publish your extension: Once you’re satisfied with your extension, you can package it and publish it to the VS Code Marketplace. You can use the command vsce publish to create a .vsix file and publish it to the marketplace.</li></ol><h4>Example:</h4><p>How you can create a simple VS Code extension that adds a new command to the command palette that shows a message when executed:</p><p><strong>1. Create a new folder for your extension:</strong></p><pre>mkdir my-extension<br>cd my-extension</pre><p><strong>2. Initialize your package.json file:</strong></p><pre>npm init</pre><p><strong>3. Create a new folder called </strong><strong>src:</strong></p><pre>mkdir src</pre><p><strong>4. Create a new file called </strong><strong>extension.ts in the </strong><strong>src folder:</strong></p><pre>touch src/extension.ts</pre><p><strong>5. Add the following code to </strong><strong>extension.ts:</strong></p><pre>import * as vscode from &#39;vscode&#39;;<br><br>export function activate(context: vscode.ExtensionContext) {<br>    console.log(&#39;Congratulations, your extension &quot;my-extension&quot; is now active!&#39;);<br><br>    let disposable = vscode.commands.registerCommand(&#39;my-extension.helloWorld&#39;, () =&gt; {<br>        vscode.window.showInformationMessage(&#39;Hello World from my-extension!&#39;);<br>    });<br><br>    context.subscriptions.push(disposable);<br>}<br><br>export function deactivate() {}</pre><p>This code defines an extension with a single command called my-extension.helloWorld that shows a message when executed.</p><p><strong>6. Add the following code to </strong><strong>package.json to configure the extension</strong></p><pre>&quot;contributes&quot;: {<br>    &quot;commands&quot;: [{<br>        &quot;command&quot;: &quot;my-extension.helloWorld&quot;,<br>        &quot;title&quot;: &quot;Hello World&quot;<br>    }]<br>},</pre><p><strong>7. Test your extension: <br></strong>You can test your extension by running the command npm run watch (or yarn watch) in the terminal. This command will start a local development server and launch a new instance of VS Code with your extension installed. You can make changes to your code and see the results in real-time.</p><p><strong>8. Publish your extension:</strong></p><p>Once you’re satisfied with your extension, you can package it and publish it to the VS Code Marketplace. You can use the command vsce publish to create a .vsix file and publish it to the marketplace.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e41db6148d5d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>