DEV Community: kishor sutradhar

The Secret Language of the Internet: Common Protocols Explained

kishor sutradhar — Sat, 16 Aug 2025 17:05:58 +0000

As I continue to learn about cybersecurity, I must know how to interact with various protocols that are the languages that computers use to communicate. Sending an email or securing a server, protocols define how data is transmitted, authenticated, and interpreted across networks. Understanding these protocols is not just academic knowledge; it's crucial for building robust, secure, and efficient applications and systems. So here are some of the common protocols.

Hypertext Transfer Protocol (HTTP)

HTTP is the foundation of data communication for the World Wide Web. It defines how clients (like web browsers) request and receive resources (like HTML pages, images, videos) from servers. The

Use: Fetching web pages and other resources from web servers.
port: By default, HTTP uses port 80
purpose: communication between web browsers and servers.

Hypertext Transfer Protocol Secure (HTTPS)

HTTPS is the secure version of HTTP. It encrypts the communication between the client and the server using protocols like TLS/SSL, protecting data from eavesdropping and tampering.

Use: Securely transmitting sensitive information like login credentials, financial data, and personal details over the web.
port: By default, HTTP uses port 443
purpose: Delivering web pages, APIs, and online services securely.

Dynamic Host Configuration Protocol (DHCP)

The Dynamic Host Configuration Protocol (DHCP) is a fundamental network protocol that automates the process of assigning IP addresses and other network configuration parameters to devices on a network. Without DHCP, a network administrator would have to manually assign a static IP address, subnet mask, default gateway, and DNS server to every single device—a task that is impractical and prone to errors, especially on large or frequently changing networks.

Internet Protocol (IP)

At the heart of the Internet lies the Internet Protocol (IP). It's responsible for addressing and routing packets of data across networks. Think of IP addresses as postal addresses for computers on a network, allowing data to find its destination.

Use: Fundamental for internet communication, enabling data transfer between devices across different networks.

Transmission Control Protocol (TCP)

Built on top of IP, TCP provides reliable, ordered, and error-checked delivery of a stream of bytes between applications running on hosts communicating via an IP network. It establishes a connection before data transfer and ensures that all data arrives correctly and in the correct order.

Use: Web browsing (HTTP/HTTPS), email (SMTP, POP3, IMAP), file transfer (FTP, SFTP), and many other applications requiring reliable data transmission.
port: Multiple (layer-dependent).
purpose: defines how data is packetized, addressed, transmitted, and routed.

User Datagram Protocol (UDP)

UDP is another core protocol that also sits on top of IP. Unlike TCP, UDP is connectionless and provides unreliable data transmission. It doesn't guarantee delivery, order, or error checking. This makes it faster but less reliable than TCP.

Use: Applications where speed is critical and occasional data loss is acceptable, such as streaming video and audio, online gaming, and DNS lookups.

Domain Name System (DNS)

DNS translates human-readable domain names (like example.com) into IP addresses that computers understand. It acts as the internet's phonebook.

Use: Resolving website names to their corresponding IP addresses, enabling users to access websites using memorable names.
port: port 53
purpose: Converts human-readable domains into IP addresses.

Simple Mail Transfer Protocol (SMTP)

SMTP is the standard protocol for sending emails between mail servers.

Use: Sending email messages.
port: port 25

Post Office Protocol version 3 (POP3)

POP3 is used by email clients to retrieve emails from a mail server. Typically, after downloading the emails, they are removed from the server.

Use: Downloading emails from a mail server to a local email client.
port: port 110 and 995

Internet Message Access Protocol (IMAP)

IMAP is another protocol used by email clients to access emails on a mail server. Unlike POP3, IMAP typically leaves the emails on the server, allowing users to access their emails from multiple devices.

Use: Accessing and managing emails on a mail server, keeping emails synchronized across multiple devices.
port: port 143 and 993

File Transfer Protocol (FTP)

FTP is a standard network protocol used for transferring files between a client and a server on a computer network.

Use: Uploading and downloading files between computers.
port: port 20 and 21

Secure File Transfer Protocol (SFTP)

SFTP is a secure version of FTP. It uses SSH (Secure Shell) to encrypt the data transfer, providing a more secure way to transfer files.

Use: Securely transferring files between computers.
port: port 22

Secure Shell (SSH)

SSH is a cryptographic network protocol for operating network services securely over an unsecured network. It provides a secure channel over an insecure network by using strong encryption.

Use: Secure remote access to servers and other network devices, executing commands remotely, and secure file transfer (SFTP).
port: port 22

The key to understanding why they share the same port is that SFTP (SSH File Transfer Protocol) is not a standalone protocol. It is a subsystem of the SSH (Secure Shell) protocol.

Telnet

Telnet is designed for remote connectivity. It establishes connections between a remote endpoint and a host machine to enable a remote session. Telnet prompts the user at the remote endpoint to log on. Once the user is authenticated, Telnet gives the endpoint access to network resources and data at the host computer.

Address Resolution Protocol (ARP)

Its primary job is to translate a logical address (an IP address) to a physical address (a MAC address) on a local network segment. When data is sent over a local network (like your home Wi-Fi or a corporate LAN), devices need to know the destination's physical address to deliver the data directly to the correct network interface card (NIC). While a packet is routed across the Internet using IP addresses, the final delivery within the local network requires the MAC address.

VPN Protocols (e.g., OpenVPN, IPsec, WireGuard)

Virtual Private Network (VPN) protocols create secure tunnels across a network, allowing users to send and receive data as if their computing devices were directly connected to a private network.

Use: Creating secure and private connections over public networks, encrypting internet traffic, and accessing resources on private networks remotely.

Network Time Protocol (NTP)

NTP is used to synchronize the clocks of computer systems over packet-switched, variable-latency data networks. Accurate time synchronization is crucial for many security and logging mechanisms.

Use: Synchronizing system clocks across a network.

Conclusion

This is just a glimpse into the vast world of network protocols. As my journey to be a cyber developer, a deep understanding of these protocols, their functionalities, and their potential vulnerabilities is needed. I am doing this blog to deepen my understanding of this subject and become a better developer. thanks for reading this. Hope to see you soon.

One week ago, I finally started learning cybersecurity — after years of avoiding it. This is how it’s going.

kishor sutradhar — Mon, 04 Aug 2025 07:47:29 +0000

For the past two years, I focused on web development — learning both frontend and backend. I always had an interest in cybersecurity, but whenever I tried to get into it, it felt too complex and intimidating. So, I set it aside and focused on web development instead.

Recently, that curiosity came back stronger than ever. This time, I decided not to run from the challenge. I committed to taking cybersecurity seriously — and I’ve officially completed my first week of focused learning!

Here’s a breakdown of everything I did and learned in Week 1 👇

📚 Starting with the Fundamentals

I think fundamentals are so important in any field. To build a solid foundation, I began with CompTIA A+ certification prep videos by Professor Messer on YouTube.

I haven’t finished the playlist yet, but I’m currently on Lesson 2.6, going in order. It’s a great starting point for anyone new to IT or cybersecurity.

🧠 Hands-On with TryHackMe

Next, I created an account on TryHackMe — a fantastic platform for interactive cybersecurity training. Here’s what I’ve completed so far:

✅ Linux Fundamentals Part 1

Parts 2 and 3 are premium, so I couldn’t access them directly. But I watched YouTube walkthroughs to learn the content anyway!
✅ Windows Fundamentals Parts 1, 2, and 3
Even though I’ve been using Windows my whole life, I discovered many things I never knew about it.

💻 Setting Up My Lab: VirtualBox + Kali Linux

To practice in a more realistic environment, I installed VirtualBox and set up a Kali Linux virtual machine. This setup will be key as I dive deeper into ethical hacking and penetration testing.

🎮 Playing Bandit: A Linux Wargame

I also started the Bandit wargame from OverTheWire. It’s a text-based game where each level teaches you a new Linux command or concept.

I’m currently on Level 15, and I’ve learned more about file manipulation, SSH, permissions, and command-line navigation than I ever did through tutorials alone.

🧪 What I Learned This Week

Core hardware and OS concepts from CompTIA A+
Linux and Windows fundamentals (especially user/system management)
Navigating Linux with real command-line practice
Setting up a secure environment with Kali and VirtualBox
Gained confidence in solving real-world security puzzles (thanks to Bandit)

💬 Let’s Connect

Thanks for reading my blog! If you’ve been down this road before, or you’re also starting in cybersecurity, I’d love to hear your thoughts or advice — feel free to drop a comment!

Also… I’m thinking of coming up with a cool hacker name 😎
Right now, I’m leaning toward HELLVIRUS — but if you’ve got a better one, let me know!

See you next week with another update.
Until then — stay curious, stay learning.
বিদায় বন্ধুরা !

Today’s new knowledge #10 (Building a Flexible Query Builder for MongoDB with Mongoose)

kishor sutradhar — Mon, 09 Dec 2024 19:28:53 +0000

Today’s Overview:

Kon'nichiwa, everyone! I hope you're all doing great. Recently I learned an effective way to querying in a MongoDB database and I wanted to share it with you. The process of creating a custom QueryBuilder class can be extremely useful. This class helps you build flexible, reusable queries that can handle filtering, sorting, pagination, and more. Hope you find this useful in your own projects. so let's get started!

The QueryBuilder Class
- Implementation of QueryBuilder
UseCase of QueryBuilder
- Search Functionality
- Filter Functionality
- Sort Functionality
- Pagination Functionality
- Limit Fields Functionality
Benefits of QueryBuilder
Conclusion

The `QueryBuilder` Class

import { FilterQuery, isValidObjectId, Model, Query } from 'mongoose';

class QueryBuilder<T> {
  public modelQuery: Query<T[], T>;
  public query: Record<string, unknown>;
  private allowedFields = [
    'searchTerm',
    'sort',
    'page',
    'limit',
    'fields',
    'id',
  ];

  constructor(
    modelQuery: Query<T[], T>,
    query: Record<string, unknown>,
    model: Model<T>,
  ) {
    this.modelQuery = modelQuery;
    this.query = query;
    this.allowedFields = [
      ...Object.keys(model.schema.paths),
      ...this.allowedFields,
    ];
  }

  private isPositiveInteger(value: unknown): boolean {
    return Number.isInteger(Number(value)) && Number(value) > 0;
  }
  private escapeString(value: string): string {
    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  }

  private validateQuery(
    query: Record<string, unknown>,
    strictValidation = true,
  ): Record<string, unknown> {
    const sanitizedQuery: Record<string, unknown> = {};

    for (const key in query) {
      if (!this.allowedFields.includes(key)) {
        if (strictValidation) {
          throw new Error(Invalid query parameter: ${key});
        }
        continue;
      }

      const value = query[key];

      if (key === 'page' || key === 'limit') {
        sanitizedQuery[key] = this.isPositiveInteger(value) ? Number(value) : 1;
      } else if (key === 'id' && typeof value === 'string') {
        sanitizedQuery[key] = isValidObjectId(value) ? value : null;
      } else if (typeof value === 'string') {
        sanitizedQuery[key] = this.escapeString(value);
      } else {
        sanitizedQuery[key] = value;
      }
    }
    return sanitizedQuery;
  }

  search(searchableFields: string[] ) {
    const searchTerm = this.query.searchTerm as string;
    if (searchTerm && searchableFields.length > 0) {
      this.modelQuery = this.modelQuery.find({
        $or: searchableFields.map((field) => ({
          [field]: { $regex: searchTerm, $options: 'i' },
        })),
      });
    }

    return this;
  }

  filter() {
    const sanitizedQuery = this.validateQuery(this.query);
    const queryObj = { ...sanitizedQuery }; // copy

    // Filtering
    const excludeFields = ['searchTerm', 'sort', 'limit', 'page', 'fields'];

    excludeFields.forEach((el) => delete queryObj[el]);

    this.modelQuery = this.modelQuery.find(queryObj as FilterQuery<T>);

    return this;
  }

  sort(defaultSort = '-createdAt') {
    const sort =
      (this?.query?.sort as string)?.split(',')?.join(' ') || defaultSort;
    this.modelQuery = this.modelQuery.sort(sort as string);

    return this;
  }

  paginate(defaultPage = 1, defaultLimit = 10) {
    const page = Number(this?.query?.page) || defaultPage;
    const limit = Number(this?.query?.limit) || defaultLimit;
    const skip = (page - 1) * limit;

    this.modelQuery = this.modelQuery.skip(skip).limit(limit);

    return this;
  }

  limitFields(defaultFields = '-__v') {
    const fields =
      (this?.query?.fields as string)?.split(',')?.join(' ') || defaultFields;

    this.modelQuery = this.modelQuery.select(fields);
    return this;
  }
}

export default QueryBuilder;

The QueryBuilder class is generic and can handle any Mongoose model.

The constructor accepts:

modelQuery: The Mongoose query object that will be modified by the builder.
query: The query parameters passed by the user, typically from the request URL.
model: The Mongoose model, which helps determine the allowed fields based on the schema.

Implementation of `QueryBuilder`

It's simple. Imagine you have a Mongoose model called UserModel.

import QueryBuilder from "./QueryBuilder";
import UserModel from "./models/User";

const queryBuilder = new QueryBuilder(UserModel.find(), req.query, UserModel);

const results = await queryBuilder
  .search(["name.first", "name.last", "email"]) // Search in nested fields
  .filter()
  .sort()
  .paginate()
  .limitFields()
  .modelQuery.exec();

console.log(results);

UseCase of `QueryBuilder`

Search Functionality

The search() method allows you to perform full-text searches across multiple fields. You can specify the fields you want to search using the searchableFields parameter. I recommend using the searchableFields parameter to limit the fields you wish to search for performance and security reasons. searchTerm is used for partial matches.

The example endpoint is:GET

http://localhost:3000/user?searchTerm=John

Filter Functionality

The filter() method allows you to apply filters to your query. It uses the validateQuery() method to sanitize the query parameters and then applies the filters to the query. It is used for exact matches.

The example endpoint is:GET
http://localhost:3000/user?name.first=John&name.last=Doe

So in this example, you will get all users with the first name John and last name Doe.

Sort Functionality

The sort() method allows you to sort the results of your query. It uses the sort() method to apply the sort to the query. In the query parameter, you can specify the sort order using the sort parameter.

The example endpoint is:GET
http://localhost:3000/user?sort=name
http://localhost:3000/user?sort=-name

For ascending order you should use sort=fieldName and for descending order, you should use sort=-fieldName. Note that you have to use - before the field name.

Pagination Functionality

Pagination is essential when dealing with large datasets. The paginate() method accepts parameters for the current page and the number of items per page (limit). It calculates the skip value and limits the results accordingly.

The example endpoint is:GET
http://localhost:3000/user?page=2&limit=10

Limit Fields Functionality

The limitFields() method allows you to specify the fields you want to include in the results.

The example endpoint is:GET
http://localhost:3000/user?fields=name.first,email

Note that you have to use , after each field name.

Benefits of `QueryBuilder`

It provides a flexible way to build complex queries.
It handles validation and sanitization of query parameters.
It ensures that only allowed fields are included in the query.
It provides a consistent way to apply filters, sorting, pagination, and limiting fields to your queries.
It helps to keep your code DRY and maintainable.
It makes it easy to add new features to your queries without modifying the existing code.
It helps to ensure that your queries are secure and efficient.
It makes the code more readable and maintainable.

Conclusion

The QueryBuilder class provides a powerful way to manage MongoDB queries with Mongoose. A query builder like this is a great tool to simplify database queries while ensuring security and efficiency. So that's it. I hope you find this useful in your projects. Don't forget to give like and share it if you find this useful. Thanks for reading. Talk to you soon.

Today’s new knowledge #9 (Understanding Transaction Rollbacks in Mongoose)

kishor sutradhar — Sat, 07 Dec 2024 16:58:07 +0000

Today’s Overview:

Hola, everyone! I hope you're all doing great. It's been a while since I last wrote a blog post. I've been working on a full-stack project for my resume, and since I'm the only one developing it, it is taking some time to complete the project. After completing the project I want some feedback from you guys. ok enough about me, I learned some new concepts about MongoDB and Mongoose. Here is one I find quite useful for any project which is Transaction Rollbacks. So let's dive into it.

Transactions and Rollbacks
- Why Use Transaction Rollbacks?
- What to consider when using Transaction Rollbacks?
Steps to Implement a Transactions and Rollback in Mongoose
Example
Conclusion

Transactions and Rollbacks

A transaction rollback is a powerful mechanism that helps you maintain consistency especially when multiple operations need to either be fully completed or entirely undone.
A transaction in MongoDB is a way to group multiple operations together into a single unit. All operations within a transaction are treated as if they happen at once.
If any operation in the transaction fails, MongoDB will automatically rollback the entire transaction to its initial state, undoing all changes made.

Why Use Transaction Rollbacks?

Single unit: Transactions allow you to bundle several operations into a single unit.
Prevent Data Corruption: When the operation fails rollback prevents data corruption.
Maintain consistency As multiple operations must work together or roll back if fail to perform the operation it helps to maintain consistency.
Error Handling: In the case of unexpected errors or failures, transaction rollbacks provide a safety net by reversing any changes made during the transaction.
Simplify Complex Operations: When working with multiple collections or documents, rollbacks provide a simple way to handle complex operations

What to consider when using Transaction Rollbacks?

While transaction rollbacks are a powerful tool for maintaining data integrity, there are several factors to consider when using them:

Performance: Transactions come with some performance overhead due to the need to track changes and ensure atomicity. Use them judiciously in performance-sensitive applications.
Transaction Limits: MongoDB has certain limits on the size of transactions, such as the maximum number of operations or document size. Be mindful of these limits when dealing with large or complex transactions.

Steps to Implement a Transactions and Rollback in Mongoose

Create a mongoose sassion const session = await mongoose.startSession();
Start a transaction await session.startTransaction();
Perform the operations
Commit the transaction await session.commitTransaction();
Close the session session.endSession();
In case of error and rollback the transaction await session.abortTransaction();

Example

Here's an example using Mongoose:


async function performTransaction() {

  //create a session and start transaction
  const session = await mongoose.startSession();
  session.startTransaction();

  try {
    //  operations within the transaction
    const user = await User.findOneAndUpdate(
      { _id: "userId1" },
      { $set: { name: "John Doe" } },
       //have to specify the session in the options field
      { new: true, session }
    );

    if (!user) {
      throw new Error("User not found");
    }

    const order = await Order.create(
      [
        {
          userId: user._id,
          item: "Laptop",
          status: "Processing",
        },
      ],
      {
        //have to specify the session in the options field
       session 
      }
    );

    // If all operations are successful, commit the transaction
    await session.commitTransaction();

  } catch (error) {
    // If an error occurs, abort the transaction (rollback)
    await session.abortTransaction();
    console.error("Transaction aborted due to error:", error);
  } finally {
   // and finally end the session
    session.endSession();
  }
}

Conclusion

I think this is a great feature for every developer to use in their complex write operation. one more thing Transaction rollbacks can not be used in read operations. ok that's all for today.

Today’s new knowledge #8(Markdown)

kishor sutradhar — Sat, 23 Nov 2024 15:22:54 +0000

Today’s Overview:

Hello again everyone ❤❤❤! Hope you're all doing well. I've been super busy these past two days with an assignment for my advanced web development course, which left me with little time to write a blog post. As part of the assignment, i have to deep dive into markdown language. so i decided to write a blog post about what i learned about markdown language. I hope you find it useful and hope you guys like it.

What is Markdown?
why developers use markdown?
Table of contents
- Few things to note for TOC in markdown
Headings
Bold
Italic
Links
Images
Code
- Escaping Backticks
- Code Blocks
ordered list
unordered list
Checkbox
Table
Horizontal line
Emoji
Html
Methamatical expression

What is Markdown?

Markdown is a text-to-HTML conversion tool for web writers. It allows you to write using an easy-to-read, easy-to-write plain text format, then convert it to well-formatted HTML. For more details, check out the Markdownguide website.

Why developers use markdown?

It allows you to write using an easy-to-read, easy-to-write plain text format, then convert it to well-formatted HTML.

It is easy to read and write
It is easy to convert to HTML
It is easy to share
It is easy to search
It is easy to edit
It is easy to learn

Table of contents in markdown

For every proper documentation, we need a table of contents. It is easy to create a table of contents in markdown. Here is an example:

- [Today’s Overview](#todays-overview)

Today’s Overview

If you click this link, you will be redirected to the top of the page. This is a very useful feature for users who want to quickly navigate through the documentation.

Few things to note for Table of contents in markdown:

1. Follow Anchor ID Generation Rules

Markdown parsers automatically generate anchor IDs from headings. To ensure links in your ToC work, follow these rules:

Convert text to lowercase.
Replace spaces with hyphens (-)
Anchor IDs should be hyphenated
Remove special characters (like ?, !, #, etc.).

[what is markdown](#what-is-markdown)

## What is Markdown?

2. Avoid Duplicate Section Names

If multiple headings have the same name, Markdown parsers usually append a unique number (e.g., -1, -2) to their IDs. Avoid this by making your section titles unique.

toc:
[installation](#installation)
[installation](#installation-1)

## Installation

## Installation

3. Use a Logical Structure

Arrange the ToC to match the document's hierarchy, using indentation for subsections:

Top-level sections are unindented.
- Subsections are indented.

## Table of Contents

- [Introduction](#introduction)
- [Getting Started](#getting-started)
  - [Installation](#installation)
  - [Setup](#setup)
- [Conclusion](#conclusion)

4. Use a Logical Structure

Ensure the order of links in your ToC matches the order of sections in your document to avoid confusion.

5. Optional: Number the Sections

If your document is lengthy, numbering sections in the ToC can help with navigation.

## Table of Contents

1. [Introduction](#introduction)
2. [Getting Started](#getting-started)
   2.1. [Installation](#installation)
   2.2. [Setup](#setup)
3. [Usage](#usage)
4. [Conclusion](#conclusion)

Headings in markdown

Headings are important in markdown because they allow you to create sections in your document.

- # Heading 1
- ## Heading 2
- ### Heading 3
- #### Heading 4
- ##### Heading 5
- ###### Heading 6

output:

Heading 1

Heading 2

Heading 3

Heading 4

Heading 5

Heading 6

Bold text in markdown

Headings are important in markdown because they allow you to create sections in your document.

**bold text 1**

output:

bold text 1

Italic text in markdown

_italic text 1_

output:

italic text 1

Link in markdown

For various perpose we need to add link in markdown.

[kishor github](https://github.com/SDKishor)

output:

kishor github

Link with Title (Tooltip)

[kishor github](https://github.com/SDKishor "kishor github profile")

output:

if you hover over the link, you will see the tooltip

kishor github

Image in markdown

To add an image in markdown, you can use the following syntax:

#syntax
![Alt Text](url)

#example
![markdown](https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTsTfXwY_1HFsyuMhX0ajaCCv_ZsKlUb9k0kA&s)

output:

Image with hyperlink

[![markdown](https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTsTfXwY_1HFsyuMhX0ajaCCv_ZsKlUb9k0kA&s)](https://en.wikipedia.org/wiki/Markdown)

output:

if you click on the image, you will be redirected to the link

Code in markdown

To indicate code, surround it with backticks ( ` ).

#syntax
`code`

output:

code

Escaping Backticks

If you want to use backticks inside a code block, you can escape them by doubling them.

#syntax
`` `code` ``

output:

`code`

Code blocks

To add a code block in markdown, you can use the following syntax:

#syntax
`javascript
      console.log("hello world");
      `

output:

console.log("hello world");

Tips: In order to highlight the code, you can add language name at the start of the backticks

ordered list in markdown

To add an ordered list in markdown, you can use the following syntax:

#syntax

1. item 1
2. item 2
3. item 3

output:

item 1
item 2
item 3

unordered list in markdown

To add an unordered list in markdown, you can use the following syntax:

#syntax

- item 1
- item 2
- item 3

output:

item 1
item 2
item 3

Checklist in markdown

To add a checklist in markdown, you can use the following syntax:

#syntax

- [x] item 1
- [ ] item 2
- [ ] item 3

output:

[x] item 1
[ ] item 2
[ ] item 3

Table in markdown

To add a table in markdown, you can use the following syntax:

#syntax

| Column 1 | Column 2 | Column 3 |
| -------- | -------- | -------- |
| Row 1    | Row 2    | Row 3    |
| Row 4    | Row 5    | Row 6    |

output:

Column 1	Column 2	Column 3
Row 1	Row 2	Row 3
Row 4	Row 5	Row 6

Table with alignment

To add a table with alignment you have to a column with : at the 2nd column.

#syntax

| Column 1 | Column 2 | Column 3 |
| :------- | :------: | -------: |
| Row 1    |  Row 2   |    Row 3 |
| Row 4    |  Row 5   |    Row 6 |

output:

left aligned, center aligned and right aligned
| Column 1 | Column 2 | Column 3 |
| :-------- | :--------: | --------: |
| Row 1 | Row 2 | Row 3 |

| Row 4 | Row 5 | Row 6 |

Horizontal line in markdown

To add a horizontal line in markdown, you can use the following syntax:

#syntax

---

output:

Horizontal line

_Note: You can also use *** or ___ instead of --- & add space at the start and end of the line._

Emoji in markdown

To add an emoji in markdown, you can use the following syntax:

#syntax

:smile:

output:

😄

HTML in markdown

Yes, you can add HTML in the markdown. But, it is not recommended. It is better to use the HTML tags in your HTML file.

#syntax

<p>hello world</p>

output:

hello world

Audio and Video in markdown

Markdown itself doesn’t natively support embedding audio and videos, but you can use HTML or platform-specific extensions to add audio and videos in Markdown.

Embedding Audio and Videos with HTML

#syntax

<video width="320" height="240" controls>
  <source src="movie.mp4" type="video/mp4">
</video>
<audio controls>
  <source src="audio-file-url.mp3" type="audio/mpeg">
  Your browser does not support the audio element.
</audio>

output:

Your browser does not support the audio element.

Methamatical expression in markdown

To add a methamatical expression in markdown, you can use the following syntax:

#syntax

**inline**
$ x^2 + y^2 = z^2 $

**block**

$$
x^2 + y^2 = z^2
$$

output:

inline

$ x^2 + y^2 = z^2 $

block

$$
x^2 + y^2 = z^2
$$

Conclusion

That's it. I hope this article has been helpful to you. If you have any questions or suggestions, please leave a comment below.

Today’s new knowledge #7(GSAP)

kishor sutradhar — Wed, 20 Nov 2024 20:47:01 +0000

Today's Overview:

Hello again everyone ❤❤❤! Hope you're all doing well. Today, I decided to focus on front-end development and, as usual, started exploring YouTube for inspiration. I came across a video on creating website animations with GSAP, which caught my interest. I thought it would be a great opportunity to dive into GSAP and learn something new. Here's a summary of what I explored and learned today.

What is GSAP

GSAP (GreenSock Animation Platform) is a powerful JavaScript library for creating high-performance animations for the web. It’s widely used for animating DOM elements, SVG, canvas, WebGL, and more.

so the first concept I learn is Tween.

TWEEN

In GSAP, a tween is a single animation instance that animates a property or set of properties over time.
Methods like gsap.to(), gsap.from(), and gsap.fromTo() are used to create tweens.

gsap.to()

The gsap.to() method in GSAP is used to animate an element or object from its initial state to a specified state.It's one of the most commonly used methods in GSAP for creating smooth transitions. CSS properties Transforms, colors, padding, border radius, GSAP can animate it all! Just remember to camelCase the properties - e.g. background-color becomes backgroundColor.

gsap.to(".box", {
  duration: 1,    
// Animation lasts 1 second
  x: 200,         
// Moves the element 200px on the X-axis
  opacity: 0.5,   
// Fades the element to 50% opacity
});

gsap.from()

The gsap.from() method in GSAP is used to animate an element or object from a defined starting state to its initial state. This is the opposite of gsap.to()

gsap.from(".box", {
  duration: 1.5,
  x: -200,    
// Starts 200px left of its original position
  opacity: 0, 
// Starts with 0% opacity
  ease: "power2.out" 
// Eases out to the current state
});

gsap.fromTo()

The gsap.fromTo() method in GSAP is a versatile way to define both the starting (from) and ending (to) states of an animation.

gsap.fromTo(".box", 
  { x: -200, opacity: 0 }, 
// Starting state: off-screen to the left and invisible
  { x: 200,
 opacity: 1,
 duration: 2,
 ease: "power2.out" }
 // Ending state: on-screen and fully visible
);

Here's a list of the shorthand transforms and some other commonly used properties.

Property	Equivalent CSS	Notes
`x: 100`	`transform: translateX(100px)`	Moves element 100px along X-axis
`y: 100`	`transform: translateY(100px)`	Moves element 100px along Y-axis
`xPercent: 50`	`transform: translateX(50%)`	Moves element 50% along X-axis
`yPercent: 50`	`transform: translateY(50%)`	Moves element 50% along Y-axis
`scale: 2`	`transform: scale(2)`	Scales element by a factor of 2
`scaleX: 2`	`transform: scaleX(2)`	Scales element's width by a factor of 2
`scaleY: 2`	`transform: scaleY(2)`	Scales element's height by a factor of 2
`rotation: 90`	`transform: rotate(90deg)`	Rotates element 90 degrees
`rotation: "1.25rad"`	No CSS alternative	Rotates element in radians
`skew: 30`	`transform: skew(30deg)`	Skews element 30 degrees
`skewX: 30`	`transform: skewX(30deg)`	Skews element along X-axis
`skewY: "1.23rad"`	No CSS alternative	Skews element along Y-axis in radians
`transformOrigin: "center 40%"`	`transform-origin: center 40%`	Sets origin for transformations
`opacity: 0`	Adjusts the element's opacity	0 for transparent, 1 for opaque
`autoAlpha: 0`	Shorthand for opacity & visibility	0 hides both visibility & opacity
`duration: 1`	`animation-duration: 1s`	Sets animation duration to 1 second
`repeat: -1`	`animation-iteration-count: infinite`	Animation repeats infinitely
`repeat: 2`	`animation-iteration-count: 2`	Animation repeats twice
`delay: 2`	`animation-delay: 2`	Animation starts after 2 seconds
`yoyo: true`	`animation-direction: alternate`	Animation alternates direction

gsap.timeline()

The gsap.timeline() method in GSAP allows you to sequence multiple animations in a controlled and coordinated manner. Using a timeline, you can precisely manage the timing and relationships between tweens, making it easier to create complex, synchronized animations.

let tl = gsap.timeline();

tl.to(".box", { x: 100, duration: 1 })
  .to(".circle", { y: 100, duration: 1 }, "-=0.5") // Starts 0.5s before the previous animation ends
  .to(".triangle", { rotation: 180, duration: 1 });

Control Methods
play(): Starts or resumes the timeline.
pause(): Pauses the timeline.
restart(): Restarts the timeline from the beginning.
reverse(): Plays the timeline in reverse.
seek(): Jumps to a specific time in the timeline.
progress(): Sets or gets the progress of the timeline (0 to 1).

Those are the core concepts of GSAP there are also some plugins you can use. like

ScrollTrigger

ScrollTrigger is a GSAP plugin that allows you to trigger animations based on scroll position, creating interactive, scroll-based animations. It's perfect for building scroll-triggered effects like pinning, parallax, or section reveals.

gsap.to(".box", {
  scrollTrigger: {
    trigger: ".box",
    start: "top 75%", // Animation starts when the top of .box reaches 75% of the viewport
    end: "top 25%",   // Animation ends when the top of .box reaches 25% of the viewport
    scrub: true,      // Links the animation progress to scroll progress
    markers: true     // Shows markers for debugging
  },
  x: 200,
  rotation: 360,
  duration: 2
});

});

Using GSAP in a React

First, install GSAP via npm or yarn:

npm install gsap

`useGsap` hook

The useGsap hook, provided by the GSAP library, is a powerful tool for managing animations in React applications. It simplifies the process of creating and managing animations, ensuring proper cleanup and preventing potential issues.

import React, { useRef } from 'react';
import { useGsap } from '@gsap/react';
import gsap from 'gsap';

function MyComponent() {
  const ref = useRef(null);
  const { contextSafe } = useGsap();

  // Use contextSafe to ensure proper cleanup
  const animate = contextSafe(() => {
    gsap.to(ref.current, {
      x: 200,
      duration: 1,
      ease: 'power2.out'
    });
  });

  return (
    <div onClick={animate} ref={ref}>
      Hello, World!
    </div>
  );
}

those are the things I learned today.

Today’s new knowledge #6(Mongoose)

kishor sutradhar — Tue, 19 Nov 2024 12:02:27 +0000

Today's Overview:

Hello everyone❤❤❤! Hope you're all doing well. Today, I began exploring Mongoose. With my solid understanding of MongoDB, I felt it was the right time to dive into Mongoose, as it offers a higher-level abstraction for interacting with MongoDB. Here's a summary of what I learned today.

Mongoose

Mongoose is a popular Object Data Modeling (ODM) library for MongoDB and Node.js. It acts as a bridge between your Node.js application and the MongoDB database, enabling you to define data structures and interact with MongoDB in a more structured and efficient way. when you send data to MongoDB, mongoose maps the data with the model, and if the data matches the model structure then with the help of the MongoDB driver the data is sent to mongoDB. so it ensures the validity of the data.

Why should we use Mongoose?

Schema Definition
Model Creation
Data Validation
Querying
Middleware Support
Population of reference data

Connecting to MongoDB

Mongoose establishes a connection to the MongoDB database using a URI. Once connected, it provides methods to interact with the database.

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mydatabase')
.then(() => console.log('Connected to MongoDB'))
.catch(err => console.error('Connection error:', err));

Schemas:

A schema in Mongoose is a blueprint that defines the structure, data types, default values, and validation rules for documents in a MongoDB collection. It ensures data consistency and makes working with MongoDB collections more structured.

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
    name: { type: String, required: true },       
// Required field of type String
    email: { type: String, required: true },      
// Required and must be unique
    age: { type: Number, min: 0 },                
// Number with minimum value validation
    isAdmin: { type: Boolean, default: false },   
// Default value if not provided
    createdAt: { type: Date, default: Date.now }  
// Automatically sets the current date
});

Common Schema Properties

type: Specifies the data type (String, Number, Boolean, Date, Buffer, ObjectId, Array, etc.).
required: Ensures the field must be provided.
default: Sets a default value if none is provided.
unique: Ensures the value in the field is unique across documents.
enum: Specifies allowed values for a field.
validate: Provides custom validation logic.

Model

In Mongoose, a model is a class that provides an interface to interact with a specific MongoDB collection.

const User = mongoose.model('User', userSchema);

CRUD Operations

Mongoose simplifies operations like creating, reading, updating, and deleting documents. Here's how:

//create
const newUser = new User({ 
name: 'Alice',
email: 'alice@example.com',
age: 25 
});
await newUser.save(); 
// Saves the document to MongoDB

//read
const users = await User.find(); 
// Retrieves all users
const user = await User.findOne({ email: 'alice@example.com' }); 
// Finds a specific user

//update
await User.updateOne(
{ email: 'alice@example.com' }, 
{ age: 26 }
);

//delete
await User.deleteOne({ email: 'alice@example.com' });

Relationships (Population)

In Mongoose, population is a feature that enables you to work with relationships between documents stored in different collections.

const postSchema = new mongoose.Schema({
    title: String,
    author: { type: mongoose.Schema.Types.ObjectId, ref: 'User' }
});
const Post = mongoose.model('Post', postSchema);

// Populate author details when querying posts
const posts = await Post.find().populate('author');

Validation

Mongoose provides robust built-in validation to ensure data integrity before it is saved to the database. You can define validation rules directly in the schema to enforce constraints like required fields, value ranges, custom checks, and more.

const userSchema = new mongoose.Schema({
    name: { type: String, required: true }, 
// Name is mandatory
    email: { type: String, required: [true, 'Email is required'], match: /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/ } 
// Custom error message and regex validation
price: { type: Number, min: 0, max: 1000 } 
// Price must be between 0 and 1000
});
title: { type: String, minlength: 5, maxlength: 100 }
 // Title length must be 5–100 characters

 age: {
        type: Number,
        validate: {
            validator: function (value) {
                return value >= 18; 
                 // Age must be at least 18
            },
            message: 'Age must be 18 or older' 
            // Custom error message
        }
    }
});
//custom validation

Query Building

Mongoose provides a powerful, chainable API to construct and execute database queries with ease. Queries are built using query objects, which allow you to filter, project, sort, and paginate data.

const users = await User.find({ age: { $gte: 18 } });

const user = await User.findOne({ email: 'example@example.com' });

const user = await User.findById('648e5f2a7a1b2c6d4e5f3a4d');

Query Chain

Mongoose queries are chainable, meaning you can combine filters, projections, and options.

const users = await User.find({ age: { $gte: 18 } }) // Filter users by age
    .select('name email')                          // Project only 'name' and 'email' fields
    .sort({ name: 1 })                             // Sort by name in ascending order
    .limit(10);                                    // Limit to 10 results

*note: * For advanced data processing, use the MongoDB Aggregation Framework via Mongoose.

Conclusion:

That's all I learned today about mongoose. I also practice other things that I learned previously. Hope to talk to you soon. Bye Bye 🖐.

Today’s new knowledge #5 (Three.js)

kishor sutradhar — Sun, 17 Nov 2024 16:12:12 +0000

Today's Overview:

Hello again, everyone! ❤️❤️ Hope you're all doing great! Today, I began learning THREE.js to create 3D effects for websites.I have some knowledge in 3D modeling and game development which allowed me to understand THREE.js concepts quickly. I aim to incorporate at least one 3D effect into my portfolio. Here's a summary of what I've learned in THREE.js.

Three.js:

For those who doesn't know Three.js is a popular JavaScript library that simplifies creating and displaying 3D graphics in web applications using WebGL. It provides tools and abstractions to build and animate 3D scenes, making it easier to work with complex graphics without writing WebGL code directly.

so I start from the basic of three js. The first part is the Scene

Scene:

The core of a Three.js project starts with a scene. A scene acts as a container for all objects, including geometries, lights, cameras, and other elements.

const scene = new THREE.Scene();

Cameras:

In Three.js, cameras are essential for rendering the scene. Cameras determine what portion of the 3D scene is visible to the user. there are two main cameras that are used in the scene

1. PerspectiveCamera

Mimics the perspective of human vision, where objects farther away appear smaller. Commonly used in games and realistic 3D scenes.

const camera = new THREE.PerspectiveCamera(fov, aspect, near, far);

fov: Field of view in degrees (vertical).
aspect: Aspect ratio (width divided by height of the viewport).
near: Near clipping plane (objects closer will not be rendered).
far: Far clipping plane (objects farther away will not be rendered).

2. OrthographicCamera

Maintains the same size for objects regardless of distance, without perspective distortion. Common in 2D games, CAD applications, or UI elements.

const camera = new THREE.OrthographicCamera(left, right, top, bottom, near, far);

left, right: Horizontal clipping planes.
top, bottom: Vertical clipping planes.
near, far: Clipping planes for depth.

there are other cameras in three js like ArrayCamera, CubeCamera or StereoCamera. you can learn more from the documentation about those.

Geometries

Then i stated learning about Geometries. These are the basic shapes (e.g., cubes, spheres, planes) used to construct 3D objects. some of the example are BoxGeometry CapsuleGeometry CircleGeometry CylinderGeometry.you can learn more from the documentation.

const geometry = new THREE.BoxGeometry();

if you want to add custom 3D object from a 3d modeling software like blender, maya. The GLTFLoader is a popular choice for modern 3D models.Export your model as a .glb or .gltf file. Load it into the Three.js scene.

import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';

const loader = new GLTFLoader();
loader.load('path/to/model.glb', (gltf) => {
    const model = gltf.scene;
    model.scale.set(1, 1, 1); // Adjust size
    model.position.set(0, 0, 0); // Position in the scene
    scene.add(model);
}, undefined, (error) => {
    console.error('An error occurred loading the model', error);
});

Materials

Define how the surfaces of objects appear when rendered. Materials control properties like color, texture, opacity, reflectivity, and how the object interacts with lights in the scene.

Basic Material A simple material that does not react to lighting. It's always fully visible. Great for debugging or non-shaded visuals like 2D-like graphics.

const material = new THREE.MeshBasicMaterial({ color: 0x00ff00 });

Standard Material (PBR) Physically Based Rendering (PBR) material for realistic surfaces. Reacts realistically to lighting. High-quality visuals for realistic simulations, games, and AR/VR.

const material = new THREE.MeshStandardMaterial({ color: 0x888888, metalness: 0.5, roughness: 0.2 });

metalness: Controls how metallic the material appears (0 = non-metallic, 1 = metallic).
roughness: Defines surface smoothness (0 = smooth, 1 = rough).
map: Adds textures.
normalMap: For detailed surface bumps.
envMap: Adds reflections from the environment.

Physical Material Similar to MeshStandardMaterial but includes advanced PBR properties like clear coats and sheen. For ultra-realistic surfaces like cars, gemstones, or coated objects.

const material = new THREE.MeshPhysicalMaterial({ clearcoat: 1.0, reflectivity: 0.9 });

there are meterial like those.you can learn more from the documentation.

Texture mapping

Texture mapping in Three.js is a technique to apply images or patterns (textures) onto the surface of 3D objects to make them visually realistic or stylized. Three.js provides the TextureLoader to load textures into your scene.

const textureLoader = new THREE.TextureLoader();
const texture = textureLoader.load('path/to/texture.jpg');

const material = new THREE.MeshStandardMaterial({
    map: texture, // Assign texture to material
});

Textures can be used in various ways to enhance materials:
Color Texture (map): The base texture that covers the surface.
Normal Map: Adds surface details like bumps without modifying geometry.
Bump Map: Similar to a normal map but simpler.
Displacement Map: Modifies geometry vertices for real surface bumps.
Roughness Map: Controls the roughness of the surface for reflections.
Metalness Map: Dictates metallic appearance.
Alpha Map: Creates transparency on parts of the surface.
Ambient Occlusion Map: Adds shadows for depth perception.

Mesh

In Three.js, a Mesh is a 3D object created by combining geometry with a material. Meshes are fundamental in creating visual objects in a Three.js scene.

const cube = new THREE.Mesh(geometry, material); // Combine into a mesh
scene.add(cube); // Add the mesh to the scene

Lights

In Three.js, lights are essential for illuminating a scene, giving depth, and highlighting the materials applied to objects. They simulate real-world lighting conditions to create realistic or stylized effects in 3D environments.

Ambient Light

Provides uniform lighting across the entire scene without direction. Does not create shadows. Basic fill light or to soften shadows.

const ambientLight = new THREE.AmbientLight(0xffffff, 0.5); // Color and intensity
scene.add(ambientLight);

Directional Light

Mimics sunlight by casting parallel rays in a specific direction. Can cast shadows.

const directionalLight = new THREE.DirectionalLight(0xffffff, 1);
directionalLight.position.set(5, 10, 7.5);
scene.add(directionalLight);

// Enable shadows
directionalLight.castShadow = true;
directionalLight.shadow.mapSize.width = 1024; // Higher values for better quality
directionalLight.shadow.mapSize.height = 1024;

Point Light

Emits light in all directions from a single point, like a bulb. Can cast shadows.

const pointLight = new THREE.PointLight(0xffffff, 1, 100); // Color, intensity, distance
pointLight.position.set(5, 5, 5);
scene.add(pointLight);

// Enable shadows
pointLight.castShadow = true;

Spotlight

Emits a cone of light, like a flashlight or stage spotlight. Can cast sharp, focused shadows.

const spotlight = new THREE.SpotLight(0xffffff, 1);
spotlight.position.set(5, 10, 5);
spotlight.angle = Math.PI / 6; // Cone angle
spotlight.penumbra = 0.2; // Soft edges
scene.add(spotlight);

// Enable shadows
spotlight.castShadow = true;

Environment Lighting

Uses an HDR texture to create realistic ambient lighting and reflections.
Does not require specific light objects but uses a texture.

const loader = new THREE.TextureLoader();
const envTexture = loader.load('path/to/hdr.jpg');
scene.environment = envTexture; // Applies to all reflective materials

There are various types of lights in the documentation.

Animation

In Three.js, animations are a powerful way to bring 3D scenes to life, enabling movement, transformations, or dynamic changes in objects, lights, or cameras.

Animating Using the Animation Loop

The render/animation loop updates the scene continuously, enabling you to animate objects frame by frame.

function animate() {
    requestAnimationFrame(animate); // Loop the animation

    mesh.rotation.x += 0.01; // Rotate on the X-axis
    mesh.rotation.y += 0.01; // Rotate on the Y-axis

    renderer.render(scene, camera); // Render the scene
}
animate();

Using GSAP for Advanced Animations

GSAP (GreenSock Animation Platform) is a powerful library for smooth and complex animations.

gsap.to(mesh.position, {
    x: 5,
    duration: 2,
    ease: "power1.inOut", // Easing function
    onComplete: () => console.log('Animation complete!'),
});

there are other way to animate as well for that read documentation.

renderer

In Three.js, rendering is the process of converting a 3D scene into a 2D image or series of images for display. This involves calculating light, shadows, materials, and transformations based on the current camera perspective and displaying the result to the screen.

const renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);  // Add canvas to DOM

function animate() {
    requestAnimationFrame(animate);  // Repeats the animation loop
    renderer.render(scene, camera);  // Renders the scene from the camera's perspective
}
animate();

randerer is used for Post-Processing and Antialiasing. Post-processing allows you to apply effects like bloom, depth of field, or color grading after the scene has been rendered. It’s achieved using the EffectComposer and shaders. Helps smooth jagged edges (aliasing) in the rendered image by averaging colors around edges.

const composer = new THREE.EffectComposer(renderer);
const renderPass = new THREE.RenderPass(scene, camera);
composer.addPass(renderPass);
const renderer = new THREE.WebGLRenderer({ antialias: true });

Conclusion

Those are the things i learn today that are new. hope you guys like it. see you soon. Thank you.

Today’s new knowledge #4

kishor sutradhar — Thu, 14 Nov 2024 19:07:25 +0000

Today's Overview:

Hello again, everyone! ❤️❤️ Hope you're all doing great! Today, I started by watching some frontend design tutorials and discovered a fantastic video on YouTube by Olivier Larose. I’m planning to incorporate some of those ideas into my portfolio website. Later, I shifted focus to my advanced web course, diving into Node.js modules. Here are a few topics I covered today.

Node.js module

Node.js module is essentially a set of JavaScript functions or objects that can be included in an application. Node modules enable you to break up your code into smaller, reusable pieces. There are three main types of Node modules:

Core Modules: These are built into Node.js and provide essential functionality, such as fs (file system), http (HTTP server/client), path, url, and more. You can access these modules without installing them by using require():

const fs = require('fs');

Local Modules: These are custom modules created within your project.You can define and export a function or an object in a file and then import it into another file.

// File: myModule.js
module.exports = function() {
  console.log("This is a custom module!");
};

// File: app.js
const myModule = require('./myModule');
myModule();

Third-Party Modules: These are modules written by others and published on the npm (Node Package Manager) registry. You can install them with npm install <module-name> and import them into your code.

// Installing and requiring Express
// Terminal: npm install express
const express = require('express');

Next, I explored the most frequently used core modules in Node.js and created a blog post to share insights on them. Here’s the link!
5 Most Used Core Modules of Node.js

That sums up all the new knowledge I gained today! hope to talk to you soon have a great day.

5 Most Used Core Modules of Node.js

kishor sutradhar — Thu, 14 Nov 2024 19:01:51 +0000

A Node.js module is essentially a set of JavaScript functions or objects that can be included in an application. Node modules enable you to break up your code into smaller, reusable pieces.

Core Modules:

These are built into Node.js and provide essential functionality, such as fs (file system), http (HTTP server/client), path, url, and more. You can access these modules without installing them by using require(<modulename>)

Here is the most used core modules developer used in their project.

1. path

The path module in Node.js provides utilities for working with file and directory paths. Here are some of the most commonly used methods in the path module.

path.join()

Combines multiple path segments into a single path. It normalizes the resulting path, handling redundant slashes or relative paths

const path = require('path');
const filePath = path.join('/users', 'john', 'documents', 'file.txt');
console.log(filePath); 
// Output: /users/john/documents/file.txt

path.resolve()

Resolves a sequence of paths or path segments into an absolute path, starting from the current working directory.

const absolutePath = path.resolve('documents', 'file.txt');
console.log(absolutePath); 
// Output: /your/current/working/directory/documents/file.txt

path.basename()

Returns the last part of a path, usually the file name. You can also specify an extension to remove from the result.

const fullPath = '/users/john/file.txt';
console.log(path.basename(fullPath));       
 // Output: file.txt
console.log(path.basename(fullPath, '.txt')); 
// Output: file

path.dirname()

Returns the directory portion of a path.

const filePath = '/users/john/documents/file.txt';
console.log(path.dirname(filePath)); 
// Output: /users/john/documents

path.extname()

Returns the extension of the file in the path, including the dot (.).

const filePath = '/users/john/documents/file.txt';
console.log(path.dirname(filePath));
 // Output: /users/john/documents

path.parse()

Returns an object with properties representing different parts of the path

const parsedPath = path.parse('/users/john/file.txt');
console.log(parsedPath);
/* Output:
{
  root: '/',
  dir: '/users/john',
  base: 'file.txt',
  ext: '.txt',
  name: 'file'
}
*/

path.isAbsolute()

Checks if a path is absolute, meaning it starts from the root directory (/ on UNIX or C:\ on Windows).

console.log(path.isAbsolute('/users/john'));  
// Output: true
console.log(path.isAbsolute('file.txt'));    
 // Output: false

There are more methods you can use for that check official document of path module

2. fs (File System)

The fs (File System) module in Node.js allows you to interact with the file system to read, write, and manipulate files and directories. Here are some of the most commonly used methods in the fs module

fs.readFile() & fs.readFileSync()

Reads the contents of a file asynchronously and synchronously.

const fs = require('fs');
fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

const data = fs.readFileSync('example.txt', 'utf8');
console.log(data);

fs.writeFile() & fs.writeFileSync()

Writes data to a file asynchronously and synchronously.

fs.writeFile('example.txt', 'Hello, World!', (err) => {
  if (err) throw err;
  console.log('File written successfully');
});

fs.writeFileSync('example.txt', 'Hello, World!');
console.log('File written successfully');

fs.appendFile() & fs.appendFile()

Appends data to a file asynchronously and synchronously.

fs.appendFile('example.txt', 'Hello, World!', (err) => {
  if (err) throw err;
  console.log('File written successfully');
});

fs.appendFileSync('example.txt', 'Hello, World!');
console.log('File written successfully');

fs.rename() & fs.renameSync()

Renames or moves a file asynchronously and synchronously.

fs.rename('example.txt', 'renamed.txt', (err) => {
  if (err) throw err;
  console.log('File renamed successfully');
});

fs.renameSync('example.txt', 'renamed.txt');
console.log('File renamed successfully');

fs.unlink() & fs.unlinkSync()

Deletes a file asynchronously and synchronously.

fs.unlink('example.txt', (err) => {
  if (err) throw err;
  console.log('File deleted');
});

fs.unlinkSync('example.txt');
console.log('File deleted');

fs.mkdir() & fs.mkdirSync()

Creates a new directory asynchronously and synchronously.

fs.mkdir('newDirectory', (err) => {
  if (err) throw err;
  console.log('Directory created');
});

fs.mkdirSync('newDirectory');
console.log('Directory created');

fs.existsSync()

Checks if a file or directory exists synchronously.

const exists = fs.existsSync('example.txt');
console.log(exists ? 'File exists' : 'File does not exist');

fs.copyFile()

Copies a file asynchronously from one location to another.

fs.copyFile('source.txt', 'destination.txt', (err) => {
  if (err) throw err;
  console.log('File copied successfully');
});

There are more methods you can use for that check official document of fs module

3. events

The events module in Node.js is essential for implementing event-driven programming. It allows you to create, listen to, and manage custom events. The most commonly used class in this module is EventEmitter, which provides various methods for handling events. Here are some of the most used methods:

emitter.on()

Registers a listener (callback function) for a specific event. Multiple listeners can be registered for a single event.

emitter.emit()

Emits a specific event, triggering all listeners registered for that event. You can pass arguments to the listeners.

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('greet', (name) => {
  console.log(`Hello, ${name}!`);
});

emitter.emit('greet', 'Alice'); // Output: Hello, Alice!

emitter.once()

Registers a listener for an event that will be called only once. After the event is emitted, the listener is automatically removed.

emitter.once('welcome', (name) => {
  console.log(`Welcome, ${name}!`);
});

emitter.emit('welcome', 'Alice'); // Output: Welcome, Alice!
emitter.emit('welcome', 'Bob');   // No output (listener is removed after first call)

emitter.removeAllListeners()

Removes all listeners for a specific event or for all events if no event is specified.

emitter.on('goodbye', () => console.log('Goodbye!'));
emitter.removeAllListeners('goodbye');

There are more methods you can use for that check official document of events module

4. URL()

The url module in Node.js provides utilities for URL parsing, formatting, and resolving. This module is useful for handling and manipulating URL strings in web applications.

new URL()

Creates a new URL object, which parses a given URL and provides access to its components.

URL.searchParams

Creates a new URL object, which parses a given URL and provides access to its components.

const { URL } = require('url');
const myUrl = new URL('https://example.com/path?name=John&age=30');

console.log(myUrl.searchParams.get('name'));  // Output: John

URL.toString() & URL.toJSON()

Converts a URL object into a string representation. Serializes the URL as a JSON string

const { URL } = require('url');
const myUrl = new URL('https://example.com/path?name=John');
console.log(myUrl.toString()); 
// Output: https://example.com/path?name=John

console.log(myUrl.toJSON()); 
// Output: "https://example.com/path?name=John"

URL.hostname & URL.port

Gets or sets the hostname portion of the URL (without port). Gets or sets the port portion of the URL.

const { URL } = require('url');
const myUrl = new URL('https://example.com:8000/path?name=John');
console.log(myUrl.hostname); 
// Output: example.com

console.log(myUrl.port); 
// Output: 8000

There are more methods you can use for that check official document of url module

5. http

The http module in Node.js provides functionality to create and handle HTTP requests and responses. Here are some of the most commonly used methods in the http module:

http.createServer()

Creates an HTTP server that listens for incoming requests. This method returns an instance of http.Server.

server.listen()

Starts the HTTP server and listens for requests on the specified port and host.

server.close()

Stops the server from accepting new connections and closes existing connections.

const http = require('http');

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello, World!\n');
});

server.listen(3000, () => {
  console.log('Server is running on http://localhost:3000');
});

server.close(() => {
  console.log('Server has been closed');
});

There are more methods you can use for that check official document of http module

Chrome Extensions I Installed In My Pc

kishor sutradhar — Wed, 13 Nov 2024 17:48:33 +0000

As a developer, productivity and efficiency are crucial. The right tools can make a huge difference in your workflow, and Chrome extensions offer valuable functionalities that integrate directly into your browser.

Here’s a look at some essential Chrome extensions that I use to enhance productivity, design, and development.

1. ColorZilla

ColorZilla is a powerful color tool for web developers and designers. It provides a color picker, eye-dropper, gradient generator, and several other color-related tools. With a single click, you can pick a color from any webpage, and it’s added to your clipboard for easy pasting. It’s a must-have for ensuring color consistency across designs.

2. WhatFont

Fonts are fundamental to user interface (UI) design. WhatFont allows you to inspect fonts on any webpage. Just hover over text, and WhatFont instantly reveals the font’s name, size, weight, and line height. This tool is indispensable when working on typography or drawing inspiration from existing designs.

3. Dark Reader

Dark Reader helps reduce eye strain by enabling a dark mode on any website. It inverts bright colors into darker tones, allowing for a more comfortable browsing experience. You can adjust brightness, contrast, and font settings to your liking. It’s not only about aesthetics but also about maintaining healthy screen habits.

4. Fake Filler

Filling out forms for testing can be tedious. Fake Filler automates this by populating forms with random data. Whether you’re testing a contact form or a checkout process, this extension saves time by quickly filling all fields with placeholder information. It’s especially useful during the testing phase of web development.

5. JSON Formatter

When dealing with APIs, JSON responses can be difficult to read in raw format. JSON Formatter makes JSON data more readable by adding color coding and indentation, which helps with debugging and verifying API responses. It’s a simple but effective tool for anyone working with JSON-based applications.

6. Wappalyzer

Wappalyzer is a technology profiler that identifies the tech stack behind any website. It reveals frameworks, libraries, content management systems (CMS), and other tools used on a site. This information is valuable for competitive analysis, finding inspiration, or simply learning from how other sites are built.

7. Just YouTube Playback

This extension allows you to control the playback speed of YouTube videos with custom increments. It’s particularly useful for developers watching tutorials, as it allows you to speed up or slow down videos to better absorb information or skip through repetitive sections. it is simple to use.

Conclusion

Chrome extensions like these provide an essential toolkit for developers and designers, making tasks easier and more efficient. From color picking and font inspection to automated form filling and JSON formatting, these tools cover a wide range of needs in web development.

Today’s new knowledge #3

kishor sutradhar — Tue, 12 Nov 2024 19:52:26 +0000

Today's Overview:

Hello everyone❤❤❤! Hope you're all doing well. Yesterday, my friend and I set up a public Git repository and started working on a practice project together. Today, I kicked off my coding journey by reviewing my front-end skills and practicing on the project we started. I also learned a bit about managing a project within a team. Later, I played a few matches of Valorant and won them of course 😎, then went on to explore some new topics. and here I what I learned.

Yesterday, I began learning about the MongoDB Aggregation Framework, though I didn’t manage to finish it all. I covered some of what I learned in my blog—here’s the link if you’re interested:

Today’s new knowledge #2

kishor sutradhar ・ Nov 11

. That’s where I kicked things off!

Mongodb Aggregation operators

$group, $unwind, $bucket

Example:

Imagine we have a sales collection with the following documents:

[
  { "_id": 1, "product": "laptop", "category": "electronics", "quantity": 2, "price": 800, "storeLocation": "New York", "date": "2024-11-01" },
  { "_id": 2, "product": "smartphone", "category": "electronics", "quantity": 5, "price": 500, "storeLocation": "Los Angeles", "date": "2024-11-02" },
  { "_id": 3, "product": "laptop", "category": "electronics", "quantity": 1, "price": 800, "storeLocation": "Chicago", "date": "2024-11-03" },
  { "_id": 4, "product": "desk", "category": "furniture", "quantity": 3, "price": 150, "storeLocation": "New York", "date": "2024-11-04" },
  { "_id": 5, "product": "chair", "category": "furniture", "quantity": 10, "price": 75, "storeLocation": "Los Angeles", "date": "2024-11-05" }
]

`$group`

The $group Groups documents by a specified field and can perform aggregate operations. if you use {group:{_id: null}} all the document will be shown in this group.

`$group` aggregation operators

$count Calculates the number of documents in the given group.
$max Displays the maximum value of a document’s field in the collection.
$min Displays the minimum value of a document’s field in the collection.
$avg Displays the average value of a document’s field in the collection.
$sum Sums up the specified values of all documents in the collection.
$push Adds extra values to the array of the resulting document. if you want to get all data of the document you can use{$push: "$$ROOT" }

db.sales.aggregate([
  { $group: { _id: "$product", totalQuantity: { $sum: "$quantity" } } }
])

//output
[
  { "_id": "laptop", "totalQuantity": 3 },
  { "_id": "smartphone", "totalQuantity": 5 },
  { "_id": "desk", "totalQuantity": 3 },
  { "_id": "chair", "totalQuantity": 10 }
]

`$unwind`

The $unwind stage in MongoDB is used to "deconstruct" an array field from the documents in a collection, creating a separate document for each element in the array.

//data
[
  { "_id": 1, "name": "Alice", "hobbies": ["reading", "swimming", "cycling"] },
  { "_id": 2, "name": "Bob", "hobbies": ["painting", "hiking"] },
  { "_id": 3, "name": "Charlie", "hobbies": [] }
]

db.people.aggregate([
  {
    $unwind: {
      path: "$hobbies",
      preserveNullAndEmptyArrays: true
    }
  }
])

//output
[
  { "_id": 1, "name": "Alice", "hobbies": "reading" },
  { "_id": 1, "name": "Alice", "hobbies": "swimming" },
  { "_id": 1, "name": "Alice", "hobbies": "cycling" },
  { "_id": 2, "name": "Bob", "hobbies": "painting" },
  { "_id": 2, "name": "Bob", "hobbies": "hiking" },
  { "_id": 3, "name": "Charlie", "hobbies": null }
]

Charlie’s document is included with hobbies as null because of preserveNullAndEmptyArrays: true.

`$bucket`

The $bucket stage in MongoDB’s aggregation pipeline groups documents into buckets based on specified ranges.

//data
[
  { "_id": 1, "name": "Laptop", "price": 1200 },
  { "_id": 2, "name": "Smartphone", "price": 600 },
  { "_id": 3, "name": "Tablet", "price": 300 },
  { "_id": 4, "name": "Monitor", "price": 200 },
  { "_id": 5, "name": "Keyboard", "price": 50 }
]

db.products.aggregate([
  {
    $bucket: {
      groupBy: "$price",         // Field to group by
      boundaries: [0, 200, 500, 1000, 2000], // Define bucket ranges
      default: "Other",           
      output: {
        count: { $sum: 1 },       
        products: { $push: "$name" } 
      }
    }
  }
])

//output
[
  { "_id": 0, "count": 2, "products": ["Keyboard", "Monitor"] },
  { "_id": 200, "count": 1, "products": ["Tablet"] },
  { "_id": 500, "count": 1, "products": ["Smartphone"] },
  { "_id": 1000, "count": 1, "products": ["Laptop"] }
]

groupBy: Specifies the field to group by, in this case, price.
boundaries: Defines the ranges for each bucket. For instance, [0, 200) will group products with a price between 0 (inclusive) and 200 (exclusive).
default: Specifies the bucket for any values that don’t fall within defined boundaries.
output: Specifies fields to include in each bucket. Here, we count the number of products in each bucket and list product names.

`$sort`

$sort Sorts documents by a specified field.


db.products.aggregate([
{ $sort: { price: -1 } }
])

//output
[
  { "_id": 1, "name": "Laptop", "price": 1200 },
  { "_id": 2, "name": "Smartphone", "price": 600 },
  { "_id": 3, "name": "Tablet", "price": 300 },
  { "_id": 4, "name": "Monitor", "price": 200 },
  { "_id": 5, "name": "Keyboard", "price": 50 }
]

`$limit`

$limit: Limits the number of documents returned by the pipeline.

db.products.aggregate([
{ $limit: 2 }
])

//output
[
  { "_id": 1, "name": "Laptop", "price": 1200 },
  { "_id": 2, "name": "Smartphone", "price": 600 },
]

`$facet`

The $facet stage in MongoDB’s aggregation pipeline allows you to run multiple aggregation pipelines on the same dataset in a single stage, returning separate results for each pipeline.

db.products.aggregate([
  {
    $facet: {
      topExpensiveProducts: [
        { $sort: { price: -1 } },
        { $limit: 3 }
      ],
      avgPriceByCategory: [
        { $group: { _id: "$category", avgPrice: { $avg: "$price" } } }
      ]

    }
  }
])

//output
[
  {
    "topExpensiveProducts": [
      { "_id": 1, "name": "Laptop", "category": "electronics", "price": 1200, "quantity": 30 },
      { "_id": 2, "name": "Smartphone", "category": "electronics", "price": 600, "quantity": 50 },
      { "_id": 3, "name": "Tablet", "category": "electronics", "price": 300, "quantity": 70 }
    ],
    "avgPriceByCategory": [
      { "_id": "electronics", "avgPrice": 700 },
      { "_id": "furniture", "avgPrice": 150 }
    ],

  }
]

`$lookup`

The $lookupstage allows us to join the two collections

Let’s say we have two collections: orders and customers.

//order collection
[
  { "_id": 1, "customerId": 101, "product": "Laptop", "total": 1200 },
  { "_id": 2, "customerId": 102, "product": "Smartphone", "total": 600 },
]
//customers collection
[
  { "_id": 101, "name": "Alice", "location": "New York" },
  { "_id": 102, "name": "Bob", "location": "Los Angeles" },
]

db.orders.aggregate([
  {
    $lookup: {
      from: "customers",             
      localField: "customerId",     
      foreignField: "_id",         
      as: "customerInfo"           
    }
  }
])

//output
[
  {
    "_id": 1,
    "customerId": 101,
    "product": "Laptop",
    "total": 1200,
    "customerInfo": [
      { "_id": 101, "name": "Alice", "location": "New York" }
    ]
  },
  {
    "_id": 2,
    "customerId": 102,
    "product": "Smartphone",
    "total": 600,
    "customerInfo": [
      { "_id": 102, "name": "Bob", "location": "Los Angeles" }
    ]
  }
]

from: Specifies the collection to join with (customers).
localField: Specifies the field in the current collection (orders) that you want to match (customerId).
foreignField: Specifies the field in the customers collection that corresponds to localField (_id).
as: Specifies the name of the new field where matched documents from customers will be added as an array (customerInfo).

Indexes in Mongodb

In MongoDB, indexes improve query performance by allowing the database to quickly locate documents that match a specific search criterion. You can create indexes on fields that you frequently query.

db.collection.createIndex({ field: order })

field: The field you want to index.
order: 1 for ascending order or -1 for descending order.

Indexes should be created thoughtfully, as each index requires storage space and may affect write performance.

To delete an index

db.users.dropIndex("index_name")

DEV Community: kishor sutradhar

The Secret Language of the Internet: Common Protocols Explained

Hypertext Transfer Protocol (HTTP)

Hypertext Transfer Protocol Secure (HTTPS)

Dynamic Host Configuration Protocol (DHCP)

Internet Protocol (IP)

Transmission Control Protocol (TCP)

User Datagram Protocol (UDP)

Domain Name System (DNS)

Simple Mail Transfer Protocol (SMTP)

Post Office Protocol version 3 (POP3)

Internet Message Access Protocol (IMAP)

File Transfer Protocol (FTP)

Secure File Transfer Protocol (SFTP)

Secure Shell (SSH)

Telnet

Address Resolution Protocol (ARP)

VPN Protocols (e.g., OpenVPN, IPsec, WireGuard)

Network Time Protocol (NTP)

Conclusion

One week ago, I finally started learning cybersecurity — after years of avoiding it. This is how it’s going.

📚 Starting with the Fundamentals

🧠 Hands-On with TryHackMe

✅ Linux Fundamentals Part 1

💻 Setting Up My Lab: VirtualBox + Kali Linux

🎮 Playing Bandit: A Linux Wargame

🧪 What I Learned This Week

💬 Let’s Connect

Today’s new knowledge #10 (Building a Flexible Query Builder for MongoDB with Mongoose)

Today’s Overview:

Table of contents

The QueryBuilder Class

Implementation of QueryBuilder

UseCase of QueryBuilder

Search Functionality

Filter Functionality

Sort Functionality

Pagination Functionality

Limit Fields Functionality

Benefits of QueryBuilder

Conclusion

Today’s new knowledge #9 (Understanding Transaction Rollbacks in Mongoose)

Today’s Overview:

Table of contents

Transactions and Rollbacks

Why Use Transaction Rollbacks?

What to consider when using Transaction Rollbacks?

Steps to Implement a Transactions and Rollback in Mongoose

Example

Conclusion

Today’s new knowledge #8(Markdown)

Today’s Overview:

Table of contents

What is Markdown?

Why developers use markdown?

Table of contents in markdown

Few things to note for Table of contents in markdown:

1. Follow Anchor ID Generation Rules

2. Avoid Duplicate Section Names

3. Use a Logical Structure

4. Use a Logical Structure

5. Optional: Number the Sections

Headings in markdown

output:

Heading 1

Heading 2

Heading 3

Heading 4

Heading 5

Heading 6

Bold text in markdown

output:

Italic text in markdown

output:

Link in markdown

output:

Link with Title (Tooltip)

output:

Image in markdown

output:

The `QueryBuilder` Class

Implementation of `QueryBuilder`

UseCase of `QueryBuilder`

Benefits of `QueryBuilder`

`useGsap` hook