DEV Community: Khushi Patel

Implement LFU using LRU

Khushi Patel — Thu, 02 Apr 2026 09:27:06 +0000

📌 Core Idea

LFU (Least Frequently Used) means:

Remove the least frequently used key
If multiple keys have same frequency → remove least recently used (LRU)

📦 Data Structures Used

We maintain:

key → node (for O(1) access)
freq → doubly linked list (group nodes by frequency)
minFreq (track minimum frequency in cache)

🧱 Structure Visualization

Freq = 1 → [ most recent .... least recent ]

Freq = 2 → [ most recent .... least recent ]

Freq = 3 → [ most recent .... least recent ]

Each frequency has its own LRU list

🚀 Example Walkthrough

Capacity = 2

Step 1: put(1,10)

Freq 1: [1]

minFreq = 1

Step 2: put(2,20)

Freq 1: 2, 1

minFreq = 1

Step 3: get(1)

Access key 1
Increase its frequency: 1 → 2

Freq 1: [2]

Freq 2: [1]

minFreq = 1

👉 We removed 1 from freq 1 and added to freq 2

Step 4: put(3,30)

Cache is FULL → eviction needed

minFreq = 1
Look at Freq 1 → [2]

👉 Remove 2

After insertion:

Freq 1: [3]

Freq 2: [1]

minFreq = 1

Step 5: get(3)

Move 3 from freq 1 → freq 2

Freq 1: []

Freq 2: [3, 1]

minFreq = 2 (freq 1 is empty now)

Step 6: put(4,40)

Cache full → eviction

minFreq = 2
Freq 2 → [3, 1]

👉 Remove LRU → 1

After insertion:

Freq 1: [4]

Freq 2: [3]

minFreq = 1

🔥 Key Observations

1. Why multiple lists?

Different frequencies → cannot maintain in single list
Each frequency maintains its own LRU order

2. Why minFreq?

Helps directly find which list to evict from in O(1)

3. Why doubly linked list?

O(1) removal
Maintain LRU order inside same frequency

🧠 Mental Model

Think of LFU like books:

Shelf 1 → least used books
Shelf 2 → moderately used
Shelf 3 → most used

When removing:

Pick least used shelf
Remove oldest book from that shelf

🧩 Mapping to Code

Concept	Code
Increase frequency	updateFreq(node)
Remove LRU	list->tail->prev
Track minimum	minFreq
Insert new node	freq = 1

🚨 Common Mistake

When a frequency list becomes empty:

if(freq == minFreq && list is empty)
    minFreq++;

❗ If you don’t update minFreq, eviction will break

Code

class LFUCache {
public:
    class Node {
    public:
        int key, val, freq;
        Node* prev;
        Node* next;

        Node(int k, int v) {
            key = k;
            val = v;
            freq = 1;
        }
    };

    class List {
    public:
        Node* head;
        Node* tail;
        int size;

        List() {
            head = new Node(-1, -1);
            tail = new Node(-1, -1);
            head->next = tail;
            tail->prev = head;
            size = 0;
        }

        void addFront(Node* node) {
            Node* temp = head->next;
            node->next = temp;
            node->prev = head;
            head->next = node;
            temp->prev = node;
            size++;
        }

        void removeNode(Node* node) {
            Node* prevv = node->prev;
            Node* nextt = node->next;
            prevv->next = nextt;
            nextt->prev = prevv;
            size--;
        }
    };

    int cap;
    int minFreq;

    unordered_map<int, Node*> keyNode;        // key -> node
    unordered_map<int, List*> freqList;       // freq -> DLL

    LFUCache(int capacity) {
        cap = capacity;
        minFreq = 0;
    }

    void updateFreq(Node* node) {
        int freq = node->freq;
        freqList[freq]->removeNode(node);

        if (freq == minFreq && freqList[freq]->size == 0) {
            minFreq++;
        }

        node->freq++;

        if (freqList.find(node->freq) == freqList.end()) {
            freqList[node->freq] = new List();
        }

        freqList[node->freq]->addFront(node);
    }

    int get(int key) {
        if (keyNode.find(key) == keyNode.end()) return -1;

        Node* node = keyNode[key];
        updateFreq(node);
        return node->val;
    }

    void put(int key, int value) {
        if (cap == 0) return;

        if (keyNode.find(key) != keyNode.end()) {
            Node* node = keyNode[key];
            node->val = value;
            updateFreq(node);
            return;
        }

        if (keyNode.size() == cap) {
            List* list = freqList[minFreq];
            Node* nodeToRemove = list->tail->prev;

            keyNode.erase(nodeToRemove->key);
            list->removeNode(nodeToRemove);
        }

        Node* newNode = new Node(key, value);
        minFreq = 1;

        if (freqList.find(1) == freqList.end()) {
            freqList[1] = new List();
        }

        freqList[1]->addFront(newNode);
        keyNode[key] = newNode;
    }
};

7-Day Beginner’s Mindmap to Learn GenAI

Khushi Patel — Tue, 15 Jul 2025 04:26:23 +0000

Perfect for anyone curious about ChatGPT, LLMs, image generation & more!
Each day has clear topics + free resources (courses, videos, articles) 🧠✨

👉 Explore the full mindmap here: Link

Follow on Instagram CodeAndCrunch

Understanding Video Streaming and Optimize Media Downloads 📽️📂

Khushi Patel — Tue, 04 Mar 2025 12:48:33 +0000

Video streaming has become an integral part of our digital experience, powering everything from YouTube and Netflix to social media platforms like Facebook, Twitter (X), and Instagram. While streaming is optimized for seamless playback, there are times when users might want to download content for offline access. This raises the question: How does video streaming work, and how can we optimize media downloads while staying within ethical boundaries?

In this post, we’ll break down the core principles of video streaming, explore how video downloads work, and discuss ways to optimize media retrieval efficiently.

How Video Streaming Works ⚒️

Streaming works by delivering media data in small chunks rather than requiring users to download the entire file before playback. Here’s a breakdown of key concepts:

1. Streaming Protocols

HTTP Live Streaming (HLS): Used by Apple devices and many streaming platforms, HLS splits videos into small .tssegments, which are loaded dynamically.
Dynamic Adaptive Streaming over HTTP (DASH): A widely used protocol that adjusts video quality based on network conditions.
Real-Time Messaging Protocol (RTMP): Previously popular for live streaming but now largely replaced by HLS/DASH.

2. Video Encoding & Compression

Codecs (H.264, H.265, VP9, AV1): Used to compress video files while maintaining quality.
Bitrate Adaptation: Streaming platforms adjust video quality based on bandwidth to avoid buffering.

3. Content Delivery Networks (CDNs)

CDNs store video files across multiple servers worldwide to reduce latency and improve load times.

How Media Downloads Work

Downloading a video is different from streaming because it involves retrieving the full file instead of fetching segments dynamically. However, many platforms restrict direct downloads to protect content rights. Here’s how media downloads typically work:

1. Direct File Download

Some platforms provide direct download options (e.g., YouTube Premium for offline viewing).

2. M3U8 Parsing (HLS Streams)

Some media files are segmented into .m3u8 playlists containing multiple .ts files. These need to be reconstructed into a full video. read more

3. API-Based Downloads

Some services provide APIs to fetch media content legally, All in One Downloader All in One Downloader is a great example of this which allow user to download video from multiple social media platform

Conclusion

By leveraging the right technologies and understanding video formats, you can enhance your workflow and make media retrieval more seamless.

What are your thoughts on video downloads and streaming optimization? Have you built any tools to enhance media retrieval? Let’s discuss in the comments! 🚀

you know about this tools?

Khushi Patel — Thu, 30 Jan 2025 12:56:42 +0000

5 Open Source Tools Every SaaS Founder Should Use for Free 🚀

Khushi Patel ・ Jan 30

#startup #marketing #saas #javascript

5 Open Source Tools Every SaaS Founder Should Use for Free 🚀

Khushi Patel — Thu, 30 Jan 2025 12:52:44 +0000

Starting a SaaS business is exciting—until you realize how expensive it can get. Hosting, analytics, support, marketing... it all adds up!

But what if I told you there are powerful open-source tools that can save you thousands of dollars while giving you full control over your data?

Yep, you heard that right! Here are five open-source gems every SaaS founder should be using (for free!) to build, grow, and scale their startup.

1️⃣ Plausible – Privacy-Friendly Analytics 📊
Why pay for Google Analytics when you can own your data? Plausible is an open-source, lightweight analytics tool that gives you clear insights without slowing down your website. Plus, it’s GDPR compliant by design—no cookies, no tracking nightmares.

🔹 Why you'll love it?
✔️ Simple, clean UI (No need for a data science degree!)
✔️ No invasive tracking—privacy-first 🌍
✔️ Self-host it for zero monthly costs

💡 Perfect for: Founders who care about privacy and want an easy-to-understand analytics dashboard.

👉 Check it out: plausible.io

2️⃣ Chatwoot – Open-Source Live Chat & Support 💬
Forget Intercom’s hefty price tag! Chatwoot is an open-source alternative that helps you chat with customers in real-time, manage support tickets, and automate conversations.

🔹 Why you'll love it?
✔️ Omnichannel support (Website, WhatsApp, Facebook, etc.)
✔️ Customizable & developer-friendly
✔️ No per-agent pricing, scale for free!

💡 Perfect for: SaaS founders who want direct customer engagement without burning a hole in their wallet.

👉 Check it out: chatwoot.com

3️⃣ PostHog – Product Analytics on Steroids 🔥
Want to know how users interact with your SaaS? PostHog gives you session replays, feature flags, and event tracking all in one place. It’s like Mixpanel & Hotjar had an open-source baby.

🔹 Why you'll love it?
✔️ Event-based analytics (track anything!)
✔️ User session recordings for UI/UX insights
✔️ Feature flags to test new features safely

💡 Perfect for: SaaS founders who want deep product insights to optimize their UX.

👉 Check it out: posthog.com

4️⃣ NocoDB – Open-Source Airtable Alternative 🏗️
Who needs Airtable when NocoDB lets you turn any database into a smart, spreadsheet like interface? You can build admin panels, internal tools, and dashboards—no coding required!

🔹 Why you'll love it?
✔️ Works with MySQL, PostgreSQL, and more
✔️ Drag & drop interface, just like Airtable
✔️ Self-host it = No monthly fees!

💡 Perfect for: SaaS founders who need a database-driven app without expensive SaaS subscriptions.

👉 Check it out: nocodb.com

5️⃣ Mautic – Open-Source Marketing Automation 🎯
Want to automate email campaigns, lead scoring, and customer journeys without paying for HubSpot or ActiveCampaign? Mautic is your answer!

🔹 Why you'll love it?
✔️ Powerful marketing automation (emails, SMS, social, web)
✔️ Advanced segmentation & lead scoring
✔️ Self-hosted = Own your data + Save $$$

💡 Perfect for: SaaS founders who need automated marketing on a budget.

👉 Check it out: mautic.org

Final Thoughts 💡
SaaS founders, stop burning cash on expensive tools when open-source alternatives are just as powerful! These tools let you:
✅ Cut costs 💰
✅ Own your data 🔐
✅ Customize and scale your startup your way 🚀

Which open-source tool are you most excited to try? Drop a comment below! 👇

The DSA Revision Mindmap

Khushi Patel — Sat, 11 Jan 2025 14:52:11 +0000

The DSA Revision Mindmap is your ultimate companion for revisiting core concepts in Data Structures and Algorithms. It provides a bird’s-eye view of essential topics and key problem-solving strategies, making your preparation efficient and well-structured.

This mindmap organizes complex topics into digestible sections, including data structures like arrays, trees, and graphs, as well as algorithmic techniques such as dynamic programming, greedy methods, and backtracking. It also integrates mathematical foundations, complexity analysis, and real-world problem patterns to ensure you’re prepared for coding interviews and competitive programming challenges.

Whether you’re gearing up for interviews, tackling coding contests, or simply strengthening your fundamentals, this mindmap helps you stay focused and systematic, covering all the essentials you need to excel in DSA.

Link: https://miro.com/app/board/uXjVL1_8PFI=/?share_link_id=385430008121

Mindmap for graphQL in 7 days

Khushi Patel — Wed, 18 Sep 2024 16:54:34 +0000

Here i have create mindmap for graphql
for each days it has some topics and tasks attached
for each days it attached one youtube video
link :
https://miro.com/app/board/uXjVLdCFL7I=/

Happy Coding ! 🫶🏻

Lerna – The key of Monorepo Management

Khushi Patel — Thu, 12 Sep 2024 03:37:38 +0000

Welcome Back to Monorepo Castle!
The castle is now built, and every room (project) is in place. But without the right management, things could get messy. Who will help the castle run smoothly? That’s when Lerna enters—a powerful wizard with magical commands that keep everything in order.

Lerna is your guide in the land of monorepo, making sure all the rooms (projects) are in sync, all the packages are linked, and nothing falls apart.

Meet the Magical Wizard: Lerna

Lerna isn't just any wizard—it’s a super wizard designed to make your life easier while managing multiple projects in one repo. Let’s take a peek at some of Lerna’s spells (commands):

1. lerna init – The “Let’s Build a Castle” Spell
This is where it all starts. You summon Lerna with this command, and it sets up the structure for your monorepo. It’s like laying the foundation for your castle—each room has its place.

lerna init

Then define your workspaces in package.json. With Yarn or pnpm, you can list all the packages that should be managed:


{
  "private": true,
  "workspaces": [
    "packages/*"
  ]
}

This tells the package manager to treat everything inside the packages/ directory as individual sub-projects (frontend, backend, shared libraries, etc.).

2. Yarn or pnpm for Dependency Management
Previously, Lerna had lerna bootstrap to link dependencies across packages, but this has been deprecated. Instead, use Yarn or pnpm for this task. you can run any of bellow command

yarn install
pnpm install

This automatically links all the projects inside your monorepo, so they can share dependencies. It also deduplicates packages to reduce size, making the installation process faster.

3. Running Commands Across Packages
One of the most powerful features of Lerna is still intact: running scripts across multiple packages in the monorepo. If your monorepo has both a frontend and backend, for example, you can run build or test commands across both without switching directories.

Run the build script in every package:

lerna run build

Lerna will go into each package and execute the build script, which is extremely useful when you want to ensure all packages are in sync before deployment.

4. Versioning & Publishing
Lerna’s original focus remains unchanged: versioning and publishing.
Versioning: Lerna will automatically bump versions for your packages based on the changes you’ve made. This ensures that when you make updates, version numbers are consistent across the whole project.

lerna version

Publishing: When it’s time to release, you can use Lerna to publish all packages at once, or selectively, depending on your needs:

lerna publish

With Lerna by your side, managing a monorepo becomes an absolute easy. From syncing dependencies to running scripts across projects, Lerna keeps the castle organized, efficient, and fast.

Stay tuned for more wizardry as we explore other tools in this magical land of web development. ✨

till then, Happy Coding ! 🫶🏻

Monorepo – The Magic of One Repo you must know as full stack developer

Khushi Patel — Sat, 07 Sep 2024 09:16:01 +0000

So nextJS is inveted in 2016 people befefore that

Once Upon a Time, in the Land of Repos...
There was chaos. Developers were running around, managing multiple repositories like juggling fireballs. The frontend was in one repo, backend in another, and libraries were scattered across the kingdom Then, one day developers comes up with solution Monorepo!

Monorepo is like the grand library where all your books (code) are stored in one place. No more running around fetching them from different locations. You simply open one door, and all your projects are neatly tucked in!

What is a Monorepo?

Imagine a castle (repo) with many rooms (folders). Each room has its own purpose:

Frontend: Where the React code lives, playing with cool user interfaces.
Backend: The secret chamber of Node.js where data flows
Shared Components: The royal pantry, stocked with reusable goodies for all the rooms.
All these rooms are part of the same castle (mono repository). You don’t have to go from one castle to another to find what you need—it’s all under one roof!

What's problem before this?

Traditionally, you might create two separate repositories. one for the frontend and one for the backend. At first, this seems simple. But as the project grows, you run into some annoying problems.

The frontend repo has its own set of dependencies, pipelines, and code.
The backend repo is also completely separate, with its own setup.
You have to manually sync shared code (like authentication logic) between the two repos
The frontend and backend use similar libraries, but they’re often running different versions

How Monorepo Solves These Problems:

All-in-One Repo: Frontend and backend live together in one repo. No more switching, making development smoother.
Shared Code Folder: Utility functions are shared between frontend and backend without duplication. Update once, and it's reflected everywhere. You can Start both parts of the app with one command
Unified Dependencies: All packages use the same versions, avoiding compatibility issues.
Single CI/CD Pipeline: One pipeline handles the entire app, making deployments and testing faster and error-free.

But wait—how do we manage such a grand castle of projects efficiently?

Enter Lerna, the magical wizard who keeps everything in the castle running smoothly. And that’s where our next blog will come into picture.....

Stay tuned ! 🔔

till then happy coding ! 🫶🏻

Handling Errors in Node.js: Turning Oops into Success 🚀

Khushi Patel — Sun, 01 Sep 2024 04:02:11 +0000

Errors are like uninvited guests, Let me share with you how I’ve learned to handle errors in Node.js, transforming those "Oops" moments into success.
The key point here is "Expect the Unexpected"

Understanding Errors: The Usual Suspects

Before we dive into handling errors, Let me recall you types of ERROR In Node.js, errors typically fall into a few categories:

Syntax Errors: (They usually happen when you forget a } or add an extra). Node.js will shout at you (in red text) and refuse to run your code until you fix it (Thanks to compiler! 🙏🏻).

Runtime Errors: These occur when your code tries to do something impossible(reading a property of undefined).

Logical Errors: These are the sneaky ones. Your code runs without crashing, but it doesn’t do what it’s supposed to.

Operational Errors: They’re often caused by factors outside of your control, but they’re still your responsibility to handle (when your database suddenly decided to take nap!!😂).

Error Handling: My Go-To Techniques

1. Try-Catch: The First Line of Defence
When working with asynchronous code, try-catch is your best friend. I’ve found that wrapping code in a try-catch block can save you a lot of headaches.

async function fetchData() {
    try {
        const data = await someAsyncFunction();
        return data;
    } catch (error) {
        console.error('Error fetching data:', error.message);
        throw new Error('Failed to fetch data');
    }
}

2. Centralized Error Handling: Keeping Things Organized
I centralize my error handling in one place—usually a middleware function. This approach keeps my code clean and makes it easier to manage errors across the entire application.

app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json({ message: 'Something went wrong!' });
});

3. Custom Error Classes: Making Errors Work for You
I create custom error classes. This allows me to throw meaningful errors that can be handled differently depending on the situation.

class NotFoundError extends Error {
    constructor(message) {
        super(message);
        this.name = 'NotFoundError';
        this.statusCode = 404;
    }
}

throw new NotFoundError('Resource not found');

4. Promise Rejection Handling: Because Promises Don’t Always Keep Theirs
Working with Promises? Then you’ve probably run into the dreaded unhandled promise rejection. It’s important to catch these errors too, as they can easily slip by unnoticed if you’re not careful.

process.on('unhandledRejection', (reason, promise) => {
    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
    // Application-specific logging, throwing an error, or other logic here
});

Conclusion: Turning Oops into Success

By handling errors thoughtfully and proactively, you not only improve your code but also create a better experience for your users.

Happy coding ! 🫶🏻

Types of Middleware: The Different Flavors

Khushi Patel — Thu, 29 Aug 2024 05:34:36 +0000

After reading last post let's see types of middleware in ExpressJs ,Middleware comes in different flavors(😛), each serving a unique purpose:

1. Application-level Middleware: This is like the main ingredient. You add it to your whole application, and it runs on every request.🫡

app.use((req, res, next) => {
    console.log('This runs on every request!');
    next();
});

2. Router-level Middleware: This is more like a specialty topping. It’s used for specific routes or groups of routes.🤓

const router = express.Router();
router.use('/special', (req, res, next) => {
    console.log('Special route middleware!');
    next();
});

3. Built-in Middleware: These are like pre-made sauces that come with Express, such as express.json() for parsing JSON. 😌

app.use(express.json());

4. Error-handling Middleware: This is the chef’s secret weapon. It catches any errors and serves up a custom response. 😎

app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('Something broke!');
});

The Power of Composing Middleware 🫱🏻‍🫲🏽

One of the coolest things about middleware is that you can stack them together to create complex workflows. Each middleware function can either end the request-response cycle or pass control to the next function using next(). This makes it easy to add features like authentication, logging, error handling, and more—just like adding layers to your sandwich.
Here’s how you might use middleware to protect a route:

const authenticate = (req, res, next) => {
    if (req.isAuthenticated()) {
        return next();
    }
    res.redirect('/login');
};

app.get('/dashboard', authenticate, (req, res) => {
    res.send('Welcome to your dashboard!');
});

In this example, the authenticate middleware checks if the user is authenticated before allowing them to access the dashboard.

*Conclusion: Middleware Mastery 👩🏻‍🍳 *
Middleware is truly the secret sauce of Express.js, adding layers of functionality to your Node.js applications. Whether you’re handling requests, managing responses, or catching errors, mastering middleware will make your code cleaner, more organised, and a lot more powerful.

So next time you’re building an Express.js app, think about the flavors you can add with middleware. Mix, match, and create your own secret sauce—it’s what makes your application uniquely yours!

Happy C̶o̶o̶k̶i̶n̶g̶ Coding! 🫶🏻

Types of Middleware: The Different Flavors 😋