Forem: Abhishek Pathak

whatis htop

Abhishek Pathak — Tue, 09 Dec 2025 12:26:21 +0000

This is one of the tools that I use on a daily basis, and though sometimes I have to Google what these columns mean…
So I thought of creating some notes, but then I am here writing this blog with the help of ~AI, funny :), but it is what it is.
I won’t be going into minor things, as you are smart enough for that…

Headers

PID

ID of the process, like a unique identifier.

USER

Which user started the process.
root – system-level
daemon, syslog, etc – service users

PRI

Priority.
Lower number = higher priority.
Kernel decides who gets CPU time first.

NI

Nice value.
User-assigned priority tweak.
Range: -20 (very important) to +19 (not so much).
This exists to help us give priority to the process.

VIRT

Virtual Memory.
Total memory the process can use.
Includes swapped memory, shared libs, etc.
In the image above, the numbers are in KB (kilobytes).

RES

Resident Memory.
Actual RAM being used right now.
This is the important one.
In the image above, the numbers are in KB (kilobytes).

SHR

Shared Memory.
Memory shared with other processes:
- Shared libs
- Common system libs
In the image above, the numbers are in KB (kilobytes).

So this means XX KB of the process’s memory can be shared with others.

S

What the process is doing now:
- S → Sleeping
- R → Running
- D → Uninterruptible sleep
- Z → Zombie
We mostly see S because most processes wait for input.

CPU%

How much of the CPU the process is using right now.

MEM%

How much RAM it uses relative to total system RAM.

TIME+

Total CPU time a process has consumed since it started.

Command

The actual program that launched the process.

Why do we have different colors in the USER column?

Each has a story...

Green
- Normal user processes
- Custom Python scripts, CLI scripts, etc.
Blue
- Low-priority processes
Red/Orange
- Kernel threads / High-priority tasks
Cyan / Light Blue
- Threads inside a process (e.g., Python worker threads)
Purple
- System daemons
Bold Green
- Running processes
Dark Gray / Dim
- Idle or sleeping processes taking almost 0 CPU

Inside the Tech Stack of dblayer - Go, Next.js 15, Express & Beyond

Abhishek Pathak — Wed, 06 Aug 2025 02:49:23 +0000

After several months of building dblayer — a platform that turns your PostgreSQL database into secure, ready-to-use APIs and Apps,
I wanted to share the technical architecture behind it.

dblayer is modular by design. It consists of multiple services — all optimized for performance, maintainability, and scalability.

Let’s dive into the stack

API Server (.dblayer.dev) This is the core Go-based API server that powers requests coming from the frontend or external clients.

Language: Go 1.22
Framework: Fiber v2
Database: PostgreSQL via lib/pq and sqlx
Logging: zap for high-performance structured logging
UUID: google/uuid for consistent IDs
Config: yaml.v3, godotenv
Caching: go-cache, with optional Redis via go-redis
Middleware & Compression: Brotli, gzip via valyala/fasthttp

This service acts as the "runtime engine" for all DB-generated APIs.

Background Worker (.dblayer.dev) Handles asynchronous tasks: email, file processing, S3 uploads, and more.

Language: Go
Mailing: go-mail
Logging: zerolog + lumberjack for daily log rotation
AWS SDK v2: For uploading to S3 and interacting with cloud services
Environment Handling: godotenv for secrets
This allows us to separate performance-sensitive user requests from slower, async operations.

Dashboard Backend (.dblayer.dev) An Express.js backend for managing the dashboard, auth, projects, and billing.

Language: TypeScript + Node.js
Framework: Express
ORM: Drizzle ORM — fully typed, SQL-first
Auth: passport, jwt, passport-google-oauth20
Redis: For rate-limiting + caching (rate-limit-redis, ioredis)
Validation: zod + zod-validation-error
Security: helmet, express-rate-limit, input sanitization
Logging: winston, daily-rotate-file

This is the admin engine of dblayer — managing everything from auth to token issuance to flows.

App Frontend (.dblayer.dev) A React-based web app built with Next.js 15, acting as the user-facing playground.

State Management: zustand
Editor: Monaco (via @monaco-editor/react) for live code editing
UI Framework: Radix UI components + Tailwind CSS
Utils: axios, dayjs, nanoid, clsx, js-cookie
Animation: framer-motion
Markdown & XLSX: react-markdown, xlsx, syntax-highlighter

This is where users build, test, and deploy their API endpoints.

Landing Page (dblayer.dev) Built with Next.js and optimized for SEO, performance, and minimal load.

Next.js 15 with Turbopack
Dark mode support: next-themes
Components: shadcn ui
Animations: framer-motion, tailwindcss-animate

Documentation (dblayer-documents) Static documentation site with MDX support, diagrams, LaTeX, and smart content indexing.

Framework: Next.js 15
Markdown tooling: remark, rehype, unified, gray-matter
Diagram Support: Mermaid.js
Math Support: KaTeX
Themes + Animations: Same shared system (Radix UI + Tailwind)

Content is auto-indexed using a custom content.ts script for search-ready JSON output.

Dev Practices & Tooling

TypeScript everywhere — from backend to docs
Strict linting & formatting: Prettier, ESLint, Husky
Modern package managers: pnpm for consistent and fast builds
Scripts: Unified across all repos (dev, build, lint, format, seed)
Env Management: .env, dotenv, tsconfig-paths

Architecture Philosophy
I have optimized dblayer to:

Be modular: APIs, workers, UI, docs — all loosely coupled
Stay typed: No guesswork across services
Minimize cold starts: Workers are long-lived; logs and metrics help debug fast
Enable fast iteration: Fast builds, local-first tooling, cloud-native by default

If you're building a platform or tool and thinking about your stack, hope this breakdown helps.

You can try DBLayer at https://dblayer.dev
Happy to answer Feedback or questions?

How to Monitor Network Traffic on Linux

Abhishek Pathak — Mon, 09 Jun 2025 17:45:28 +0000

Directly starting with the topic

1. `iftop` — Real-time Bandwidth Monitoring Per Connection

Use Case: View which remote hosts are consuming bandwidth in real-time.

Install:

sudo apt install iftop

Usage:

sudo iftop -i eth0         # Replace eth0 with your network interface

Key Features:

Shows top connections by bandwidth
Inbound/outbound traffic

Tips:

Press t to toggle display modes
Press p to pause
Combine with -B for display in bytes

2. `nload` — Simple Interface Bandwidth

Use Case: Monitor incoming/outgoing traffic per interface.

Install:

sudo apt install nload

Usage:

sudo nload eth0

Key Features:

Graphical view of upload/download rate
Totals and current stats

3. `bmon` — Bandwidth Monitoring and Visualization

Use Case: Visual tool to monitor all interfaces and track traffic.

Install:

sudo apt install bmon

Usage:

sudo bmon

Key Features:

Auto-detects interfaces
Live graphs and rate history

4. `tcpdump` — Deep Packet Inspection

Use Case: Capture and inspect packets on an interface.

Install:

sudo apt install tcpdump

Usage:

sudo tcpdump -i eth0

Example:

sudo tcpdump -i eth0 port 80  # Capture only HTTP traffic

Tips:

Use -w to save packets to file
Analyze with Wireshark: tcpdump -w capture.pcap

5. `netstat` / `ss` — Network Connection Stats

Use Case: List active connections, ports, and listening services.

Usage:

ss -tulwn           # Faster replacement for netstat

Example Output:

t – TCP
u – UDP
l – Listening
w – Raw sockets
n – Numeric output

Bonus: Use ss -p to see which process owns a port.

6. `nethogs` — Bandwidth by Process

Use Case: Identify processes using the most bandwidth.

Install:

sudo apt install nethogs

Usage:

sudo nethogs eth0

Features:

Lists per-process bandwidth usage
Real-time updates

7. `vnstat` — Long-term Network Usage Stats

Use Case: Track data usage over time (hourly/daily/monthly).

Install:

sudo apt install vnstat
sudo vnstat -u -i eth0

Usage:

vnstat                # Summary of usage
vnstat -d             # Daily usage
vnstat -m             # Monthly usage

Great For:

Auditing bandwidth
Avoiding data cap overages

Best Practices & Tips

Run tools with sudo to ensure full interface access
Know your interface name: Use ip a to list interfaces
Combine tools: Use vnstat for history, iftop for live monitoring

If the article helps you, leave a like, follow, or anything 🙂.

You can follow me on LinkedIn, GitHub, Dev.to and hashnode.

Bye

What is Caddy and How It Helped My Product DBLayer.dev

Abhishek Pathak — Tue, 03 Jun 2025 16:58:57 +0000

When building my first SaaS project, DBlayer.dev, I needed a reliable, secure, and !!hassle web server that could scale effortlessly. That’s when I discovered Caddy—a powerful and modern web server that truly stands out.

In this post, I’ll share what Caddy is, why I chose it, and how it solved my domain and subdomain management challenges.

What is Caddy?

Caddy is an open-source web server known for its automatic HTTPS, developer-friendly configuration, and modern architecture. Unlike traditional web servers like Nginx or Apache, Caddy is built with simplicity and security in mind—perfect for developers.

Key Features of Caddy

🔒 Automatic HTTPS – Caddy automatically issues and renews SSL certificates using Let's Encrypt.
⚡ Simple Configuration – Define your routes using a clean Caddyfile format—easy to read, easy to update.
🧩 Extensible – Add plugins for reverse proxying, static file serving, rate limiting, and more.
📦 Single Binary – No external dependencies. Just download and run. It works on almost any platform.

(Feature list adapted from my experience and official documentation.)

Why I Picked Caddy for DBLayer.dev

1. Zero SSL Headache

DBLayer.dev supports custom subdomains like username.dblayer.dev. Managing HTTPS manually for each subdomain would’ve been a nightmare. With Caddy, it was a non-issue—SSL was automatically provisioned and renewed without any manual steps.

2. Effortless Reverse Proxy

Caddy handles reverse proxying to my Go and Express.js backends with elegant simplicity. Here's how I route all subdomains to my app:

*.dblayer.dev {
  reverse_proxy 127.0.0.1:3000
}

That’s it—no complicated config blocks, rewrites, or certificate handling.

3. Hot Reloads with Zero Downtime

Caddy supports seamless configuration reloads without downtime. Whether I update routing rules or change backend ports, Caddy applies changes instantly—perfect for continuous deployment workflows.

4. Lightweight and Reliable

Since DBLayer is a bootstrapped project, cost is a major concern. Caddy, being written in Go and packaged as a single binary, runs efficiently with minimal memory usage. I can deploy it on my server without any extra overhead.

My Domain Management Approach

DBLayer allows users to claim a custom subdomain (e.g., johndoe.dblayer.dev) to give their endpoints a personal touch.
Initially, I looked into traditional setups like Nginx + Let's Encrypt, but managing dynamic subdomains and certificates was complex and expensive.
As a solo founder of a bootstrapped project, I needed a smarter, cost-effective solution.
That’s when I found Caddy. I explored it, tested it, and it turned out to be what I needed—auto SSL, reverse proxying, dynamic subdomain support, and more.
Looking ahead, I also plan to support dynamic host mappings, and Caddy is flexible enough for those use cases too.

My Setup in Practice

I run a cron job that checks table for subdomains that haven’t yet been added.
If a new subdomain is found, the script checks if it exists in the Caddyfile. If not, it appends the new block and reloads Caddy.
The best part? ~No downtime. Caddy handles updates fast and gracefully.

You can check out my actual Caddy config here:

👉 Caddyfile Gist

(Some parts are for upcoming features—stay tuned!)

Caddy has been a good product for DBLayer.dev. If you're building something similar with dynamic subdomains, SSL, and reverse proxying—Caddy is absolutely worth trying.

Checkout My Product: https://dblayer.dev/

Thank you

SQL Query Execution Order

Abhishek Pathak — Wed, 29 Jan 2025 15:15:52 +0000

How SQL Queries Are Executed Behind the Scenes

Note: The flow described below isn't how SQL engines always execute queries internally, but rather how SQL execution is logically ordered.

1. FROM and JOINs

The engine starts by selecting the tables mentioned in the FROM clause. If there are any JOINs, it combines the tables according to the specified conditions

2. WHERE

After the tables are joined, It will filter rows based on the conditions in the WHERE clause.

3. GROUP BY

Next, grouping rows that have the same values in the specified columns (e.g., grouping by customer or product). This is useful when you want to apply aggregate functions like COUNT, SUM, or AVG.

4. HAVING

Then HAVING clause.
It filters the results of the groups, just like WHERE filters individual rows before grouping.

5. SELECT

At this point, It selects the columns. If any aggregate calculations are involved, they are performed here.

6. DISTINCT

If specified, removing of duplicate rows in the result will be performed.

7. ORDER BY

Then sorting will take place on the ORDER BY clause, either in ascending or descending order.

8. LIMIT / OFFSET

Finally, LIMIT will be applied to restrict the number of rows returned and OFFSET to skip a specified number of rows.

Example:

SELECT
    t1.id,
    t1.name,
    COUNT(t2.order_id) AS order_count
FROM
    users t1
LEFT JOIN
    orders t2 ON t1.id = t2.user_id
WHERE
    t1.status = 'half-blood'
GROUP BY
    t1.id
HAVING
    COUNT(t2.order_id) > 5
ORDER BY
    order_count DESC
LIMIT 10 OFFSET 20;

Order in which SQL processes it:

FROM and JOINs: Combines users and orders.
WHERE: Filters users who are active.
GROUP BY: Groups the data by user id.
HAVING: Filters groups where the user has more than 5 orders.
SELECT: Selects the columns to display.
ORDER BY: Sorts the result by order_count.
LIMIT / OFFSET: Returns the 10th to 20th row.

any feedback about the article will make me more happy

If the article helps you, leave a like, follow, or anything 🙂.

You can follow me on LinkedIn, GitHub, Dev.to and hashnode.

Bye

Schedule Wallpaper for mobile.

Abhishek Pathak — Fri, 17 Jan 2025 11:20:29 +0000

Hi Dev Community! 🌻

I’m thrilled to share the launch of my very first mobile app, Bello, built using React Native! 🚀

What is Bello?
Bello is a handy app designed to simplify scheduling wallpaper changes on your device. With Bello, you can effortlessly update:
📱 Your Home Screen
🔒 Your Lock Screen
✨ Both Screens

Simply pick your favorite wallpapers, set a schedule, and Bello takes care of the rest!

Try it out:
🌐 Homepage: https://bello.scor32k.com/
📥 Google Play Store: https://play.google.com/store/apps/details?id=com.scor32k.bello

Notes & Collaboration
The app is still a Work in Progress—I’m actively working on fixing a few missing strings and polishing the experience. That said, it felt like the perfect moment to release it and hear what you think!

If you have experience with React Native (especially React Native Background Fetch), I’d love to connect and collaborate. Feel free to reach out at abhishek@scor32k.com.

I’d genuinely appreciate your support, feedback, and thoughts. If you give it a try, let me know your experience! 😊

Top AWS Services for Developers

Abhishek Pathak — Sun, 29 Dec 2024 14:37:07 +0000

Top 3 AWS Services Every Developer Should know

prathamesh gawade ・ Aug 20

#aws #cloud #devops #webdev

understanding chmod 777

Abhishek Pathak — Mon, 16 Sep 2024 01:59:47 +0000

Understanding `chmod 777` ❓

NOTE: The is a contains small portion of Linux file permission blog. Contents from the parent blog are pruned and customize for this article. Thank you for reading.

In Linux, permissions define the access rights for three categories of users: 👤User, 👥Group, and Others.

The User is the file or directory owner.
The Group consists of users belonging to the same group as the owner.
Others refers to the general public.

Each of these users can have three types of permissions: 📕Read, ✍️Write, and Execute🥬.

Read ( r ): Allows viewing the content of the file. Represented by an octal value of 4.
Write ( w ): Allows modifying or editing the file. Represented by an octal value of 2.
Execute ( x ): Allows running the file (if it's a script) or traversing a directory. Represented by an octal value of 1.

These permissions are presented as a string of nine characters for each file or directory:

Example:



rw-r--r--

rw- means the owner has read and write permissions.
r-- means the group has read-only permissions.
r-- means others have read-only permissions.

Octal Mode in `chmod`

In advanced file permission manipulation, numeric values are used to represent permissions:

Read ( r ) = 4
Write ( w ) = 2
Execute ( x ) = 1

To set permissions using octal values, you assign a three-digit number representing the permissions for User, Group, and Others. For example, 777 gives read, write, and execute permissions to everyone.

Note: The maximum permission 777 means User, Group, and Others all have full read, write, and execute permissions. However, granting such permissions can pose a security risk.

Example: Modifying File Permissions with Octal Values

Let’s say we want to set specific permissions:

User: Read (4) and Execute (1) ⇒ 4 + 1 = 5
Group: Read-only (4)
Others: Read-only (4)

The combined permission value is 544, meaning the user can read and execute, and both the group and others can only read.



chmod 544 myfile.txt

This sets the permission to r-xr--r--, which breaks down into three blocks:

r-x for the User
r-- for the Group
r-- for Others

Note: The - before the permissions indicates the file type, where - is for regular files and d is for directories.

Example 2: Complex Permission Setup

Let’s give the following permissions:

User: Read (4) and Write (2) ⇒ 4 + 2 = 6
Group: Write (2) and Execute (1) ⇒ 2 + 1 = 3
Others: Read (4)

The combined value is 634, meaning:



chmod 634 myfile.txt

Changing File Ownership

To change the ownership of a file or directory, use the chown command:



chown username myfile.txt

Note: You might require root privileges for this command.

Changing File Group Ownership

To change the group ownership of a file, use the chgrp command:



chgrp groupname myfile.txt

Important Tips

Avoid using 777: It’s a significant security risk.
Use ls -l to display detailed file information, including permissions.
Don’t forget about umask_, which affects default file permissions.

If this article helped you, feel free to like, follow, or connect!

You can follow me on LinkedIn, GitHub, Dev.to, and Hashnode.

🍕

JavaScript Objects | Complete Guide

Abhishek Pathak — Mon, 13 May 2024 01:57:31 +0000

JavaScript Objects

Similar to other programming languages javascript objects is a collection of key-value pairs, where each key is a string and each value can be of any data type.

Ways to create JavaScript Object

Object liternal Notation
The simplests way that you will use 98% of time.
```
    const scorcism = {
        name: "Abhishek",
        age:21
    }
```
The key-value pairs are enclosed within curly braces {}

Using the new Keyword
Creating objects with constructor functions and the new keyword. You will use this only 1.8% of the time

    function About(name, age, city) {
        this.name = name;
        this.age = age;
        this.city = city;
    }   

    const me = new About("Abhishek", 21, "Mumbai");

"new" creates an object containing an internal "this". If you omit "new", this is the global context, so your properties are created outside of your object. ~ Eckehard

Using Object.create()
This method allows creating a new object with specified prototype object.
You will use this only 0.2% of the time

    const aboutData = {
        greet:function(){
                return `Hello, my is ${this.name}`; // {this.name} is the key of this object
            }
    }
    const me = Object.create(aboutData);
    me.name = 'Abhishek'
    me.age = 21;

Don't worry much about this :)

Accessing Object Properties

Properties of JS object can be accessed using dot notation and bracket notation.

    const me = {
            name: "Abhishek",
            age:21
    }
    console.log(me.name);   
    console.log(me["age"]);

Try run the code snippet.

(The undefined after each console log is the return value fo the console.log function itself. Relax, Nothing to worry🕺)

Object Prototypes and Inheritance

At the core of JS, lies the concept of prototype. Every object in JS is associated with a prototype object, which acts as a blueprint for that object.

In short; object prototype serves as a template for creating new objects.

This prototype object contains properties and method that are accessible to all instances created from it.🍰

Inheritance is acheived by linking objects through their prototypes.
Consider Object.create() that we used above. It is an method that creates a new object.

Static Method

(Try😃)

Object.keys()

Returns an array of a given object's own enumerable property names.

TL;DR Object.keys() method will return list of keys.

NOTE: Own enumerable refers to the properties of an object that are both owned by the object itself (Not inherited from its property chain)
```
    const aboutMe= {
        name: "Abhishek",
        age:21
    }
    let aboutMeKeys = Object.keys(aboutMe);
    // Expected Output: [ 'name', 'age' ]
```

Object.values()

Return an array of a given object's own enumerable property values.

TL;DR Object.values() method will return list of values.

            const aboutMe= {
                name: "Abhishek",
                age:21
            }
            let aboutMeKeys = Object.values(aboutMe);
            // Expected Output: [ 'Abhishek', 21 ]

Object.assign()

Copies the values of all enumerable own properties from one or more source objects to a target object.

    const target = {age: 21}
    const source = {name: "Abhishek"}
    const merged = Object.assign(target, source);
    console.log(merged)
    // Expected Output: { age: 21, name: 'Abhishek' }

Note: You can add any number of source args.

target will contain the modified object.

    console.log(merged === target)
    // Expected Output: true

Object.create()

Create new object, using an existing object as the prototype.

    const me = {
          name: "Abhishek",
          eatsAppleDaily: false,
          printAbout: function(){
            console.log(`I am ${this.name}. and I ${this.eatsAppleDaily ? "eat" :"don't eat"} 
                            apple daily.`);
          }
        };

    // Creating a myFriend Object inheriting from me. 
    const myFriend = Object.create(me); // He is my child now😃.  

    myFriend.name = "Ladoo";
    myFriend.eatsAppleDaily = true;

    console.log(me.printAbout());
    // Expected Output: I am Abhishek. and I don't eat apple daily.
    console.log(myFriend.printAbout());
    // Expected Output: I am Ladoo. and I eat apple daily.

Object.entries()

Return array of he given object's own enumerable string-keyed property key-value pair😒.

It returns an array where each element is a key-value pair of the object. Each key-value pair is represented as an array with two elements: the key as the first element and the corresponding value as the second element.
```
    const me = { name:"Abhishek", age:21 }
    console.log(Object.entries(me))
    // Expected output: [ [ 'name', 'Abhishek' ], [ 'age', 21 ] ]
```

Object.fromEntries()

Object.fromEntries transforms a list of key-value pairs into an object.

TL;DR Oppsite of Object.entries().

    const me = [ [ 'name', 'Abhishek' ], [ 'age', 21 ] ]
    console.log(Object.fromEntries(me))
    // Expected output: { name: 'Abhishek', age: 21 }

Object.freeze()

The Object.freeze() is a method that "freezes" an object.

When you freeze an object, you prevent new properties from being added to it, existing properties from being removed or changed, and also prevent the prototype from being changed.

        const me = { name:"Abhishek", age:21 }
        Object.freeze(me); // Freezing the object
        me.name = "scorcism";
        me.age = 22;
        console.log(me) 
        // Expected output: { name: "Abhishek", age: 21 }

Changes are not affected to the object

Object.isFrozen()

 Determines if the object is frozen

    const me = { name:"Abhishek", age:21 }
    Object.freeze(me); 
    console.log(Object.isFrozen(me))
    // Expected output: true

Object.seal()

Object.seal() is a method that "seals" an object.

Sealing an object prevent new properties from being added to it and marks all existing properties an non-configurable (i.e prevent them from bein deleted or theri attributes from being changed).
```
     const me = { name:"Abhishek", age:21 }
     Object.seal(me); 
    me.name = "scorcism"; // This change will be affected 
    delete me.age; // This deleting will not take effect
    console.log(me)
    // Expected Output: { name: 'scorcism', age: 21 }
```
Note: Object.freeze() prevents any changes to the object, while Object.seal() allows changes to existing properties but prevents addition or removal of properties.

Object.isSealed()
Determines if an object is sealed.

    const me = { name:"Abhishek", age:21 }
     Object.seal(me);   
     console.log(Object.isSealed(me));
     // Expected output: true

Inheritance static method

Before moving to instance static methods, Lets get idea of this keyword in object

Suppose we have an Object

    const person = { name: 'Abhishek' };

So If we add a function in the object; this will refer to all the properties of the same object

    const person = { 
        name: 'Abhishek',
        sayMyName: function() {
            return `My name is ${this.name}`;
        }
    };

    console.log(person.sayMyName());
    // Expected Output: My name is Abhishek

As you can observe here, this.name is replaced with the key name value.

Now that you have idea of this keyword usecase, lets continue further

1.. prototype.bind()

The bind() method creates a new function that, when called, has its this keyword set to the provided value.
This is usefull when we want to borrow a method from one object and use it in the context of other object,

    function sayMyName (){
        return `My name is ${this.name}`
    }

    const person = { 
        name: 'Abhishek',
        sayMyName: sayMyName
    };

    console.log(person.sayMyName());
    // Expected Output: My name is Abhishek

    const person2 = {
        name: 'Walter'
    }

    const person2NameFunc = sayMyName.bind(person2);

    console.log(person2NameFunc());
    // Expected Output: My name is Walter

for the person2NameFunc the person object this.name is taken from the person2 object as we have bind the sayMyName function with person2 object.

2.. prototype.call()

The call() method is used to call a function with given this value and arguments provided individaully.

        function introduce(language) {
              console.log(`I code in ${language}. My name is ${this.name}.`);
        }

        const mySelf = {
            name: "Abhishek"
        }

        introduce.call(mySelf, 'Java');
        // Expected output: I code in Java. My name is Abhishek.

Here, the introduce function takes a language argument and logs information about the language and the person's name.

The call() method is used to invoke this function with the mySelf object as the this value, allowing access to its properties.

Unlike bind(), which creates a new function with a specified this value, call() directly invokes the function with the specified this value along with individual arguments.

3.. prototype.apply()

The apply() method is similar to call(), but insted of accepting arguments individually, it accepts arguments as an array.

        function add(...args){
            let sum = args.reduce((acc, curr)=> acc + curr, 0 );
            console.log(sum);
        }
        const numbers = [1,2,3,4,5];
        add.apply(null, numbers)
        // Expected output: 15

When to use call, bind and apply

call: Use call when you want to execute a function immediately and specify what this should refer to
bind: Use bind when you want to create a new function that, when executed later, has a predeterminf this value
apply" Use apply when you have an array of arguments that you want to pass to a function.

PS: The reason to use my name everywhere is that, while reading, whenever you see my name, you will tend to try it with your name too

These are the most common one to use, You can explore more here

If the article helps you, leave a like, follow, or anything 🙂.

You can follow me on LinkedIn, GitHub, Dev.to and hashnode.

Bye🍕

Linux File Permission

Abhishek Pathak — Tue, 19 Sep 2023 11:32:31 +0000

What are file permissions

File permissions play a crucial role in ensuring proper privacy and security.

Don't worry, I'll guide you through it step by step .

How do they work ?

Unlike Windows , Linux❤️‍🔥 files cannot be executed directly. This is because file permissions must allow the execution of a file for it to be executed.

File permissions prevent unauthorized access to sensitive files or directories and also ensure data privacy.

In short, without proper file permissions, file execution, access, and modification cannot occur.

Now, before we move into file permissions description, let's understand the Linux roles .

User Role

There are three roles or entities in the Linux system: user👤, group👥, and others.

Here is the brief overview👀:

👤User(u): The Individual user who owns the file, directory. The user is often the person/guy who creatd the file or directory and becomes the owner of the file. The owner has the most extensive control over the it.

👥Group(g): Users in the same group as the file owner will have access to the file. To allow a specific set of users to access the file, you can add them to a group and grant access to that group. This way, only the users in that group will have access to the file. Group permisssions allow collaboration among users with the similar access.

Others(o): Everyone else who has access to the system but isn't the owner or in the group associated with the file. Others include the general public.

All three users/entities will have three types of permissions

💭Entities Permission

📕Read(r): Allows viewing the content of a file or listing the content of a directory. Read permission is represented by the "r" symbol. Read permission also has an octal value of 4. Octal value is another way↕️ of representing file permissions.

We will explore this further.

✍️Write(w): Allows modification of the file’s content or creating, deleting and renaiming within the directory. Write permission is represented by “w” symbol, it has an octal value of 2.

Execute(x): This enables running the file as a program or traversing a directory. Execute has octal value of 1.

To summarize, there are three roles in a Linux system: 👤user, 👥group, and others.

The user is the owner of the file or directory,
Group consists of users who belong to the same group as the file owner,
others refers to the general public.

Each of these users has three individual permissions: 📕Read, ✍️Write, and Execute.

Read permission allows the user to only read the file, and it is represented by the octal value of 4.
Write permission allows the user to modify the file, and it is represented by the octal value of 2.
Execute permission allows the user to execute a file or traverse a directory, and it is represented by the octal value of 1.

These permissions are organized in a string of nine characters for each file or diectory.

eg:

rw-r--r-- ([rw-] represents read and write permission for the owner), ([r--]and read only permission to the group) and ([r--]and read only permission to the others).

🌅Viewing file Permissions

To view the permissions of files and directories, you can use the ls command with the -l option🛩️. Here's an example:

    ls -l

The output will display file information, including permissions, ownership, group, size, modification date, and filename.

Here's a breakdown of what a typical ls -l output looks like:

-rw-r--r-- 1 scor32k scor32k 43 Sep 19 01:00 myfile_scor32k.txt

In this example:

rw-r--r-- represents the permissions.
1 indicates the number of hard links.
user is the owner of the file.
group is the group associated with the file.
43 is the file size.
Sep 19 01:00 is the modification date.
myfile_scor32k.txt is the filename.

You may be thinking🤔 but how -rw-r--r-- permission got attached to the file when we created it,

this is becase of UMASK.

USMAK ?

In simple terms, whenever we create a file or directory in a Linux system, the system assigns default permissions to the file or directory based on Linux itself.

Interesting! more

The umask is generally set to 022. You can check that using umask command.

Notes: The default permission for a file is 666, and the default permission for a directory is 777.

The entire process is as follows:

When a user creates a file, it will have a default permission of 666. The 022 umask will then be subtracted from 666, resulting in a final permission of 644.

The user will have read and write permission(6=4+2), the group will have read permission(4), and others will also have read permission(4).

🌱You can also try this with a directory: 777 - 022 = 755.

Modifying file permissions

chown which stands for change file mode or change file permission command is used to modify the permissions.

Add execute permission to file.

chmod +x myfile.txt

This +x adds execute permission to the file.

-rwxr-xr-x 1 scor32k scor32k 43 Sep 19 01:00 myfile.txt

See the image below:

Remove Permission

chmod -x myfile.txt

+ is used to add permission.
- is used to remove permission.

-rw-r--r-- 1 scor32k scor32k 43 Sep 19 01:00 myfile.txt

Give permission based on specifc role:

User/owner Permission

Add Permission

chmod u+x myfile.txt

Remove Permission

chmod u-x myfile.txt

Group Permisson

chmod g+x myfile.txt

The same goes for others(o). You can experiment with this.

Octal Mode in chmod

This is the advanced version of file permission manipulation. Here, we use numeric values to represent each permission types (read, write, execute).

Read[r] = 4
Write(w) = 2
Execute(x) = 1

To set permissions using an octal value, we assign a three-digit number to each entity (user, group, others) based on the desired permission.

Note: The file or directory can max have 777 file permission, which means the user,group and others will have read, write, and execute permission resepectively.

Modifying file permissions, Octal edition.

Before moving forward,

we need to remember that the permissions are just a combination of (4, 2, 1), and as per our requirements, we can alter this.

Suppose we want to add read and execute permission to only the user and read permission to groups and others.

So,

We use 1 as the octal value for execute, and for read, we use 4.

The combined value will be 544.

Example 1:

Add read and execute permission to the user, and read permission to the group and others.

chmod 544 myfile.txt

To be precise devide the r-xr—r— into 3 blocks r-x r-- r--, this will clear your doubts.

Note: The - before permission is for the file type. - for file and d is for directory.

Example 2:

Suppose, we want to add read and write to user, write and execute to group and read to others.

user: read = 4, write = 2 ⇒ 4+2 ⇒ 6

group: write = 2, execute = 1 ⇒ 2+1 ⇒ 3

others: read = 4 ⇒ 4

chmod 634 myfile.txt

If i take examples there will not be any end, you can play around with this.

Changing file ownership

chown which stands for change ownership command is used to chnage the ownership of file or directory.

chown abhishek myfile.txt

you my require root privelage.

Changing file group Ownership

chgrp command will be used to chnage the file group.

chgrp geet myfile.txt

add myfile.txt to group geet

Some tips

Never use 777 → It’s a severe security risk and show be avoided.
use ls -l → This displays detailed information about files and directories, including their permissions.
use chmod
Limit the global access
umask matters a lot
Review permissions regularly.

If the article helps you, leave a like, follow, or anything 🙂.

You can follow me on LinkedIn, GitHub, Dev.to and hashnode.

Bye

Data Plane/Worker Node - k8s

Abhishek Pathak — Fri, 15 Sep 2023 09:40:34 +0000

When I started learning about the K8S architecture, the basic building blocks were the control plane, which is the master node, and the data plane, which is the worker node.

I thought, Why not share what I have learned?

This will be a three-part post: 1) Data Place 2) Control Place; and 3) The entire arch, which will be a combination of the data plane and the control plane.

So here it is:

Data Plane/Worker Node Simplified

In Kubernetes (K8s), the smallest unit of deployment is called a pod.

Pod ?

Pod is a "wrapper" over the containers, which has advanced capabilities. Think of it as a little package that can contain your application.

When you run a pod, it's pretty much like starting a container.

In Docker, you have a thing called the "Docker engine", which runs the container, while in K8s, we have a similar thing called the "container runtime." This runtime takes care of running the actual container inside the pod.

Here's where it gets interesting. A pod can actually hold multiple containers. So, while Docker does containers, K8s does pods with containers inside them.

In Docker, we have the trusty Dockershim for running containers. But in K8s, we're more flexible. We can use Dockershim, Container, or Crio; these are all like different flavours of the same ice cream, competing to be your runtime. K8s allow you to pick the one you like.

Now, let's talk about the magic happening inside a pod on a K8s worker node. We have a little helper called Kubelet. This Kubelet is like a caretaker for your Kubernetes pod. It keeps an eye on whether your pod is running smoothly or not, and if not, it raises the alarm.

In Docker, we've got docker0 and some network tricks to make sure containers talk to each other and to the host. In K8s, we've got something called kube-proxy doing similar network magic. It helps pods communicate with each other, sort of like a networking wizard.

So far, we've met three main characters in our K8s story:

kube-proxy: The networking guru. It handles IP addresses and load balancing, and it loves using something called "iptables" to work its magic on Linux machines.
Kubelet: The pod creator and babysitter It gets pods up and running, and if something goes wrong, it raises a flag to the control plane.
Container runtime: The workhorse It's the one that actually runs your container, making sure your application is alive and kicking.

That's a glimpse into the world of worker nodes and pods in Kubernetes, where containers and pods work together in harmony.

This is the architecture of the data plane. Simple
Check the diagram, will help you understand more.

Pagination - Mongo DB, Express

Abhishek Pathak — Thu, 14 Sep 2023 14:53:31 +0000

In working with the dashbord system,

There is always a question: What is the best way to do pagination?

Pagination ?

Suppose we have 1000 rows of data, so it will take a lot of bandwidth to fetch data all the at one time, and it will cause a latency(delay). To overcome this, we use pagination.

We set the number of rows per page to 10, 20, 30, and so on. based on the requirements.

In my recent project , I had the same issue.

What I did was use the concepts of skip and limit to achieve my goal.

As you can see in the image attached:

we have,

id: As the system is dynamic, id will help to fetch specific user data. id is attached to req by a custom middleware fetchuser, which will check if the JWT token is valid, and if it is valid, it will get the id from the token and pass the require.

ITEMS-PER-PAGE: It is a numeric value that is set to 10. This means we are requesting 10 rows or documents per request.

page: This represents the current page. If not, it will be set to 1. I have used parameters to check what page we are on.

skip: Based on the page number and ITEMS-PER-PAGE, it will skip x rows or documents. Supposing we are on page 2 and ITEMS-PER-PAGE is set to 10, skip = (page (2) - 1) * ITEMS-PER-PAGE = 10 ,
and the endpoint will return data from the 11th record.

countPromise: This is to get the total document or row count. This will be helpful to get the maximum number of pages we have. Suppose there are 50 documents in the table, and ITEMS-PER-PAGE is 10, so we will have 5 pages.

usersPromise: This is the list of users that the endpoint will send.

pageCount: The count of pages.

Code is very simple once you read it and do.

If any error, comments are alwyas welcome. I'm trying out this things.

If the article helps you, leave a like, follow, or anything 🙂.

You can follow me on LinkedIn, GitHub, Dev.to and hashnode.

Bye

Forem: Abhishek Pathak

whatis htop

Headers

PID

USER

PRI

NI

VIRT

RES

SHR

S

CPU%

MEM%

TIME+

Command

Why do we have different colors in the USER column?

Inside the Tech Stack of dblayer - Go, Next.js 15, Express & Beyond

How to Monitor Network Traffic on Linux

1. iftop — Real-time Bandwidth Monitoring Per Connection

2. nload — Simple Interface Bandwidth

3. bmon — Bandwidth Monitoring and Visualization

4. tcpdump — Deep Packet Inspection

5. netstat / ss — Network Connection Stats

6. nethogs — Bandwidth by Process

7. vnstat — Long-term Network Usage Stats

Best Practices & Tips

Bye

What is Caddy and How It Helped My Product DBLayer.dev

What is Caddy?

Key Features of Caddy

Why I Picked Caddy for DBLayer.dev

1. Zero SSL Headache

2. Effortless Reverse Proxy

3. Hot Reloads with Zero Downtime

4. Lightweight and Reliable

My Domain Management Approach

My Setup in Practice

SQL Query Execution Order

How SQL Queries Are Executed Behind the Scenes

1. FROM and JOINs

2. WHERE

3. GROUP BY

4. HAVING

5. SELECT

6. DISTINCT

7. ORDER BY

8. LIMIT / OFFSET

Example:

Schedule Wallpaper for mobile.

Top AWS Services for Developers

Top 3 AWS Services Every Developer Should know

prathamesh gawade ・ Aug 20

understanding chmod 777

Understanding chmod 777 ❓

Octal Mode in chmod

Example: Modifying File Permissions with Octal Values

Example 2: Complex Permission Setup

Changing File Ownership

Changing File Group Ownership

Important Tips

JavaScript Objects | Complete Guide

JavaScript Objects

Ways to create JavaScript Object

Accessing Object Properties

Object Prototypes and Inheritance

Static Method

Inheritance static method

When to use call, bind and apply

Linux File Permission

What are file permissions

How do they work ?

User Role

💭Entities Permission

🌅Viewing file Permissions

USMAK ?

Modifying file permissions

Remove Permission

Give permission based on specifc role:

Octal Mode in chmod

Modifying file permissions, Octal edition.

1. `iftop` — Real-time Bandwidth Monitoring Per Connection

2. `nload` — Simple Interface Bandwidth

3. `bmon` — Bandwidth Monitoring and Visualization

4. `tcpdump` — Deep Packet Inspection

5. `netstat` / `ss` — Network Connection Stats

6. `nethogs` — Bandwidth by Process

7. `vnstat` — Long-term Network Usage Stats

Understanding `chmod 777` ❓

Octal Mode in `chmod`