DEV Community: Asutosh Kataruka

🚆 Build a Train Station Management App in C++ (Beginner Friendly 🚀)

Asutosh Kataruka — Tue, 15 Jul 2025 19:57:08 +0000

Have you ever wondered how trains are managed at a busy station? What happens when there are only a few tracks and multiple trains arriving and leaving? In this blog post, I’ll walk you through a fun console-based project I built using C++ to simulate train management at a station!

🧠 What Is It?

This is a Train Station Management System written in C++. It lets you:

Add or delete trains 🚉
Automatically assign tracks based on arrival times and availability 🎯
Handle delays and reschedule track allocation ⚙️
View upcoming trains (with filters!) 📅

🔧 What You Need

Basic knowledge of C++ (OOP, functions, vectors)
A C++ compiler like g++
A terminal to run the app

🏗️ How It Works

➕ Adding Trains

You can add new trains by providing:

Train name
Arrival time (e.g., 1430 means 2:30 PM)
Departure time
Source and Destination

The system will automatically assign the best available track.

🕒 Delays? No Problem!

If a train is delayed, the system will reallocate tracks and update the schedule.

🔍 View Next Trains

You can see which trains are coming next based on:

Time
Number of trains
Specific track

🗂️ All Trains

Want to see all train details? You can sort them by:

Arrival time
Departure time
Track number

👨‍💻 How to Run

Clone the repo

git clone https://github.com/Akataruka/station-management-app.git
cd station-management-app

Compile the code

g++ -std=c++17 main.cpp -o station-management-app

Run it

./station-management-app

📸 Demo

WELCOME TO STATION MANAGEMENT APP
1. Create a new Station
Enter station Name: GrandCentral
Enter number of tracks: 2
Station Created ✅

1. Add/Delete trains
2. View Next trains
3. Add delay
4. View all trains
5. Get station details

✨ What I Learned

Priority Queue Interval Processing - Implemented real-time track allocation using min-heaps to efficiently manage overlapping arrival-departure intervals and ensure optimal scheduling.
Timestamp-Based Binary Search - Used binary search on sorted train schedules to quickly identify the next available train based on a user-defined time query.
Function Overloading - Leveraged overloaded functions to support multiple formats of train queries, including time-based, track-based, and count-based filters.
Dynamic Memory Allocation - Created and managed Train objects dynamically using heap allocation, with proper cleanup handled in destructors to prevent memory leaks.
Encapsulation - Encapsulated object properties and behaviors within dedicated classes (Train, Station) to maintain modularity and object-oriented integrity.
Command-Line Interface Support - Designed an interactive CLI for querying and managing station operations, providing a smooth user experience for scheduling and reporting.

📌 Want to Try It?

👉 GitHub Repository

🙌 Final Thoughts

This was a fun and rewarding project. It's simple, educational, and can be extended in many ways like:

Saving data to files
Real-time simulation with random train traffic

If you're learning C++ and want to build something cool — give this a try!

Feel free to ask questions or suggest features. 😊
Happy coding! 👨‍💻👩‍💻

More about Author

👉 Asutoshk - Linktree

🔍 Building a LeetCode Rank Search Chrome Extension — Track Multiple Users in One Click!

Asutosh Kataruka — Thu, 26 Jun 2025 15:10:05 +0000

🧠 Motivation

Have you ever participated in a LeetCode contest and then spent time manually flipping through rank pages just to find where you or your friends placed?

I did too. And it was painful.

So, I decided to solve it with code — by building a Chrome extension that automates this entire process!

In this post, I’ll walk you through:

Challenge for data access on LeetCode 🚫
The idea 💡
The tech stack ⚙️
How it works 🧩
Chrome extension architecture 🧱
Publishing & usage 🚀

Overcoming the Challenge of Data Access on LeetCode

🚫 API Blocking by LeetCode

LeetCode has strict anti-bot mechanisms in place that block automated API requests. This makes traditional API-based data retrieval methods unreliable for scraping or automation tasks.

🔄 Dynamic Frontend Architecture

LeetCode’s frontend is built on dynamic JavaScript frameworks. The platform frequently updates its internal routing, selectors, and page structures, often breaking static scraping solutions.

✅ Our Adaptive Solution: Real-Time Page Scraping

To overcome these challenges, we implemented real-time page scraping using browser automation. By simulating real user interactions, we dynamically search for usernames on the leaderboard and determine their corresponding pages.

🧠 Smart DOM Traversal for Robustness

Instead of relying on static links or outdated selectors, our method adapts to DOM changes by querying elements intelligently. This makes our solution more robust against frontend updates and layout shifts.

💡 Result: Resilient and Reliable Data Extraction

This adaptive approach ensures that we can consistently retrieve user data from LeetCode, even as the platform evolves. It strikes a balance between compliance and flexibility in a dynamically changing environment.

📌 What the Extension Does

LeetCode Rank Search is a Chrome extension that:

✅ Lets you enter multiple LeetCode usernames
✅ Automatically flips through contest ranking pages
✅ Finds the page number for each user
✅ Stops when all users are found
✅ Gives you a friendly floating UI to view results

⚙️ Tech Stack

🧭 JavaScript (Vanilla, for DOM manipulation & search logic)

🧰 Folder Structure

leetcode-rank-search-extension/
├── manifest.json
├── background.js
├── content.js
├── popup.html
├── popup.js
├── styles.css
├── icon16.png
├── icon48.png
├── icon128.png
├── screenshot.png
└── README.md

🧱 Key Components

1. `manifest.json`

The brain of the extension, defining permissions, content scripts, icons, and popup.

"content_scripts": [
  {
    "matches": ["https://leetcode.com/contest/*/ranking/*"],
    "js": ["content.js"]
  }
],
"action": {
  "default_popup": "popup.html"
},
"icons": {
  "16": "icon16.png",
  "48": "icon48.png",
  "128": "icon128.png"
}

2. `popup.html` + `popup.js`

Provides a simple UI button (Start Search) that sends a message to the active tab to trigger the rank search.

3. `content.js`

Handles:

Prompting for user IDs
Navigating back to the first page
Looping through rank pages
Detecting usernames
Updating the floating dialog
Handling STOP and Search Again

🔄 How the Flow Works

You open the LeetCode contest ranking page (e.g., weekly-contest-455/ranking)
Click the extension icon → hit “Start Search”
You enter usernames like: alice123, bob_dev, codewarrior
Extension:

Goes to the first page
Starts flipping pages
Checks for usernames on each page
Displays found page numbers in a nice floating box
Stops when done or on your command

💡 Special Features

✅ Multi-user support
🛑 Manual STOP at any time
🔄 Search Again without reloading
❌ Close button to dismiss the box
🧱 Handles dynamically loaded LeetCode pages
🧠 Special case handled: if rank table not found, instructs user to reload the page

📸 Preview

A floating UI helps you track user ranks in real-time while flipping pages automatically.

⚠️ Common Pitfall: Rank Page Not Found?

Sometimes LeetCode uses dynamic loading which makes the table undetectable initially.

🔧 Fix: Just reload the contest rank page and try again.

🚀 How to Install Locally

Clone the repo or download ZIP
Go to chrome://extensions
Enable Developer Mode
Click “Load unpacked” and select the folder
Visit any LeetCode contest rank page and start using it!

🔓 Open Source

Find the full source code on GitHub:

👉 GitHub Repo Link

Feel free to star, fork, or contribute!

🙌 Final Thoughts

This was a fun weekend project that solved a real annoyance and introduced me to the world of Chrome Extensions + browser scripting.

If you're into problem-solving, automating workflows, or just love clean tools — consider trying it out!

Thanks for reading! 💛

More about Author

👉 Asutoshk - Linktree

Crafting Perfect Cold Messages: My AI-Powered Streamlit App Journey 🧊

Asutosh Kataruka — Fri, 20 Jun 2025 06:40:44 +0000

The digital world thrives on connections, and often, those connections start with a "cold" message. Whether it's for a dream job, a collaboration, or just networking, crafting personalized, impactful messages can be a time sink. This challenge inspired me to build the Cold Message Generator – an AI-powered Streamlit application designed to automate and enhance this process.

In this post, I'll walk you through how this app works, its core functionalities, and the step-by-step workflow that empowers you to create compelling outreach messages in minutes.

The Problem: Tedious & Time-Consuming Outreach

We've all been there: staring at a blank screen, trying to figure out how to introduce ourselves or pitch an idea to someone we don't know. Manually extracting relevant details from a resume, summarizing key achievements, and then weaving it all into a compelling message is a multi-step process that demands attention to detail and significant time.

My goal was to create a tool that could significantly reduce this effort, allowing users to focus on the relationship rather than the drafting.

The Solution: A Seamless AI-Powered Workflow

The Cold Message Generator automates much of this process using the power of Large Language Models (LLMs) and a friendly Streamlit interface. Here’s a detailed look at the user experience and the underlying processes:

Step 1: Secure Setup & Resume Upload 🚀

The journey begins when you launch the application.

API Key Input: First, you'll provide your Groq API key in the dedicated sidebar section. This ensures the app has the necessary credentials to communicate with the powerful AI models.
Resume Upload: The primary input is your resume. You simply upload your resume in PDF format using the designated file uploader.

Once your resume is uploaded, the application immediately gets to work behind the scenes:

Text Extraction: The system rapidly extracts all textual content from your PDF resume.
Initial Link Discovery: Simultaneously, it scans the extracted text for any visible URLs.

Step 2: Intelligent Link Classification & Summarization 🧠

This is where the AI and smart processing truly shine, transforming raw data into actionable insights.

Hidden Link Classification: Beyond simple extraction, the app employs a specialized utility that goes through the discovered links. It intelligently classifies ambiguous or "hidden" links, ensuring that your LinkedIn, GitHub, and personal portfolio URLs are correctly identified and categorized, ready for easy inclusion in your message.
AI-Powered Resume Summarization: The full text of your resume is then sent to an advanced LLM. This AI model doesn't just condense text; it analyzes your experience and skills to generate a concise, professional, and impactful summary. This summary is automatically populated into a dedicated text area on the screen, ready for your review. This feature saves you the significant effort of crafting a summary from scratch.

At this point, you'll see the AI-generated summary and any automatically detected and classified links pre-filled into input fields, allowing you to easily review and make any minor adjustments or add links if they weren't detected.

Step 3: Message Tailoring & Template Generation ✍️

With your profile data processed, you guide the AI in crafting the perfect message.

Define Message Type: You select the desired message type from a dropdown, such as "Cold Email," "LinkedIn Message," or "Other," indicating the communication channel.
Specify Target Role: You input the specific job title or role you're targeting (e.g., "Software Engineer," "Data Scientist"). This critical piece of information allows the AI to tailor the message's content directly to the context of that role.
Trigger Generation: With a simple click of the "Generate Template" button, the application sends all your prepared inputs – the refined resume summary, your social links, the chosen message type, and the target job type – back to the LLM.

The AI then processes this comprehensive input to produce a customized message template. This template is designed for immediate use and includes dynamic placeholders, specifically {{recipient_name}} and {{company_name}}.

Step 4: Final Personalization & Send-Ready Message ✨

The last mile of customization is in your hands, leading to a complete, ready-to-send message.

Recipient Details Input: You'll see dedicated input fields where you simply type in the specific recipient's name and the company's name for your current outreach.
Final Message Creation: Upon clicking "Generate Message," the application seamlessly substitutes your entered recipient and company names into the template's placeholders.

The result is a fully formatted, personalized message displayed in a large text area, ready for you to copy and paste directly into your email client or LinkedIn message window. This entire process significantly reduces manual effort, allowing you to scale your outreach while maintaining a personalized touch.

Why Groq & Streamlit? (Under the Hood Efficiency)

Groq's Blazing Speed: The choice of Groq's API for the LLM inference is crucial. Its Language Processing Units (LPUs) provide incredible speed, making the AI summarization and message generation almost instantaneous. This eliminates frustrating wait times, providing a snappy user experience that truly saves time.
Streamlit's User-Friendliness: For building interactive Python web applications, Streamlit is a fantastic choice. Its simplicity allowed me to focus primarily on the core AI logic and user workflow, rather than getting bogged down in complex web development frameworks.
Robust Backend Logic: Leveraging libraries like LangChain helps orchestrate the LLM calls and ensures structured outputs. Pydantic schemas enforce data consistency, guaranteeing that the AI's responses are always in the expected format, leading to reliable processing at every step.

Future Enhancements

I'm always thinking about how to make this tool even better:

Expanded Message Types: Introducing options for networking events, informational interview requests, and more diverse outreach scenarios.
Tone Customization: Allowing users to specify the desired tone (e.g., formal, friendly, direct, assertive) for their messages.
ATS Keyword Optimization: Integrating functionality to analyze job descriptions and suggest relevant keywords to include in the message for Applicant Tracking System (ATS) compatibility.
Basic CRM Integration: Exploring options for simple export functionality to popular Customer Relationship Management (CRM) tools.

Try it Yourself!

Ready to automate your outreach and make impactful first impressions?

Experience the Web App: Cold Message Generator
Dive into the Codebase: Find the full project on GitHub
See More of My Work: Check out my portfolio at asutosh-kataruka.vercel.app

I'm keen to hear your feedback, suggestions, or ideas for future improvements! Drop a comment below or reach out on GitHub.

🚀 Introduction to System Design: LLD and SOLID Principles

Asutosh Kataruka — Sun, 15 Jun 2025 17:48:36 +0000

🚀 Introduction to System Design: LLD and SOLID Principles

In the context of system design, Low-Level Design (LLD) serves as the foundational layer that translates high-level architectural decisions into detailed class structures, interfaces, and method definitions. While High-Level Design (HLD) outlines the overall system architecture, components, and technology stack, LLD focuses on the internal logic and object interactions that enable the system to function effectively. A critical component of effective LLD is the application of SOLID principles, which provide a structured approach to building maintainable, scalable, and extensible software systems.

This blog dives deep into why LLD matters, what SOLID principles are, and how they help create clean, maintainable, and scalable systems—with practical code examples.

🧩 Why Low-Level Design (LLD) Matters

LLD is all about breaking a problem into classes and interactions while maintaining principles like reusability, extensibility, and testability. It:

Bridges the gap between HLD and code
Helps in better planning of class responsibilities
Makes systems modular and easier to debug
Supports clean architecture and future scalability

🔍 What are SOLID Principles?

SOLID is an acronym for five key design principles in object-oriented programming that promote better LLD. Introduced by Robert C. Martin (Uncle Bob), they aim to make code:

More readable
Easier to maintain
Flexible to change

SOLID stands for:

S – Single Responsibility Principle (SRP)
O – Open/Closed Principle (OCP)
L – Liskov Substitution Principle (LSP)
I – Interface Segregation Principle (ISP)
D – Dependency Inversion Principle (DIP)

🧱 Deep Dive into SOLID with Examples

1. ✅ Single Responsibility Principle (SRP)

Definition: A class should have one, and only one, reason to change.
Example: A class should either manage user data or send emails—not both.

❌ Bad Example:

class User {
public:
    void saveUser() {
        // Save user to DB
    }
    void sendEmail() {
        // Send confirmation email
    }
};

✅ Good Example:

class User {
public:
    void saveUser() {
        // Save user to DB
    }
};

class EmailService {
public:
    void sendEmail() {
        // Send confirmation email
    }
};

Each class now has a single responsibility, improving maintainability.

2. 🧯 Open/Closed Principle (OCP)

Definition: Software entities should be open for extension but closed for modification.

Example: Add new discount types without touching old code.

❌ Bad Example:

class DiscountCalculator {
public:
    int getDiscount(string type) {
        if (type == "regular") return 10;
        if (type == "vip") return 20;
        return 0;
    }
};

✅ Good Example:

lass Discount {
public:
    virtual int getDiscount() = 0;
};

class RegularDiscount : public Discount {
public:
    int getDiscount() override { return 10; }
};

class VIPDiscount : public Discount {
public:
    int getDiscount() override { return 20; }
};

Add new customer types by extending, not modifying existing logic.

3. 🧬 Liskov Substitution Principle (LSP)

Definition: Subtypes must be substitutable for their base types without altering the correctness of the program.

Example: A Bird base class should not assume all birds can fly.

❌ Bad Example:

class Bird {
public:
    virtual void fly() { cout << "Flying" << endl; }
};

class Ostrich : public Bird {
public:
    void fly() override { throw; } // Ostrich can't fly
}

✅ Good Example:

class Bird {
public:
    virtual void makeSound() { cout << "Chirp" << endl; }
};

class FlyingBird : public Bird {
public:
    virtual void fly() { cout << "Flying" << endl; }
};

class Sparrow : public FlyingBird {};
class Ostrich : public Bird {};

Child classes behave correctly when used in place of their base class.

4. 🧩 Interface Segregation Principle (ISP)

Definition: Clients should not be forced to depend on interfaces they do not use.

Example: Not every machine can fax

❌ Bad Example:

class Machine {
public:
    virtual void print() = 0;
    virtual void scan() = 0;
    virtual void fax() = 0;
};

class BasicPrinter : public Machine {
public:
    void print() override {}
    void scan() override {}
    void fax() override { throw; } // Doesn’t support fax
};

✅ Good Example:

class Printer {
public:
    virtual void print() = 0;
};

class Scanner {
public:
    virtual void scan() = 0;
};

class SimplePrinter : public Printer {
public:
    void print() override {}
};

Separate interfaces prevent unnecessary method implementations.
Only implement what’s needed. No empty or broken methods.

5. 🔄 Dependency Inversion Principle (DIP)

Definition: High-level modules should not depend on low-level modules. Both should depend on abstractions.

Example: Let the app depend on Database abstraction, not directly on MySQL.

❌ Bad Example:

class MySQL {
public:
    void connect() { cout << "Connected to MySQL" << endl; }
};

class App {
    MySQL db;
public:
    void run() {
        db.connect(); // Tightly coupled
    }
};

✅ Good Example:

class Database {
public:
    virtual void connect() = 0;
};

class MySQL : public Database {
public:
    void connect() override { cout << "Connected to MySQL" << endl; }
};

class App {
    Database* db;
public:
    App(Database* db) : db(db) {}
    void run() {
        db->connect();
    }
};

You can easily switch to PostgreSQL or mock the DB for testing.

🌟 Advantages of SOLID Principles

Applying SOLID principles offers several benefits:

✅ Maintainability: Code becomes easier to modify without unintended side effects.
✅ Scalability: New features can be added with minimal changes to existing code.
✅ Testability: Modular design improves unit testing capabilities.
✅ Readability: Clear structure and responsibility make the code easier to understand.
✅ Reusability: Decoupled components are easier to reuse across different projects.

Understanding and applying the SOLID principles is a foundational step toward writing clean, scalable, and maintainable software. These principles help in reducing code complexity, enhancing reusability, and ensuring long-term success in system design, especially at the Low-Level Design (LLD) stage.

This blog presents the core understanding in a simplified, practical way with easy-to-follow C++ examples

DEV Community: Asutosh Kataruka

🚆 Build a Train Station Management App in C++ (Beginner Friendly 🚀)

🧠 What Is It?

🔧 What You Need

🏗️ How It Works

➕ Adding Trains

🕒 Delays? No Problem!

🔍 View Next Trains

🗂️ All Trains

👨‍💻 How to Run

📸 Demo

✨ What I Learned

📌 Want to Try It?

🙌 Final Thoughts

More about Author

🔍 Building a LeetCode Rank Search Chrome Extension — Track Multiple Users in One Click!

🧠 Motivation

Overcoming the Challenge of Data Access on LeetCode

🚫 API Blocking by LeetCode

🔄 Dynamic Frontend Architecture

✅ Our Adaptive Solution: Real-Time Page Scraping

🧠 Smart DOM Traversal for Robustness

💡 Result: Resilient and Reliable Data Extraction

📌 What the Extension Does

⚙️ Tech Stack

🧰 Folder Structure

🧱 Key Components

1. manifest.json

2. popup.html + popup.js

3. content.js

🔄 How the Flow Works

💡 Special Features

📸 Preview

⚠️ Common Pitfall: Rank Page Not Found?

🚀 How to Install Locally

🔓 Open Source

🙌 Final Thoughts

More about Author

Crafting Perfect Cold Messages: My AI-Powered Streamlit App Journey 🧊

The Problem: Tedious & Time-Consuming Outreach

The Solution: A Seamless AI-Powered Workflow

Step 1: Secure Setup & Resume Upload 🚀

Step 2: Intelligent Link Classification & Summarization 🧠

Step 3: Message Tailoring & Template Generation ✍️

Step 4: Final Personalization & Send-Ready Message ✨

Why Groq & Streamlit? (Under the Hood Efficiency)

Future Enhancements

Try it Yourself!

🚀 Introduction to System Design: LLD and SOLID Principles

🚀 Introduction to System Design: LLD and SOLID Principles

🧩 Why Low-Level Design (LLD) Matters

🔍 What are SOLID Principles?

🧱 Deep Dive into SOLID with Examples

1. ✅ Single Responsibility Principle (SRP)

❌ Bad Example:

✅ Good Example:

2. 🧯 Open/Closed Principle (OCP)

❌ Bad Example:

✅ Good Example:

3. 🧬 Liskov Substitution Principle (LSP)

❌ Bad Example:

✅ Good Example:

4. 🧩 Interface Segregation Principle (ISP)

❌ Bad Example:

✅ Good Example:

5. 🔄 Dependency Inversion Principle (DIP)

❌ Bad Example:

✅ Good Example:

🌟 Advantages of SOLID Principles

Further Reading & References

1. `manifest.json`

2. `popup.html` + `popup.js`

3. `content.js`