<?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[Modern Frontend - Medium]]></title>
        <description><![CDATA[“Modern Frontend” is a blog dedicated to helping frontend developers prepare for technical interviews. Whether you’re aiming for a position at a top tech company or refining your coding skills, this blog provides in-depth articles, real-world interview questions. - Medium]]></description>
        <link>https://medium.com/frontend-interviews?source=rss----fee69df3a99c---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Modern Frontend - Medium</title>
            <link>https://medium.com/frontend-interviews?source=rss----fee69df3a99c---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 22:15:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/frontend-interviews" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Building getElementsByClassName() from Scratch in JavaScript]]></title>
            <link>https://medium.com/frontend-interviews/building-getelementsbyclassname-from-scratch-in-javascript-ba62813d89df?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/ba62813d89df</guid>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Thu, 29 Oct 2026 14:48:18 GMT</pubDate>
            <atom:updated>2026-10-29T14:48:20.012Z</atom:updated>
            <content:encoded><![CDATA[<p>Ever wondered how to implement a native DOM method yourself? This frontend problem is a great way to practice <strong>DOM traversal, recursion, and class matching</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jxeqAt5DqQpOuQQZ" /><figcaption>Photo by <a href="https://unsplash.com/@dkomow?utm_source=medium&amp;utm_medium=referral">Daniil Komov</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>The Problem</h3><p>Implement getElementsByClassName(element, classNames) to return all descendant elements that contain every requested class.</p><p>It should handle:</p><ul><li>Multiple class names, like &quot;foo bar&quot;.</li><li>Duplicate class names in the input.</li><li>Extra whitespace in the input or HTML class attributes.</li><li>Nested elements without returning duplicates.</li></ul><h3>The Approach</h3><p>We can solve this using <strong>Depth-First Search (DFS)</strong>.</p><ol><li>Split the requested class names by whitespace.</li><li>Remove duplicates using a Set.</li><li>Traverse the DOM tree recursively.</li><li>Check whether each element contains every requested class.</li><li>Add matching elements to the result.</li></ol><h3>Implementation</h3><pre>export default function getElementsByClassName(element, classNames) {<br>  const result = [];<br>  const classes = [<br>    ...new Set(classNames.trim().split(/\s+/).filter(Boolean)),<br>  ];<br>  function solve(node) {<br>    for (const child of node.children) {<br>      if (classes.every((cls) =&gt; child.classList.contains(cls))) {<br>        result.push(child);<br>      }<br>      solve(child);<br>    }<br>  }<br>  solve(element);<br>  return result;<br>}</pre><h3>Key Insights</h3><p><strong>1. Why use </strong><strong>classList.contains()?</strong></p><p>It checks for an exact class token rather than a partial string match. For example, &quot;foo&quot; should not match &quot;fooz&quot;.</p><p><strong>2. Why use </strong><strong>every()?</strong></p><p>When the input is &quot;foo bar&quot;, an element must contain both classes to qualify.</p><p><strong>3. Why use a </strong><strong>Set?</strong></p><p>Duplicate requested classes, such as &quot;foo foo&quot;, should not change the result.</p><p><strong>4. Why use recursion?</strong></p><p>Elements can be nested at any depth. Recursion lets us explore every descendant while preserving document order.</p><h3>Complexity Analysis</h3><p>Let n be the number of descendant elements and m the number of unique requested classes.</p><ul><li><strong>Time:</strong> O(n × m) in the worst case.</li><li><strong>Space:</strong> O(m + h + k), where h is the DOM tree height and k is the number of matching elements.</li></ul><h3>Takeaway</h3><p>This problem is more than a DOM exercise. It combines tree traversal, recursion, sets, and array methods in one practical frontend interview question.</p><p>Understanding these fundamentals makes implementing other DOM utilities much easier.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba62813d89df" width="1" height="1" alt=""><hr><p><a href="https://medium.com/frontend-interviews/building-getelementsbyclassname-from-scratch-in-javascript-ba62813d89df">Building getElementsByClassName() from Scratch in JavaScript</a> was originally published in <a href="https://medium.com/frontend-interviews">Modern Frontend</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JavaScript Interview: Implement deepOmit() Without Mutating the Original Object]]></title>
            <link>https://medium.com/frontend-interviews/javascript-interview-implement-deepomit-without-mutating-the-original-object-368fc148da94?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/368fc148da94</guid>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 06:35:54 GMT</pubDate>
            <atom:updated>2026-10-26T06:35:55.651Z</atom:updated>
            <content:encoded><![CDATA[<h3>Problem Statement</h3><p>Implement deepOmit(val, keys) to remove specified keys from an object, including nested objects and arrays, <strong>without modifying the original object</strong>.</p><p>For example, if we want to remove b and e, the function should remove them wherever they appear in the nested structure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rtoDBJ_fWsNLkrss" /><figcaption>Photo by <a href="https://unsplash.com/@gary_at_unsplash?utm_source=medium&amp;utm_medium=referral">Gary Chan</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Input</h3><pre>const data = {<br>  a: 1,<br>  b: 2,<br>  c: {<br>    d: 3,<br>    e: 4<br>  },<br>  f: [5, 6]<br>};</pre><pre>deepOmit(data, [&quot;b&quot;, &quot;e&quot;]);</pre><h3>Expected Output</h3><pre>{<br>  a: 1,<br>  c: {<br>    d: 3<br>  },<br>  f: [5, 6]<br>}</pre><p>The original data object must remain unchanged.</p><h3>Solution</h3><pre>export default function deepOmit(val, keys) {<br>  // Handle primitives and null<br>  if (val === null || typeof val !== &quot;object&quot;) {<br>    return val;<br>  }<br> // Handle arrays<br>  if (Array.isArray(val)) {<br>    return val.map(item =&gt; deepOmit(item, keys));<br>  }<br>  // Create a new object<br>  const result = {};<br>  // Iterate through the object&#39;s keys<br>  for (const key of Object.keys(val)) {<br>    // Skip keys that should be omitted<br>    if (!keys.includes(key)) {<br>      // Recursively process the value<br>      result[key] = deepOmit(val[key], keys);<br>    }<br>  }<br>  return result;<br>}</pre><h3>Understanding the Approach</h3><p>The key idea is to <strong>create a new structure instead of modifying the original one</strong>.</p><h3>1. Handle primitives and null</h3><pre>if (val === null || typeof val !== &quot;object&quot;) {<br>  return val;<br>}</pre><p>If the value is a number, string, boolean, undefined, or null, return it directly.</p><p>For example, deepOmit(5, keys) returns 5.</p><p>We check null separately because JavaScript considers typeof null to be &quot;object&quot;.</p><h3>2. Handle arrays</h3><pre>if (Array.isArray(val)) {<br>  return val.map(item =&gt; deepOmit(item, keys));<br>}</pre><p>If the value is an array, use map() to create a new array.</p><p>Each element is passed through deepOmit() so that nested objects inside arrays are also processed.</p><p>For example:</p><pre>[1, { a: 2, b: 3 }]</pre><p>With keys [&quot;b&quot;], the result becomes:</p><pre>[1, { a: 2 }]</pre><h3>3. Create a new object</h3><pre>const result = {};</pre><p>This creates an empty object to store the properties we want to keep.</p><p>We do not use delete because that would modify the original object.</p><h3>4. Iterate through the properties</h3><pre>for (const key of Object.keys(val)) {</pre><p>Object.keys(val) returns the object&#39;s own enumerable property names.</p><p>For the input object, the keys are:</p><pre>[&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;f&quot;]</pre><p>The loop processes each key one by one.</p><h3>5. Skip unwanted keys</h3><pre>if (!keys.includes(key)) {</pre><p>keys.includes(key) checks whether the current property exists in the omit list.</p><ul><li>If it exists, skip the property.</li><li>If it does not exist, copy the property into the new object.</li></ul><p>For example, when key is &quot;b&quot;, the condition is false, so b is not copied.</p><h3>6. Recursively process each value</h3><pre>result[key] = deepOmit(val[key], keys);</pre><p>This is the most important line.</p><p>It copies the property’s value into the new object, but first passes that value through deepOmit().</p><p>If the value is a primitive, it returns directly. If it is an array or object, the function processes it recursively.</p><p>This ensures that unwanted keys are removed at every nesting level.</p><h3>7. Return the new object</h3><pre>return result;</pre><p>Once all properties have been processed, return the newly created object.</p><p>The original object remains unchanged.</p><h3>Dry Run</h3><p>Let’s walk through the complete execution.</p><p><strong>Input:</strong></p><pre>const data = {<br>  a: 1,<br>  b: 2,<br>  c: {<br>    d: 3,<br>    e: 4<br>  },<br>  f: [5, 6]<br>};</pre><pre>deepOmit(data, [&quot;b&quot;, &quot;e&quot;]);</pre><h3>Step 1: Start with the root object</h3><p>The function receives data and [&quot;b&quot;, &quot;e&quot;].</p><p>The value is an object, not null or a primitive, and it is not an array.</p><p>Therefore, we create a new empty object:</p><pre>result = {};</pre><h3>Step 2: Process a</h3><p>The current key is &quot;a&quot;.</p><pre>keys.includes(&quot;a&quot;); // false</pre><p>Since a is not in the omit list, we execute:</p><pre>result[&quot;a&quot;] = deepOmit(1, keys);</pre><p>The recursive call receives 1. Since it is a primitive, it returns 1.</p><p>Now:</p><pre>result = { a: 1 };</pre><h3>Step 3: Process b</h3><p>The current key is &quot;b&quot;.</p><pre>keys.includes(&quot;b&quot;); // true</pre><p>Because b is in the omit list, the if block is skipped.</p><p>No property is added to result.</p><pre>result = { a: 1 };</pre><p>Notice that we did not delete b from data. We simply did not copy it.</p><h3>Step 4: Process c</h3><p>The current key is &quot;c&quot;.</p><p>Since c is not in the omit list, we execute:</p><pre>result[&quot;c&quot;] = deepOmit(data[&quot;c&quot;], keys);</pre><p>A recursive call starts for the nested object:</p><pre>{<br>  d: 3,<br>  e: 4<br>}</pre><p>This call creates another empty object:</p><pre>result = {};</pre><p>Inside this recursive call:</p><ul><li>d is not in the omit list, so d: 3 is copied.</li><li>e is in the omit list, so it is skipped.</li></ul><p>The nested call returns:</p><pre>{ d: 3 }</pre><p>That returned object is assigned to the outer object’s c property.</p><p>The outer result is now:</p><pre>{<br>  a: 1,<br>  c: {<br>    d: 3<br>  }<br>}</pre><h3>Step 5: Process f</h3><p>The current key is &quot;f&quot;.</p><p>Since f is not in the omit list, we execute:</p><pre>result[&quot;f&quot;] = deepOmit(data[&quot;f&quot;], keys);</pre><p>The value is an array:</p><pre>[5, 6]</pre><p>The array condition is true, so this line executes:</p><pre>return val.map(item =&gt; deepOmit(item, keys));</pre><p>map() processes both elements:</p><ul><li>5 is a primitive, so it returns 5.</li><li>6 is a primitive, so it returns 6.</li></ul><p>A new array is returned:</p><pre>[5, 6]</pre><p>The outer result becomes:</p><pre>{<br>  a: 1,<br>  c: {<br>    d: 3<br>  },<br>  f: [5, 6]<br>}</pre><h3>Step 6: Return the final result</h3><p>The loop has finished, so the function executes:</p><pre>return result;</pre><p><strong>Final output:</strong></p><pre>{<br>  a: 1,<br>  c: {<br>    d: 3<br>  },<br>  f: [5, 6]<br>}</pre><p>The original data object still contains b and c.e.</p><h3>Why Does This Not Mutate the Original Object?</h3><p>We never modify val directly.</p><p>Instead, we create:</p><ul><li>A new object for every object encountered.</li><li>A new array for every array encountered.</li><li>References to primitive values, which are immutable.</li></ul><p>Therefore, changes to the returned structure do not affect the original nested objects or arrays.</p><p>This is a recursive, non-mutating transformation.</p><h3>Complexity Analysis</h3><p>Let N be the total number of values and properties visited, and K be the number of keys to omit.</p><ul><li><strong>Time complexity:</strong> (O(N \times K)) in the worst case, because keys.includes() may scan up to K keys for each property.</li><li><strong>Space complexity:</strong> (O(N)) for the newly created objects and arrays, plus the recursion stack.</li></ul><p>For better lookup performance with a large omit list, we can convert keys into a Set, making key membership checks average (O(1)).</p><h3>Interview Takeaways</h3><ul><li>Use recursion to process nested objects.</li><li>Use Array.isArray() to preserve arrays as arrays.</li><li>Check for null before treating a value as an object.</li><li>Avoid delete when the original input must remain unchanged.</li><li>Create new objects and arrays to preserve immutability.</li></ul><p><strong>Remember:</strong> The main idea is to build a new structure containing only the properties you want to keep, recursively processing every nested value.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=368fc148da94" width="1" height="1" alt=""><hr><p><a href="https://medium.com/frontend-interviews/javascript-interview-implement-deepomit-without-mutating-the-original-object-368fc148da94">JavaScript Interview: Implement deepOmit() Without Mutating the Original Object</a> was originally published in <a href="https://medium.com/frontend-interviews">Modern Frontend</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementing getElementsByStyle() in JavaScript]]></title>
            <link>https://medium.com/frontend-interviews/implementing-getelementsbystyle-in-javascript-2580c959fb2a?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/2580c959fb2a</guid>
            <category><![CDATA[html]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[css]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Sat, 24 Oct 2026 16:35:47 GMT</pubDate>
            <atom:updated>2026-10-24T16:35:48.683Z</atom:updated>
            <content:encoded><![CDATA[<p>How can we find all DOM elements that match a specific CSS property and value without using querySelectorAll()?</p><p>The solution uses <strong>DOM traversal and recursion</strong> to visit every descendant and collect matching elements in an array.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EuOfYMWLmJqPHU2S" /><figcaption>Photo by <a href="https://unsplash.com/@grakozy?utm_source=medium&amp;utm_medium=referral">Greg Rakozy</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>1. The Problem</h3><p>Implement a function that accepts three arguments:</p><ul><li>element: The root element to search from.</li><li>property: The CSS property to check.</li><li>value: The expected CSS value.</li></ul><p>For example:</p><p>javascript</p><pre>getElementsByStyle(document.body, &#39;font-size&#39;, &#39;12px&#39;);</pre><p>The function should return all descendants whose computed font size is 12px, excluding the root element itself.</p><h3>2. Implementation</h3><p>javascript</p><pre>export default function getElementsByStyle(element, property, value) {<br>  const result = [];<br>  function traverse(node) {<br>    for (const child of node.children) {<br>      if (getComputedStyle(child).getPropertyValue(property) === value) {<br>        result.push(child);<br>      }<br>      traverse(child);<br>    }<br>  }<br>  traverse(element);<br>  return result;<br>}</pre><h3>3. Understanding the Approach</h3><ul><li>node.children gives us the direct child elements.</li><li>getComputedStyle(child).getPropertyValue(property) gets the browser-computed value of the specified CSS property.</li><li>If the value matches, we add the child to result.</li><li>traverse(child) recursively searches that child&#39;s descendants.</li><li>Finally, we return the array of matching elements.</li></ul><p>The recursive call is important because matching elements can be nested several levels deep.</p><h3>4. Dry Run: Step-by-Step Execution</h3><p>Consider the following HTML:</p><pre>&lt;div id=&quot;root&quot;&gt;<br>  &lt;span style=&quot;font-size: 12px&quot;&gt;Span&lt;/span&gt;<br>  &lt;section&gt;<br>    &lt;p style=&quot;font-size: 12px&quot;&gt;Paragraph&lt;/p&gt;<br>  &lt;/section&gt;<br>  &lt;blockquote style=&quot;font-size: 14px&quot;&gt;Blockquote&lt;/blockquote&gt;<br>&lt;/div&gt;</pre><p>We call:</p><p>javascript</p><pre>getElementsByStyle(root, &#39;font-size&#39;, &#39;12px&#39;);</pre><p>Initial values:</p><p>javascript</p><pre>result = []<br>property = &#39;font-size&#39;<br>value = &#39;12px&#39;</pre><p>Let’s trace the execution.</p><h3>Step 1: Start with root</h3><p>traverse(root) begins iterating over the root&#39;s children.</p><p>The first child is span.</p><p>Computed style:</p><p>javascript</p><pre>getComputedStyle(span).getPropertyValue(&#39;font-size&#39;)<br>// &quot;12px&quot;</pre><p>Comparison:</p><p>javascript</p><pre>&quot;12px&quot; === &quot;12px&quot; // true</pre><p>So, span is added to the result.</p><p>javascript</p><pre>result = [span]</pre><p>Next, traverse(span) is called. Since span has no children, the recursive call returns immediately.</p><h3>Step 2: Visit section</h3><p>The loop continues to the next child, section.</p><p>Its computed font size is assumed to be 16px in this example.</p><p>javascript</p><pre>&quot;16px&quot; === &quot;12px&quot; // false</pre><p>Nothing is added.</p><p>javascript</p><pre>result = [span]</pre><p>But we still call:</p><p>javascript</p><pre>traverse(section)</pre><p>This explores the children inside section.</p><h3>Step 3: Visit the nested p</h3><p>Inside section, the child is p.</p><p>javascript</p><pre>getComputedStyle(p).getPropertyValue(&#39;font-size&#39;)<br>// &quot;12px&quot;</pre><p>Comparison:</p><p>javascript</p><pre>&quot;12px&quot; === &quot;12px&quot; // true</pre><p>The paragraph is added.</p><p>javascript</p><pre>result = [span, p]</pre><p>Next, traverse(p) runs. Since p has no children, it returns immediately.</p><p>Control then returns to the loop inside traverse(root).</p><h3>Step 4: Visit blockquote</h3><p>The next child of root is blockquote.</p><p>javascript</p><pre>getComputedStyle(blockquote).getPropertyValue(&#39;font-size&#39;)<br>// &quot;14px&quot;</pre><p>Comparison:</p><p>javascript</p><pre>&quot;14px&quot; === &quot;12px&quot; // false</pre><p>The element is not added.</p><p>javascript</p><pre>result = [span, p]</pre><p>Since blockquote has no children, its recursive call returns immediately.</p><h3>Step 5: Return the result</h3><p>All descendants have now been checked.</p><p>javascript</p><pre>return [span, p];</pre><p>The final result contains the span and p elements, in document order.</p><h3>5. Complexity Analysis</h3><ul><li><strong>Time:</strong> O(n), where n is the number of descendant elements, assuming each style lookup takes constant time.</li><li><strong>Recursive stack space:</strong> O(h), where h is the maximum depth of the DOM tree.</li><li><strong>Result array:</strong> O(n) in the worst case if every descendant matches.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2580c959fb2a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/frontend-interviews/implementing-getelementsbystyle-in-javascript-2580c959fb2a">Implementing getElementsByStyle() in JavaScript</a> was originally published in <a href="https://medium.com/frontend-interviews">Modern Frontend</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Frontend System Design: Build News Feed]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/frontend-interviews/system-design-build-news-feed-74720d0ae767?source=rss----fee69df3a99c---4"><img src="https://cdn-images-1.medium.com/max/1024/1*JTNBr05p7zjX9dTLNR09tg.jpeg" width="1024"></a></p><p class="medium-feed-snippet">News feed applications, such as Facebook, Twitter, and Reddit, have become a staple in modern web experiences. While much has been written&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/frontend-interviews/system-design-build-news-feed-74720d0ae767?source=rss----fee69df3a99c---4">Continue reading on Modern Frontend »</a></p></div>]]></description>
            <link>https://medium.com/frontend-interviews/system-design-build-news-feed-74720d0ae767?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/74720d0ae767</guid>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[frontend-system-design]]></category>
            <category><![CDATA[build-news-feed]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Sun, 24 Aug 2025 18:14:24 GMT</pubDate>
            <atom:updated>2025-04-21T15:20:45.299Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Frontend System Design: Infinite Scroll (Radio Method)]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/frontend-interviews/frontend-system-design-infinite-scroll-radio-method-ecf75336a600?source=rss----fee69df3a99c---4"><img src="https://cdn-images-1.medium.com/max/910/1*0VGNmgyJoosootdcs5egqA.png" width="910"></a></p><p class="medium-feed-snippet">Objective: Design a production&#x2011;ready, accessible, high&#x2011;performance infinite scroll experience (e.g.,</p><p class="medium-feed-link"><a href="https://medium.com/frontend-interviews/frontend-system-design-infinite-scroll-radio-method-ecf75336a600?source=rss----fee69df3a99c---4">Continue reading on Modern Frontend »</a></p></div>]]></description>
            <link>https://medium.com/frontend-interviews/frontend-system-design-infinite-scroll-radio-method-ecf75336a600?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/ecf75336a600</guid>
            <category><![CDATA[system-design-interview]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[infinite-scroll]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[satish-shriwas]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Sun, 24 Aug 2025 18:08:06 GMT</pubDate>
            <atom:updated>2025-08-24T18:07:44.383Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Top Frontend System Design Questions Nobody Prepares For]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/frontend-interviews/top-frontend-system-design-questions-nobody-prepares-for-3db549892518?source=rss----fee69df3a99c---4"><img src="https://cdn-images-1.medium.com/max/2600/0*lGgJvYjqRP7oWCKZ" width="3882"></a></p><p class="medium-feed-snippet">Let&#x2019;s be honest: most frontend interview prep is boringly predictable.</p><p class="medium-feed-link"><a href="https://medium.com/frontend-interviews/top-frontend-system-design-questions-nobody-prepares-for-3db549892518?source=rss----fee69df3a99c---4">Continue reading on Modern Frontend »</a></p></div>]]></description>
            <link>https://medium.com/frontend-interviews/top-frontend-system-design-questions-nobody-prepares-for-3db549892518?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/3db549892518</guid>
            <category><![CDATA[system-design-interview]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[satish-shriwas]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Sun, 24 Aug 2025 10:04:45 GMT</pubDate>
            <atom:updated>2025-08-24T06:25:20.101Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[HTML Is Dead. And Honestly? That’s Fine.]]></title>
            <link>https://medium.com/frontend-interviews/html-is-dead-and-honestly-thats-fine-5fa6574243f0?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/5fa6574243f0</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[html]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[html-is-dead]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Fri, 15 Aug 2025 06:14:10 GMT</pubDate>
            <atom:updated>2025-08-15T06:13:48.577Z</atom:updated>
            <content:encoded><![CDATA[<p>Yeah, I said it: <strong>HTML is dead</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HZULRloNMQ-bMpJynUg-Lw.png" /></figure><p>Okay, before the web purists come at me with pitchforks, let me clarify — HTML still technically exists. Your browser still uses it. Every webpage is built on it. But in the day-to-day work of modern web development, <strong>HTML as we used to know it is basically gone</strong>.</p><p>We don’t write HTML anymore — <strong>we generate it</strong>, <strong>abstract over it</strong>, or let <strong>AI do it for us</strong>. It’s no longer front and center in how we build for the web.</p><h3>Nobody’s Hand-Coding HTML in 2025</h3><p>Think about it. When was the last time you opened up a blank .html file and started typing out &lt;html&gt;&lt;head&gt;&lt;body&gt;?</p><p>Exactly.</p><p>These days, most developers are working inside component frameworks like React, Vue, or Svelte. You write JSX, or Svelte syntax, or use libraries that spit out the structure for you. And if you’re using tools like Webflow, Framer, or even AI copilots, you’re not even <em>seeing</em> the HTML anymore — it’s just happening behind the scenes.</p><p>HTML used to be step one of learning web dev. Now it’s an afterthought — or worse, skipped entirely.</p><h3>We’re Building with Components, Not Tags</h3><p>Let’s be real — no one wants to handcraft endless &lt;div class=&quot;container&quot;&gt; blocks anymore. We think in components, design systems, and layout grids.</p><p>We import a Navbar, drop in a HeroSection, and wire it up with some Tailwind or Chakra UI. The structure? That’s taken care of for us. HTML is the lowest level of the stack now — like plumbing in a house. Essential, but not something you touch unless something breaks.</p><h3>AI Just Took It Further</h3><p>AI tools like ChatGPT, GitHub Copilot, and every new “design to code” startup are accelerating this even more.</p><p>Want a landing page? Type:</p><blockquote><em>“Build a simple landing page with a hero, some features, and a contact form.”</em></blockquote><p>Boom. AI gives you perfect HTML (with CSS and maybe some JS too), and you barely need to read it, let alone write it. And honestly? That’s a win.</p><h3>So… Is That a Bad Thing?</h3><p>No, not really.</p><p>HTML had its moment. It taught us how the web works. It gave us semantic structure. It helped us build everything from Geocities pages to full-blown apps. But the web has changed — and our tools have evolved.</p><p>We’re focused on DX (developer experience), not just syntax. We’re optimizing for speed, reusability, accessibility, and performance. If HTML can happen in the background while we focus on those things, isn’t that kind of the dream?</p><h3>Look, It’s Not Dead Dead…</h3><p>HTML is still everywhere. It’s rendered by browsers. It’s required for SEO. It matters for accessibility. But the <em>act</em> of writing raw HTML by hand? That’s slowly disappearing from the average developer’s workflow.</p><p>So maybe a better way to put it is this:</p><p><strong>HTML isn’t dead — it’s just retired.</strong><br>Hanging out behind the scenes, still doing important work… but no longer the star of the show.</p><p>And honestly? It’s earned that rest.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5fa6574243f0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/frontend-interviews/html-is-dead-and-honestly-thats-fine-5fa6574243f0">HTML Is Dead. And Honestly? That’s Fine.</a> was originally published in <a href="https://medium.com/frontend-interviews">Modern Frontend</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ReactJS Cheatsheet (2025 Edition)]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/frontend-interviews/reactjs-cheatsheet-2025-edition-95676259b5ee?source=rss----fee69df3a99c---4"><img src="https://cdn-images-1.medium.com/max/2600/0*xA5y_EXCUh2VEfQu" width="4515"></a></p><p class="medium-feed-snippet">A compact, dev-friendly ReactJS cheatsheet covering core concepts, hooks, routing, performance, and new features from React 18 &amp; 19.</p><p class="medium-feed-link"><a href="https://medium.com/frontend-interviews/reactjs-cheatsheet-2025-edition-95676259b5ee?source=rss----fee69df3a99c---4">Continue reading on Modern Frontend »</a></p></div>]]></description>
            <link>https://medium.com/frontend-interviews/reactjs-cheatsheet-2025-edition-95676259b5ee?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/95676259b5ee</guid>
            <category><![CDATA[cheatsheet]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[reactjs]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Fri, 15 Aug 2025 06:06:57 GMT</pubDate>
            <atom:updated>2025-08-15T06:06:41.293Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Why Learning Go Feels Natural for Frontend Developers]]></title>
            <link>https://medium.com/frontend-interviews/why-learning-go-feels-natural-for-frontend-developers-63ceddd984c3?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/63ceddd984c3</guid>
            <category><![CDATA[go-language]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[upskilling]]></category>
            <category><![CDATA[backend]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Thu, 10 Jul 2025 07:28:35 GMT</pubDate>
            <atom:updated>2025-07-10T07:28:12.075Z</atom:updated>
            <content:encoded><![CDATA[<p>As a frontend developer, you’ve likely mastered JavaScript, dabbled in TypeScript, and worked with modern frameworks like React or Vue. You’re comfortable with components, state management, REST APIs, and asynchronous code. So, when it comes to learning backend technologies, Go (Golang) might not seem like the obvious next step — but here’s the surprise:</p><p><strong>Go is <em>way more similar</em> to your frontend experience than you think.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DcvZbgx03GYUw01z6wtUZA.jpeg" /></figure><p>In fact, Go might be the most natural backend language for frontend devs looking to expand their skills. Let’s break down exactly why.</p><h3>1. Clean and Minimal Syntax — Like JavaScript, but Typed</h3><p>Go’s syntax is simple and readable — just like modern JavaScript. No semicolon gymnastics, no unnecessary verbosity, no crazy hierarchies.</p><p><strong>Side-by-side:</strong></p><pre>// JavaScript<br>function greet(name) {<br>  return `Hello, ${name}`;<br>}</pre><pre>// Go<br>func greet(name string) string {<br>  return &quot;Hello, &quot; + name<br>}</pre><p>The structure and flow are nearly identical. You declare functions, pass parameters, and return values — just with clear types.</p><p>If you’ve adopted TypeScript, Go will feel even more familiar. It’s type-safe, but without being overwhelming.</p><h3>2. Functions First, Objects Optional</h3><p>In JavaScript, everything revolves around <strong>functions</strong>. While Go supports structs and methods (think: lightweight objects), the core of the language is built on <strong>functions and composition</strong> — not classes or inheritance.</p><p>That means less mental shift for you.</p><p><strong>In both Go and JS:</strong></p><ul><li>Functions are first-class citizens</li><li>Composition is favored over inheritance</li><li>You rarely need to define classes</li></ul><h3>3. Easy HTTP Servers (Just Like Express)</h3><p>You already know how to build APIs with Express or Next.js. Go’s standard library makes doing the same <em>shockingly</em>straightforward.</p><p><strong>Express (Node.js):</strong></p><pre>app.get(&#39;/&#39;, (req, res) =&gt; {<br>  res.send(&#39;Hello World&#39;);<br>});</pre><pre>Go:<br><br>http.HandleFunc(&quot;/&quot;, func(w http.ResponseWriter, r *http.Request) {<br>  fmt.Fprintln(w, &quot;Hello World&quot;)<br>})</pre><p>Looks familiar, right? Same concepts: routes, request handlers, response objects. Only difference? Go compiles to a single fast binary.</p><h3>4. Async = Concurrency (Same Idea, Different Tools)</h3><p>Frontend devs live in an async world — async/await, Promises, event loops. Go embraces the same philosophy of non-blocking code with its unique <strong>goroutines</strong>.</p><p><strong>JavaScript:</strong></p><pre>async function fetchData() {<br>  const res = await fetch(&#39;/api/data&#39;);<br>}</pre><p>GO:</p><pre>go fetchData()</pre><h3>5. Reusable Components = Reusable Packages</h3><p>In frontend, you think in components and modules. In Go, you think in <strong>packages</strong>. Both encourage:</p><ul><li>Modularity</li><li>Reuse</li><li>Isolation of concerns</li></ul><p>Just like importing a component in React, you can import packages in Go for routing, database access, authentication, and more. No bloated config, no magical tooling.</p><h3>6. Developer Experience That Feels Familiar</h3><p>If you love tools like:</p><ul><li>ESLint</li><li>Prettier</li><li>Jest</li><li>Vite</li></ul><p>Then you’ll appreciate that Go ships with:</p><ul><li>go fmt (automatic formatting)</li><li>go test (built-in testing)</li><li>go run (quick execution)</li><li>go build (easy compilation)</li></ul><p>It’s like having a full dev setup baked into the language — just like modern frontend frameworks do.</p><h3>Final Thoughts: You’re Closer Than You Think</h3><p>Learning Go as a frontend developer isn’t a leap — it’s a <strong>step sideways</strong>. The patterns you’ve mastered in JavaScript and TypeScript map cleanly to Go. With just a bit of syntax to pick up, you’ll unlock the power to:</p><ul><li>Build your own backend</li><li>Deploy APIs</li><li>Handle async tasks</li><li>Write server-side code that just works</li></ul><p>And the best part? You’ll do it with the same clarity and simplicity that drew you to frontend dev in the first place.</p><p>Just like importing a component in React, you can import packages in Go for routing, database access, authentication, and more. No bloated config, no magical tooling.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63ceddd984c3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/frontend-interviews/why-learning-go-feels-natural-for-frontend-developers-63ceddd984c3">Why Learning Go Feels Natural for Frontend Developers</a> was originally published in <a href="https://medium.com/frontend-interviews">Modern Frontend</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Decided to Go Full-Stack (and Why You Might Want to Too)]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/frontend-interviews/why-i-decided-to-go-full-stack-and-why-you-might-want-to-too-3af28149f3ac?source=rss----fee69df3a99c---4"><img src="https://cdn-images-1.medium.com/max/600/1*Cdwyvpr5QJZCB1jk45RLrA.jpeg" width="600"></a></p><p class="medium-feed-snippet">A few years ago, I was deep into frontend development&#x200A;&#x2014;&#x200A;living in React land, styling with Tailwind, and obsessing over pixel-perfect UI&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/frontend-interviews/why-i-decided-to-go-full-stack-and-why-you-might-want-to-too-3af28149f3ac?source=rss----fee69df3a99c---4">Continue reading on Modern Frontend »</a></p></div>]]></description>
            <link>https://medium.com/frontend-interviews/why-i-decided-to-go-full-stack-and-why-you-might-want-to-too-3af28149f3ac?source=rss----fee69df3a99c---4</link>
            <guid isPermaLink="false">https://medium.com/p/3af28149f3ac</guid>
            <category><![CDATA[advice]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[full-stack]]></category>
            <category><![CDATA[frontend]]></category>
            <dc:creator><![CDATA[Satish Shriwas]]></dc:creator>
            <pubDate>Sun, 25 May 2025 18:09:59 GMT</pubDate>
            <atom:updated>2025-05-25T06:53:14.729Z</atom:updated>
        </item>
    </channel>
</rss>