DEV Community: Utkarsh Yadav

Why Most Resumes Fail ATS (What I Learned While Building One)

Utkarsh Yadav — Mon, 05 Jan 2026 07:21:14 +0000

I used to think resumes fail because people aren’t skilled enough.

That’s wrong.

Most resumes fail because they never reach a human.

While building an AI-powered resume ATS tool, I spent time understanding how Applicant Tracking Systems actually work. What I found was frustrating, especially for genuinely good candidates.

ATS doesn’t read resumes like humans

ATS systems don’t “understand” design.

They extract text, match patterns, and score relevance. That’s it.

If your resume relies on:

Tables
Icons
Fancy columns
Visual timelines

there’s a good chance important information never gets parsed correctly.

A clean-looking resume to a human can look broken to an ATS.

Keyword stuffing doesn’t work anymore

A common piece of advice is to repeat keywords as much as possible.

That used to work.

Modern ATS systems look at context, not repetition.

They care about:

Where a skill appears
Which role it’s connected to
Whether it matches the job description naturally

Writing “React” ten times won’t help if it doesn’t align with the role.

One resume for every job is a losing strategy

This is the most painful truth.

Most people send the same resume to dozens of jobs and hope for the best. ATS systems don’t reward that.

They expect resumes to be tailored:

Skills aligned to the role
Experience phrased using job-specific language
Keywords that actually match the posting

Manually doing this for every application is exhausting. Most people just give up.

The worst part is the silence

The hardest part of job hunting isn’t rejection.

It’s not knowing why.

Your resume gets rejected in seconds, without feedback, without explanation, without a human involved. You’re left guessing what went wrong.

That’s the part that bothered me the most.

Why I’m building a resume ATS tool

I didn’t start building this to “disrupt hiring”.

I started because I wanted answers.

I’m building a tool that:

Scores resumes the way ATS does
Shows what’s missing or misaligned
Helps tailor resumes to specific job descriptions
Focuses on clarity instead of buzzwords

It’s still a work in progress. I’m learning as I go.

Final thoughts

If you’re job hunting right now, you’re not bad at what you do.

Your resume might just be speaking a different language than the system reading it.

If you’re a developer, designer, or founder building in public, I’d love to connect and share notes. I’ll keep writing about what I learn along the way.

I’m Building an AI Resume ATS Tool Because the System Is Broken

Utkarsh Yadav — Fri, 02 Jan 2026 22:15:07 +0000

I didn’t wake up one day and think,

“Wow, the world really needs another AI SaaS.”

This started out of frustration.

I’ve seen good developers, designers, and engineers get rejected again and again — not because they lacked skill, but because their resume never even reached a human. It died silently inside an ATS.

No feedback.

No reason.

Just rejection emails or, worse, complete silence.

So I decided to actually understand why this happens and build something around it.

The Ugly Truth About ATS

Here’s the uncomfortable reality:

ATS doesn’t care about:

Passion
Hustle
“Fast learner”
“Team player”

It cares about:

Keywords
Structure
Formatting
Context matching with the job description

A resume can be objectively good and still score terribly because it wasn’t written for machines.

Most resume advice online is written for humans.

Most resumes are rejected by machines.

That mismatch is the problem.

What I’m Building (and What I’m Not)

I’m building a simple AI-powered resume ATS analysis tool.

Not a magic job-guarantee machine.

Not a “one-click FAANG offer” scam.

Here’s what it does right now:

You upload your resume
You paste the job description
The system analyzes:
- ATS score
- Missing keywords
- Formatting risks
- Context gaps
Then it helps you generate a more ATS-friendly version of your resume

That’s it.

No fake promises.

No motivational nonsense.

Just clarity.

Why Another Resume Tool?

Fair question. There are already dozens.

Most of them fail in one of these ways:

They give vague feedback
They overwhelm users with buzzwords
They don’t explain why something is wrong
They try to upsell before delivering value

I’m taking a different approach:

Brutally clear feedback
Resume + JD comparison, not generic advice
Focus on why ATS rejects, not how to “look impressive”

If something is bad, the tool says it’s bad.

Building This in Public (Because Why Not)

I’m sharing progress on X (Twitter) — screenshots, failures, small wins.

Not because everything is going great,

but because building in silence is overrated.

Some days the UI clicks.
Some days the ATS logic breaks.
Some days I question why I started at all.

That’s normal.

This is an MVP. It’s rough around the edges. And that’s fine.

Who This Is For

This tool is for:

Developers tired of being ghosted
Students applying blindly to hundreds of roles
Professionals switching domains
Anyone who suspects their resume isn’t the real problem — ATS is

If you’re looking for shortcuts or guarantees, this isn’t it.

If you want signal instead of noise, you’ll probably like it.

What’s Next

Right now, the focus is simple:

Make ATS feedback clearer
Improve resume-to-JD matching
Keep the product honest and usable

No feature creep.
No “AI agents doing everything”.
Just solving one real problem properly.

Final Thought

The hiring system isn’t fair.

But pretending it works differently won’t help.

If resumes are filtered by machines,

we might as well understand the machines.

I’ll keep building.

I’ll keep sharing.

If this resonates, you’ll probably see more updates soon.

I Built a Resume ATS Tool After Applying to 15–20 Jobs a Day

Utkarsh Yadav — Fri, 02 Jan 2026 05:05:45 +0000

Job hunting broke my patience before it broke my confidence

During my final year, job hunting became a full-time job.

Every day looked the same:

Open career portals
Read job descriptions
Tailor resume
Apply
Repeat

I was applying to 15–20 companies per day, across different roles and domains.

And every single application required a slightly different resume.

Change the summary.

Reorder skills.

Rewrite bullet points.

Remove things that “don’t match this role.”

It wasn’t difficult work, it was mentally draining work.

After the 40th rewrite, I realized something was wrong.

The real problem wasn’t my resume

Most people assume resumes fail because:

formatting is bad
skills are missing
experience is weak

That’s only part of the truth.

The bigger issue is relevance.

A resume that works for one role can quietly fail for another, even if:

the candidate is qualified
the experience is solid
the skills are there

Why?

Because ATS systems don’t evaluate potential, they match text.

If your resume doesn’t map cleanly to the job description:

it doesn’t get rejected loudly
it just disappears silently

That’s the worst kind of rejection.

So I built something out of frustration

At some point, I got tired of manually editing resumes.

Not because I couldn’t do it :
but because it felt like solving the same problem every day.

So I built a small script.

No UI.

No product vision.

Just a tool running inside my VS Code terminal.

It did three things:

Took my resume
Took a job description
Generated a tailored version aligned to that role

That was it.

It wasn’t pretty.

But it saved time.

And more importantly it worked.

Eventually, I got selected.

The obvious question came later

After I got hired, I looked back and thought:

“If this helped me, why is everyone else still suffering through this manually?”

Most people:

either use one generic resume everywhere
or spend hours rewriting it without knowing what actually matters

Neither approach works consistently.

That’s when I decided to turn the script into a proper tool.

What the MVP actually does

I’m intentionally keeping the MVP small and focused.

The tool:

Analyzes your resume against a job description
Identifies missing or underrepresented skills
Adjusts content to improve ATS compatibility
Keeps the resume readable for humans

The tool does not:

promise guaranteed interviews
blindly stuff keywords
redesign your resume into flashy templates
pretend hiring is “easy with AI”

The goal is simple:

Make it easier to submit a relevant resume every time.

Why ATS optimization matters (whether we like it or not)

ATS systems aren’t smart.
They’re not evil either.

They’re just filters.

They help companies handle volume, not quality.

That means:

Great candidates can get filtered out
Average candidates can get through if they match better

This tool isn’t about gaming the system.
It’s about communicating clearly within its constraints.

Humans still make the final decision.

ATS just decides who gets seen.

Things I learned while building and testing

A few patterns showed up quickly:

People struggle more with what to remove than what to add
Overloaded resumes perform worse than focused ones
Trying to fit every role reduces clarity
Manual tailoring leads to inconsistency and fatigue

The hardest part of job hunting isn’t skill
it’s decision fatigue.

That’s what I’m trying to reduce.

Why I’m building this in public

Job hunting is isolating.

You don’t know:

if you’re doing things right
if others are struggling the same way
if the system is broken or it’s just you

Building in public helps:

validate real pain points
get honest feedback
avoid building imaginary features

I’m not trying to “disrupt hiring.”

I’m just trying to make one painful step less painful.

What’s next (and what’s not)

For now:

I’m testing with real resumes
Improving accuracy
Keeping the scope intentionally small

I’m resisting the urge to add features unless users clearly ask for them.

Shipping a boring, useful product

is better than building a shiny, confusing one.

Final thought

Most resumes don’t fail because people aren’t capable.

They fail because relevance is hard to maintain manually, every single day.

If you’ve ever rewritten your resume at 2 AM wondering

“Does this even matter?”

this project exists because of that feeling.

Still building.

Still learning.

Still shipping.

Built and Launched My Own AI Image Generation SaaS Boilerplate – Now Selling It for Devs & Founders

Utkarsh Yadav — Mon, 07 Jul 2025 15:49:32 +0000

Hey devs 👋

Over the last couple of months, I went full tunnel vision and built a complete AI image generation SaaS platform from scratch — solo.

No team, no VC money, just caffeine and a hatred for boilerplate code.

Introducing VisionAI: A full-stack, production-ready AI image generation boilerplate that lets you launch your own Midjourney-style platform with payments, user management, and community features already wired in.

🚀 What It Does

This isn’t a toy project or a half-baked clone. VisionAI is packed with everything you'd expect from a serious SaaS product:

✅ 2K / 4K AI image generation
✅ Stripe-powered credit system & subscription plans
✅ Community gallery with likes, follows, comments
✅ Auth system with JWT, role-based access, email verification
✅ User dashboard, credit usage tracking, generation history
✅ Admin-level controls and secure APIs
✅ Modern, responsive UI with dark/light mode

It's designed so you don’t have to spend weeks rebuilding the same stack over and over.

🧠 Tech Stack

Here's what powers it under the hood:

Frontend:

React 18 + TypeScript
Vite for fast dev
TailwindCSS + Radix UI
React Query for state/data
Lucide Icons

Backend:

Node.js + Express (TypeScript)
MongoDB + Mongoose
JWT for authentication
Stripe integration (subscriptions + credits)
Multer for file handling
Helmet for basic security

DevOps & Infra:

Dockerized
Frontend: Deploy on Vercel / Netlify
Backend: Deploy on Railway / Heroku
Database: MongoDB Atlas
Image Storage: Cloudinary
Payments: Stripe (with full webhook flow)

🛠️ Who It’s For

If you’re:

A solo indie hacker building in public
A dev freelancing for AI startups
An agency looking to white-label AI tools
Or just tired of building the same SaaS structure from scratch...

VisionAI can save you a ridiculous amount of time.

💰 Where to Buy

You can check out the full breakdown, features, live demo, and pricing on my Gumroad here:

👉 https://iamutkarshyadav.gumroad.com/l/visionai-builder

I’ve listed different license tiers (Basic, Pro, Enterprise) so you can pick what fits your use case.

🧵 The Why

I built VisionAI because every time I started a new SaaS, I ended up spending 70% of my time building the same base logic — auth, payments, usage tracking, etc.

So this time, I just said screw it and turned it into something that others can use too.

🧃 Bonus

Want to preview the UI or see how I structured the project? I’m happy to share screenshots, folder structure, or even a quick walkthrough video. Just drop a comment or message me on Twitter/X or LinkedIn.

Thanks for reading 🙌 Feedback is always welcome.

Backend web Server using Rust!

Utkarsh Yadav — Thu, 03 Apr 2025 11:27:52 +0000

Building a Simple Web API in Rust with Actix Web

Rust is a powerful language known for its speed and memory safety, but its strict type system and borrow checker can be challenging, especially for those coming from JavaScript or C++. When exploring web development with Rust, I found a lack of beginner-friendly resources, particularly for Actix Web.

When I first attempted to build a web backend in Rust, I underestimated the complexity. Between the borrow checker and the scarcity of beginner-oriented Actix Web tutorials, the learning curve was steep. This guide aims to provide a structured approach to setting up an Actix Web backend, covering essential concepts and API development.

Scope of the Article

We'll cover:

Setting up a Rust project for Actix Web
Writing a simple API with route handling
Running and testing the server
Understanding the project structure and key concepts

Framework and Tools Used

Actix Web – The Rust web framework we’ll use for handling HTTP requests
Cargo – The Rust package manager for managing dependencies
Rust (Stable Version) – Make sure you have Rust installed before proceeding
Postman – We will use Postman to test the API rather than curl.

Now, let's dive in and build our Actix Web backend.

1. Creating the Project

Open your terminal and run:

cargo new actix-web-demo --bin

This creates a new Rust project named actix-web-demo with a binary (--bin) target. Now, navigate into the project directory:

cd actix-web-demo

2. Adding Dependencies

Open the Cargo.toml file and add actix-web as a dependency:

[dependencies]
actix-web = "4"

Then, run:

cargo build

This downloads and compiles the dependencies, ensuring everything is set up correctly.

3. Writing a Simple API with Route Handling

Open src/main.rs and replace its contents with the following:

use actix_web::{web, App, HttpResponse, HttpServer, Responder};

// A simple handler function that returns a welcome message
async fn greet() -> impl Responder {
    HttpResponse::Ok().body("Hello from Actix Web!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

This creates a basic Actix Web server with a route (/) that maps GET requests to greet().

4. Running and Testing the Server

Run:

cargo run

Now, open your browser and navigate to 127.0.0.1:8080. You should see the message:

Hello from Actix Web!

Testing with Postman

Now that the server is running, let's test the API using Postman instead of curl.

Open Postman

If you haven't already, download and install Postman.
Set up the request in Postman
- Method: GET
- URL: http://127.0.0.1:8080/
- Click "Send"
- Expected Result: You should see the response Hello from Actix Web!.

5. Adding More Routes

We’ll extend this API by adding multiple routes that return dummy JSON data. Our endpoints will include:

GET /users – Returns a list of users
GET /users/{id} – Fetches a single user by ID
POST /users – Creates a new user (dummy response)
DELETE /users/{id} – Deletes a user (dummy response)

6. Updating Dependencies

Modify Cargo.toml to include serde and serde_json for JSON parsing:

[dependencies]
actix-web = "4"
serde = { version = "1", features = ["derive"] }
serde_json = "1"

Run:

cargo build

7. Writing the API

Modify src/main.rs:

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};

// Struct to represent a user
#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}

// Dummy user data
fn get_dummy_users() -> Vec<User> {
    vec![
        User { id: 1, name: "Alice".into(), email: "alice@example.com".into() },
        User { id: 2, name: "Bob".into(), email: "bob@example.com".into() },
    ]
}

// GET /users - Returns all users
async fn get_users() -> impl Responder {
    HttpResponse::Ok().json(get_dummy_users())
}

// GET /users/{id} - Fetch user by ID
async fn get_user_by_id(path: web::Path<u32>) -> impl Responder {
    let user_id = path.into_inner();
    let users = get_dummy_users();

    if let Some(user) = users.into_iter().find(|u| u.id == user_id) {
        HttpResponse::Ok().json(user)
    } else {
        HttpResponse::NotFound().body("User not found")
    }
}

// POST /users - Create a new user (dummy response)
#[derive(Deserialize)]
struct NewUser {
    name: String,
    email: String,
}

async fn create_user(user: web::Json<NewUser>) -> impl Responder {
    let new_user = User {
        id: 3, // Dummy ID
        name: user.name.clone(),
        email: user.email.clone(),
    };

    HttpResponse::Created().json(new_user)
}

// DELETE /users/{id} - Delete a user (dummy response)
async fn delete_user(path: web::Path<u32>) -> impl Responder {
    let user_id = path.into_inner();
    HttpResponse::Ok().body(format!("User with ID {} deleted", user_id))
}

// Main function to set up the Actix Web server
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/users", web::get().to(get_users))
            .route("/users/{id}", web::get().to(get_user_by_id))
            .route("/users", web::post().to(create_user))
            .route("/users/{id}", web::delete().to(delete_user))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

8. Running and Testing the API

Start the server:

cargo run

Test Endpoints Using Postman

1. Get All Users

Method: GET
URL: http://127.0.0.1:8080/users
Click "Send"
Expected Result: You should see a list of users in JSON format.

2. Get a User by ID

Method: GET
URL: http://127.0.0.1:8080/users/1 (or any other ID)
Click "Send"
Expected Result: You should see the user with the specified ID or a "User not found" message.

3. Create a New User

Method: POST
URL: http://127.0.0.1:8080/users

Body:

Select raw and set the type to JSON.
Add the following JSON:

{
  "name": "Charlie",
  "email": "charlie@example.com"
}

Click "Send"
Expected Result: You should see a response with the newly created user, including a dummy ID.

4. Delete a User

Method: DELETE
URL: http://127.0.0.1:8080/users/2 (replace 2 with the ID of the user you want to delete)
Click "Send"
Expected Result: You should receive a message like "User with ID 2 deleted".

Conclusion

Now we have a simple CRUD-style API in Rust using Actix Web. From here, you can:

Connect it to a real database like PostgreSQL using Diesel
Improve error handling with Result<T, Error)
Implement authentication with JWT

Rust’s strictness might feel frustrating at first, but once you get through it, the speed and safety make it worth the effort. With Postman, testing and interacting with your API is more intuitive, and you can expand the API with additional functionality or features as needed.

How to Create an API Using Node.js, Express.js, and Axios

Utkarsh Yadav — Sun, 19 May 2024 15:26:50 +0000

Creating an API with Node.js and Express.js is a powerful way to handle HTTP requests and responses, enabling you to build robust back-end services. Axios, on the other hand, is a promise-based HTTP client for the browser and Node.js that makes it easier to interact with external APIs. This guide will take you through the steps of creating an API using these technologies.

Prerequisites

Basic knowledge of javascript and Node.js
Node.js installed on your machine
A code editor of your choice .(I will be using VS CODE)

Setting up the project

Initialise a new Node.js project
You can create a new empty folder (with name example-api) on your desktop and then drag and drop it to vs code editor to open the folder.
Installing the necessary Packages
For installing the packages I will be using node package manager (npm), you can use yarn as well.
Now to install open your terminal and run the following

npm install express axios

Additionally, install nodemon as a dev dependency to automatically restart your server when file changes are detected:

npm install --save-dev nodemon

Now, update your package.json to use nodemon for starting the server:

{
  "type": "module",
  "dependencies": {
    "axios": "^1.6.8",
    "express": "^4.19.2",
    "nodemon": "^3.1.0"
  },
  "scripts": {
    "server": "nodemon server.js",
    "test": "mocha",
    "fetch":"nodemon fetch.js",
    "dev":"nodemon index.js"
  }
}

Creating the Express Server

Create server.js File

In the root of your project directory, create a file named server.js and then we'll setup a basic express server.

import express from "express"

const PORT = 3000;
const app = express();

app.get("/", (req, res) => {
    res.send("Hello from homepage");
})

app.listen(PORT, () => {
    console.log(`[SERVER] ExpressJS is listening to port http://localhost:${PORT}`);
})

Run the Server Start the server using nodemon

npm run server

Visit http://localhost:3000 in your browser, and you should see "Hello from homepage".

Adding routes to our API
Organizing our Express.js application by separating routes into different files and using Express Router is a best practice for maintaining clean, scalable, and manageable code. To do this we will create a new folder named routes in our root directory and inside our routesfolder create a new file named routes.js

Creating a cricket match score route Now, to create a route that will send the data of a demo match for the scope of this article, navigate to routes.js file inside routes folder and write the following code


import express from "express";
const apiRoutes = express.Router();

const matchDetails = [
  {
    matchID: 60,
    Teams: "Rajasthan Royals vs Kolkata Knight Riders",
    Venue: {
      Stadium: "Eden Gardens",
      City: "Kolkata",
    },
    Weather: "Haze, Dew after sunset",
    Time: "7:30 pm IST",
    Date: "19 May 2024",
    Toss: {
      wonBy: "Team Name",
      Decision: "TBD",
    },
    pitchReport: "Flat track with movement expected for pacers",
    liveScore: {
      totalScore: "60",
      wickets: "1",
      FOW: "12",
      overs: "7",
      Batter1: {
        Name: "Jos Buttler",
        Score: "32",
        ballsFaced: "12",
        sixes: "3",
        fours: "2",
      },
      Batter2: {
        Name: "Sanju Samson",
        Score: "28",
        ballsFaced: "20",
        sixes: "2",
        fours: "1",
      },
      Bowler: {
        Name: "Glenn Maxwell",
        Overs: "2",
        wickets: "1",
        Maiden: "1",
      },
    },
    teamRosters: {
      RajasthanRoyals: [
        "Jos Buttler",
        "Sanju Samson",
        "Ben Stokes",
        "Jofra Archer",
      ],
      KolkataKnightRiders: [
        "Eoin Morgan",
        "Shubman Gill",
        "Andre Russell",
        "Pat Cummins",
      ],
    },
  },
  {
    matchID: 61,
    Teams: "Mumbai Indians vs Chennai Super Kings",
    Venue: {
      Stadium: "Wankhede Stadium",
      City: "Mumbai",
    },
    Weather: "Clear skies",
    Time: "7:30 pm IST",
    Date: "20 May 2024",
    Toss: {
      wonBy: "Team Name",
      Decision: "TBD",
    },
    pitchReport: "Good batting surface with some assistance for spinners",
    liveScore: {
      totalScore: "85",
      wickets: "2",
      FOW: "45",
      overs: "10",
      Batter1: {
        Name: "Rohit Sharma",
        Score: "45",
        ballsFaced: "30",
        sixes: "4",
        fours: "3",
      },
      Batter2: {
        Name: "Suryakumar Yadav",
        Score: "35",
        ballsFaced: "25",
        sixes: "2",
        fours: "2",
      },
      Bowler: {
        Name: "Deepak Chahar",
        Overs: "3",
        wickets: "1",
        Maiden: "0",
      },
    },
    teamRosters: {
      MumbaiIndians: [
        "Rohit Sharma",
        "Suryakumar Yadav",
        "Kieron Pollard",
        "Jasprit Bumrah",
      ],
      ChennaiSuperKings: [
        "MS Dhoni",
        "Ravindra Jadeja",
        "Deepak Chahar",
        "Faf du Plessis",
      ],
    },
  },

];

apiRoutes.get("/ipl", (req, res) => {
  res.status(200).json(matchDetails);
});

export default apiRoutes;

Our /ipl route has been create and now we need to import this route to our main server.js file and update the existing code to

import express from "express"
import apiRoutes from "./routes/routes.js"

const PORT = 3000;
const app = express();

app.get("/", (req, res) => {
    res.send("Hello from homepage");
})
app.get("/ipl", apiRoutes)

app.listen(PORT, () => {
    console.log(`[SERVER] ExpressJS is listening to port http://localhost:${PORT}`);
})
export default app;

now visit to http://localhost:3000/ipl and you will be able to see the data in json format of the matchDetails.

CLI Library Management-System C++

Utkarsh Yadav — Tue, 04 Jul 2023 22:18:25 +0000

In this article, we will explore a simple Command Line Interface (CLI) program for a Library Management System. The program allows users to register books, register library members, and perform basic operations such as printing book data and saving data to files. The program is written in C++ and demonstrates the usage of classes, vectors, file handling, and user input.

Code Walkthrough

#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <vector>

using namespace std;

class BookEntry
{
public:
    string bookName;
    string bookAuthor;
    string publisher;
    int ISBN;
    int edition;
    int publishYear;
    int numberOfBooks;
    vector<BookEntry> books; // Store multiple books

    void registerBook();
    void printData();
    void saveBookDataToFile(const string &filename);
};

class MemberEntry
{
public:
    string memberName;
    string memberAddress;
    string memberEmail;
    int memberID;

    void registerMember();
    void saveMemberDataToFile(const string &filename);
    bool isMemberExist(const string &filename);
};

// ...

The code starts by including necessary libraries (iostream, fstream, string, iomanip, and vector) and using the std namespace. Then, it defines two classes: BookEntry and MemberEntry. These classes encapsulate the functionality related to book and member management, respectively.

The BookEntry class has member variables representing book details such as name, author, publisher, ISBN, edition, publish year, and the number of books. It also includes a vector named books to store multiple book entries. The class provides member functions to register a book, print book data, and save book data to a file.

The MemberEntry class contains member variables for member details like name, address, email, and member ID. It has member functions to register a member, save member data to a file, and check if a member already exists.

Now, let's take a look at the member function implementations of BookEntry:

void BookEntry::registerBook()
{
    cout << "Enter the number of Books this time:\n";
    cin >> numberOfBooks;

    for (int i = 0; i < numberOfBooks; ++i)
    {
        cout << "===============================\n";
        cout << "     CLI for Book Entry\n";
        cout << "===============================\n";
        cout << "Enter the Name of the Book: ";
        cin >> bookName;
        cout << "Enter the Author of the Book: ";
        cin >> bookAuthor;
        cout << "Enter the Publisher: ";
        cin >> publisher;
        cout << "Enter the ISBN number of the Book: ";
        cin >> ISBN;
        cout << "Enter the Edition (numbers only): ";
        cin >> edition;

        BookEntry book;
        book.bookName = bookName;
        book.bookAuthor = bookAuthor;
        book.publisher = publisher;
        book.ISBN = ISBN;
        book.edition = edition;
        books.push_back(book);
    }
}

void BookEntry::printData()
{
    cout << "=========================================\n";
    cout << "           Books in Library\n";
    cout << "=========================================\n";

    if (books.empty())
    {
        cout << "No books available.\n";
        return;
    }

    cout << left << setw(6) << "S.No"
         << setw(25) << "Title"
         << setw(25) << "Author"
         << setw(25) << "Publication"
         << setw(15) << "ISBN"
         << setw(10) << "Edition"
         << "\n";

    for (int i = 0; i < books.size(); i++)
    {
        if (i >= books.size() - numberOfBooks)
            cout << left << setw(6) << i + 1 << "*"
                 << setw(25) << books[i].bookName
                 << setw(25) << books[i].bookAuthor
                 << setw(25) << books[i].publisher
                 << setw(15) << books[i].ISBN
                 << setw(10) << books[i].edition
                 << "\n";
        else
            cout << left << setw(6) << i + 1
                 << setw(25) << books[i].bookName
                 << setw(25) << books[i].bookAuthor
                 << setw(25) << books[i].publisher
                 << setw(15) << books[i].ISBN
                 << setw(10) << books[i].edition
                 << "\n";
    }
}

void BookEntry::saveBookDataToFile(const string &filename)
{
    ofstream outputFile(filename);

    if (!outputFile.is_open())
    {
        cout << "Failed to open the file: " << filename << endl;
        return;
    }

    outputFile << "Books in Library\n";
    outputFile << "=========================================\n";
    outputFile << left << setw(6) << "S.No"
               << setw(25) << "Title"
               << setw(25) << "Author"
               << setw(25) << "Publication"
               << setw(15) << "ISBN"
               << setw(10) << "Edition"
               << "\n";

    for (int i = 0; i < books.size(); i++)
    {
        if (i >= books.size() - numberOfBooks)
            outputFile << left << setw(6) << i + 1 << "*"
                       << setw(25) << books[i].bookName
                       << setw(25) << books[i].bookAuthor
                       << setw(25) << books[i].publisher
                       << setw(15) << books[i].ISBN
                       << setw(10) << books[i].edition
                       << "\n";
        else
            outputFile << left << setw(6) << i + 1
                       << setw(25) << books[i].bookName
                       << setw(25) << books[i].bookAuthor
                       << setw(25) << books[i].publisher
                       << setw(15) << books[i].ISBN
                       << setw(10) << books[i].edition
                       << "\n";
    }

    cout << "Book data saved to file: " << filename << endl;

    outputFile.close();
}

The registerBook() function allows the user to register multiple books. It prompts the user to enter the number of books to register and then iterates that many times to collect book details such as name, author, publisher, ISBN, and edition. For each book, a BookEntry object is created and its member variables are set accordingly. The object is then added to the books vector.

The printData() function displays the book data stored in the books vector. It first checks if the vector is empty and prints a message if there are no books. If books are available, it formats and prints the book details in a tabular format.

The saveBookDataToFile() function saves the book data to a file. It opens the specified file in output mode (ofstream) and checks if the file is successfully opened. If the file fails to open, an error message is displayed. The function then writes the book data to the file in a formatted manner. It first writes the table header, followed by the book details. For the last numberOfBooks books in the books vector, an asterisk (*) is added to indicate their availability. Finally, it displays a success message and closes the file.

Now, let's move on to the member function implementations of MemberEntry:

void MemberEntry::registerMember()
{
    cout << "===============================\n";
    cout << "     CLI for Member Entry\n";
    cout << "===============================\n";
    cout << "Enter the Name of the Member: ";
    cin >> memberName;
    cout << "Enter the Address of the Member: ";
    cin >> memberAddress;
    cout << "Enter the Email of the Member: ";
    cin >> memberEmail;
    cout << "Enter the Member ID: ";
    cin >> memberID;
}

void MemberEntry::saveMemberDataToFile(const string &filename)
{
    ofstream outputFile(filename, ios::app);

    if (!outputFile.is_open())
    {
        cout << "Failed to open the file: " << filename << endl;
        return;
    }

    outputFile << "Member Details\n";
    outputFile << "=========================================\n";
    outputFile << "Name: " << memberName << endl;
    outputFile << "Address: " << memberAddress << endl;
    outputFile << "Email: " << memberEmail << endl;
    outputFile << "Member ID: " << memberID << endl;
    outputFile << "--------------------------------------" << endl;

    cout << "Member data saved to file: " << filename << endl;

    outputFile.close();
}

bool MemberEntry::isMemberExist(const string &filename)
{
    ifstream inputFile(filename);

    if (!inputFile.is_open())
    {
        cout << "Failed to open the file: " << filename << endl;
        return false;
    }

    string line;
    string searchName = "Name: " + memberName;
    string searchEmail = "Email: " + memberEmail;

    while (getline(inputFile, line))
    {
        if (line.find(searchName) != string::npos || line.find(searchEmail) != string::npos)
        {
            cout << "Member already exists.\n";
            inputFile.close();
            return true;
        }
    }

    inputFile.close();
    return false;
}

The registerMember() function collects member details from the user. It prompts the user to enter the member's name, address, email, and ID. The entered values are stored in the corresponding member variables.

The saveMemberDataToFile() function saves the member data to a file. It opens the specified file in append mode (ofstream with ios::app flag) and checks if the file is successfully opened. If the file fails to open, an error message is displayed. The function then writes the member details to the file, including the member's name, address, email, and ID. The data is formatted with appropriate labels. Finally, it displays a success message and closes the file.

The isMemberExist() function checks if a member already exists in the given file. It opens the file in input mode (ifstream) and checks if the file is successfully opened. If the file fails to open, an error message is displayed. The function then reads the file line by line and compares each line with the search criteria (name and email) to determine if a matching member already exists. If a match is found, a message is displayed, and the function returns true to indicate that the member exists. If no match is found, the function returns false.

Next, let's examine the Options class and its options() member function:

class Options : public BookEntry, public MemberEntry
{
public:
    void options();
};

void Options::options()
{
    char opts;
    bool running = true;

    while (running)
    {
        cout << "===============================\n";
        cout << "      CLI for Options\n";
        cout << "===============================\n";
        cout << "1. To make an Entry of Book\n";
        cout << "2. To Issue Book \n";
        cout << "3. Register a Member \n";
        cout << "Press Esc key to exit\n";
        cin >> opts;

        switch (opts)
        {
        case '1':
            registerBook();
            printData();
            saveBookDataToFile("book_data.txt");
            break;
        case '2':
            cout << "Issuing the book...\n";
            break;
        case '3':
            registerMember();
            if (!isMemberExist("member_data.txt"))
                saveMemberDataToFile("member_data.txt");
            break;
        case 27:
            running = false;
            break;
        default:
            cout << "Invalid option\n";
            break;
        }
    }
}

The Options class inherits from both BookEntry and MemberEntry classes. It provides the options() member function to display a menu and handle user input for different operations. Within the options() function, a while loop runs until the user chooses to exit by pressing the Esc key. In each iteration, the menu is displayed, and the user's choice is read into the opts variable.

Based on the user's input, the switch statement performs different actions:

If the user chooses '1', it calls the registerBook() function to register books, then prints the book data using printData(), and finally saves the book data to a file using saveBookDataToFile().
If the user chooses '2', a placeholder message is displayed for issuing a book (you can customize this functionality).
If the user chooses '3', it calls the registerMember() function to register a member. Before saving the member data, it checks if the member already exists using isMemberExist(). If the member does not exist, the member data is saved to a file using saveMemberDataToFile().
If the user presses the Esc key (27), the loop is terminated, and the program exits.
If the user inputs any other character, an "Invalid option" message is displayed.

This implementation allows users to interact with the CLI and perform operations such as registering books and members, and saving the data to files.

Final Code

#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <vector>

using namespace std;

class BookEntry
{
public:
    string bookName;
    string bookAuthor;
    string publisher;
    int ISBN;
    int edition;
    int publishYear;
    int numberOfBooks;
    vector<BookEntry> books; // Store multiple books

    void registerBook();
    void printData();
    void saveBookDataToFile(const string &filename);
};

class MemberEntry
{
public:
    string memberName;
    string memberAddress;
    string memberEmail;
    int memberID;

    void registerMember();
    void saveMemberDataToFile(const string &filename);
    bool isMemberExist(const string &filename);
};

void BookEntry::registerBook()
{
    cout << "Enter the number of Books this time:\n";
    cin >> numberOfBooks;

    for (int i = 0; i < numberOfBooks; ++i)
    {
        cout << "===============================\n";
        cout << "     CLI for Book Entry\n";
        cout << "===============================\n";
        cout << "Enter the Name of the Book: ";
        cin >> bookName;
        cout << "Enter the Author of the Book: ";
        cin >> bookAuthor;
        cout << "Enter the Publisher: ";
        cin >> publisher;
        cout << "Enter the ISBN number of the Book: ";
        cin >> ISBN;
        cout << "Enter the Edition (numbers only): ";
        cin >> edition;

        // Create a book object and add it to the vector of books
        BookEntry book;
        book.bookName = bookName;
        book.bookAuthor = bookAuthor;
        book.publisher = publisher;
        book.ISBN = ISBN;
        book.edition = edition;
        books.push_back(book);
    }
}

void BookEntry::printData()
{
    cout << "=========================================\n";
    cout << "           Books in Library\n";
    cout << "=========================================\n";

    if (books.empty())
    {
        cout << "No books available.\n";
        return;
    }

    cout << left << setw(6) << "S.No"
         << setw(25) << "Title"
         << setw(25) << "Author"
         << setw(25) << "Publication"
         << setw(15) << "ISBN"
         << setw(10) << "Edition"
         << "\n";

    for (int i = 0; i < books.size(); i++)
    {
        if (i >= books.size() - numberOfBooks)
            cout << left << setw(6) << i + 1 << "*"
                 << setw(25) << books[i].bookName
                 << setw(25) << books[i].bookAuthor
                 << setw(25) << books[i].publisher
                 << setw(15) << books[i].ISBN
                 << setw(10) << books[i].edition
                 << "\n";
        else
            cout << left << setw(6) << i + 1
                 << setw(25) << books[i].bookName
                 << setw(25) << books[i].bookAuthor
                 << setw(25) << books[i].publisher
                 << setw(15) << books[i].ISBN
                 << setw(10) << books[i].edition
                 << "\n";
    }
}

void BookEntry::saveBookDataToFile(const string &filename)
{
    ofstream outputFile(filename);

    if (!outputFile.is_open())
    {
        cout << "Failed to open the file: " << filename << endl;
        return;
    }

    outputFile << "Books in Library\n";
    outputFile << "=========================================\n";
    outputFile << left << setw(6) << "S.No"
               << setw(25) << "Title"
               << setw(25) << "Author"
               << setw(25) << "Publication"
               << setw(15) << "ISBN"
               << setw(10) << "Edition"
               << "\n";

    for (int i = 0; i < books.size(); i++)
    {
        if (i >= books.size() - numberOfBooks)
            outputFile << left << setw(6) << i + 1 << "*"
                       << setw(25) << books[i].bookName
                       << setw(25) << books[i].bookAuthor
                       << setw(25) << books[i].publisher
                       << setw(15) << books[i].ISBN
                       << setw(10) << books[i].edition
                       << "\n";
        else
            outputFile << left << setw(6) << i + 1
                       << setw(25) << books[i].bookName
                       << setw(25) << books[i].bookAuthor
                       << setw(25) << books[i].publisher
                       << setw(15) << books[i].ISBN
                       << setw(10) << books[i].edition
                       << "\n";
    }

    cout << "Book data saved to file: " << filename << endl;

    outputFile.close();
}

void MemberEntry::registerMember()
{
    cout << "===============================\n";
    cout << "     CLI for Member Entry\n";
    cout << "===============================\n";
    cout << "Enter the Name of the Member: ";
    cin >> memberName;
    cout << "Enter the Address of the Member: ";
    cin >> memberAddress;
    cout << "Enter the Email of the Member: ";
    cin >> memberEmail;
    cout << "Enter the Member ID: ";
    cin >> memberID;
}

void MemberEntry::saveMemberDataToFile(const string &filename)
{
    ofstream outputFile(filename, ios::app);

    if (!outputFile.is_open())
    {
        cout << "Failed to open the file: " << filename << endl;
        return;
    }

    outputFile << "Member Details\n";
    outputFile << "=========================================\n";
    outputFile << "Name: " << memberName << endl;
    outputFile << "Address: " << memberAddress << endl;
    outputFile << "Email: " << memberEmail << endl;
    outputFile << "Member ID: " << memberID << endl;
    outputFile << "--------------------------------------" << endl;

    cout << "Member data saved to file: " << filename << endl;

    outputFile.close();
}

bool MemberEntry::isMemberExist(const string &filename)
{
    ifstream inputFile(filename);

    if (!inputFile.is_open())
    {
        cout << "Failed to open the file: " << filename << endl;
        return false;
    }

    string line;
    string searchName = "Name: " + memberName;
    string searchEmail = "Email: " + memberEmail;

    while (getline(inputFile, line))
    {
        if (line.find(searchName) != string::npos || line.find(searchEmail) != string::npos)
        {
            cout << "Member already exists.\n";
            inputFile.close();
            return true;
        }
    }

    inputFile.close();
    return false;
}

class Options : public BookEntry, public MemberEntry
{
public:
    void options();
};

void Options::options()
{
    char opts; // Change the data type to char
    bool running = true;

    while (running)
    {
        cout << "===============================\n";
        cout << "      CLI for Options\n";
        cout << "===============================\n";
        cout << "1. To make an Entry of Book\n";
        cout << "2. To Issue Book \n";
        cout << "3. Register a Member \n";
        cout << "Press Esc key to exit\n";
        cin >> opts;

        switch (opts)
        {
        case '1': 
            registerBook();
            printData();
            saveBookDataToFile("book_data.txt");
            break;
        case '2':
            cout << "Issuing the book...\n";
            break;
        case '3':
            registerMember();
            if (!isMemberExist("member_data.txt"))
                saveMemberDataToFile("member_data.txt");
            break;
        case 27:
            running = false;
            break;
        default:
            cout << "Invalid option\n";
            break;
        }
    }
}

int main()
{
    Options op;
    op.options();

    return 0;
}

Introduction to Windows GUI Programming with C++: Building Your First Window

Utkarsh Yadav — Wed, 28 Jun 2023 22:44:08 +0000

Windows GUI programming allows developers to create interactive and user-friendly applications for the Windows operating system. In this article, we will explore the basics of Windows GUI programming using C++ and the Win32 API. We will walk through the process of building a simple "Hello, World!" application with a graphical user interface (GUI) to help you get started with Windows GUI programming.

Prerequisites:

Before diving into Windows GUI programming, make sure you have a basic understanding of C++ programming concepts. Familiarity with functions, variables, control flow, and the C++ syntax will be beneficial. Additionally, a Windows development environment, such as Visual Studio or Code::Blocks with MinGW, will be required to compile and run the code examples.

Setting Up the Project:

To begin, create a new C++ project in your preferred development environment. Ensure that you have the necessary tools and libraries configured to build Windows applications. For example, if you're using Code::Blocks with MinGW, ensure that the appropriate compiler and linker settings are in place.

Creating a Basic Window:

Let's start by creating a basic window for our "Hello, World!" application. Open a new C++ source file and enter the following code:

#include <windows.h>

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR pCmdLine, int nCmdShow)
{
    const wchar_t CLASS_NAME[] = L"HelloWorldWindowClass";

    WNDCLASS wc = {};
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = CLASS_NAME;

    RegisterClass(&wc);

    HWND hwnd = CreateWindowEx(
        0,
        CLASS_NAME,
        L"Hello, World!",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        NULL,
        NULL,
        hInstance,
        NULL
    );

    if (hwnd == NULL)
    {
        return 0;
    }

    ShowWindow(hwnd, nCmdShow);

    MSG msg = {};
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return 0;
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
        case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);
            FillRect(hdc, &ps.rcPaint, (HBRUSH)(COLOR_WINDOW + 1));
            EndPaint(hwnd, &ps);
        }
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

Understanding the Code:

Now, let's break down the code and understand how it creates a basic window for our "Hello, World!" application.

#include <windows.h>

This line includes the necessary header file <windows.h>, which provides access to the Windows API functions, constants, and data types required for creating and managing Windows applications.

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

A forward declaration of the WindowProc function is provided. This function serves as the window procedure that processes messages sent to the application's window.

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR pCmd

Line, int nCmdShow)

The wWinMain function is the entry point for the Windows application, replacing the standard main function. It takes several parameters:

hInstance: Represents the handle to the application instance.
HINSTANCE (unused in this code): Represents the previous instance handle.
PWSTR pCmdLine: Pointer to a null-terminated Unicode string that contains the command-line arguments.
nCmdShow: Specifies how the window should be shown, such as maximizing, minimizing, or normal.

const wchar_t CLASS_NAME[] = L"HelloWorldWindowClass";

A window class name is defined as a null-terminated Unicode string. This name will be used to register the window class.

WNDCLASS wc = {};
wc.lpfnWndProc = WindowProc;
wc.hInstance = hInstance;
wc.lpszClassName = CLASS_NAME;

RegisterClass(&wc);

A WNDCLASS structure is created and initialized. It specifies the window class attributes, including the window procedure (WindowProc), the application instance handle (hInstance), and the class name (CLASS_NAME). The window class is then registered using RegisterClass to make it available for creating windows.

HWND hwnd = CreateWindowEx(
    0,
    CLASS_NAME,
    L"Hello, World!",
    WS_OVERLAPPEDWINDOW,
    CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
    NULL,
    NULL,
    hInstance,
    NULL
);

The CreateWindowEx function creates the main application window. It takes parameters such as window styles, class name, window text, window size, and other attributes. In this code, we use the CLASS_NAME as the class name, "Hello, World!" as the window text, and WS_OVERLAPPEDWINDOW as the window style. The CW_USEDEFAULT parameters are used to set the default size and position of the window.

if (hwnd == NULL)
{
    return 0;
}

After creating the window, we check if the creation was successful. If the hwnd variable is NULL, it indicates an error, and the program returns 0.

ShowWindow(hwnd, nCmdShow);

The ShowWindow function displays the window using the specified nCmdShow parameter, which determines how the window is initially shown (e.g., maximized, minimized, or normal).

MSG msg = {};
while (GetMessage(&msg, NULL, 0, 0))
{
    TranslateMessage(&msg);
    DispatchMessage(&msg);
}

The message loop processes messages sent to the window, such as user input, window resizing, or system events. The GetMessage function retrieves messages from the application's message queue. The retrieved message is then translated using TranslateMessage, which converts keyboard input into character messages, and dispatches the message to the WindowProc function using DispatchMessage.

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
        case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);
            FillRect(hdc, &ps.rcPaint, (HBRUSH)(COLOR_WINDOW + 1));
            EndPaint(hwnd, &ps);
        }
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

The WindowProc function is the window procedure that handles various window messages sent to the application's window. In this code, two message cases are handled: WM_DESTROY and WM_PAINT. When the window receives the WM_DESTROY message, it posts a quit message to the message queue using PostQuitMessage, signaling the termination of the application. The WM_PAINT message is responsible for painting the window's client area. In this example, it fills the window with the COLOR_WINDOW system color.

In this article, we introduced the basics of Windows GUI programming using C++ and the Win32 API. We walked through the process of creating a basic "Hello, World!" application with a graphical user interface. Understanding the concepts of registering a window class, creating a window, handling window messages, and implementing a window procedure are essential for building more complex and interactive Windows applications. With the knowledge gained from this article, you can start exploring and building your own Windows GUI applications using C++.Peace!

Mastering State Management in React!

Utkarsh Yadav — Wed, 28 Jun 2023 16:58:23 +0000

React has emerged as one of the most popular JavaScript libraries for building user interfaces, thanks to its component-based architecture and efficient virtual DOM rendering. While React provides a solid foundation for building web applications, effective state management is crucial for handling complex data flows and ensuring a seamless user experience. In this article, we will explore various state management techniques in React and discuss their pros and cons.

Understanding React's Built-in State Management:

React's built-in state management revolves around the concept of "state" and "props." State refers to the internal data of a component that can change over time, while props are used to pass data down from parent to child components. React components manage their own state using the useState hook, which allows you to declare and update state variables within a functional component. This approach works well for simple applications with limited state requirements.

Leveraging React Context for Global State:

React Context provides a way to share data across components without explicitly passing it through props at each level. It allows you to create a global state accessible to all components within a specific context. By using the createContext and useContext hooks, you can easily manage and consume global state within your application. React Context is particularly useful when you need to share data across multiple components or when using third-party libraries that rely on global state.

Unleashing the Power of Redux:

Redux is a powerful state management library that offers a predictable and centralized approach to managing application state. It introduces the concepts of actions and reducers, enabling you to define how state changes in response to specific actions. Redux works well for large-scale applications with complex state requirements. You can integrate Redux into your React application using the react-redux bindings, which provide a convenient way to connect your components to the Redux store.

Exploring Alternatives: MobX and Zustand:

In addition to Redux, there are other state management libraries worth exploring. MobX is a reactive state management library that allows you to define observable data and automatically tracks changes, updating the user interface accordingly. Zustand, on the other hand, is a lightweight state management library that offers a minimalistic API while still providing powerful features such as state selectors and middleware support. Both libraries offer different approaches to state management and can be a good fit depending on your application's requirements.

Integrating GraphQL with React:

GraphQL has gained popularity as a powerful alternative to RESTful APIs for fetching and managing data in web applications. When combining GraphQL with React, you can take advantage of libraries like Apollo Client, which provides seamless integration and powerful caching capabilities. Apollo Client simplifies the process of fetching and managing data from a GraphQL server, making it an excellent choice for applications that heavily rely on data-driven components.

Optimizing Performance with React.memo and React.lazy:

React.memo is a higher-order component that can be used to memoize functional components, preventing unnecessary re-renders when props haven't changed. By wrapping your components with React.memo, you can significantly boost performance by skipping unnecessary rendering cycles. React.lazy, on the other hand, enables you to lazy-load components, allowing for more efficient code splitting and faster initial load times.

State management is a critical aspect of building web applications using React. By understanding the various state management techniques available, such as React's built-in state, React Context, Redux, MobX, and Zustand, you can choose the approach that best suits your application's complexity and requirements. Additionally, exploring integration with GraphQL and leveraging performance optimizations like React.memo and React.lazy can further enhance your development workflow and improve user experience. Keep experimenting, stay updated with the latest tools, and continue to refine your state management strategies to build robust and performant React applications.

Building a RESTful API with Node.js and Express.js

Utkarsh Yadav — Tue, 27 Jun 2023 00:50:07 +0000

Introduction:

In this developer journal, we will dive into building a RESTful API using Node.js and Express.js. RESTful APIs have become a fundamental part of modern web development, enabling communication between client applications and servers. We will explore the basic setup, routing, handling requests and responses, and connecting to a database. Let's get started!

Setting Up the Project:

To begin, let's set up our project. Open your terminal and follow these steps:
1.Create a new directory for your project:

mkdir restful-api
cd restful-api

2.Initialize a new Node.js project:

npm init -y

3.Install Express.js:

npm install express

Creating the Express App:

Now that we have our project set up, let's create our Express application. Create a file named app.js in the project directory and add the following code:

const express = require('express');
const app = express();
const port = 3000;

app.use(express.json());

// We will define the routes here!!

app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

Defining Routes:

Replace the comment // We will define the routes here!! in app.js with the following code:

const books = [];

app.get('/books', (req, res) => {
  res.json(books);
});

app.post('/books', (req, res) => {
  const { title, author } = req.body;
  const book = { title, author };
  books.push(book);
  res.status(201).json(book);
});

Testing the API

Start the server by running the following command in your terminal:

node app.js

Open your favorite API testing tool (e.g., Postman, curl) and send some requests to http://localhost:3000/books. Use a GET request to retrieve all books and a POST request to add a new book.

Handling Database Integration:

We'll use MongoDB and the mongoose library. Install mongoose by running the following command:

npm install mongoose

In app.js add the following code after the -
const books = []; line

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/books', { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => {
    console.log('Connected to the database');
  })
  .catch((error) => {
    console.error('Error connecting to the database:', error);
  });

const Book = mongoose.model('Book', {
  title: String,
  author: String,
});

app.post('/books', (req, res) => {
  const { title, author } = req.body;
  const book = new Book({ title, author });
  book.save()
    .then((savedBook) => {
      res.status(201).json(savedBook);
    })
    .catch((error) => {
      res.status(500).json({ error: 'An error occurred' });
    });
});

This code connects to a local MongoDB database named "books" and defines a Book model using Mongoose. The POST route now saves the book to the database using the model.

Conclusion:

In this developer journal, I've covered the basics of building a RESTful API with Node.js and Express.js. We set up the project, defined routes, handled requests and responses, and integrated a database using MongoDB and Mongoose. This is just the beginning of what you can accomplish with Node.js and Express.js in building powerful and scalable APIs. Happy coding!
ThankYou!

A Comprehensive Guide to Various Sorting Algorithms in C++

Utkarsh Yadav — Mon, 26 Jun 2023 16:58:25 +0000

Introduction

Sorting algorithms are fundamental tools in computer science and programming. They allow us to efficiently organize data in a specific order, enabling faster search and retrieval. In this blog post, we will explore a variety of sorting algorithms, including greedy and dynamic approaches, implemented in C++. Each algorithm will be accompanied by a well-commented code snippet and a detailed explanation. Let's dive into the world of sorting!

Bubble Sort:

Bubble Sort is a simple comparison-based sorting algorithm. It works by repeatedly swapping adjacent elements if they are in the wrong order until the entire array is sorted. The name "Bubble Sort" comes from the way smaller (or larger) elements "bubble" to their correct positions in each iteration. Let's break down the steps involved in Bubble Sort:

Compare adjacent elements:
The first step of Bubble Sort is to compare adjacent elements in the array. Starting from the beginning, compare the first element with the second element, then the second element with the third element, and so on. If the adjacent elements are in the wrong order (based on the desired sorting order), swap them.
Repeat the process:
After the first pass, the largest (or smallest) element is guaranteed to be at the end of the array. In each subsequent pass, the comparison and swapping process is repeated for the remaining unsorted elements. The number of passes required is equal to the number of elements in the array minus one.
Optimization: Early termination
To optimize Bubble Sort, we can introduce a flag variable to track whether any swaps were made during a pass. If no swaps were made in a pass, it means the array is already sorted, and the algorithm can terminate early.
Repeat until fully sorted:
The process of comparing and swapping adjacent elements is repeated until the array is fully sorted. Each pass moves the next largest (or smallest) element to its correct position, gradually building the sorted portion of the array.

The time complexity of Bubble Sort is O(n^2), where n is the number of elements in the array. In the worst case, when the array is in reverse order, Bubble Sort requires the maximum number of comparisons and swaps. However, if the array is already sorted, Bubble Sort has a best-case time complexity of O(n) due to the early termination optimization.

Bubble Sort is not suitable for large data sets due to its quadratic time complexity. It is primarily used for educational purposes or when simplicity is preferred over performance.

#include <iostream>
using namespace std;

void bubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; ++i) {
        for (int j = 0; j < size - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    bubbleSort(arr, size);

    cout << "Sorted array using Bubble Sort:\n ";
    for (int i = 0; i < size; ++i)
        cout << arr[i] << "\t";

    return 0;
}

Selection Sort:

Selection Sort is a simple in-place comparison-based sorting algorithm. It works by dividing the input array into two parts: the sorted portion and the unsorted portion. The algorithm repeatedly selects the smallest (or largest, depending on the sorting order) element from the unsorted part and swaps it with the leftmost element of the unsorted part. This process continues until the entire array is sorted. Let's break down the steps involved in Selection Sort:

Find the minimum (or maximum) element:
The first step of Selection Sort is to find the minimum (or maximum) element from the unsorted part of the array. This is done by iterating through the unsorted portion and keeping track of the index of the smallest (or largest) element found.
Swap with the leftmost element of the unsorted part:
Once the minimum (or maximum) element is identified, it is swapped with the leftmost element of the unsorted part. This brings the smallest (or largest) element to its correct position in the sorted portion of the array.
Expand the sorted portion:
After the swap, the sorted portion is expanded by considering the next element of the unsorted part. The previously swapped element now becomes a part of the sorted portion, and the process is repeated until the entire array is sorted.

To better understand Selection Sort, let's walk through an example using the following array: [64, 34, 25, 12, 22, 11, 90].

Initial array: [64, 34, 25, 12, 22, 11, 90]
Find the minimum element:
The minimum element in the entire array is 11, found at index 5.
Swap with the leftmost element of the unsorted part:
Swap the minimum element (11) with the leftmost element of the unsorted part (64).
Array after the first swap: [11, 34, 25, 12, 22, 64, 90]
Expand the sorted portion:
The sorted portion now includes the leftmost element (11), and the unsorted portion becomes [34, 25, 12, 22, 64, 90].
Find the minimum element:
The minimum element in the unsorted part is 12, found at index 3.
Swap with the leftmost element of the unsorted part:
Swap the minimum element (12) with the leftmost element of the unsorted part (34).
Array after the second swap: [11, 12, 25, 34, 22, 64, 90]
Expand the sorted portion:
The sorted portion now includes the first two elements (11, 12), and the unsorted portion becomes [25, 34, 22, 64, 90].
Repeat the steps:
Continue the process of finding the minimum element, swapping, and expanding the sorted portion until the entire array is sorted.
Sorted array:
The final sorted array using Selection Sort is [11, 12, 22, 25, 34, 64, 90].

The time complexity of Selection Sort is O(n^2), where n is the number of elements in the array. Selection Sort performs the same number of comparisons and swaps regardless of the order of the elements in the input array. However, it is not suitable for large data sets due to its quadratic time complexity. Selection Sort is an in-place sorting algorithm, meaning it does not require additional memory for sorting.

Selection Sort is primarily used for educational purposes or when simplicity is preferred over performance. It is not as efficient as more advanced sorting algorithms like Merge Sort or Quick Sort but can still be useful

#include <iostream>
using namespace std;

void selectionSort(int arr[], int size) {
    for (int i = 0; i < size - 1; ++i) {
        int minIndex = i;
        for (int j = i + 1; j < size; ++j) {
            if (arr[j] < arr[minIndex])
                minIndex = j;
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    selectionSort(arr, size);

    cout << "Sorted array using Selection Sort: \n";
    for (int i = 0; i < size; ++i)
        cout << arr[i] << "\t";

    return 0;
}

Insertion Sort

Insertion Sort is a simple comparison-based sorting algorithm that works by dividing the input array into two parts: the sorted portion and the unsorted portion. The algorithm iterates through the unsorted portion, selects an element, and inserts it into its correct position within the sorted portion. This process continues until the entire array is sorted. Let's break down the steps involved in Insertion Sort:

Initial setup:
The first element of the array is considered as the sorted portion. The remaining elements are considered as the unsorted portion.
Select an element from the unsorted portion:
Starting from the second element, the algorithm selects one element at a time from the unsorted portion and moves it to its correct position within the sorted portion.
Compare and shift:
The selected element is compared with the elements in the sorted portion, moving larger elements one position to the right until the correct position for the selected element is found.
Insert the element into its correct position:
Once the correct position for the selected element is determined, it is inserted into the sorted portion at that position.
Repeat until fully sorted:
Steps 2 to 4 are repeated for each remaining element in the unsorted portion until the entire array is sorted.

The time complexity of Insertion Sort is O(n^2), where n is the number of elements in the array. In the worst case, when the array is in reverse order, each element needs to be compared and shifted to its correct position. However, if the array is already sorted, Insertion Sort has a best-case time complexity of O(n) due to the early termination optimization.

Insertion Sort is efficient for small data sets or partially sorted arrays. It is also an in-place sorting algorithm, meaning it does not require additional memory for sorting.

#include <iostream>
using namespace std;

void insertionSort(int arr[], int size) {
    for (int i = 1; i < size; ++i) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    insertionSort(arr, size);

    cout << "Sorted array using Insertion Sort:\n";
    for (int i = 0; i < size; ++i)
        cout << arr[i] << "\t";

    return 0;
}

Merge Sort

Merge Sort is a divide-and-conquer sorting algorithm that works by dividing the input array into smaller halves, recursively sorting them, and then merging the sorted halves to produce the final sorted array. Let's break down the steps involved in Merge Sort:

Divide:
The first step of Merge Sort is to divide the input array into two halves. This is done recursively until each subarray contains only one element or is empty. The division is performed by finding the middle index of the array and splitting it into two parts.
Conquer (Recursive Sort):
After dividing the array, the next step is to sort the divided subarrays. This is done by recursively calling the Merge Sort function on each half. This recursive process continues until the base case is reached, i.e., when a subarray contains only one element. At this point, the subarray is considered sorted.
Merge:
The final step of Merge Sort is the merge operation. It merges the sorted subarrays to produce the final sorted array. The merging process compares elements from the two subarrays and places them in the correct order in a temporary array. The merged elements are then copied back to the original array, resulting in a sorted sequence.

To better understand Merge Sort, let's walk through an example using the following array: [64, 34, 25, 12, 22, 11, 90].

Divide:
The initial array is divided into two halves: [64, 34, 25, 12] and [22, 11, 90].
The process continues recursively until the subarrays contain only one element.
Conquer (Recursive Sort):
The recursive sorting process is applied to each subarray.
Subarray 1: [64, 34, 25, 12]
Divided into [64, 34] and [25, 12]
Further divided into [64] [34] [25] [12]
The base case is reached, and the subarrays are considered sorted.

Subarray 2: [22, 11, 90]

Divided into [22] [11] [90]
The base case is reached, and the subarrays are considered sorted.

Merge: The sorted subarrays are merged back into a single sorted array.
[64] [34] are merged into [34, 64]
[25] [12] are merged into [12, 25]
[34, 64] and [12, 25] are merged into [12, 25, 34, 64]

[22] [11] are merged into [11, 22]
[11, 22] and [90] are merged into [11, 22, 90]

Finally, the two merged subarrays, [12, 25, 34, 64] and [11, 22, 90], are merged into the final sorted array: [11, 12, 22, 25, 34, 64, 90].

The time complexity of Merge Sort is O(n log n), where n is the number of elements in the array. It performs equally well for best, average, and worst-case scenarios. Merge Sort is a stable sorting algorithm, meaning it maintains the relative order of elements with equal values.

Merge Sort's key advantage is its efficiency in handling large data sets since it divides the problem into smaller subproblems. However, it requires additional memory for the temporary array used during the merging process.

Merge Sort is a widely-used sorting algorithm due to its consistent performance and stability. Its divide-and-conquer approach makes it an excellent choice for sorting large datasets efficiently.

#include <iostream>
using namespace std;

void merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int leftArr[n1], rightArr[n2];

    for (int i = 0; i < n1; ++i)
        leftArr[i] = arr[left + i];
    for (int j = 0; j < n2; ++j)
        rightArr[j] = arr[mid + 1 + j];

    int i = 0, j = 0, k = left;

    while (i < n1 && j < n2) {
        if (leftArr[i] <= rightArr[j]) {
            arr[k] = leftArr[i];
            i++;
        } else {
            arr[k] = rightArr[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = leftArr[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = rightArr[j];
        j++;
        k++;
    }
}

void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    mergeSort(arr, 0, size - 1);

    cout << "Sorted array using Merge Sort:\n";
    for (int i = 0; i < size; ++i)
        cout << arr[i] << "\t";

    return 0;
}

Heap Sort:

Heap Sort is a comparison-based sorting algorithm that leverages the properties of a binary heap data structure. It works by first constructing a max-heap (in the case of sorting in ascending order) or a min-heap (in the case of sorting in descending order) from the input array. Once the heap is built, the largest (or smallest) element is repeatedly removed from the root of the heap and placed at the end of the array. This process is repeated until the entire array is sorted. Here's a step-by-step explanation of Heap Sort:

Build the heap:
- The first step of Heap Sort is to construct a heap from the input array.
- To build the heap, start from the last non-leaf node of the array (index n/2-1) and perform heapify operations on each node in reverse order.
- The heapify operation ensures that each node satisfies the heap property, which means that the parent node is greater (for max-heap) or smaller (for min-heap) than its children.
- By applying heapify to each node, we ensure that the entire array satisfies the heap property and can be treated as a valid heap.
Extract elements from the heap:
- After the heap is constructed, the largest (or smallest) element is at the root of the heap.
- Swap the root element with the last element of the heap (considering the remaining heap size).
- Reduce the heap size by one to exclude the sorted element from future heapify operations.
- Perform heapify on the root to restore the heap property.
Repeat until the array is sorted:
- Repeat the extraction step until all elements are extracted from the heap.
- After each extraction, the next largest (or smallest) element is moved to the end of the array.
- The extracted elements are placed in the reverse order of their sorted position, resulting in a sorted array.

The time complexity of Heap Sort is O(n log n) in all cases, where n is the number of elements in the array. Building the heap takes O(n) time, and the extraction step is performed n times with a time complexity of O(log n) per extraction. The space complexity of Heap Sort is O(1) since the sorting is done in-place without requiring additional memory.

Heap Sort is an efficient and widely used sorting algorithm. It guarantees a worst-case time complexity of O(n log n), making it suitable for large data sets. Additionally, Heap Sort is an in-place sorting algorithm and can be implemented in a way that preserves the stability of equal elements in the array.

#include <iostream>
using namespace std;

void heapify(int arr[], int n, int i)
{
    int largest = i;       
    int left = 2 * i + 1;   
    int right = 2 * i + 2;  

    if (left < n && arr[left] > arr[largest])
        largest = left;

    if (right < n && arr[right] > arr[largest])
        largest = right;

    if (largest != i) {
        swap(arr[i], arr[largest]);

        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n)
{
    // Build max-heap (rearrange array)
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n - 1; i > 0; i--) {
        swap(arr[0], arr[i]);

        heapify(arr, i, 0);
    }
}


void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    cout << "\n";
}

int main()
{
    int arr[] = { 12, 11, 13, 5, 6, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "Original array: ";
    printArray(arr, n);

    heapSort(arr, n);

    cout << "Sorted array: ";
    printArray(arr, n);

    return 0;
}

Quick Sort:

Lets walk through Quick Sort with an example. Consider the following array of integers: [7, 2, 1, 6, 8, 5, 3, 4].

Step 1: Choosing a Pivot:

In this example, we'll choose the last element, which is 4, as the pivot.

Step 2: Partitioning:

We initialize i to the start of the array (i = 0) and j to one position ahead of the start (j = 1).
We compare each element from the start to the second-to-last element with the pivot (4).
If the element is less than or equal to the pivot, we swap it with the element at index i and increment i.
After iterating through the array, we swap the pivot (4) with the element at index i.
The array after partitioning becomes: [2, 1, 3, 4, 8, 5, 7, 6].
The pivot (4) is now in its correct sorted position.

Step 3: Recursive Sorting:

The array is divided into two sub-arrays: 2, 1, 3 and 8, 5, 7, 6.
We recursively apply the partitioning process to each sub-array.
For the left sub-array, we choose 3 as the pivot. After partitioning, it becomes [2, 1, 3], and the pivot (3) is in its correct sorted position.
For the right sub-array, we choose 6 as the pivot. After partitioning, it becomes [5, 6, 7, 8], and the pivot (6) is in its correct sorted position.
Now, both sub-arrays are sorted.

Step 4: Final Sorted Array:

Since both sub-arrays are sorted, the entire array is sorted. Concatenating the sorted sub-arrays gives us the final sorted array: [1, 2, 3, 4, 5, 6, 7, 8].

The steps of partitioning and recursive sorting are repeated until the array is completely sorted. Quick Sort has an average-case time complexity of O(n log n) and a worst-case time complexity of O(n^2), but the worst-case scenario is rare and can be mitigated by choosing a good pivot. It is an in-place sorting algorithm and does not require additional memory. Quick Sort is widely used due to its efficiency and simplicity.

#include <iostream>
using namespace std;

void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int low, int high)
{
    int pivot = arr[high]; 
    int i = (low - 1);   

    for (int j = low; j <= high - 1; j++) {

        if (arr[j] <= pivot) {
            i++; 
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);                
}

void quickSort(int arr[], int low, int high)
{
    if (low < high) {
        int pivotIndex = partition(arr, low, high); 
        quickSort(arr, low, pivotIndex - 1);        
        quickSort(arr, pivotIndex + 1, high);       
    }
}

void printArray(int arr[], int size)
{
    for (int i = 0; i < size; i++)
        cout << arr[i] << " ";
    cout << endl;
}

int main()
{
    int arr[] = { 64, 34, 25, 12, 22, 11, 90 };
    int size = sizeof(arr) / sizeof(arr[0]);

    cout << "Original array: ";
    printArray(arr, size);

    quickSort(arr, 0, size - 1);

    cout << "Sorted array: ";
    printArray(arr, size);

    return 0;
}

Conclusion

In this blog post, I have explained various sorting algorithms implemented in C++, including Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, heap Sort and Quick Sort. Each algorithm was accompanied by detailed explanations and well-commented code snippets. Sorting algorithms are powerful tools for organizing data efficiently, and understanding their workings can greatly enhance your programming skills. Feel free to experiment with the provided code snippets and explore more sorting algorithms to expand your knowledge further. Happy sorting!