DEV Community: Samyabrata Maji

The Indie Hacker's Guide to Global Payments

Samyabrata Maji — Sun, 08 Feb 2026 15:39:10 +0000

You built your product in nights and weekends. You validated it with real users. You're ready to charge for it.

Then reality hits: setting up payments means choosing between spending $5,000 on Stripe Atlas to incorporate in Delaware, waiting months for payment processor approval in your home country, or limiting yourself to a tiny local market.

For the 95% of indie hackers who don't have VC backing or a legal team on retainer, going global has always meant navigating an impossible maze of compliance, fees, and restrictions.

Until now.

The Solo Founder's Payment Paradox

Here's the frustrating irony: the tools that make it easiest to build software (no-code platforms, AI coding assistants, cloud infrastructure) have made launching a product almost trivial. You can go from idea to working prototype in a weekend.

But actually getting paid for that product? That's where dreams go to die.

The Three Walls Every Indie Hacker Hits

Wall #1: The Access Problem

You want to use Stripe—everyone does. It's the gold standard. But if you're in India, Indonesia, Pakistan, Nigeria, or dozens of other countries, you're stuck on an invite-only waitlist. Or completely blocked.

Your options become:

Wait indefinitely (while your competitors launch)
Pay $500+ for Stripe Atlas and deal with US tax obligations
Use a local processor that doesn't support international customers
Give up on the international market entirely

Wall #2: The Compliance Nightmare

Let's say you somehow get access to a payment processor. Congratulations! Now you need to:

Register for VAT in every EU country where you have customers
Understand and comply with GST rules in India, Australia, Singapore
Handle sales tax across different US states
File quarterly tax returns in multiple jurisdictions
Keep track of changing tax thresholds and regulations

You're a solo developer. You don't have a legal team. You barely have time to build features, let alone become a tax expert across 50+ countries.

Wall #3: The Death by a Thousand Fees

Even if you clear the first two walls, the fees eat you alive:

2.9% + $0.30 per transaction (standard)
2-3% currency conversion fees
$15-30/month for various SaaS tools (invoicing, tax calculation, analytics)
Monthly accounting fees: $200-500
Annual tax filing: $500-2,000 per jurisdiction

On $5,000 MRR, you're easily losing $500-1,000 to fees and overhead. That's 10-20% of your revenue before you even start.

Why Traditional Solutions Don't Work for Indie Hackers

The conventional wisdom says: "Just use Stripe/PayPal/Razorpay and figure it out."

But that advice comes from people who either:

Already had access to these tools
Had the budget to hire help
Were in a supported country
Started before regulations tightened

For today's indie hacker, especially in emerging markets, this advice is increasingly useless.

The Stripe Atlas Trap

"Just incorporate in the US!" they say.

Sure, for $500 you get:

A Delaware C-Corp
An EIN
A US bank account (maybe)
Stripe access

But what they don't tell you:

You now have US tax obligations (federal and state)
You need a registered agent ($100-300/year)
You must file annual reports and taxes even at $0 revenue
You might need an ITIN or SSN for certain filings
Currency conversion eats 2-3% every time you move money home
You're dealing with two countries' worth of compliance instead of one

For someone making $500-2,000/month, this overhead makes no sense. You're not building a unicorn. You're trying to make rent.

The "Just Do It Manually" Mistake

Some indie hackers think: "I'll just handle taxes myself and save money."

This works until:

You hit the VAT threshold in Germany ($22,000)
A customer in France asks for a compliant invoice
You realize you should have been collecting GST in Australia from day one
You get a letter from HMRC about unpaid VAT
Your payment processor freezes your account for compliance issues

The cost of fixing these mistakes is always higher than preventing them.

What Indie Hackers Actually Need

After talking to hundreds of solo founders, the pattern is clear. Indie hackers need:

Instant access - No waitlists. No months-long approval processes.
Global from day one - Accept payments from anywhere without extra setup.
Zero tax headaches - Someone else handles VAT, GST, sales tax—all of it.
Transparent, affordable pricing - No hidden fees. No monthly minimums.
Fast integration - Hours, not weeks.
Support that gets it - Talk to humans who understand bootstrapped startups.

The problem? No traditional payment processor was built with these needs in mind.

Enter the Merchant of Record Model

This is where Dodo Payments changes the game with a different approach: the Merchant of Record (MoR) model.

Here's how it works:

Instead of YOU being the legal seller (with all the compliance that entails), the payment platform becomes the seller. They handle:

All tax registrations (VAT, GST, sales tax)
Tax collection and remittance
Legal compliance across 220+ countries
Invoice generation with proper tax documentation
Cross-border regulatory requirements

You simply get clean payouts to your bank account. The tax compliance happens invisibly in the background.

Why This Is Perfect for Indie Hackers

Think about what this means practically:

Before (Traditional Processor):

Spend weeks researching tax requirements
Register in multiple jurisdictions as you grow
File quarterly/monthly tax returns
Risk penalties for mistakes
Hire accountant ($200-500/month)
Constant worry about compliance

After (Merchant of Record):

Sign up in minutes
Start selling globally immediately
Never think about tax compliance
Focus entirely on building and marketing
Sleep well at night

The MoR model essentially gives you an enterprise-level tax and compliance team for the price of a slightly higher transaction fee.

The Real Cost Comparison for a $3K/Month Indie Product

Let's run the actual numbers for a solo founder making $3,000/month:

Option 1: DIY with Stripe

Setup:

Stripe Atlas: $500 (one-time)
Registered agent: $200/year
US tax filing: $500-800/year
Accounting software: $15/month

Monthly costs:

Transaction fees (2.9% + $0.30): ~$95
Currency conversion (2.5%): $75
Tax software: $30/month
Accountant: $300/month
Risk buffer for tax mistakes: ???

Total monthly: ~$500 + stress + compliance risk

Total first year: $6,500 + opportunity cost

Option 2: Dodo Payments (MoR)

Setup:

Sign up: Free
Integration: 2-3 hours of dev time

Monthly costs:

Transaction fees (4% + $0.40): ~$132
Tax compliance: Included
Multi-currency: Included
Analytics: Included
Support: Included

Total monthly: ~$132

Total first year: $1,584

Savings: $4,916 in the first year alone.

But more importantly: zero compliance stress, zero tax filing, zero risk of getting it wrong.

Real Indie Hackers Making It Work

The testimonials tell the story better than any marketing copy:

"Finally I've found a stripe alternative as an Indian indie hacker. It's hard to survive as an invite only platform. Thanks @dodopayments LFG! and make more MRRs 🚀" — Abishua Blessmic

"I used Dodo Payments at @resume_mate for Payments outside India. And the simplicity and reliability Dodo offers is out of the box. Love the product." — Aviral

"I'm using dodopayments for 2 of my products. Loved the developer experience. Rooting for you guys 🥳" — CodeBucks

These aren't funded startups with finance teams. These are solo developers building products in their spare time. And they're selling globally without the traditional barriers.

The Step-by-Step Launch Plan

Here's exactly how to go from "I have a product" to "I'm accepting global payments" in one day:

Morning: Setup (30 minutes)

Sign up at Dodo Payments
- Use your email
- Complete basic KYC (Aadhaar/PAN for India, equivalent elsewhere)
- Add your bank details for payouts
Create your product
- Set your pricing (one-time, subscription, or usage-based)
- Add product description
- Upload any digital deliverables

Afternoon: Integration (2-3 hours)

Choose your integration method:

Option A - No Code (5 minutes):

Use Dodo's no-code checkout
Customize the checkout page
Add the link to your website
Done!

Option B - Code Integration (1-2 hours):

   // Install the SDK
   npm install @dodopayments/payments-sdk

   // Initialize (literally 10 lines)
   import { DodoPayments } from '@dodopayments/payments-sdk';

   const dodo = new DodoPayments({
     apiKey: process.env.DODO_API_KEY
   });

   // Create a checkout
   const checkout = await dodo.createCheckout({
     productId: 'your-product-id',
     successUrl: '/success',
     cancelUrl: '/cancel'
   });

Test with their sandbox
- Make test purchases
- Verify webhooks
- Confirm everything works

Evening: Launch (1 hour)

Go live
- Switch to production keys
- Update your website
- Make your first real sale!
Tell the world
- Tweet your launch
- Post in indie hacker communities
- Email your waitlist

Total time investment: 4-5 hours

Compare this to the 2-3 weeks most founders spend setting up payments traditionally.

Advanced Features You'll Actually Use

As you grow, Dodo grows with you:

Usage-Based Billing

Perfect for API products, AI tools, or any consumption-based model. Track usage automatically and bill accordingly.

// Report usage
await dodo.reportUsage({
  subscriptionId: 'sub_123',
  metricName: 'api_calls',
  quantity: 150
});

Purchasing Power Parity

Automatically adjust pricing based on the customer's country. A developer in India might pay $9/month while someone in the US pays $29/month for the same product. Ethical pricing that maximizes global reach.

Affiliate Program

Built-in affiliate tracking and payouts. No need for separate tools like Rewardful or PartnerStack.

Digital Product Delivery

Automatically deliver downloads, license keys, or access codes upon purchase. Perfect for ebooks, courses, software licenses, or templates.

Common Questions from Indie Hackers

Q: Is 4% too expensive compared to Stripe's 2.9%?

A: Not when you factor in:

Tax software: $30-50/month
Accounting: $200-500/month
Currency conversion: 2-3%
Time spent on compliance: Priceless
Risk of tax penalties: Potentially thousands

The effective rate with all hidden costs included makes traditional processors more expensive.

Q: Can I really trust a newer platform with my revenue?

A: Dodo is:

PCI DSS compliant
Backed by Antler, 9Unicorns, DVC, and Venture Catalysts
Trusted by 15,000+ businesses
Has operators from PayU, AWS, Flipkart, and OYO

Plus, you can start small. Test with one product. Scale as you gain confidence.

Q: What if I want to switch processors later?

A: Your data is portable. Export customer lists, transaction history, and analytics anytime. No lock-in.

Q: Do I lose control of the customer relationship?

A: No. You have full access to customer data, can export it anytime, and control all communication. Dodo is just handling the payment and tax infrastructure.

Q: What about customers asking why "Dodo Payments" is on their statement?

A: This is standard for MoR models (LemonSqueezy, Paddle, Gumroad all work this way). You can customize the statement descriptor to include your brand name.

The Indie Hacker Success Pattern

After analyzing hundreds of successful indie products using Dodo, a pattern emerges:

Week 1: Set up payments, launch publicly

Week 2-4: Focus entirely on marketing and product (not payment infrastructure)

Month 2-3: First international sales start coming in automatically

Month 4-6: Scale to $1K-5K MRR without hiring anyone

Month 6+: Reinvest saved time and money into features and growth

The founders who succeed aren't smarter or more talented. They just removed the payment bottleneck early and focused on what matters: building and selling.

Your 30-Day Challenge

Here's my challenge to you:

If you have a product idea or existing project:

Day 1-7: Build your MVP or polish your existing product
Day 8: Sign up for Dodo Payments
Day 9: Integrate payments (use no-code if you want to move fast)
Day 10-20: Focus on marketing and getting your first customers
Day 21-30: Iterate based on feedback and scale

The rule: Spend ZERO time worrying about tax compliance, international regulations, or payment infrastructure.

If you can't launch and get paying customers in 30 days with this approach, the problem isn't payments—it's product-market fit.

The Bottom Line: Time Is Your Scarcest Resource

As an indie hacker, you have three scarce resources:

Time
Money
Mental bandwidth

Traditional payment setups consume all three.

The Merchant of Record model gives you back:

100+ hours you would have spent on compliance
$3,000-6,000 in first-year savings
Infinite peace of mind knowing tax compliance is handled

That's 100 hours you could spend:

Building the features that drive growth
Creating content that attracts customers
Having conversations that lead to sales
Actually living your life

Ready to Launch?

Stop letting payments hold you back. The opportunity cost of waiting is higher than you think.

Every day you delay because "payments are complicated" is a day your competitors are:

Making sales
Learning from customers
Building momentum
Taking market share

The good news? You can catch up fast. Really fast.

Get started today:

Sign up for Dodo Payments
Integrate in an afternoon
Launch globally tomorrow

Join the thousands of indie hackers who've already made the switch to simpler, smarter payments.

Your first international customer is waiting.

Resources for Indie Hackers

Quick Start Guide: docs.dodopayments.com
Integration Examples: Check out the SDKs for your stack
Community: Join the Discord to connect with other indie hackers
Comparison: See how Dodo stacks up against Stripe, Paddle, and Gumroad
Pricing Calculator: dodopayments.com/pricing

Built by indie hackers, for indie hackers. Start accepting global payments in minutes, not months.

Create dropdown menu (tui) in c

Samyabrata Maji — Mon, 10 Mar 2025 05:26:27 +0000

In this article, I’ll show how to create a simple dropdown menu using C, with the ability to navigate through options using the arrow keys and select one using the Enter key. Here’s how it would look.

Disable terminal modes

First, we need to disable canonical mode and terminal echo.

In canonical mode, input is processed when line by line (when enter key is pressed). For our application, we want to read key press when it happens.

The echo mode, prints out everything that is typed. Again, not really useful - we don’t want to log every key press.

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>

void init_terminal() {
  struct termios term;
  tcgetattr(STDIN_FILENO, &term);
  term.c_lflag &= ~(ICANON | ECHO); // Disable canonical mode and echo
  tcsetattr(STDIN_FILENO, TCSANOW, &term);
}

void reset_terminal() {
  struct termios term;
  tcgetattr(STDIN_FILENO, &term);
  term.c_lflag |= (ICANON | ECHO);
  tcsetattr(STDIN_FILENO, TCSANOW, &term);
}

The init_terminal function disables canonical mode and terminal echo. reset_terminal re-enables it.

Here, c_lflag is an unsigned int, where each bit indicates some property. ICANON and ECHO are unsigned int as well. If our, c_lflag is 1011, it indicates that canonical mode is turned on, since the bit that indicates canonical mode (2nd last bit) is 1. ICANON is 0010. When we do a bit-wise and operation, we flip only the bit indicating canonical mode and keep all the others as it is.

1011 & ~0010 → 1011 & 1101 → 1001

In our case, we are flipping bits for canonical mode and echo mode.

ANSI and Key Codes

We define some ANSI escape codes and some key codes.

Here, HIGHLIGHT escape code will flip the colors of the background and text, useful of highlighting an item.

#define CLEAR_SCREEN "\033[2J\033[H"
#define CURSOR_UP "\033[A"
#define CURSOR_DOWN "\033[B"
#define CLEAR_LINE "\033[K"
#define HIGHLIGHT "\033[7m" // Reverse video (highlight)
#define RESET "\033[0m"     // Reset attributes

Struct definition

Let us also create a struct to store all the data in the dropdown menu. The create_dropdown method can be used to initialize the struct.

typedef struct {
    char **options;
    int num_options;
    int selected;
    char *title;
} Dropdown;

Dropdown *create_dropdown(char *title, char **options, int num_options) {
    Dropdown *dropdown = (Dropdown *) malloc(sizeof(Dropdown));
    if (!dropdown) {
        return NULL;
    }

    dropdown->options = options;
    dropdown->num_options = num_options;
    dropdown->selected = 0;
    dropdown->title = title;
    return dropdown;
}

void free_dropdown(Dropdown *dropdown) {
    free(dropdown);
}

Printing dropdown

The code is pretty straightforward. We run over the options and print them one by one. We highlight the selected option.

void display_dropdown(Dropdown *dropdown) {
    printf(CLEAR_SCREEN);
    printf("%s\n\n", dropdown -> title);

    for (int i = 0; i < dropdown -> num_options; i++) {
        if (i == dropdown -> selected) {
            printf("%s> %s%s\n", HIGHLIGHT, dropdown -> options[i], RESET);
        } else {
            printf("  %s\n", dropdown -> options[i]);
        }
    }
}

Input handling

The read_key function defined below reads a single character and returns it.

int read_key() {
    char c;
    if (read(STDIN_FILENO, &c, 1) == 1) {
        return c;
    }
    return 0;
}

When we press arrow keys, three characters are pushed to the input buffer:

'\033' (start of escape sequence)
'['
'A', 'B', 'C' or 'D' (up, down, right, left)

So if we get \033[A, it indicates up arrow key press.

Let us define these character codes as macros:


#define KEY_UP 65
#define KEY_DOWN 66
#define KEY_ENTER 10
#define KEY_ESC 27
#define KEY_Q 113

The run_dropdown method will read characters and re-renders the dropdown menu accordingly.

void handle_arrow_key(Dropdown *dropdown) {
    switch (read_key()) {
    case KEY_UP: // ascii code for A
        if (dropdown->selected > 0) {
            dropdown->selected--;
            display_dropdown(dropdown);
        }
        break;

    case KEY_DOWN: // ascii code for B
        if (dropdown->selected < dropdown->num_options - 1) {
            dropdown->selected++;
            display_dropdown(dropdown);
        }
        break;
    }
}

int run_dropdown(Dropdown *dropdown) {
    init_terminal();
    bool is_running = true;
    display_dropdown(dropdown);

    while (is_running) {
        int key = read_key();

        switch (key) {
        case KEY_ESC: // Check if this is an escape sequence for arrow keys
            if (read_key() == '[') {
                handle_arrow_key(dropdown);
            } else {
                // Plain ESC key was pressed - cancel selection
                dropdown->selected = -1;
                is_running = false;
            }
            break;

        case KEY_ENTER:
            // Confirm selection
            is_running = false;
            break;

        case KEY_Q:
            // Cancel selection
            dropdown->selected = -1;
            is_running = false;
            break;
        }
    }

    reset_terminal();
    return dropdown->selected;
}

That’s it.

Now, you can use it to create a dropdown.

int main() {
    char title[] = "Select an option:";
    char *options[] = {
        "Option 1",
        "Option 2",
        "Option 3",
        "Option 4",
        "Option 5"
    };
    int num_options = sizeof(options) / sizeof(options[0]);
    Dropdown *dropdown = create_dropdown(title, options, num_options);

    int selected = run_dropdown(dropdown);

    // Clear screen and show result
    printf(CLEAR_SCREEN);
    if (selected >= 0) printf("You selected: %s\n", options[selected]);
    else printf("Selection cancelled\n");

    free_dropdown(dropdown);
    return 0;
}

Here’s link to the full source code.

Now that you've implemented a basic dropdown, you can build more complex tui elements. You could handle signals (like SIGINT or SIGTERM), add mouse support, focus groups, etc.

Build and deploy a chat application using Socket.io and Redis.

Samyabrata Maji — Mon, 26 Aug 2024 10:43:00 +0000

In this tutorial, we will be building a chat application using web sockets. Web sockets are really useful when you want to build applications that require real-time transfer of data.

By the end of this tutorial, you will be able to setup your own socket server, send and receive messages in real time, store data in Redis and deploy your application on render and google cloud run.

What we will be building?

We will be building a chat application. To keep it short, we will only setup the server. You can use your own front end framework and follow along.

In this chat application, there will be rooms and users can join a room and start chatting. To keep everything simple, we will assume the usernames are not unique. However each room can have only one user with a specific username.

Setup a socket server.

First we need to install the required dependencies.

npm i express cors socket.io -D @types/node

We will be using the http module to setup our socket server. Since our app will be running in the terminal, we will have to allow all origins.

import express from "express";
import cors from "cors"
import { Server } from "socket.io";
import { createServer } from "http"

const app = express();
const server = createServer(app);

// create a socket server.
const io = new Server(server, {
  cors: {
    origin: "*",
    credentials: true,
  }
});

// listen to connections errors
io.engine.on("connection_error", console.log)

app.use(cors())

const PORT = 3000;
server.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Setting up Redis.

We will be using redis to store our messages along with room and user information. You can use upstash redis (free). Create a new redis instance in your upstash dashboard. After creation you will receive a redis url which you can use to connect to your redis instance.

Install any redis client of your choice. I'll be using ioredis.

npm i ioredis

Next, we will initialize our redis client and connect it to our redis server using the connection url we got.

/** /src/index.ts */
import { Redis } from "ioredis"

if (!process.env.REDIS_URL) throw new Error("REDIS_URL env variable is not set");
const redis = new Redis(process.env.REDIS_URL);

// listen to connection events.
redis.on("connect", () => console.log("Redis connected"))
redis.on("error", console.log)

Handling events.

Users can create rooms or join existing rooms. Rooms are identified by unique room ids. Each member has a username which is unique inside a room, and not globally.

We can keep track of all the active rooms in our server, by storing their room ids inside a redis set.

For our purpose, usernames are only unique inside a room. So, we store them in a set along with the room id. This ensures that the combination of the room id along with the member id is unique globally.

We can setup socket event for creating room. When we create a room, we also add the member that requested its creation into the room.

io.on("connection", () => {
    // ...
    socket.on("create:room", async (message) => {
        console.log("create:room", message)

        const doesRoomExist = await redis.sismember("rooms", message.roomId)
        if (doesRoomExist === 1) return socket.emit("error", { message: "Room already exist."})

        const roomStatus = await redis.sadd("rooms", message.roomId)
        const memStatus = await redis.sadd("members", message.roomId + "::" + message.username)

        if (roomStatus === 0 || memStatus === 0) return socket.emit("error", { message: "Room creation failed." })

        socket.join(message.roomId)
        io.sockets.in(message.roomId).emit("create:room:success", message)
        io.sockets.in(message.roomId).emit("add:member:success", message)
  })
}

To add new member into an existing room, we first need to check if the member already exists in that room.

io.on("connection", () => {
    // ...
    socket.on("add:member", async (message) => {
        console.log("add:member", message)

        const doesRoomExist = await redis.sismember("rooms", message.roomId)
        if (doesRoomExist === 0) return socket.emit("error", { message: "Room does not exist." })

        const doesMemExist = await redis.sismember("members", message.roomId + "::" + message.username)
        if (doesMemExist === 1) return socket.emit("error", { message: "Username already exists, please choose another username." })

        const memStatus = await redis.sadd("members", message.roomId + "::" + message.username)
        if (memStatus === 0) return socket.emit("error", { message: "User creation failed." })

        socket.join(message.roomId)
        io.sockets.in(message.roomId).emit("add:member:success", message)
  })

    socket.on("remove:member", async (message) => {
        console.log("remove:member", message)

        const doesRoomExist = await redis.sismember("rooms", message.roomId)
        if (doesRoomExist === 0) return socket.emit("error", { message: "Room does not exist." })

        await redis.srem("members", message.roomId + "::" + message.username)

        socket.leave(message.roomId)
        io.sockets.in(message.roomId).emit("remove:member:success", message)
      })
}

Finally, we create the chat event.

io.on("connection", () => {
    socket.on("create:chat", (message) => {
    console.log("create:chat", message)
    redis.lpush("chat::" + message.roomId, message.username + "::" + message.message)
    io.sockets.in(message.roomId).emit("create:chat:success", message)
  })
}

Deployment.

Socket server requires persistent connections, it won't work in serverless environments. So you can't deploy your socket server in vercel.

You can deploy it in many places like Render, fly.io or Google Cloud Run.

Render

Deploying on render simple. If you have a dockerfile, it will automatically build your project from that dockerfile. Render has a free tier, but keep in mind there will be cold start in the free tier.

Here's my dockerfile.

# syntax=docker/dockerfile:1
ARG NODE_VERSION=20.13.1
ARG PNPM_VERSION=9.4.0

FROM node:${NODE_VERSION}-bookworm AS base

## set shell to bash
SHELL [ "/usr/bin/bash", "-c" ]
WORKDIR /usr/src/app

## install pnpm.
RUN --mount=type=cache,target=/root/.npm \
    npm install -g pnpm@${PNPM_VERSION}

# ------------
FROM base AS deps
# Download dependencies as a separate step to take advantage of Docker's caching.
# Leverage a cache mount to /root/.local/share/pnpm/store to speed up subsequent builds.
# Leverage bind mounts to package.json and pnpm-lock.yaml to avoid having to copy them
# into this layer.
RUN --mount=type=bind,source=package.json,target=package.json \
    --mount=type=bind,source=pnpm-lock.yaml,target=pnpm-lock.yaml \
    --mount=type=cache,target=/root/.local/share/pnpm/store \
    pnpm install --prod --frozen-lockfile

# -----------
FROM deps AS build
## downloading dev dependencies.
RUN --mount=type=bind,source=package.json,target=package.json \
    --mount=type=bind,source=pnpm-lock.yaml,target=pnpm-lock.yaml \
    --mount=type=cache,target=/root/.local/share/pnpm/store \
    pnpm install --frozen-lockfile

COPY . .
RUN pnpm run build

# -------------
FROM base AS final
ENV NODE_ENV=production
USER node
COPY package.json .

# Copy the production dependencies from the deps stage and also
# the built application from the build stage into the image.
COPY --from=deps /usr/src/app/node_modules ./node_modules
COPY --from=build /usr/src/app/dist ./dist

EXPOSE 3000
ENTRYPOINT [ "pnpm" ]
CMD ["run", "start"]

Google Cloud Run

If you want a free alternative to render and avoid cold starts, you should use Google Cloud Run. The steps to deploy on cloud run is beyond the scope of this article, but here's a short list of things you need to do.

Build you docker image from the dockerfile provided below.
Create an artifact repository using Google Artifact Registry service.
Rename your docker image into the format <region>-docker.pkg.dev/<artifact-repository-name>/<image-name>:<tag-name>
Push your image to your artifact repository.
Deploy the image to Google Cloud Run. Make sure to set the minimum active instances to one, to avoid cold starts.

That's it for this tutorial.

Thanks for reading ❣️

How to show progress while downloading data in node.js

Samyabrata Maji — Sat, 27 Apr 2024 05:42:14 +0000

What if you are downloading a large file and need to show the users the progress of the download. You can do that by downloading the data in chunks. This is called streaming. Unfortunately, fetch doesn't have any support for streaming.

We need to use the node http module. Here's an example.

const Http = require('http');
const Fs   = require('fs');
const url = 'url'; // some large file
const path = 'save_path';

let downloaded = 0;
let percents = 0;
let size = 0;

const request = Http.request(url, (response) => {
  size = parseInt(response.headers['content-length']);

  response.on('data', (chunk) => {
    downloaded += chunk.length;
    percents = parseInt((downloaded / size) * 100);

    console.log(percents +'%', downloaded +'/'+size);
  });

  response.on('error', (error) => {
    console.log(error);
  });

  response.pipe(Fs.createWriteStream(path));

  setTimeout(() => {
    response.pause(); console.log('stream paused');

    setTimeout(() => {
      response.resume(); console.log('stream resumed');
    }, 5000);
  }, 5000);
}).end();

Everything about Data Fetching & the JavaScript Fetch API.

Samyabrata Maji — Tue, 12 Mar 2024 14:43:16 +0000

The lifeblood of modern web applications is data. They rely on fetching information from various sources to deliver dynamic and interactive experiences. This is where the JavaScript Fetch API comes in – a powerful tool that simplifies how you retrieve data across networks.

Making a fetch request.

Fetch is a promise based api. To make a fetch request, use the fetch() function. It takes two arguments - first, the URL endpoint you want to send the request to. The second argument is optional and you can put additional properties, like headers, body, etc.

Here's an example of using the fetch() function:

const makeReq = async () => {
    const res = await fetch('https://dummyjson.com/todos');
    const json = await res.json();
    console.log(json);
}

makeReq();

In the above example, we make a HTTP GET request to https://dummyjson.com/todos. We get a response object back, containing all the information we need. The json() method is used to convert the body of the response object into JSON.

Post request with Headers.

The default request type is GET. But, you can make other types of requests too. Here is an example of a POST request, with some custom headers and a body.

fetch('https://dummyjson.com/todos/add', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Accept-Type': 'application/json'
    },
  body: JSON.stringify({
    todo: 'example todo',
    completed: false,
    userId: 5,
  })
})

The method property is used to define the type of the HTTP request. It can be GET, POST, PUT, PATCH, DELETE and OPTION . The body contains the payload you want to send. We convert our object into a string, as the body can only be a string, buffer or blob. You can't put a body if you are making a get request.

The headers property will accept all the headers. In our example we included two headers. Many apis, will require you to put api keys or access token in the headers.

HTTP status codes.

When we get an HTTP response from a server, it contains a status code, indicating whether the request was successful or not. For example, a status code of 404 means the resource you are requesting does not exist. A status code 422 might mean you haven't provided something the server needs. A status code of 401 means you are not authorised to access the resource. In general:

status code between 200-299 means success.
status code between 400-499 means client side error, error from your side.
status code between 500-599 means server side error, error from the server.

The fetch() api doesn't throw any error even for error status codes. You have to do it manually.

const makeReq = async () => {
    const res = await fetch('https://dummyjson.com/todos');
    if (res.ok) {  // true for status codes <400
        const json = await res.json();
        console.log(json);
    }
    else {
        console.error("failed to fetch todos");
    }
}

makeReq();

Cancelling Fetch Request

You can cancel a fetch request using AbortController. The AbortController interface represents a controller object that allows you to abort one or more requests as and when desired. It has a signal property which returns an AbortSignal object. If you pass this object in your fetch request, then you can abort that request.

Here's an example:

const controller = new AbortController();

const start_download = async () =>
  await fetch("url", { signal: controller.signal });

const stop_download = async () => controller.abort();

// start download
const btn_startDownload = document.getElementById("#btn_start_download");
btn_startDownload?.onclick(() => {
  alert("starting download...");
  start_download()
    .then((data) => alert("download finished!!"))
    .catch(() => alert("can't download"));
});

// cancel download
const btn_cancelDownload = document.getElementById("#btn_cancel_download");
btn_cancelDownload?.onclick(() => {
  stop_download();
  alert("downloading stopped!!");
});

If you run this code, you will notice that the "can't download" message will be shown when your download is cancelled or request is aborted. The reason is when, a request is aborted, a DOMException, named AbortError is thrown. If the fetch request is already complete, no error is thrown.

We can modify our code to not display any error message when the request is successfully aborted.

const btn_startDownload = document.getElementById("#btn_start_download");
btn_startDownload?.onclick(() => {
  alert("starting download...");
  start_download()
    .then((data) => alert("download finished!!"))
    .catch((error) => {
      // no error messages when request is aborted
      if (error.name === "AbortError") return;
      alert("cancelled download!");
    });
});

That's all you need to know about the fetch api. Thanks for reading ❣️

Beginner's guide to monorepos and turborepo.

Samyabrata Maji — Thu, 30 Nov 2023 19:20:33 +0000

In this article we will look at how to manage monorepos using turbo repo.

What is a monorepo?

Monolithic repositories or monorepos are code bases where multiple projects are stored in a single place. Code can be shared between multiple projects and versioned separately.

Monorepos are not monoliths

Monorepos are not monoliths.

A monorepo is a code base where multiple projects or components are stored in a single repository. It's a way of organising code that allows multiple, potentially unrelated projects to coexist in the same repository.

On the other hand, monolith is a type of software architecture where the entire application is built as a single, tightly integrated unit. All components, modules, and features are part of a single code base and run within a single process.

Workspace

Workspaces are a way of sharing packages inside a monorepo. A workspace contains multiple smaller packages, each having their own package.json file. Each of these packages can be shared across the workspace.

Package managers like npm, yarn and pnpm have support for workspaces. For this article we will use pnpm as our package manager. There procedure is the same for any other package manager.

Creating a workspace

To create a workspace you need to have a pnpm-workspace.yml file at the root. There you can specify the packages you want to include in your workspace.

# make docs and everything inside
# packages and apps part of the workspace.
docs
packages/*
apps/*

In the above example, we made the docs folder and everything inside the packages and the apps folder part of our workspace.

Each package or app in your workspace must have a name mentioned in its package.json. The name is necessary as package managers uses the package name to figure out where to install a package.

Say, we have three packages foo, bar and web (packages/foo, packages/bar and apps/web).

Installing a package inside a workspace project

Installing a package is same as how you would install normally, except you need to also mention where you want to install the package. For example, if you want to install react, in app/web, you need to do run the following command. In our case, the package name is same as the name of the folder.

# pnpm add react --filter package-name
pnpm add react --filter web

Sharing packages

To use a workspace package inside another package, you need to specify it as a dependency with the workspace: suffix in it's version. This tells the package manager to use a local version instead of downloading it from the package registry.

pnpm i foo@workspace:* --filter web

{
    "dependencies": {
        "shared-package": "workspace:*"
    }
}

Here, * means the latest version, which saves us from needing to bump the versions of our dependency if the versions of our packages change. You can use a specific version too.

Turborepo

Turborepo is a high-performance build system for JavaScript and Typescript code bases. It makes working with monorepos a lot simpler.

Tasks

Tasks are basically a batch of processes you can run. For example, if you run turbo run dev, it will run the dev scripts from each of your packages. You can also filter which scripts to run using the filter flag. Running turbo run dev --filter docs,foo will run the dev script inside docs and foo.

You can configure the behaviour of these tasks. First create a turbo.json. Inside this file, you can list all the task and modify their default configuration. For example, turbo caches every build, you can change that by changing the cache property.

{ "pipeline": { "dev": { "cache": false } }}

If you want intellisense in your turbo.json file, add a $schema property and set it to https://turbo.build/schema.json.

If a task depends on other tasks, we can mention it.

{
  "pipeline": {
    "lint": { "cache": false },
    "publish": {
      "dependsOn": ["lint"],
      "cache": true
    }
  }
}

Caching

Turborepo tries to cache results whenever possible. Basically, it keeps track of the inputs (your code) and outputs (your build outputs and terminal outputs). If the inputs changes, then only it will re-run a task, otherwise, it will just use the cached results.

For every task, you can set cache property to true or false. By default, turbo will cache a task. However, for the caching to work properly, we need to specify the build outputs, otherwise it will only cache terminal outputs.

The outputs options takes an array of glob paths that are generated as a result of building an application. These outputs will not be rebuild if the cache is valid. For example, in a next.js application, you would want to include the .next folder, as that is where the build output is generated.

Similar to outputs, you can also mention the inputs. By default, turbo will consider everything (except your outputs) to be your inputs.

{
  "pipeline": {
    "build": {
      "outputs": [".next/**", "!.next/cache/**"],
      "inputs": ["src/**"]
    }
  }
}

If you use the no-cache flag while running a task, turbo will not write to the cache (but it will use the cache if possible).

If you use use the force flag, it will not use the cache (but it will write to the cache if possible).

Remote Caching

Just like local cache, you can download cached results from a remote server and then use it. This is especially helpful for CI pipelines, making them extremely fast. You can learn more about remote caching here.

That's it for today. If you learnt something new, do drop a like ❤️

Detailed Introduction To Prisma ORM

Samyabrata Maji — Mon, 25 Sep 2023 13:26:04 +0000

Prisma is an open-source object-relational mapper (ORM) tool for Node.js and TypeScript. In this article, we will cover the basics of Prisma and understand how it works.

What is an ORM?

Object Relational Mappings or ORMs provide a high-level abstraction. They expose a programmatic interface through objects to create, read, delete, and manipulate data while hiding some of the complexity of the database.

The idea with ORMs is that you define your models as classes that map to tables in a database. The classes and their instances provide you with a programmatic API to read and write data in the database.

In Prisma, you define your models in the declarative Prisma schema which serves as the single source of truth for your database schema and the models in your programming language.

Prisma is full-typesafe, which means you can get type intellisense in your typescript code.

To get started run the following command:

npx prisma init

This will set up Prisma in your project. A new folder named Prisma will be created, containing a single file prisma.schema. That is your schema file. The Prisma schema file is where you define everything related to your database.

The schema file consists of three parts:

Data Source: specifies how Prisma should connect to your database.
Generators: specifies how your Prisma client will be generated, the Prisma client provides APIs for interacting with your database.
Models: your data models, which will be mapped to tables, relations or collections in your database.

Data Sources

The data source specifies how Prisma should connect to your database. You can specify only one data source.

By default you'll find this as your data source:

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

The provider is the database you want to connect to. Prisma supports these databases: postgresql, mysql, sqlite, sqlserver, mongodb or cockroachdb.

The url is the connection URL which is required for connecting with your database. You can set that to an environment variable using env() function.

Generators

Prisma reads your Prisma schema and generates a Prisma client which provides useful APIs for interacting with your database.

The generator block contains configurations which specify how your Prisma client will be generated. You can multiple generator blocks.

The provider property describes which generator to use. This can point to a file that implements a generator or specifies a built-in generator directly. Prisma has tons of community-created generators.

One built-in generator is the prisma-client-js which generates a javascript client based on your schema. You'll be using this most of the time.

To generate Prisma client from your Prisma schema, run the following command:

npx prisma generate

If you run it right now, it will complain as you don't have any models. Just add the following line and re-run the command:

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
}

Now, look into your node_modules, and you will find @prisma/client. You will use this to work with your database.

You can change the output directory of your schema, by changing the output property. If you set it to out/client and run npx prisma generate, you'll see your new client being generated at prisma/out/client.

Models

Models are entities that represent data in your database. These are mapped to tables and relations (for relational databases like PostgreSQL) or collections (for nosql databases like Mongodb).

Let's look at the model we defined previously:

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
}

Here we created a model called User, with three fields. Each field has a type and some optional attributes. Prisma provides a few built-in datatypes like BigInt, String, Float, etc. Some datatypes are only supported by certain databases only, e.g., the Json datatype is only supported by PostgreSQL.

Field Level Attributes

Field-level attributes modify the properties of a field. Field-level attributes are prefixed by @.

Every model must have a unique identifier. You can use the @id attribute to specify a particular field as a primary key. Is similar to PRIMARY KEY property, if you're familiar with SQL.

The @default() attribute sets the default value of your field. In most cases you won't want to manage your id manually. You can use this modifier to automatically set the IDs. Here, the autoincrement() function provides a unique integer everytime. If your ID is of string type, you can use uuid() or cuid() to generate unique IDs.

model User {
  id String @id @default(cuid())
}

If you're using MongoDB, your unique id must be named _id. Alternatively, you can use the @map attribute to map the id field of your model to _id field of your database.

/// for mongodb
model User {
  id    Int     @id @default(autoincrement()) @map("_id")
  email String  @unique
  name  String?
}

Type Modifiers

There are two type modifiers in prisma: optional modifier (?) and array modifier (?). Both are self explanatory.

Adding the optional modifier makes a property optional. In the previous example, name was an optinal property. You can choose to not provide a name and the prisma client will not complain.

The array modifier lets you accept an array of values. In the example below, the field posts accepts an array of string values.

model User {
  id    Int     @id @default(autoincrement()) @map("_id")
  email String  @unique
  name  String?
  posts String[]
}

These modifiers cannot be chained together, ie, you can't have optinal arrays in prisma.

Enums

Enums store a set number of values, which can be used as state in your models.

enum Role {
  USER
  ADMIN
}

model User {
  id   Int  @id @default(autoincrement())
  role Role @default(USER)
}

Block Level Attributes

As we saw previously, the field level attributes modify the properties of an individual field. There is another type of attribute, namely, the block level attribute. Block level attributes are prefixed by @@.

Here's an example, let's say you want to ensure that first name and last name of an user, combined must be unique. You can use the block level attribute @@unique to do so.

model User {
  id        Int    @id @default(autoincrement())
  firstName String
  lastName  String

  @@unique([firstName, lastName])
}

For the above example, two users can have the same first name or same last name but they cannot have the same full name.

We can also create composite ids, using the @@id modifier. Composite ids are simply unique identifiers that are composed of multiple fields. The fields may or may not have the same data type.

For the previous example, since we know that the full name of the user is unique, we can use that as an id.

model User {
  firstName String
  lastName  String

  @@id([firstName, lastName])
}

You can define indexes on one or multiple fields of your models via the @@index attribute. Having indexes helps in optimizing lookup time for a field. There are some limitations of creating indexes using prisma. For example, you cannot create indexes partially using WHERE clause or concurrently using CONCURRENTLY.

That's it for now, there are few things left to cover like, how to use the prisma client, relational data modelling and migrations. I'll be covering them in future articles.

Did you like this article? Do provide you feedback in the comments. Thank you for reading ❣️

Vite: The Fast, Simple, and Efficient Build Tool for Web Developers

Samyabrata Maji — Sun, 26 Feb 2023 11:38:04 +0000

If you're a developer who's looking for a faster, simpler and more efficient way to build web applications, then Vite might be just what you need.

In this blog post, we'll learn to use Vite, and how it can help you build your web applications more quickly and efficiently. We'll also cover topics like Hot Module Replacement, Tree Shaking, SWC and so on.

What is Vite?

Vite is a modern build tool for web development that emphasizes speed and simplicity. It uses native ES modules to deliver lightning-fast performance during development and leverages features like hot module replacement and tree shaking to optimize the size and performance of your production builds. Vite is designed to be easy to use, with a simple configuration and a low learning curve, making it an ideal tool for web developers who want to build fast and efficient web applications without getting bogged down in complex configuration and setup.

Getting Started

Getting started with Vite is a breeze. All you need to do is run a few commands.

npm create vite@latest app-name
yarn create vite app-name

Then go ahead and select the template you want. For example, we want to create a react project with JavaScript. Go ahead and select react and then JavaScript + SWC.

This will create an empty project with no dependencies installed. You need to do it manually.

# go to project directory
cd app-name

# install dependencies
npm install
yarn install

Now you are good to go.

Development Server

When you're working on your application during development, you'll typically use a development server to serve your files. The development server is designed to make it easy to test your code as you're writing it. To start your development server in Vite, all you have to do is run npm run dev or yarn dev. Here are some of the key features of the development server:

Fast Build Times

The development server can build and serve your application quickly, so you can test your changes in real-time.

Hot Module Replacement

Hot module replacement (HMR) is a technique used to improve the developer experience by allowing you to see your changes in real-time without having to refresh the page.

Traditionally, when you make changes to your code, you need to refresh the page to see the updates. This can be time-consuming and disruptive to your workflow. With HMR, the changes you make to your code are automatically injected into the running application, without the need for a page refresh.

HMR works by detecting which modules in your code have changed and then updating them in the running application. This means that you can see your changes instantly, without losing your current state or having to navigate back to where you were in the application.

HMR is especially useful in larger applications, where navigating to a specific page or state can take time. With HMR, you can make changes to your code and see the results in real-time, without having to spend time navigating back to the relevant page or state.

Debugging Tools:

The development server often comes with built-in debugging tools, like error messages and console logs, to help you find and fix issues in your code.

The development server is not intended for use in a production environment, as it is optimized for speed and ease-of-use, rather than performance and security.

Production Build

When you're ready to deploy your application to a live environment, you'll typically use a production build. A production build is a version of your application that has been optimized for performance and security.

To create your production build, run the command:

# create your production build (for vite)
npm run build
yarn build

# start a server for viewing your production build
npm run preview
yarn preview

Here are some of the key features of a production build:

Minified Code

The code in a production build is typically minified. This is done by removing comments and blank spaces. It also changes function names and variable names to something smaller. This is done to reduce the bundle size and make it load faster in the browser.

/* ORIGINAL CODE*/
// this function prints a message to the console
const printMessage = (message) => {
    console.log(message);
}
/* MINIFIED CODE */
const p=s=>{console.log(s)};

Tree Shaking

Tree shaking is a technique used to remove unused code from your application, also known as dead code elimination. The term "tree shaking" comes from the idea of shaking a tree to remove dead leaves or branches.

When you build a web application, you typically include a lot of code that you don't actually need. This could be code that you wrote but never ended up using, or code that you imported from a library but only used a small portion of. This unused code takes up space in your application, which can slow down its performance.

Tree shaking works by analyzing your code to determine which parts are actually being used. It then removes the unused code from your application, resulting in a smaller and more efficient codebase. This process can dramatically reduce the size of your application, leading to faster load times and improved performance.

Tree shaking is typically done as part of the build process for your application. Many modern module bundlers, such as Webpack and Rollup, include built-in support for tree shaking (Vite uses Rollup under the hood). When you run your application through one of these tools, it will automatically analyze your code and remove any unused portions.

It's important to note that not all code can be tree shaken. Some code may be dynamically loaded at runtime or may have complex dependencies that make it difficult to determine whether it's being used. In these cases, you may need to manually remove unused code or optimize your application in other ways.

Caching

The assets in a production build are often cached by the browser, which means that they can be loaded more quickly for returning visitors.

A production build is designed to be used in a live environment, where performance and security are top priorities. Vite configures all of these for you so you don't have to worry about manually configuring it.

What is SWC?

SWC is a rust-based compiler that claims to be "20x faster than Babel on a single thread and 70x faster on four cores". If you want to use babel instead, just select JavaScript + SWC or TypeScript + SWC.

Keep in mind that meta-frameworks like Next and tools like Parcel and Deno use SWC.

Module Bundlers - Quick Introduction

Vite is designed to be easy to use and configure, but this simplicity can also be a disadvantage if you need more fine-grained control over your build process. Some developers may find that Vite's configuration options are too limited for their needs. If you want more fine-grained control, you need to use module bundlers.

Module bundlers are tools used in web development to combine multiple modules of JavaScript code into a single file, known as a bundle. This process is commonly referred to as "bundling". Some popular module bundlers for web development include Webpack, Rollup and Snowpack. Keep in mind Vite uses Rollup under the hood.

A Guide to Styling Your Website with Tailwind CSS

Samyabrata Maji — Fri, 17 Feb 2023 14:47:58 +0000

Are you tired of writing CSS from scratch and spending hours tinkering with styles? Do you want to speed up your web development process without sacrificing customization? Look no further than Tailwind, the utility-first CSS framework that streamlines the styling process and puts control back in your hands. In this blog, we'll cover everything you need to know about Tailwind, from installation to customization, so you can start using it in your projects right away.

Installation

The installation process is pretty straightforward. The documentation for tailwind covers that pretty well. There's an official Tailwind VSCode extension that provides intellisense for tailwind classes. There's also a prettier plugin that helps to sort and reorder tailwind classes.

With Tailwind, you style elements by applying pre-existing classes directly in your HTML.

What is Tailwind?

Tailwind is a library that allows you to style your elements in HTML itself. How does that work? Well, tailwind has some utility classes that have predefined styles. All you have to do is add those classes to your HTML elements.

Examples

Let's say there's a button you want to style with some colors and some round borders. The CSS would look something like this:

button  {
  color: green;
  background-color: greenyellow;
  padding: 1rem 1.25rem;
  border-radius: 4rem;
  border: green 2px solid;
}

button:hover {
  color: white;
  background-color: green;
}

Here's how you would do this in tailwind. First, let's add the colors. Now tailwind provides a. We'll choose the one that matches our style lime-500. To use the color as background color, just use bg-lime-500.

Now for margins and paddings, tailwind provides some convention. To add margin across all directions use m-value. For example, m-4 will apply 1 rem of margin across all directions. Use mx-value to apply margin-left and margin-right only. Similarly use my-value to apply margins across top and bottom directions. You can use mt-value, mb-value, ml-value and mr-value to apply margins across the top, bottom, left and right directions. (Padding works in a similar manner, just use p-value instead of m-value and so on.)

For border-radius, we'll use rounded-full. I highly recommend checking out the tailwind docs for reference. Here's what your tailwind style will look like.

<button class=
"px-5 py-4
 lime-500 bg-lime-500 text-lime-900
 border-2 border-lime-900 border-solid">
Styled with Tailwind
</button>

Handling Pseudo Selectors

Tailwind makes it very easy to handle pseudo-selectors. All you need to do is to append the name of the pseudo selector followed by : before your class name. So focus:bg-lime-900 would change the color of our button on focus and so on.

<button class=
"px-5 py-4
 lime-500 bg-lime-500 text-lime-900
 border-2 border-lime-900 border-solid
 hover:bg-lime-900 hover:text-neutral-50">
Styled with Tailwind
</button>

Responsiveness

Adding some responsiveness to your website is easier than ever. Tailwind comes with 5 different screen sizes. These are sm (<640px), md (<768px), lg (<1024px), xl (<1280px) and 2xl (<1536px).

To change the color of the button when the screen size gets smaller than 640px, we can add sm:bg-red-500.

Customizations

### Spacing

Remember when I mentioned that m-4 will apply 1 rem of margin across your element? Well, that is the default behavior. You can customize your spacing by modifying the tailwind config file. (If you don't have a tailwind config file, just create one: tailwind.config.js .

/* tailwind.config.js */
module.exports = {
  theme: {
    spacing: { '2': '1rem', '4': '2rem' }
  }
}

Now m-2, p-2 and so on will use 1 rem instead of 0.5 rem and m-4, p-4 and so on will use 4 rem instead of 2 rem. You can use any CSS unit.

### Colors

Similar to spacing, you can add your own colors too by modifying the tailwind config file. You can also specify weights as shown below.

/* tailwind.config.js */
module.exports = {
  theme: {
    colors: {
      primary: '#F2921D',
      secondary: '#F2CD5C',
      accent: '#BFDB38',
      purple: {
        100: '#EBC7E6',  /* different */
        200: '#BFACE2',  /* shades of */
        300: '#A084DC',  /* purple */
        400: '#645CBB'
      }
    }
  }
};

Now we can use our colors in tailwind class names, like bg-primary or text-purple-300 and so on.

### Screens

You can modify the screen size for responsiveness as shown below:

module.exports = {
  theme: {
    screens: {
      sm: '480px',
      md: '768px',
  }
};

You can customize other properties like border-radius, font family and so on. Refer to the docs.

Thank you for reading.
Author: Samyabrata Maji

A Short Introduction to React

Samyabrata Maji — Mon, 13 Feb 2023 09:13:07 +0000

React is a JavaScript library for building user interfaces. It is developed and maintained by Facebook, and is widely used for building single-page applications and mobile apps. React allows developers to build reusable UI components, manage the state of the application, and efficiently render changes to the user interface.

Why use react?

One reason is reusability. In react, you can create components that you can reuse in different places. This helps to keep your code organized and maintainable.

React uses a virtual DOM, which allows it to update the user interface efficiently. The virtual DOM optimizes updates to the user interface by minimizing the number of actual DOM updates required, resulting in improved performance.

React has a large and active community, which means that there are many resources available to learn from and get help with. It is also compatible with a variety of tools and libraries, making it easier to build complex and feature-rich applications.

"Reusability, Performance and Large Active Community"

What is JSX?

JSX is a syntax extension for JavaScript that allows you to write HTML-like code within your JavaScript files.

export default function HelloWorld() {
  const message = "World"
  return (
    <div>
      <h1>Hello, {message}!</h1>
    </div>
  );
}

As you can see, the above code returns a function called HelloWorld, but notice how we are returning some HTML elements. That's JSX. This allows us to combine HTML and JavaScript effortlessly.

Virtual DOM

Virtual DOM (VDOM) is a concept used in libraries like React to update user interfaces efficiently. The Virtual DOM is an in-memory representation of the actual DOM, the structure that represents the elements and content of a web page.

When changes are made to the user interface, React updates the Virtual DOM first, and then calculates the difference between the old Virtual DOM and the new Virtual DOM. This calculation determines the most efficient way to update the actual DOM, reducing the amount of work required to make the updates.

By using the Virtual DOM, React can optimize updates to the user interface and minimize the number of updates to the actual DOM, resulting in improved performance. This makes it possible to build fast, dynamic user interfaces with a high level of interactivity and responsiveness.

In summary, the Virtual DOM is a powerful concept used by libraries like React to efficiently update user interfaces and provide a high level of performance.

What is SPA?

A single-page application (SPA) is a web application or website that interacts with the user by dynamically rewriting the current page, instead of loading entire new pages from a server. This provides a more fluid and responsive user experience, as the application only has to load the necessary data and update specific parts of the page, instead of reloading the entire page.

In a single-page application, the majority of the application logic runs on the client side (in the user's browser), instead of on the server. This allows for fast and smooth updates to the user interface, as there is no need to wait for data to be sent back and forth between the client and server. React is well-suited for building SPAs.

The Complete Guide to User Authentication in Firebase

Samyabrata Maji — Fri, 10 Feb 2023 19:43:10 +0000

In this blog, we'll cover how to implement a simple login signup functionality using firebase. We'll be using modular JavaScript SDK, which (according to the documentation) provides a reduced SDK size and greater efficiency with modern JavaScript build tools such as Webpack or Rollup.

Why use firebase?

Although there are other options like Auth0, Cognito, Okta, etc., firebase just stands out as it is free and very easy to use.

Installation and Setup

Setting up a firebase project is pretty straightforward.

Go to your firebase console.
Select "Add project". Enter your project name and continue.
Now when you are inside your project, create a firebase app.

Copy the firebase config settings.

To install firebase in your project, just run one of these commands:

npm install firebase
yarn add firebase

# optionally you can install the firebase-cli
npm i firebase-tools
yarn add firebase-tools

Signing in a new user

Create a new file called firebase.js and add your firebase config settings. Then you can create a firebase app instance using the initializeApp function.

We can use the firebase app instance to create a firebase auth instance using getAuth function which will take your firebase app as a parameter. We'll use this auth instance to log in / sign in / sign out users.

import { initializeApp } from "firbase/app"
import { getAuth } from "firebase/auth"

/**
 * config settings for firebase
 * these setting will not work as I will delete the project
 * copy your own settings and put it in .env file
 */
const firebaseConfig = {
  apiKey: "AIzaSyCxoi3v425fyZ3WO1r4N7U-zCFWbliU4eQ",
  authDomain: "test-fireba-9108e.firebaseapp.com",
  projectId: "test-fireba-9108e",
  storageBucket: "test-fireba-9108e.appspot.com",
  messagingSenderId: "759607951227",
  appId: "1:759607951227:web:c2c071782154578f6107de"
}
const firebaseApp = initializeApp(firebaseConfig)
const firebaseAuth = getAuth(firebaseApp)

Ideally, you would want to use a .env file, where you'll put all your config settings as environment variables. If you are putting your code in a public repository, make sure you are not sending your .env file there. This will prevent others from accessing your API keys and other sensitive information.

// .env file
API_KEY=AIzaSyCxoi3v425fyZ3WO1r4N7U-zCFWbliU4eQ
AUTH_DOMAIN=test-fireba-9108e.firebaseapp.com

// firebase.js
const firebaseConfig = {
  apiKey: process.env.API_KEY,
  authDomain: process.env.AUTH_DOMAIN
}

Signing in a new user is very easy in firebase. We need to create a user with createUserWithEmailAndPassword\ function. This will return a promise that when resolved will return an UserCredentail object. That UserCredentail object will have a user property that will store all information regarding our users, if they are signed in.

We can also wrap the code in a function so that we can use it somewhere else (maybe on a button click).

import { createUserWithEmailAndPassword } from "firebase/auth"

export const SignUp = async (email, password) => {
  // firebaseAuth - the firebase auth instance we created previously
  // email, password - string values for email and password
  createUserWithEmailAndPassword(firebaseAuth, email, password)
  .then(userCred => {
    // userCred.user will have all information
    // regarding our user, if they are signed-in
    console.log(userCred.user?.email)
  }
}

Now you can set up a simple UI with inputs and buttons, and call the SignUp function on button click. You can also add some client-side email/password validation. Also, it's best to wrap the code in a catch block and display proper error messages. These are very easy to implement, so I'll leave it on you.

Loggin in an existing user

In firebase, log-in is very similar to sign-in. Just instead of calling createUserWithEmailAndPassword , we'll call signInWithEmailAndPassword .

import { signInWithEmailAndPassword } from "firebase/auth"

export const LogIn = async (email, password) => {
  // firebaseAuth - the firebase auth instance we created previously
  // email, password - string values for email and password
  signInWithEmailAndPassword(firebaseAuth, email, password)
  .then(userCred => {
    // userCred.user will have all information
    // regarding our user, if they are signed-in
    console.log(userCred.user)
  }
}

Sign Out

Sign-out is pretty simple. Just call the signOut function and pass in the firebase auth instance

import { getAuth, signOut } from "firebase/auth";

export signOut(firebaseAuth)
.then(() => {
  // Sign-out successful.
}).catch((error) => {
  // show your error messages
});

Thanks for reading the blog! Hope you enjoyed it.

JavaScript Datatypes in Detail

Samyabrata Maji — Sun, 08 Jan 2023 13:37:36 +0000

There are seven different primitive data types in JavaScript: undefined, null, number, bigint, string, boolean and symbol. We'll learn about each of them in detail.

1. Number

Number stores numerical values. This is different from some other programming languages, which may have separate data types for integers and floating-point values (decimals).

let num = 25.2; // <-- datatype of num is number

Internally, numbers are stored as double-precision 64-bit binary (IEEE 754) values. Numbers can store positive numbers between $2^{-1074}$ and $2^{1024}$, and negative numbers in the same range

Number.MAX_VALUE; // = 1.7976931348623157e+308
Number.MIN_VALUE; // = 5e-324

Here, the letter e represents “times 10 to the power of”. For example, 5e-324 simply means $5\times 10^{-324}$.

Number can safely store Integer values between $-\left( 2^{53}-1 \right)$ and $+(2^{53}-1)$. There is a method that checks whether an integer is within the safe range or not: Number.isSafeInteger(). This method returns a boolean value indicating whether the number is a safe integer or not.

Generally, you won't need to worry about the range of values. Any values that exceed or subceed the range will be converted to Infinity or 0. The Infinity property behaves very similarly to infinity in mathematics.

// for postitive numbers
value > Number.MAX_VALUE; // -> Infinity
value < Number.MIN_VALUE; // -> +0

// for negative numbers
value > -Number.MAX_VALUE; // -> -Infinity
value > Number.MAX_VALUE; // -> -0

In javascript +0 and -0 are treated the same. However, they do behave differently when used in certain operations. When a positive or negative number is divided by +0, the result is always positive infinity (Infinity) or negative infinity (-Infinity), respectively. This is because +0 is considered to be the equivalent of positive infinity when it comes to division.

On the other hand, when a positive number is divided by -0, the result is always negative infinity, and when a negative number is divided by -0, the result is always positive infinity. This is because -0 is considered to be the equivalent of negative infinity when it comes to division.

console.log(42 / +0); // -> +Infinity
console.log(42 / -0); // -> -Infinity

NaN (Not-a-Number) is returned when the result of an arithmetic operation cannot be expressed as a number. There are several different scenarios in which NaN can be returned in JavaScript. Some examples include:

Dividing 0 by 0
Dividing a non-zero number by 0
Taking the square root of a negative number
Converting a value to a number using the Number() function when the value is not a valid number

NaN is the only value in JavaScript that is not equal to itself.

let num1 = NaN;
let num2 = NaN;
console.log(num1 === num2); // false

I'll cover why that is so when discussing Floating Point Numbers. For now, if you wish check if two whether NaN values are equal or not, use Number.isNaN(value). It returns true if the value is NaN

if (Number.isNaN(num1) && Number.isNaN(num2)) {
  console.log("Both are NaN");
}

2. BigInts

BigInts are used to store integers of arbitrarily large magnitudes. This allows you to store and manipulate large integers that would not fit within the range of the number data type.

To create BigInts, add the letter "n" at the end of an integer literal or use the BigInt() constructor.

let big_num1 = 32n;
let big_num2 = new BigInt(32);

BigInts are not strictly equal (===) to numbers. Instead, they are loosely equal (==) to numbers if the number value is within the safe range for integers, which is between $-(2^{53} - 1)$ and $(2^{53} - 1)$.

let num = 57;
let big_num = 57n;

console.log(num === big_num); // false
console.log(num == big_num); // true

3. String

String is used for storing text-based data of arbitrary length. To get the length of the string, use string.length property

// "Sam" is a string value
let name = "Sam";
console.log(name.length); // 3

Your computer stores characters and symbols as integers. There are several different systems for assigning codes to characters, including ASCII, UTF-8, and UTF-16. However, the one Javascript used is UTF-16 (16-bit Unicode Transformation Format), which is capable of encoding more than 1,000,000 characters.

In the UTF-16 system, the codes for the uppercase letters A-Z are between 65 and 90, and the codes for the lowercase letters a-z are between 97 and 122. UTF-16 system also includes codes for a wide range of other characters and symbols, including punctuation, special characters, whitespace and non-Latin scripts. You can access the code for a particular character in JavaScript using the charCodeAt(index) method of the String object.

let name = "Sam MAJI";

// to get the unicode of a character
name.charCodeAt(1); // unicode of "a" is 97
name.charCodeAt(5); // unicode of "A" is 65

A string is a collection of characters and symbols. In other words, a string (in JavaScript) is a collection of unique unsigned 16-bit integer values in a specific order.

String functions is a topic of its own. Here I'll quickly review some of the important string functions.

charAt(index) returns the character at the index position. You can also use square brackets (string_value[index]).
concat(): Concatenates (joins) two or more strings together. You can also use the '+' operator
indexOf(character): Returns the index of the first occurrence of a specified value in a string
substring(index1, index2): Extracts the characters from a string between two specified indices and returns a new string. Also, note that the substring starts at index1 but end before index2 (at index2-1)
toLowerCase(): Converts a string to lowercase letters
toUpperCase(): Converts a string to uppercase letters
trim(): Removes whitespace from the beginning and end of a string

let first_name = "   Samyabrata         ";
let last_name = "Maji";

first_name = first_name.trim(); // "Samyabrata"

let full_name = first_name.concat(last_name); // "SamyabrataMaji"

full_name = first_name + " " + last_name; // "Samyabrata Maji"

let short_name = first_name.substring(0, 3) + " " + last_name; // "Sam Maji"

let initials = first_name.charAt(0) + last_name.charAt(0); // "SM"

let initials_lower_case = initials.toLowerCase(); // "sm"

4. Boolean

The boolean datatype is used to store true or false value.

A conditional statement is a statement that returns only boolean values. They are used everywhere in javascript from if..else statements to while loops. Examples of conditionals can be 1>2 or value >= 25 && name === 'Sam'.

Internally, booleans are stored as 1-bit binary values.

console.log(true + true); // 2
console.log(true + false); // 1
console.log(Boolean(1)); // true
console.log(Boolean(0)); // false

Please note that the above example might be slightly misleading because the 0 and 1 used here are of type number which is 64-bit binary and not 1-bit binary.

In the next blog post, I'll cover the remaining datatypes, ie, null, undefined and symbol. I'll also cover Objects.